PHP
Corrientes
Buscar..
Sintaxis
- Cada flujo tiene un esquema y un objetivo:
- <esquema>: // <objetivo>
Parámetros
| Nombre del parámetro | Descripción |
|---|---|
| Recurso de la corriente | El proveedor de datos que consiste en la sintaxis <scheme>://<target> |
Observaciones
Las transmisiones son esencialmente una transferencia de datos entre un origen y un destino, parafraseando a Josh Lockhart en su libro Modern PHP.
El origen y el destino pueden ser
- un archivo
- un proceso de línea de comando
- una conexión de red
- un archivo ZIP o TAR
- memoria temporal
- entrada / salida estándar
o cualquier otro recurso disponible a través de envolturas de flujo de PHP .
Ejemplos de envolturas de flujo disponibles ( schemes ):
- file: // - Accediendo al sistema de archivos local
- http: // - Accediendo a las URL de HTTP (s)
- ftp: // - Acceso a las URL de FTP (s)
- php: // - Accediendo a varias secuencias de E / S
- phar: // - PHP Archive
- ssh2: // - Secure Shell 2
- ogg: // - Transmisiones de audio
El esquema (origen) es el identificador de la envoltura del flujo. Por ejemplo, para el sistema de archivos, esto es file:// . El destino es el origen de datos del flujo, por ejemplo, el nombre del archivo.
Registro de una envoltura de flujo
Una envoltura de flujo proporciona un controlador para uno o más esquemas específicos.
El siguiente ejemplo muestra un contenedor de flujo simple que envía solicitudes HTTP PATCH cuando se cierra el flujo.
// register the FooWrapper class as a wrapper for foo:// URLs.
stream_wrapper_register("foo", FooWrapper::class, STREAM_IS_URL) or die("Duplicate stream wrapper registered");
class FooWrapper {
// this will be modified by PHP to show the context passed in the current call.
public $context;
// this is used in this example internally to store the URL
private $url;
// when fopen() with a protocol for this wrapper is called, this method can be implemented to store data like the host.
public function stream_open(string $path, string $mode, int $options, string &$openedPath) : bool {
$url = parse_url($path);
if($url === false) return false;
$this->url = $url["host"] . "/" . $url["path"];
return true;
}
// handles calls to fwrite() on this stream
public function stream_write(string $data) : int {
$this->buffer .= $data;
return strlen($data);
}
// handles calls to fclose() on this stream
public function stream_close() {
$curl = curl_init("http://" . $this->url);
curl_setopt($curl, CURLOPT_POSTFIELDS, $this->buffer);
curl_setopt($curl, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_exec($curl);
curl_close($curl);
$this->buffer = "";
}
// fallback exception handler if an unsupported operation is attempted.
// this is not necessary.
public function __call($name, $args) {
throw new \RuntimeException("This wrapper does not support $name");
}
// this is called when unlink("foo://something-else") is called.
public function unlink(string $path) {
$url = parse_url($path);
$curl = curl_init("http://" . $url["host"] . "/" . $url["path"]);
curl_setopt($curl, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_exec($curl);
curl_close($curl);
}
}
Este ejemplo solo muestra algunos ejemplos de lo que contendría un contenedor de flujo genérico. Estos no son todos los métodos disponibles. Puede encontrar una lista completa de los métodos que se pueden implementar en http://php.net/streamWrapper .
