Extract item from session then delete from the session, finally return the item
@param  string $key item to extract
@return string      return item
186953
public static function pull($key)
    {
        self::setPrefix();
        $value = $_SESSION[self::$_sessionPrefix . $key];
        unset($_SESSION[self::$_sessionPrefix . $key]);

        return $value;
    }
1035551
public function extract($key)
    {
        $extracted = [];

        foreach ($this->items as $item) {
            foreach (func_get_args() as $key) {
                if ($item instanceof CollectionInterface) {
                    $extracted[] = $item->get($key);
                } else if (is_object($item)) {
                    $extracted[] = $item->{$key};
                } else {
                    $extracted[] = $item[$key];
                }
            }
        }

        return $extracted;
    }
1136506
public function get($key)
    {
        $response = $this->dynamo->getItem([
            'TableName' => $this->table,
            'ConsistentRead' => false,
            'Key' => [
                $this->keyAttribute => [
                    'S' => $this->prefix.$key,
                ],
            ],
        ]);

        if (! isset($response['Item'])) {
            return;
        }

        if ($this->isExpired($response['Item'])) {
            return;
        }

        if (isset($response['Item'][$this->valueAttribute])) {
            return $this->unserialize(
                $response['Item'][$this->valueAttribute]['S'] ??
                $response['Item'][$this->valueAttribute]['N'] ??
                null
            );
        }
    }
1341915
public function getItem($key)
    {
        $this->validateKey($key);

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

        # If we didn't find a suitable item then create a new one now
        return new Item($key);
    }
1205783
public static function get($key)
    {
        $item = self::getCacheService()->user()->getItem(self::key($key));
        if ($item->isHit()) {
            return $item->get();
        }
        return null;
    }
112875
public function getSessionData( $key ) {
		self::ensureSession();
		if ( !isset( $_SESSION[ $key ] ) ) {
			return null;
		}
		return $_SESSION[$key];
	}
742966
public function get($key = '')
    {
        if ( !isset($_SESSION) ) {
            return false;
        }

        if ($key == '') {
            return $_SESSION;
        } elseif (array_key_exists($key, $_SESSION)) {
            return $_SESSION[$key];
        } elseif (strpos($key, '.')) {
            $names = explode('.', $key);

            $value = $_SESSION;
            foreach ($names as $v) {
                if (isset($value[$v])) {
                    $value = $value[$v];
                } else {
                    $value = false;
                    break;
                }
            }

            return $value;
        } else {
            return false;
        }
    }
601996
public function pull($key)
    {
        if (!$this->containsKey($key)) {
            return null;
        }
        $removed = $this->items[$key];
        unset($this->items[$key]);

        return $removed;
    }
733707
public function get( $key )
	{
		$prefixed = $this->prefix . $key;

		$cache = $this->table()->where( 'key', '=', $prefixed )->first();

		// If we have a cache record we will check the expiration time against current
		// time on the system and see if the record has expired. If it has, we will
		// remove the records from the database table so it isn't returned again.
		if ( !is_null( $cache ) )
		{
			if ( is_array( $cache ) )
				$cache = (object) $cache;

			if ( time() >= $cache->expiration )
			{
				$this->forget( $key );

				return null;
			}

			return $this->encrypter->decrypt( $cache->value );
		}

		return null;
	}
1214277
public static function get(string $key)
    {
        // Start session if needed
        if (! session_id()) {
            self::start();
        }

        // Fetch key
        if (Session::exists((string) $key)) {
            return $_SESSION[(string) $key];
        }

        // Key doesn't exist
        return null;
    }
229080
public function delete($key){
        $this->connection->where('keyCache = :key', array('key' => $key));
        return $this->connection->delete($this->table);
    }
563088
public static function get($key)
    {
        if (isset($_SESSION[$key]) === false) {
            return null;
        }

        return unserialize($_SESSION[$key]);
    }
1086716
public function getAndDelete($key)
    {
        $key   = $this->getCompositeKey($key);
        $value = $this->get($key);
        $this->delete($key);
        return $value;
    }
478405
public function get($key)
    {
        $session = $this->getSessionData();

        return $this->has($key) ? $session[$key] : null;
    }
796130
public function getCachedObject($key) {
        $cache = HttpSession::instance()->getValue("__SESSION_CACHED_ITEMS");

        $timeouts = HttpSession::instance()->getValue("__SESSION_CACHE_TIMEOUTS");
        if (is_array($timeouts) && isset($timeouts[$key])) {
            $now = new \DateTime();
            $expiry = date_create_from_format("d/m/Y H:i:s", $timeouts[$key]);

            if ($now >= $expiry) {
                return null;
            }
        }

        return isset($cache[$key]) ? $cache[$key] : null;
    }
330517
public function extractKey($key)
    {
        $self       = clone($this);
        $self->data = Accessor::get($this->data, $key) ?: [];
        return $self;
    }
1323340
public function getItem($key)
    {
        $data = $this->memcached->get($key);

        if ($data['ttl'] === 0 || (time() - $data['start'] <= $data['ttl'])) {
            $value = $data['value'];
        } else {
            $this->deleteItem($key);
        }

        return (isset($value)) ? $value : false;
    }