Get element in array.
@param  array        $arr
@param  string|array $path  list of nested keys.
@param  mixed        $default
@return mixed
@api
549591
public static function array_get($arr, $path, $default=null) {
		if(!is_array($path))
			$path = [$path];
		foreach($path as $key) {
			if(!isset($arr[$key]))
				return $default;
			else
				$arr = $arr[$key];
		}
		return $arr;
	}
1056777
public static function get($array, string $key, $default = null)
    {
        if (! Assert::array($array)) {
            return $default;
        }

        $key = trim($key);

        if ($key === '') {
            return $array;
        }

        if (static::exists($array, $key)) {
            return $array[$key];
        }

        foreach (explode('.', $key) as $segment) {
            if (Assert::array($array) && static::exists($array, $segment)) {
                $array = $array[$segment];
            } else {
                return $default;
            }
        }

        return $array;
    }
861932
public function getField($path, $default = null)
    {
        if (($current = $this->getContent()) && \is_array($current)) {
            $p = strtok((string) $path, '.');

            while ($p !== false) {
                if (! isset($current[$p])) {
                    return $default;
                }
                $current = $current[$p];
                $p       = strtok('.');
            }
        }

        return $current;
    }
105808
public function get($key, $default = null, $dot_syntax = true)
    {
        if ($dot_syntax === true) {
            $paths = explode('.', $key);
            $node =& $this->_data;
            
            foreach ($paths as $path) {
                if (!is_array($node) || !isset($node[$path])) {
                    // error occurred
                    return $default;
                }
                $node =& $node[$path];
            }
            
            return $node;
            
        } else {
            
            return isset($this->_data[$key]) ? $this->_data[$key] : $default;
            
        }
    }
878905
static function init(&$arr, $key, $default = null) 
    {
        if (! isset($arr[$key])) {
            $arr[$key] = $default;
        }
        return $arr[$key];
    }
445544
public function get($path, $default = null)
	{
		// Return default value if path is empty
		if (empty($path))
		{
			return $default;
		}

		if (!strpos($path, $this->separator))
		{
			return (isset($this->data->$path) && $this->data->$path !== null && $this->data->$path !== '') ? $this->data->$path : $default;
		}

		// Explode the registry path into an array
		$nodes = explode($this->separator, trim($path));

		// Initialize the current node to be the registry root.
		$node  = $this->data;
		$found = false;

		// Traverse the registry to find the correct node for the result.
		foreach ($nodes as $n)
		{
			if (\is_array($node) && isset($node[$n]))
			{
				$node  = $node[$n];
				$found = true;

				continue;
			}

			if (!isset($node->$n))
			{
				return $default;
			}

			$node  = $node->$n;
			$found = true;
		}

		if (!$found || $node === null || $node === '')
		{
			return $default;
		}

		return $node;
	}
200889
public function get($key, $default = null)
    {
        if (is_array($key)) {
            return $this->getMany($key, $default);
        }

        return parent::get($key, $default);
    }
976055
public static function getArray(
        array $params,
        string $key,
        $default = null
    ) {
        if (self::has($params, $key)) {
            return (array)$params[$key];
        }

        return $default;
    }
738694
public static function array_delete(&$arr, $path) {
		if(!$path)
			return;
		if(!is_array($path))
			$path = [$path];
		$lastkey = array_pop($path);
		foreach($path as $parent)
			$arr =& $arr[$parent];
		unset($arr[$lastkey]);
	}
708185
public function get($path, $default = NULL, $deep = FALSE) {

		return array_key_exists($path, $this->parameters) ? $this->parameters[$path] : $default;

	}
373399
public function get($key, $default)
    {
        if (is_array($key)) {
            $key = implode('.', $key);
        }

        return Arr::get($this->json, $key, $default);
    }
296045
public function get($key, $default = null)
    {
        $value = parent::get($key, $default);
        if (is_array($value)) {
            $value = array_shift($value);
        }
        return $value;
    }
87638
public function get($path, $default = null)
    {
        $path = explode($this->separator, $path);
        $item = &$this->item;
        
        foreach ($path as $key) {
            
            if (!is_array($item)) {
                return $default;
            }
            
            if (!array_key_exists($key, $item)) {
                return $default;
            }
            
            $item = &$item[$key];
        }
        
        return $item;
    }
1143103
public static function getByPath(string $path, ?array $array = null, $delimiter = '.')
    {
        // path of nothing? interest
        if (!Any::isArray($array) || count($array) < 1 || !Any::isStr($path) || Str::likeEmpty($path)) {
            return null;
        }

        // c'mon man, what the f*ck are you doing? ))
        if (!Str::contains($delimiter, $path)) {
            return $array[$path];
        }

        $output = $array;
        $pathArray = explode($delimiter, $path);
        foreach ($pathArray as $key) {
            if (!Any::isArray($output) || !array_key_exists($key, $output)) {
                return null;
            }

            $output = $output[$key];
        }
        return $output;
    }
1105491
public function get( $path, $array = NULL )
	{
		if( $array == NULL )
			$array	= $this->storage;
		if( substr_count( $path, "." ) )
		{
			$parts	= explode( ".", $path );
			$step	= array_shift( $parts );
			$path	= implode( ".", $parts );
			$array	= (array) $array[$step];
			return $this->get( $path, $array );
		}
		else
		{
			if( in_array( $path, array_keys( $array ) ) )
				return $array[$path];
			else
				return NULL;
		}
	}
755570
protected function arrGet(array $storage, $path, $default)
    {
        if ($path === null)
        {
            return $storage;
        }

        return $this->helper->arr()->get($storage, $path, $default);
    }
792772
public static function get(array $array, $key, $default = null)
    {
        if (strpos($key, '.') !== false) {
            $keys = explode('.', $key);
            $topKey = array_shift($keys);

            return (isset($array[$topKey])) ? static::get($array[$topKey], implode('.', $keys), $default) : $default;
        } else {
            return (isset($array[$key])) ? $array[$key] : $default;
        }
    }