Ricerca…


Sintassi

  • Ogni stream ha uno schema e un obiettivo:
  • <Schema>: // <target>

Parametri

Nome del parametro Descrizione
Stream Resource Il fornitore di dati costituito dalla sintassi <scheme>://<target>

Osservazioni

Gli stream sono essenzialmente un trasferimento di dati tra un'origine e una destinazione, per parafrasare Josh Lockhart nel suo libro Modern PHP.

L'origine e la destinazione possono essere

  • un file
  • un processo da riga di comando
  • una connessione di rete
  • un archivio ZIP o TAR
  • memoria temporanea
  • input / output standard

o qualsiasi altra risorsa disponibile tramite i wrapper di flusso di PHP .

Esempi di wrapper di flusso disponibili ( schemes ):

  • file: // - Accesso al filesystem locale
  • http: // - Accesso agli URL HTTP (s)
  • ftp: // - Accesso agli URL FTP
  • php: // - Accesso a vari flussi I / O
  • phar: // - Archivio PHP
  • ssh2: // - Secure Shell 2
  • ogg: // - Stream audio

Lo schema (origine) è l'identificatore del wrapper del flusso. Ad esempio, per il file system questo è il file:// . La destinazione è l'origine dati del flusso, ad esempio il nome del file.

Registrazione di un wrapper di flusso

Un wrapper stream fornisce un gestore per uno o più schemi specifici.

L'esempio seguente mostra un semplice wrapper di flusso che invia richieste HTTP PATCH quando lo stream viene chiuso.

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

Questo esempio mostra solo alcuni esempi di ciò che un wrapper di flusso generico conterrebbe. Questi non sono tutti i metodi disponibili. Un elenco completo di metodi che possono essere implementati può essere trovato su http://php.net/streamWrapper .



Modified text is an extract of the original Stack Overflow Documentation
Autorizzato sotto CC BY-SA 3.0
Non affiliato con Stack Overflow