Deletes multiple cache items in a single operation.

@param  iterable $keys
@return boolean
160222
public function deleteMultiple($keys)
    {
        $failTimes = 0;
        foreach ($keys as $key) {
            if (!$this->delete($key)) {
                $failTimes++;
            }
        }

        return $failTimes == 0;
    }
624039
public function forgetMany(array $keys)
    {
        if (! method_exists($this->store, 'forgetMany')) {
            return array_combine($keys, array_map([$this, 'forget'], $keys));
        }

        $success = $this->store->forgetMany($keys);

        foreach ($success as $key => $value) {
            $this->fireCacheEvent('delete', [$key]);
        }

        return $success;
    }
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);
    }
1026338
public function deleteItem($key)
    {
        $this->validateKey($key);

        if ($this->hasItem($key)) {
            unset($this->data[$key]);
        }

        return true;
    }
381381
public function forget($keys = null)
    {
        if (is_null($keys)) {
            $this->items = [];
            return $this;
        }

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

        return $this;
    }
525805
public function delete($key)
    {
        $this->type === 2 && $key = $this->conf['prefix'] . $key;
        return $this->memcache->delete($key);
    }
28539
public function purge(array $keys=null)
    {
        if ($keys === null) {
            $this->_attributes = [];
            return $this->filesystem->delete($this->url);
        }

        if (!$keys) {
            return false;
        }

        $this->bootOnce();

        foreach ($keys as $key) {
            $this->offsetUnset($key);
        }

        return $this->persist();
    }
965554
public static function removeFromCache($key)
    {
        $fullKey = static::makeCacheKey($key);
        if (!Cache::forget($fullKey)) {
            return false;
        }

        static::removeKeys($key);

        return true;
    }
340158
public function delete($key)
    {
        if (true === array_key_exists($key, $this->cache)) {
            unset($this->cache[$key]);

            return true;
        }

        return false;
    }
397054
public function delete($key){
		if(DEBUG_MODE){
			BDebug::message('[Memcached]: Delete key('.$key.')');
			}
		$mc=$this->getMemcached();
		if(empty($mc))return false;
		$this->queries_delete_count++;
		return $mc->delete($key);
		}
1075771
protected function deleteValue($key)
    {
        $this->db->getCollection($this->cacheCollection)->remove(['id' => $key]);
        return true;
    }
1363203
public function delete($key) {
        $filename = $key.'.cache';
        $file = $this->file_path_for_key($key);
        if (@unlink($file)) {
            unset($this->keys[$filename]);
            return true;
        }

        return false;
    }
115997
public function forget($key)
    {
        if ($this->has($key)) {

            unlink($this->path . $key);

            clearstatcache();

            return true;
        }

        return false;
    }
69886
public function delete($key) {
        if (!is_array($key)) {
            $key = array('key' => $key);
        }
        $key = $key['key'];
        $result = isset($this->store[$key]);
        unset($this->store[$key]);
        if ($this->maxsize !== false) {
            $this->storecount--;
        }
        return $result;
    }
465774
public function deleteMulti(array $keys): void
    {
        if ($this->enabled === false) {
            return;
        }

        foreach ($keys as $index) {
            if ($key = $this->cacheIndex[$index] ?? null) {
                unset($this->cacheIndex[$index]);
            } else {
                $key = $index;
            }

            unset($this->cache[$key], $this->cacheExpiryTime[$key], $this->cacheAccessCount[$key]);
        }
    }
1130547
public function deleteItems(array $keys)
    {
        $this->validateKeys($keys);

        $result = true;

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

        return $result;
    }
1041303
public function delete($key)
    {
        if (empty($this->memcache)) {
            return false;
        }

        $key = $this->processKey($key);

        return $this->memcache->delete($key);
    }