PHP Arr::forget方法代码示例

 /**
  * Create a new Redis connection instance.
  *
  * @param  array  $servers
  * @return void
  */
 public function __construct(array $servers = [])
 {
     Arr::forget($servers, 'cluster');
     Arr::forget($servers, 'options');
     $this->clients = $this->createClient($servers);
     $this->database = $this->saveDatabase($servers);
 }

 /**
  * Get all of the input except for a specified array of items.
  *
  * @param  array  $keys
  * @return array
  */
 public function except($keys)
 {
     $keys = is_array($keys) ? $keys : func_get_args();
     $results = self::all();
     Arr::forget($results, $keys);
     return $results;
 }

 public static final function onDeletedResource($response)
 {
     $data = (array) json_decode($response->getBody(), true);
     Arr::forget($data, ['code', 'message']);
     $data = json_encode($data);
     return $response->withBody(Psr7\stream_for($data));
 }

 /**
  * Remove index
  *
  * @param $index
  * @return $this
  */
 public function remove($index)
 {
     if ($this->has($index)) {
         Arr::forget($this->data, $index);
         Arr::forget($this->metas, $this->firstIndex($index));
     }
     return $this;
 }

 /**
  * Remove an item from the configuration
  *
  * @param  string $key
  * @return boolean
  */
 public function forget($key)
 {
     if ($this->has($key)) {
         $this->arrHelper->forget($this->data, $key);
         return true;
     }
     return false;
 }

 /**
  * Starts the bot.
  *
  * @return void 
  */
 public function start()
 {
     set_error_handler(function ($errno, $errstr) {
         if (!(error_reporting() & $errno)) {
             return;
         }
         echo "[Error] {$errno} {$errstr}\r\n";
         throw new \Exception($errstr, $errno);
     }, E_ALL);
     foreach ($this->commands as $command => $data) {
         $this->websocket->on(Event::MESSAGE_CREATE, function ($message, $discord, $new) use($command, $data) {
             $content = explode(' ', $message->content);
             $config = Config::getConfig($this->configfile);
             if ($content[0] == $config['prefix'] . $command) {
                 Arr::forget($content, 0);
                 $user_perms = @$config['perms']['perms'][$message->author->id];
                 if (empty($user_perms)) {
                     $user_perms = $config['perms']['default'];
                 }
                 if ($user_perms >= $data['perms']) {
                     try {
                         $data['class']::handleMessage($message, $content, $discord, $config, $this);
                     } catch (\Exception $e) {
                         $message->reply("There was an error running the command. `{$e->getMessage()}`");
                     }
                 } else {
                     $message->reply('You do not have permission to do this!');
                     echo "[Auth] User {$message->author->username} blocked from running {$config['prefix']}{$command}, <@{$message->author->id}>\r\n";
                 }
             }
         });
     }
     $this->websocket->on('ready', function ($discord) {
         $discord->updatePresence($this->websocket, 'DiscordPHP ' . Discord::VERSION, false);
     });
     $this->websocket->on('error', function ($error, $ws) {
         echo "[Error] {$error}\r\n";
     });
     $this->websocket->on('close', function () {
         echo "[Close] WebSocket was closed.\r\n";
         die;
     });
     $this->websocket->run();
 }

 /**
  * Unset a single item in a given Request’s input using dot-notation
  * @param Request $request to modify
  * @param string $key in dot-notation
  */
 protected function unsetRequestInput(Request $request, $key)
 {
     if (strpos($key, '.')) {
         // The data to unset is deeper than 1 level down
         // meaning the final value of the input's first level key is expected to be an array
         list($first_level_key, $key_rest) = explode('.', $key, 2);
         // Pull out the input's existing first level value to modify it as an array
         $first_level_value = $request->input($first_level_key);
         //Request::input() pulls from all input data using dot-notation (ArrayAccess on Request would also pull out files which is undesirable here).
         if (!is_array($first_level_value)) {
             $first_level_value = [];
         }
         Arr::forget($first_level_value, $key_rest);
         $request->merge([$first_level_key => $first_level_value]);
         // The only current alternatives for modifying Request input data are merge() and replace(), the latter replacing the whole input data.
     } else {
         // The data to unset is in the first level
         unset($request[$key]);
     }
 }

 /**
  * {@inheritdoc}
  */
 public function remove($key)
 {
     A::forget($this->expressions, $key);
     $this->reload();
     return $this;
 }

 /**
  * Get all of the origin input except for a specified array of items.
  *
  * @param array|mixed $keys item keys
  * @return array
  */
 public function originExcept($keys)
 {
     $keys = is_array($keys) ? $keys : func_get_args();
     $results = $this->originAll();
     Arr::forget($results, $keys);
     return $results;
 }

 /**
  * Remove an item from the session.
  *
  * @param string $key
  *
  * @return void
  */
 public static function forget($key)
 {
     Arr::forget($_SESSION, $key);
 }

 /**
  * Remove an item from the session.
  *
  * @param  string  $key
  * @return void
  */
 public function forget($key)
 {
     Arr::forget($this->attributes, $key);
 }

 /**
  * Remove validation option.
  *
  * @param string $type
  * @param string $key
  *
  * @throws ValidateException
  *
  * @return array
  */
 protected function removeValidationOption($type, $key)
 {
     $this->checkValidationTypes($type);
     Arr::forget($this->validationOptions, "{$type}.{$key}");
     return $this->validationOptions;
 }

 /**
  * Forget meta value.
  *
  * @param  string  $key
  *
  * @return void
  */
 public function forget($key)
 {
     Arr::forget($this->meta, $key);
 }

 /**
  * Unset the item at a given offset.
  *
  * @param  string  $key
  * @return void
  */
 public function offsetUnset($key)
 {
     $result = $this->convert();
     Arr::forget($result, $key);
     $this->items = Arr::dot($result);
 }

 /**
  * Forget a value from the repository file.
  *
  * @param string $key
  */
 public function forget($key)
 {
     $contents = $this->getContents();
     Arr::forget($contents, $key);
     $this->saveContents($contents);
 }