批量删除缓存
@param array $keys
@return bool
489515
public function deleteMultiple($keys)
    {
        if (!is_array($keys)) {
            throw new InvalidArgumentException(sprintf('Cache keys must be array, "%s" given', is_object($keys) ? get_class($keys) : gettype($keys)));
        }

        return $this->mem->deleteMulti($keys);
    }
790067
public function isEmpty($keys = null)
    {
        if (is_null($keys)) {
            return empty($this->elements);
        }
        $keys = (array) $keys;
        foreach ($keys as $key) {
            if (!empty($this->get($key))) {
                return false;
            }
        }
        return true;
    }
1130547
public function deleteItems(array $keys)
    {
        $this->validateKeys($keys);

        $result = true;

        foreach ($keys as $key) {
            if (!$this->deleteItem($key)) {
                $result = false;
            }
        }

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

        $results = [];

        $input = $this->all();

        foreach ($keys as $key) {
            Arr::set($results, $key, data_get($input, $key));
        }

        return $results;
    }
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;
   }
1060139
public function wasModified($keys = null)
    {
        $modified = $this->getModifiedData();
        $removedKeys = $this->getRemovedKeys();

        if (!$keys) {
            return (bool)$modified || (bool)$removedKeys;
        }

        $keys = is_array($keys) ? $keys : func_get_args();

        foreach ($keys as $key) {

            if (array_key_exists($key, $modified)) {
                return true;
            }

            if (in_array($key, $removedKeys)) {
                return true;
            }
        }

        return false;
    }
1116179
public static function has(array $array, ...$keys): bool
    {
        $key = array_shift($keys);

        if (!isset($array[$key])) {
            return false;
        }

        if (empty($keys)) {
            return isset($array[$key]);
        }

        if (!\is_array($array[$key])) {
            return false;
        }

        return self::has($array[$key], ...$keys);
    }
933433
public static function ExistsLowest ($array, $keys) {
		foreach ((array) $keys as $key) {
			if (isset($array[$key])) {
				$array = $array[$key];
			} else {
				return false;
			}
		}
		return true;
	}
160222
public function deleteMultiple($keys)
    {
        $failTimes = 0;
        foreach ($keys as $key) {
            if (!$this->delete($key)) {
                $failTimes++;
            }
        }

        return $failTimes == 0;
    }
729544
public function has_any(array $keys) {
        foreach ($keys as $arraykey => $key) {
            $keys[$arraykey] = $this->prepare_key($key);
        }
        $result = apcu_exists($keys);
        return count($result) > 0;
    }
1117879
public function has($keys)
    {
        $keys = (array) $keys;
        if (!$this->elements || $keys === []) {
            return false;
        }
        foreach ($keys as $key) {
            $items = $this->elements;
            if ($this->exists($items, $key)) {
                continue;
            }
            foreach (explode('.', $key) as $segment) {
                if (!is_array($items) || !$this->exists($items, $segment)) {
                    return false;
                }
                $items = $items[$segment];
            }
        }
        return true;
    }
571823
public function deleteMultiple($keys): bool
    {
        $this->checkIterable($keys);
        $return = true;
        foreach ($keys as $key) {
            $return = $return && $this->delete($key);
        }
        return $return;
    }
409410
public function delete(array $keys) {
		if ($this->_config['scope']) {
			$keys = $this->_addScopePrefix($this->_config['scope'], $keys);
		}
		return apc_delete($keys) === [];
	}
680972
public function delete_many(array $keys) {
        if ($this->clustered) {
            // Get the minimum deleted from any of the connections.
            $count = count($keys);
            foreach ($this->setconnections as $connection) {
                $count = min($this->delete_many_connection($connection, $keys), $count);
            }
            return $count;
        }

        return $this->delete_many_connection($this->connection, $keys);
    }
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);
        });
    }
1149768
public static function keysExist(array $collection, array $keys)
    {
        $collection = array_flip($collection);

        foreach ($keys as $key) {
            if (!in_array($key, $collection)) {
                return false;
            }
        }

        return true;
    }
1085790
public function deleteMultiple($keys): bool
    {
        if (
            !\is_array($keys)
            &&
            !($keys instanceof \Traversable)
        ) {
            throw new InvalidArgumentException('$keys is not iterable:' . \print_r($keys, true));
        }

        $results = [];
        foreach ((array) $keys as $key) {
            $results[] = $this->delete($key);
        }

        return !\in_array(false, $results, true);
    }