Delete all keys.

@param array $keys

@return bool
507866
public function deleteAll(array $keys) : bool
    {
        if (empty($keys)) {
            return false;
        }

        $status = true;

        foreach ($keys as $key) {
            $status = $status && $this->delete($key);
        }

        return $status;
    }
452012
public function delete(...$keys)
    {
        $pool = $this->cachePool();

        $results = true;
        foreach ($keys as $key) {
            $results = $pool->deleteItem($key) && $results;
        }

        return $results;
    }
124780
public static function allExcept(array $keys)
    {
        $sessions = static::all();

        if (!empty($keys))
        {
            foreach ($keys as $key) {
                unset($sessions[$key]);
            }
        }

        return $sessions;
    }
1121750
public function reduce(...$keys)
    {
        $keys = $this->normalizeKeys($keys);

        foreach ($this->keys() as $key) {
            if (!in_array($key, $keys, true)) {
                $this->remove($key);
            }
        }

        return $this;
    }
864075
public function only($keys)
    {
        $keys = is_array($keys) ? $keys : func_get_args();

        return $this->filter(function ($value, $key) use ($keys) {
            return in_array($key, $keys, true);
        });
    }
910850
public final function deleteItems(array $keys)
   {
       try {
           foreach ($keys as $value) {
               if (!$this->deleteItem($value)) {
                   return false;
               }
           }
       } catch (InvalidArgumentException $e) {
           throw $e;
       }
       return true;
   }
456694
public function forgetMany(array $keys)
    {
        if (! method_exists($this->store, 'forgetMany')) {
            return array_combine($keys, array_map([$this, 'forget'], $keys));
        }

        return $this->store->forgetMany($this->tagKeys($keys));
    }
1000141
public function hasMany(array $keys)
    {
        foreach ($keys as $key) {
            if (!$this->has($key)) {
                return false;
            }
        }

        return true;
    }
505707
public function remove($key): bool {
        if (isset($this->array[$key])) {
            unset($this->array[$key]);
            return true;
        }
        return false;
    }
1368227
public function hasAny($keys)
    {
        $keys = is_array($keys) ? $keys : func_get_args();

        $input = $this->all();

        foreach ($keys as $key) {
            if (Arr::has($input, $key)) {
                return true;
            }
        }

        return false;
    }
962591
public static function forget(&$array, $keys) {
        $original = &$array;

        $keys = (array) $keys;

        if (count($keys) === 0) {
            return;
        }

        foreach ($keys as $key) {
            // if the exact key exists in the top-level, remove it
            if (array_key_exists($key, $array)) {
                unset($array[$key]);
                continue;
            }

            $parts = explode('.', $key);

            // clean up before each pass
            $array = &$original;

            while (count($parts) > 1) {
                $part = array_shift($parts);

                if (isset($array[$part]) && is_array($array[$part])) {
                    $array = &$array[$part];
                } else {
                    continue 2;
                }
            }

            unset($array[array_shift($parts)]);
        }
    }
827966
public function deleteMultiple($keys)
    {
        array_walk($keys, function (&$v) {
            $v = $this->buildCacheKey($v);
        });

        return $this->cache->deleteMultiple($keys);
    }
824148
public function replaceAllKeys(array $keys): self
    {
        return static::create(
            \array_combine($keys, $this->getArray()),
            $this->iteratorClass,
            false
        );
    }
906577
public function except($keys)
    {
        $keys = is_array($keys) ? $keys : [$keys];
        $all = $this->all();

        foreach ($keys as $key) {
            if (array_key_exists($key, $all)) {
                unset($all[$key]);
            }
        }

        return $all;
    }
671645
public function clearMany($keys)
    {
        if (!is_array($keys))
            $keys = func_get_args();

        foreach($keys as $key) {
            unset($this->_data[$key]);
        }

        return $this;

    }
58444
public function keysExist(array $keys)
    {
        foreach ($keys as $key) {
            if (!$this->keyExists($key)) {
                return false;
            }
        }
        return true;
    }
1007715
public static function removeKeys($array, $keys)
    {
        // Loop over the array
        foreach ($array as $key => $value) {
            // Check if we want to remove it...
            if (!is_numeric($key) and in_array($key, $keys)) {
                unset($array[$key]);
                continue;
            }

            // Filter the value if it's an array also
            $array[$key] = is_array($value) ? static::removeKeys($value, $keys) : $value;
        }

        return $array;
    }