Recherche…


Syntaxe

  • Chaque flux a un schéma et une cible:
  • <scheme>: // <target>

Paramètres

Le nom du paramètre La description
Ressource de flux Le fournisseur de données constitué de la syntaxe <scheme>://<target>

Remarques

Les flux sont essentiellement un transfert de données entre une origine et une destination, pour paraphraser Josh Lockhart dans son livre Modern PHP.

L'origine et la destination peuvent être

  • un fichier
  • un processus de ligne de commande
  • une connexion réseau
  • une archive ZIP ou TAR
  • mémoire temporaire
  • entrée / sortie standard

ou toute autre ressource disponible via les gestionnaires de flux PHP .

Exemples d'encapsuleurs de flux disponibles ( schemes ):

  • file: // - Accès au système de fichiers local
  • http: // - Accès aux URL HTTP (s)
  • ftp: // - Accès aux URL FTP (s)
  • php: // - Accéder aux différents flux d'E / S
  • phar: // - Archive PHP
  • ssh2: // - Secure Shell 2
  • ogg: // - Flux audio

Le schéma (origine) est l'identifiant de l'enveloppe du flux. Par exemple, pour le système de fichiers, c'est file:// . La cible est la source de données du flux, par exemple le nom du fichier.

Enregistrement d'un wrapper de flux

Un wrapper de flux fournit un gestionnaire pour un ou plusieurs schémas spécifiques.

L'exemple ci-dessous montre un simple wrapper de flux qui envoie des requêtes HTTP PATCH lorsque le flux est fermé.

// 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);
    }
}

Cet exemple ne montre que quelques exemples de ce que contiendrait un wrapper de flux générique. Ce ne sont pas toutes les méthodes disponibles. Une liste complète des méthodes pouvant être implémentées peut être trouvée sur http://php.net/streamWrapper .



Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow