Descrizione

Ottieni oggetto richiesta

webman inietterà automaticamente l'oggetto richiesta nel primo parametro del metodo action, ad esempio

Esempio

<?php
namespace app\controller;

use support\Request;

class UserController
{
    public function hello(Request $request)
    {
        $default_name = 'webman';
        // Ottieni il parametro name dalla richiesta get, se non viene passato il parametro name restituisci $default_name
        $name = $request->get('name', $default_name);
        // Restituisci una stringa al browser
        return response('hello ' . $name);
    }
}

Attraverso l'oggetto $request possiamo ottenere qualsiasi dato relativo alla richiesta.

A volte vogliamo ottenere l'oggetto $request corrente in altre classi, in questo caso possiamo semplicemente usare la funzione helper request();

Ottieni parametri di richiesta get

Ottieni l'intero array get

$request->get();

Se non ci sono parametri get nella richiesta, restituisce un array vuoto.

Ottieni un valore specifico dall'array get

$request->get('name');

Se l'array get non contiene questo valore, restituisce null.

Puoi anche passare un valore di default come secondo parametro al metodo get; se il valore corrispondente non viene trovato nell'array get, verrà restituito il valore di default. Ad esempio:

$request->get('name', 'tom');

Ottieni parametri di richiesta post

Ottieni l'intero array post

$request->post();

Se non ci sono parametri post nella richiesta, restituisce un array vuoto.

Ottieni un valore specifico dall'array post

$request->post('name');

Se l'array post non contiene questo valore, restituisce null.

Come per il metodo get, puoi anche passare un valore di default come secondo parametro al metodo post; se non viene trovata la corrispondenza nell'array post, verrà restituito il valore di default. Ad esempio:

$request->post('name', 'tom');

Funzione helper input()

Simile alla funzione $request->input(), può ottenere tutti i parametri, la funzione helper input() ha due parametri:

  1. name: nome del parametro da ottenere (se vuoto, ottiene un array di tutti i parametri)
  2. default: valore di default (se il primo parametro fallisce, verrà utilizzato il valore di questo parametro)

Ad esempio

// Ottieni il parametro name
$name = input('name');
// Ottieni il parametro name, se non esiste usa il valore di default
$name = input('name','张三');
// Ottieni tutti i parametri
$all_params = input();

Ottieni il corpo della richiesta post originale

$post = $request->rawBody();

Questa funzionalità è simile all'operazione file_get_contents("php://input"); in php-fpm. Viene utilizzata per ottenere il corpo della richiesta http originale. Questo è utile per ottenere dati della richiesta post in formato non application/x-www-form-urlencoded.

Ottieni header

Ottieni l'intero array header

$request->header();

Se non ci sono parametri header nella richiesta, restituisce un array vuoto. Nota che tutte le chiavi sono in minuscolo.

Ottieni un valore specifico dall'array header

$request->header('host');

Se l'array header non contiene questo valore, restituisce null. Nota che tutte le chiavi sono in minuscolo.

Come per il metodo get, puoi anche passare un valore di default come secondo parametro al metodo header; se non viene trovata la corrispondenza nell'array header, verrà restituito il valore di default. Ad esempio:

$request->header('host', 'localhost');

Ottieni cookie

Ottieni l'intero array cookie

$request->cookie();

Se non ci sono parametri cookie nella richiesta, restituisce un array vuoto.

Ottieni un valore specifico dall'array cookie

$request->cookie('name');

Se l'array cookie non contiene questo valore, restituisce null.

Come per il metodo get, puoi anche passare un valore di default come secondo parametro al metodo cookie; se non viene trovata la corrispondenza nell'array cookie, verrà restituito il valore di default. Ad esempio:

$request->cookie('name', 'tom');

Ottieni tutti gli input

Include una raccolta di post e get.

$request->all();

Ottieni un valore di input specifico

Ottieni un valore dalla raccolta di post e get.

$request->input('name', $default_value);

Ottieni parziale input

Ottieni parti dei dati dalla raccolta di post e get.

// Ottieni un array composto da username e password, se le chiavi corrispondenti non ci sono verranno ignorate
$only = $request->only(['username', 'password']);
// Ottieni tutti gli input tranne avatar e age
$except = $request->except(['avatar', 'age']);

Ottieni input tramite parametri del controller

<?php
namespace app\controller;
use support\Response;

class UserController
{
    public function create(string $name, int $age = 18): Response
    {
        return json(['name' => $name, 'age' => $age]);
    }
}

La logica del codice è simile a

<?php
namespace app\controller;
use support\Request;
use support\Response;

class UserController
{
    public function create(Request $request): Response
    {
        $name = $request->input('name');
        $age = (int)$request->input('age', 18);
        return json(['name' => $name, 'age' => $age]);
    }
}

