Retrieve an array of items from the cache by keys.

@param  array  $keys
@param  mixed  $default
@return array
161105
public function getMany(array $keys, $default = null)
    {
        $keys = array_fill_keys($keys, $default);

        if (! method_exists($this->store, 'getMany')) {
            return array_combine(array_keys($keys), array_map([$this, 'get'], array_keys($keys), array_values($keys)));
        }

        $values = array_combine(array_keys($keys), $this->store->getMany(array_keys($keys)));

        foreach ($values as $key => &$value) {
            if (is_null($value)) {
                $this->fireCacheEvent('missed', [$key]);

                $value = value(array_get($keys, $key, $default));
            } else {
                $this->fireCacheEvent('hit', [$key, $value]);
            }
        }

        return $values;
    }
235513
public function choice( array $keys, $default = false )
	{
		foreach( $keys as $key )
		{
			if( $this->offsetExists($key) )
			{
				return $this->items[$key];
			}
		}

		return $default;
	}
31747
public function getFromCache($key, $default = null)
    {
        $fullKey = $this->makeCacheKey($key);

        return Cache::get($fullKey, $default);
    }
1129332
public static function get( array $storage, $key, $default = null )
	{
		if ($key === null) {
			return $storage;
		}

		if (is_array($key)) {
			return static::getArray($storage, $key, $default);
		}

		foreach (explode('.', $key) as $segment) {
			if (!is_array($storage)) {
				return $default;
			}

			if (!array_key_exists($segment, $storage)) {
				return $default;
			}

			$storage = $storage[$segment];
		}

		return $storage;
	}
1002396
function get($key, $default = null)
    {
        $index = array_search($key, $this->keys);

        if ($index !== false) {
            return $this->values[$index];
        } else {
            return $default;
        }
    }
559321
public function get($key, $default = null)
    {
        list($namespace, $group, $item) = $this->parseKey($key);

        // Configuration items are actually keyed by "collection", which is simply a
        // combination of each namespace and groups, which allows a unique way to
        // identify the arrays of configuration items for the particular files.
        $collection = $this->getCollection($group, $namespace);

        $this->load($group, $namespace, $collection);

        return array_get($this->items[$collection], $item, $default);
    }
386510
public function get($key, $default = false)
    {
        if ($this->has($key) !== false) {
            return $this->cache[$key];
        } else {
            return $default;
        }
    }
1297806
public static function get(array $array, $key, $default = null)
    {
        if (array_key_exists($key, $array)) {
            return $array[$key];
        }

        if (strpos($key, '.') === false) {
            return $default;
        }

        foreach (explode('.', $key) as $segment) {
            if (is_array($array) && array_key_exists($segment, $array)) {
                $array = $array[$segment];
            } else {
                return $default;
            }
        }

        return $array;
    }
729942
public function get($key, $default = null)
    {
        return array_key_exists($key, $this->producers) ? $this->producers[$key] : $default;
    }
381578
public function getArray(string $key, array $default = []): array
    {
        if (\array_key_exists($key, $this->data)) {
            if (\is_array($this->data[$key])) {
                return \array_values($this->data[$key]);
            }
            
            return (array) $this->data[$key];
        }
        
        return (array) $default;
    }
35460
public static function get($array, $key, $default = null)
    {
        $key = static::normalizeKey($key);

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

        $keys = explode('.', $key);
        $currentElement = $array;

        foreach ($keys as $currentKey)
        {
            if (!is_array($currentElement) || !array_key_exists($currentKey, $currentElement))
            {
                return $default;
            }

            $currentElement = $currentElement[(string) $currentKey];
        }

        return $currentElement;
    }
296850
public function get(string $key, $default = null)
    {
        $value = Arr::get($this->items, $key);

        if (\is_null($value)) {
            return \value($default);
        }

        return $value;
    }
510254
public function get($key, $default = null)
    {
        $hash = $this->key_to_hash($key);
        if (array_key_exists($hash, $this->array)) {
            return $this->array[$hash];
        } else {
            return $default;
        }
    }
808044
public static function get($array, $key, $default = null)
    {
        if (null === $key) {
            return $array;
        }

        if (isset($array[$key])) {
            return $array[$key];
        }

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

        return $array;
    }
1205839
public function getMultiple($keys, $default = null): array
    {
        if (!is_iterable($keys)) {
            throw new CacheException('Argument $keys is not iterable.');
        }
        if (!count($keys)) {
            return [];
        }
        $keys = array_unique($keys);
        $this->validateKeys($keys);
        $args = array_map(function ($key) {
            return self::PREFIX_KEY_VALUE . $key;
        }, $keys);
        $values = $this->client->mget(...$args);
        $values = array_map(function ($value) use ($default) {
            return is_null($value) ? $default : $this->unpack($value);
        }, $values);
        return array_combine($keys, $values);
    }
547678
public function get($key, $default = null)
    {
        return array_key_exists($key, $this->collection) ? $this->collection[$key] : $default;
    }
1254971
protected function getCache($key, $default)
    {
        if (!isset($this->cache[$key])) {
            $this->cache[$key] = is_callable($default) ? $default() : $default;
        }
        return $this->cache[$key];
    }