@param string $key

@return mixed|null|object
@throws OffsetNotValid
765981
public function get($key)
    {
        if(!is_string($key)) {
            throw new OffsetNotValid(sprintf("Offset must be a string, %s passed", gettype($key)));
        }

        //automatically resolve factory callables if they exist
        if(!$this->has($key) && $this->isFactory($key) && is_callable(($factory = $this->getFactory($key)))) {
            return $this->reflector->resolveCallableString($key, $factory, true);
        }

        //automatically resolve shared callables if they exist
        if(!$this->has($key) && $this->isShared($key) && is_callable(($shared = $this->getShared($key)))) {
            return $this->reflector->resolveCallableString($key, $shared);
        }

        //get alias
        $alias = $this->isAlias($key) ? $this->getAlias($key) : $key;

        //automatically resolve classes if they exist even if they don't exist in our reflector cache
        if(!$this->has($alias) && class_exists($alias, true)) {
            return $this->reflector->resolveClassString($alias, $this->isFactory($alias));
        }

        //return basic container value
        return $this->offsetGet($alias);
    }
1217474
public function getParamByKey($key)
    {
        if (isset($this->extParams[$key]))
        {
            return $this->extParams[$key];
        }

        return null;
    }
357501
private function getNestedValueByKey($key)
    {
        if (isset($this->nestedKeyCache[$key])) {
            return $this->nestedKeyCache[$key];
        }

        // Check to see if this is targeting an instance of ArrayContainer and grab it from the nested container
        $keyParts = explode('.', $key);
        if ($this->get($keyParts[0]) instanceof self && $arrayContainer = $this->get($keyParts[0])) {
            array_shift($keyParts);
            /* @var ArrayContainer $arrayContainer */
            $value = $arrayContainer->get(implode('.', $keyParts));
        } else {
            $value = $this->items;
            foreach (explode('.', $key) as $keyPart) {
                if ((! is_array($value) || ! $value instanceof self)) {
                    if (is_object($value) && method_exists($value, 'arrayAccessByKey')) {
                        if ($value = $value->arrayAccessByKey($keyPart)) {
                            break;
                        } else {
                            return null;
                        }
                    }
                }

                if (! isset($value[$keyPart])) {
                    return null;
                }

                if (is_array($value[$keyPart]) && ! array_key_exists($keyPart, $value)) {
                    return null;
                }
                $value = $value[$keyPart];
            }
        }

        $this->nestedKeyCache[$key] = $value;

        return $value;
    }
1206289
public function offsetGet($key)
    {
        assert(
            is_string($key),
            sprintf('Invalid metadata key: (%s) %s', gettype($key), VarPrinter::toString($key))
        );

        return $this->get($key);
    }
1367183
public function &__get($key)
    {
        $ret = null;

        if ($this->flag == self::ARRAY_AS_PROPS) {
            $ret =& $this->offsetGet($key);

            return $ret;
        }

        if (in_array($key, $this->protectedProperties)) {
            throw new \InvalidArgumentException('$key is a protected property, use a different key');
        }

        return $this->$key;
    }
261462
protected function get($key)
    {
        $this->checkForNonEmptyKey($key);
        if (!$this->settingsHaveBeenRetrieved) {
            $this->retrieveSettings();
        }
        if (!isset($this->cachedSettings[$key])) {
            return null;
        }

        return $this->cachedSettings[$key];
    }
83343
public function get($key)
	{
		$hash = md5($key);
		$cacheFile = $this->getPath().'/'.$hash.'.cache';

		if (!is_file($cacheFile)) {
			return null;
		}
		return unserialize(file_get_contents($cacheFile));
	}
716539
public function get($key)
    {
        $parts = explode('.', $key);
        $offset = $this->config;

        foreach($parts as $part) {
            if(!isset($offset[$part])) return null;

            $offset = $offset[$part];
        }

        return $offset;
    }
1041761
public function load($key)
    {
        if (file_exists($path = $this->path . $key)) {
            return unserialize(file_get_contents($path));
        }

        return null;
    }
168433
public function get($key){

		if(!is_null($this->args))
			if(in_array($key, array_keys($this->args)))
				return $this->args[$key];

		return null;
	}
446197
public function getOrFail($key)
    {
        $value = $this->get($key, new None());
        if (!$value instanceof None) {
            return $value;
        }
        throw new KeyNotFoundException("Key '$key' not found'");
    }
148206
public function getIssueByKey($key)
    {
        if (array_key_exists($key, $this->issues) && isset($this->issues[$key])) {
            return $this->issues[$key];
        }

        return null;
    }
506315
public function offsetGet($key){
        $raw = parent::offsetGet($key);
        return is_callable($raw) ? call_user_func($raw) : $raw;
    }
398760
public function fetch($key)
    {
        if(extension_loaded('apcu') && function_exists('apcu_fetch')) {
            $cached = apcu_fetch($key);
            if (!$cached) {
                return null;
            }

            return $cached;

        }else{
            return null;
        }
    }
906714
public function get($key)
    {
        $value  = $this->redisServer->getHashClient($key)->get($key);

        if (false !== $value) {
            return is_numeric($value) ? $value : unserialize($value);
        }

        return null;
    }
763138
protected function retrieve($key)
    {
        if (!is_null($cache = $this->redis->get($key))) {
            return unserialize($cache);
        }

        return null;
    }
7153
public function getShared(string $key)
    {
        if(!$this->isShared($key)) {
            throw new OffsetNotFound("Trying to get a shared offset that doesn't exist");
        }

        return $this[self::REFLECTOR_SHARED][$key];
    }