Per ulteriori informazioni, consultare Binding dei parametri del controller

Ottieni file caricati

Suggerimento
I file caricati devono utilizzare il formato di modulo multipart/form-data

Ottieni l'intero array di file caricati

$request->file();

Il modulo è simile a:

<form method="post" action="http://127.0.0.1:8787/upload/files" enctype="multipart/form-data" />
<input name="file1" multiple="multiple" type="file">
<input name="file2" multiple="multiple" type="file">
<input type="submit">
</form>

Il formato restituito da $request->file() è simile a:

array (
    'file1' => object(webman\Http\UploadFile),
    'file2' => object(webman\Http\UploadFile)
)

È un array di istanze di webman\Http\UploadFile. La classe webman\Http\UploadFile estende la classe PHP incorporata SplFileInfo e fornisce alcuni metodi utili.

<?php
namespace app\controller;

use support\Request;

class UploadController
{
    public function files(Request $request)
    {
        foreach ($request->file() as $key => $spl_file) {
            var_export($spl_file->isValid()); // File è valido, ad esempio true | false
            var_export($spl_file->getUploadExtension()); // Estensione del file caricato, ad esempio 'jpg'
            var_export($spl_file->getUploadMimeType()); // Tipo mime del file caricato, ad esempio 'image/jpeg'
            var_export($spl_file->getUploadErrorCode()); // Ottieni il codice di errore del caricamento, ad esempio UPLOAD_ERR_NO_TMP_DIR UPLOAD_ERR_NO_FILE UPLOAD_ERR_CANT_WRITE
            var_export($spl_file->getUploadName()); // Nome del file caricato, ad esempio 'my-test.jpg'
            var_export($spl_file->getSize()); // Ottieni la dimensione del file, ad esempio 13364, unità in byte
            var_export($spl_file->getPath()); // Ottieni la directory di caricamento, ad esempio '/tmp'
            var_export($spl_file->getRealPath()); // Ottieni il percorso del file temporaneo, ad esempio `/tmp/workerman.upload.SRliMu`
        }
        return response('ok');
    }
}

Nota:

  • I file caricati verranno nominati come file temporanei, simili a /tmp/workerman.upload.SRliMu
  • La dimensione dei file caricati è limitata dalla defaultMaxPackageSize, con un valore predefinito di 10M, modificabile nel file config/server.php impostando max_package_size.
  • Dopo la fine della richiesta, i file temporanei verranno automaticamente rimossi.
  • Se non ci sono file caricati nella richiesta, $request->file() restituirà un array vuoto.
  • I file caricati non supportano il metodo move_uploaded_file(), si prega di utilizzare il metodo $file->move() al suo posto, vedere l'esempio seguente.

Ottieni file caricati specifici

$request->file('avatar');

Se il file esiste, verrà restituita l'istanza webman\Http\UploadFile del file corrispondente, altrimenti restituirà null.

Esempio

<?php
namespace app\controller;

use support\Request;

class UploadController
{
    public function file(Request $request)
    {
        $file = $request->file('avatar');
        if ($file && $file->isValid()) {
            $file->move(public_path().'/files/myfile.'.$file->getUploadExtension());
            return json(['code' => 0, 'msg' => 'caricamento riuscito']);
        }
        return json(['code' => 1, 'msg' => 'file non trovato']);
    }
}

Ottieni host

Ottieni le informazioni host della richiesta.

$request->host();

Se l'indirizzo della richiesta non è sulla porta standard 80 o 443, le informazioni host potrebbero includere la porta, ad esempio example.com:8080. Se non è necessaria la porta, il primo parametro può essere impostato su true.

$request->host(true);

Ottieni metodo di richiesta

$request->method();

Il valore restituito potrebbe essere uno di GET, POST, PUT, DELETE, OPTIONS, HEAD.

Ottieni uri di richiesta

$request->uri();

Restituisce l'uri della richiesta, inclusa la parte path e queryString.

Ottieni percorso di richiesta

$request->path();

Restituisce la parte path della richiesta.

Ottieni queryString di richiesta

$request->queryString();

Restituisce la parte queryString della richiesta.

Ottieni url di richiesta

Il metodo url() restituisce l'URL senza i parametri Query.

$request->url();

Restituisce qualcosa di simile a //www.workerman.net/workerman-chat

Il metodo fullUrl() restituisce l'URL con i parametri Query.

$request->fullUrl();

Restituisce qualcosa di simile a //www.workerman.net/workerman-chat?type=download

Nota
url() e fullUrl() non restituiscono la parte del protocollo (non restituiscono http o https).
Questo perché gli indirizzi che iniziano con //example.com nel browser verranno automaticamente riconosciuti dal protocollo attuale del sito, avviando automaticamente una richiesta in http o https.

