Get a value from $_FILES, or the whole array.

@param (string) $key

@since 3.0.0

@return mixed
544777
public function getFiles($key = null)
    {
        if ($key === null) {
            return $this->files;
        } else {
            return (isset($this->files[$key])) ? $this->files[$key] : null;
        }
    }
752422
public function file($key = null, $default = null)
	{
		$array = $this->files->all();

		if (is_null($key))
		{
			return $array;
		}

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

		return $default;
	}
845088
public function get($key) {
        $filename = $key.'.cache';
        $file = $this->file_path_for_key($key);
        $ttl = $this->definition->get_ttl();
        $maxtime = 0;
        if ($ttl) {
            $maxtime = cache::now() - $ttl;
        }
        $readfile = false;
        if ($this->prescan && array_key_exists($filename, $this->keys)) {
            if ((!$ttl || $this->keys[$filename] >= $maxtime) && file_exists($file)) {
                $readfile = true;
            } else {
                $this->delete($key);
            }
        } else if (file_exists($file) && (!$ttl || filemtime($file) >= $maxtime)) {
            $readfile = true;
        }
        if (!$readfile) {
            return false;
        }
        // Open ensuring the file for reading in binary format.
        if (!$handle = fopen($file, 'rb')) {
            return false;
        }
        // Lock it up!
        // We don't care if this succeeds or not, on some systems it will, on some it won't, meah either way.
        flock($handle, LOCK_SH);
        $data = '';
        // Read the data in 1Mb chunks. Small caches will not loop more than once.  We don't use filesize as it may
        // be cached with a different value than what we need to read from the file.
        do {
            $data .= fread($handle, 1048576);
        } while (!feof($handle));
        // Unlock it.
        flock($handle, LOCK_UN);
        // Return it unserialised.
        return $this->prep_data_after_read($data);
    }
788658
public function get($key)
    {
        $value = $this->memcached->get($key);

        return is_array($value) ? $value[0] : $value;
    }
1291233
public function getKey(string $key)
    {
        $keys = explode('.', $key);
        $file = array_shift($keys);
        $keys = explode('/', implode('.', $keys));

        if (!isset($this->translations[$file])) {
            $this->addFile($file);
        }

        return $this->findKey($file, $keys);
    }
692182
public function getArray($key = null) {
        if (!is_null($key)) {
            return $this->getDeepValue($key);
        } else {
            return $this->_data;
        }
    }
1046604
public function get($key) {
		$fileName = $this->getFileName($key);
		
		if (file_exists($fileName)) {
			if (time() > filemtime($fileName)) {
				$this->delete($key, 0);
				return false;
			} else {
				$data = file_get_contents($fileName);
				return unserialize($data);
			}
		} else {
			return false;
		}
	}
997641
public function get($key)
	{
		if ($value = $this->memcache->get($this->prefix.$key)) {
		    return $value;
		}
	}
1141565
public function get($key=null)
    {

      if ($key == null) {
        return json_decode(file_get_contents(self::$credentials_opts['path']));
      }

      return $this->getVal($key);
    }
1008553
public function getFile($key)
    {
        $key = str_replace($this->illegalChars, '_', $this->namespace . $key);
        return $this->dir . '/' . $key . '.' . $this->ext;
    }
545614
public function get($key)
    {
        $filename = $this->cacheDir . DIRECTORY_SEPARATOR . $this->processKey($key);

        if (is_file($filename) && is_readable($filename)) {
            if (@filemtime($filename) < (time() - $this->ttl)) {
                return null;
            } else {
                return unserialize($this->safelyReadData($filename));
            }
        }

        return null;
    }
293120
public function get($key)
    {
        $path = $this->filename($key);
        $file = @fopen($path, 'r');
        if (!$file) {
            return false;
        }
        $timestamp = fgets($file, 11);
        fclose($file);
        if ($timestamp > time() || $timestamp == "00000000000") {
            return substr(file_get_contents($path), 11);
        }
        return false;
    }
249237
public function get($key)
    {
        $filePath = $this->getFilePathFromKey($key);

        if (!file_exists($filePath)) {
            return false;
        }

        if (!is_readable($filePath)) {
            return false;
        }

        $cacheFileData = file_get_contents($filePath);

        if ($this->config['gzipCompression']) {
            $cacheFileData = gzuncompress($cacheFileData);
        }

        $cacheObj = json_decode($cacheFileData);

        // Unable to decode JSON (could happen if compression was turned off while compressed caches still exist)
        if ($cacheObj === null) {
            return false;
        }

        if (!function_exists('sys_getloadavg')) {
            throw new Exception('Your PHP installation does not support `sys_getloadavg` (Windows?). Please set `unixLoadUpperThreshold` to `-1` in your RWFileCache config.');
        }

        if ($this->config['unixLoadUpperThreshold'] == -1) {
            $unixLoad = [0 => PHP_INT_MAX, 1 => PHP_INT_MAX, 2 => PHP_INT_MAX];
        } else {
            $unixLoad = sys_getloadavg();
        }

        if ($cacheObj->expiryTimestamp > time() || $unixLoad[0] >= $this->config['unixLoadUpperThreshold']) {
            // Cache item has not yet expired or system load is too high
            $content = $cacheObj->content;

            if (($unserializedContent = @unserialize($content)) !== false) {
                // Normal unserialization
                $content = $unserializedContent;
            } elseif ($content == serialize(false)) {
                // Edge case to handle boolean false being stored
                $content = false;
            }

            return $content;
        } else {
            // Cache item has expired
            return false;
        }
    }
1079768
public function get($key)
	{
		$file = $this->path($key);

		if (!file_exists($file))
		{
			return null;
		}

		$data = @unserialize(file_get_contents($file));

		if (!$data)
		{
			throw new RuntimeException('Cache file is invalid.');
		}

		if ($this->isDataExpired($data))
		{
			$this->forget($key);
			return null;
		}

		return $data['value'];
	}
36141
public static function getFileSynLock($key) {

        if ( !isset(self::$_FILELOCK_POOL[$key])  ) {
            self::$_FILELOCK_POOL[$key] = new FileSynLock($key);
        }
        return self::$_FILELOCK_POOL[$key];
    }
1149207
public function get($key)
    {
        $storageValue = null;
        if (true === array_key_exists($key, $this->storage)) {
            $storageValue = $this->storage[$key];
        }
        return $storageValue;
    }
291491
protected function removeFile($key)
    {
        $fileKey = $this->getFileKey($key);
        $storage = $this->getStorage($fileKey->getStorageName());
        
        return $storage->getFilesystem()->delete($this->getStoragePath($storage, $fileKey));
    }