Unset an element from an array.

@param  array  &$storage
@param  string $key   Specify a nested element by separating keys with full stops.
760511
public static function forget( array &$storage, $key )
	{
		$segments = explode('.', $key);

		$key = array_pop($segments);

		// iterate through all of $segments except the last one
		foreach ($segments as $segment) {
			if (!array_key_exists($segment, $storage)) {
				return;
			} else if (!is_array($storage[$segment])) {
				throw new \UnexpectedValueException('Non-array segment encountered');
			}

			$storage =& $storage[$segment];
		}

		unset($storage[$key]);
	}
200863
public function remove($key) {
    $path = $this->getFileName($key, TRUE);
    if (file_exists($path)) {
      unlink($path);
    }
  }
1033547
public function offsetUnset($key)
    {
        $this->checkKey($this->key_type, $key);
        unset($this->container[$key]);
    }
329481
public static function delete( $key, &$arr ) 
	{	
		if ( isset( $arr[$key] ) ) 
		{
			unset( $arr[$key] ); return;
		}

		if ( strpos( $key, '.' ) !== false ) 
		{	
			$kp = explode( '.', $key );

			switch ( count( $kp ) ) {
				case 2:
					unset( $arr[$kp[0]][$kp[1]] ); return; break;
				case 3:
					unset( $arr[$kp[0]][$kp[1]][$kp[2]] ); return; break;
				case 4:
					unset( $arr[$kp[0]][$kp[1]][$kp[2]][$kp[3]] ); return; break;
			}
		}
	}
420407
public static function set( array &$storage, $key, $value )
	{
		$segments = explode('.', $key);

		$key = array_pop($segments);

		// iterate through all of $segments except the last one
		foreach ($segments as $segment) {
			if (!array_key_exists($segment, $storage)) {
				$storage[$segment] = array();
			} else if (!is_array($storage[$segment])) {
				throw new \UnexpectedValueException('Non-array segment encountered');
			}

			$storage =& $storage[$segment];
		}

		$storage[$key] = $value;
	}
427039
public function remove($key) {
		$key = $this->extractKey($key);
		if (isset($this->collection[$key])) {
			$element = $this->collection[$key];
			unset($this->collection[$key]);
			
			return $element;
		}
	}
877917
public function offsetUnset( $key )
	{
		if( !isset( $this->____pairs ) )
			$this->getPairs();
		if( !array_key_exists( $key, $this->____pairs ) )
			throw new Exception( 'Pair Key "'.$key.'" is not set in Row.' );
		unset( $this->____pairs[$key] );
	}
1075250
public function remove($key)
    {
        if ($key == 'message') {
            $this->message = '';
        }

        if ($key == 'exception') {
            $this->exception = null;
        }

        if (array_key_exists($key, $this->payload)) {
            unset($this->payload[$key]);
        }
    }
985162
public function offsetUnset($key)
    {
        ArrayUtils::remove($this->parameters, $key);
        $key = ArrayUtils::implodeIfArray($key, ':');
        if (isset($this->links[$key])) {
            unset($this->links[$key]);
        }
    }
661599
public function clear(array $keys=null)
    {
        if ($keys === null) {
            foreach ($this->storages as $storage) {
                $storage->clear();
            }
            return $this;
        }

        if (!$keys) {
            return $this;
        }

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

        return $this;
    }
1028801
public function del($key, $subKey = null)
    {
        if (!is_null($subKey) && (is_array($this->data[$key]))) {
            unset($this->data[$key][$subKey]);
        } else {
            unset($this->data[$key]);
        }
    }
130082
public function remove($key)
    {
        $this->removeKeyFromNestedCache($key);

        if ($this->isNestedKey($key)) {
            $this->removeNestedValueByKey($key);

            return;
        }

        unset($this->items[$key]);
    }
284264
public static function delete(array &$array, string ...$keys)
    {
        if ($keys === []) {
            return;
        }

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

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

            $parts = \explode('.', $key);
            $delKey = \array_pop($parts);
            foreach ($parts as $part) {
                if (isset($array[$part]) && \is_array($array[$part])) {
                    $array = &$array[$part];
                } else {
                    continue 2;
                }
            }

            unset($array[$delKey]);
        }
    }
1045607
public function removeAll(self $storage)
    {
        foreach ($this->data as $key => $value) {
            foreach ($storage->data as $object) {
                if ($object === $value) {
                    unset($this->data[$key]);
                    unset($this->info[$key]);
                }
            }
        }
    }
1129098
protected function unsetValue($key) {
		$data = $this->readData();
		unset($data[$key]);
		return $this->writeData($data);
	}
813157
public function offsetUnset($key)
    {
        //unset($this->items[$key]);

        // Recursive call
        if (is_array($key))
            foreach ($key as $k)
                $this->internalRemove($this->items, $k);

        $this->internalRemove($this->items, $key);
    }
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] );
        }
    }