Unsets the value of the given key.

@param mixed key key to remove

@return void

@throws RuntimeException on write attempt when modification is forbidden
482091
public function offsetUnset($key)
    {
        if (!$this->allow_modification) {
            throw new RuntimeException('Attempting to unset key on an immutable array');
        }

        if ($this->offsetExists($key)) {
            parent::offsetUnset($key);
        }
    }
1058430
function clear($key) {
		if (array_key_exists($key,$this->adhoc))
			unset($this->adhoc[$key]);
		else
			unset($this->props[$key]);
	}
1270023
public function unset(string $key)
    {
        if (array_key_exists($key, $this->input)) {
            unset($this->input[$key]);
            unset($this->cache[$key]);
        }

        $item = &$this->input;

        foreach (explode('.', $key) as $segment) {
            if (! isset($item[$segment])) {
                return;
            }
            if (! is_array($item[$segment])) {
                unset($item[$segment]);
                break;
            }
            $item = &$item[$segment];
        }

        unset($this->cache[$key]);
    }
205276
public function remove($key)
    {
        $parts = explode('.', $key);
        $scope = &$this->array;
        $count = count($parts) - 1;
        for ($i = 0; $i < $count; $i++) {
            if (!isset($scope[$parts[$i]])) {
                return;
            }
            $scope = &$scope[$parts[$i]];
        }
        unset($scope[$parts[$i]]);
    }
409336
public static function delete( $key ) {

		if ( isset( self::$config[ strtolower( $key ) ] ) ) {
			unset( self::$config[ strtolower( $key ) ] );
		}

	}
472490
public function unsetHeader($key)
    {
        unset($this->headers[$key]);
        $headers = array();
        foreach ($this->headers as $key => $value) {
            $headers[] = $key . ': ' . $value;
        }
        $this->setOpt(CURLOPT_HTTPHEADER, $headers);
    }
1101313
public function offsetUnset( $key )
    {
        $key = strtolower( $key );
        if ( array_key_exists( $key, $this->lookup ) )
        {
            unset( $this->map[$this->lookup[$key]] );
            unset( $this->lookup[$key] );
        }
    }
54630
public function remove($key)
    {
        unset($this->_definitions[$key], $this->_singletons[$key]);
        foreach ($this->_aliases as $alias => $akey) {
        	if ($akey === $key) {
        		unset($this->_aliases[$alias]); 
        		break;
        	}
        }
    }
696660
public function offsetUnset($key)
    {
        if ($this->root) {
            $this->root = $this->root->remove($key, $this->comparator);
        }
    }
313405
function del($key)
    {
        $index = array_search($key, $this->keys);

        if ($index !== false) {
            unset($this->keys[$index]);
            unset($this->values[$index]);
            $this->_reflow();
            return true;
        }
        return false;
    }
560609
public function clear($key = null)
    {
        if (isset($key)) {
            if (isset($this->data[$key])) {
                unset($this->data[$key]);
            }
        } else {
            $this->data = [];
        }
    }
1181855
protected function _configDelete($key)
    {
        if (strpos($key, '.') === false) {
            unset($this->_config[$key]);

            return;
        }

        $update =& $this->_config;
        $stack = explode('.', $key);
        $length = count($stack);

        foreach ($stack as $i => $k) {
            if (!is_array($update)) {
                throw new Exception(sprintf('Cannot unset %s value', $key));
            }

            if (!isset($update[$k])) {
                break;
            }

            if ($i === $length - 1) {
                unset($update[$k]);
                break;
            }

            $update =& $update[$k];
        }
    }
1342594
@Override
  public V remove(Object key)
  {
    if (key == null) {
      V value = _nullValue;
      _nullValue = null;
      return value;
    }

    int hash = key.hashCode() & _mask;
    int count = _size + 1;

    V item = null;

    for (; count > 0; count--) {
      item = _values[hash];

      if (item == null)
        return null;

      if (_keys[hash].equals(key)) {
        _keys[hash] = null;
        _values[hash] = null;
        _size--;

        refillEntries(hash);
        break;
      }

      hash = (hash + 1) & _mask;
    }

    if (count < 0)
      throw new RuntimeException("internal cache error");

    return item;
  }
326328
public function offsetUnset($offset)
    {
        if ($this->offsetExists($offset)) {
            $removed_items = array_splice($this->items, $offset, 1);
            $this->propagateCollectionChangedEvent(
                new CollectionChangedEvent($removed_items[0], CollectionChangedEvent::ITEM_REMOVED)
            );
        } elseif ($this instanceof MandatoryKeyInterface) {
            throw new RuntimeException('Item to be unset not found at key: ' . $offset);
        }
    }
842332
public function remove($key)
    {
        $method = 'remove'.$key;

        if (method_exists($this, $method)) {
            $this->$method();
        } else {
            unset($this->metas[$key]);
        }
    }
340242
public function remove($key)
    {
        $file=$this->getCacheDir().$key;
        if(file_exists($file))
            unlink($file);
    }
672704
protected function forget($key)
    {
        $mapping = $this->getMappingForAttribute($key);

        list($target, $attribute) = $this->parseMappedColumn($mapping);

        $target = $target ? $this->getTarget($this, explode('.', $target)) : $this;

        unset($target->{$attribute});
    }