Se hai utilizzato il proxy nginx, aggiungi proxy_set_header X-Forwarded-Proto $scheme; alla configurazione di nginx, vedi proxy nginx,
in questo modo puoi utilizzare $request->header('x-forwarded-proto'); per determinare se è http o https, ad esempio:

echo $request->header('x-forwarded-proto'); // Restituisce http o https

Ottieni versione HTTP della richiesta

$request->protocolVersion();

Restituisce la stringa 1.1 o 1.0.

Ottieni sessionId della richiesta

$request->sessionId();

Restituisce una stringa composta da lettere e numeri

Ottieni IP del client della richiesta

$request->getRemoteIp();

Ottieni porta del client della richiesta

$request->getRemotePort();

Ottieni vero IP del client della richiesta

$request->getRealIp($safe_mode=true);

Quando il progetto utilizza un proxy (ad esempio nginx), il valore fornito da $request->getRemoteIp() è spesso l'IP del server proxy (simile a 127.0.0.1 192.168.x.x), anziché il vero IP del client. In questo caso, puoi tentare di utilizzare $request->getRealIp() per ottenere il vero IP del client.

Il metodo $request->getRealIp() cercherà di ottenere il vero IP dai campi x-forwarded-for, x-real-ip, client-ip, x-client-ip, via nell'header HTTP.

Poiché gli header HTTP possono essere facilmente falsificati, quindi l'IP del client ottenuto in questo modo non è al 100% affidabile, specialmente quando $safe_mode è false. Un modo più affidabile per ottenere il vero IP del client tramite proxy è conoscere l'IP del server proxy sicuro e sapere esplicitamente quale header HTTP trasporta il vero IP; se l'IP restituito da $request->getRemoteIp() è confermato come il server proxy noto e sicuro, quindi ottenere il vero IP con $request->header('header HTTP che trasporta il vero IP').

Ottieni IP del server

$request->getLocalIp();

Ottieni porta del server

$request->getLocalPort();

Verifica se è una richiesta ajax

$request->isAjax();

Verifica se è una richiesta pjax

$request->isPjax();

Verifica se si aspetta un ritorno json

$request->expectsJson();

Verifica se il client accetta un ritorno json

$request->acceptJson();

Ottieni il nome del plugin della richiesta

Una richiesta non proveniente da un plugin restituisce una stringa vuota ''.

$request->plugin;

Ottieni il nome dell'applicazione della richiesta

In caso di singola applicazione restituisce sempre una stringa vuota '', mentre in caso di più applicazioni restituirà il nome dell'applicazione.

$request->app;

Poiché le funzioni di chiusura non appartengono a nessuna applicazione, le richieste provenienti da una route di chiusura restituiscono sempre una stringa vuota ''
Per ulteriori informazioni sulle route di chiusura vedere Route

Ottieni il nome della classe del controller della richiesta

Ottieni il nome corrispondente alla classe del controller.

$request->controller;

Restituisce qualcosa di simile a app\controller\IndexController

Poiché le funzioni di chiusura non appartengono a nessun controller, le richieste provenienti da una route di chiusura restituiscono sempre una stringa vuota ''
Per ulteriori informazioni sulle route di chiusura vedere Route

Ottieni il nome del metodo della richiesta

Ottieni il nome del metodo del controller corrispondente alla richiesta.

$request->action;

Restituisce qualcosa di simile a index

Poiché le funzioni di chiusura non appartengono a nessun controller, le richieste provenienti da una route di chiusura restituiscono sempre una stringa vuota ''
Per ulteriori informazioni sulle route di chiusura vedere Route

Riscrivi i parametri

A volte vogliamo riscrivere i parametri della richiesta, ad esempio filtrando la richiesta e poi ri-assegnando valori all'oggetto richiesta. In questo caso possiamo utilizzare i metodi setGet(), setPost(), setHeader().

Riscrivi i parametri GET

$request->get(); // Supponiamo di ottenere ['name' => 'tom', 'age' => 18]
$request->setGet(['name' => 'tom']);
$request->get(); // Otteniamo infine ['name' => 'tom']

Nota
Come mostrato nell'esempio, setGet() riscrive tutti i parametri GET, setPost() e setHeader() hanno un comportamento simile.

Riscrivi i parametri POST

$post = $request->post();
foreach ($post as $key => $value) {
    $post[$key] = htmlspecialchars($value);
}
$request->setPost($post);
$request->post(); // Ottiene i parametri post filtrati

Riscrivi i parametri HEADER

$request->setHeader(['host' => 'example.com']);
$request->header('host'); // Restituisce example.com