Ho aggiornato il contenuto della pagina il 21 Settembre 2026
Quando si sviluppa un tema, un plugin o una funzionalità personalizzata in WordPress, capita spesso di dover passare una o più variabili da una pagina all’altra oppure da un template a un altro.
Un ID, il codice di un cliente, il valore selezionato in un form, il titolo di un articolo o un parametro necessario a costruire una determinata visualizzazione: apparentemente il problema è sempre lo stesso, ma in realtà WordPress mette a disposizione soluzioni differenti a seconda del contesto.
La prima distinzione da fare è fondamentale:
passare una variabile tra due file PHP durante la stessa richiesta non è la stessa cosa che passare una variabile da una pagina WordPress a un’altra.
Nel secondo caso viene effettuata una nuova richiesta HTTP e la variabile PHP originale non esiste più.
Vediamo quindi i sistemi principali e quando utilizzarli.
Passare una variabile attraverso l’URL con GET
Il sistema più semplice consiste nell’aggiungere uno o più parametri all’URL.
Ad esempio:
https://www.esempio.it/dettaglio-cliente/?cliente=125
In PHP potremmo costruire manualmente questo indirizzo, ma in WordPress è preferibile utilizzare add_query_arg().
<?php
$pagina_destinazione = 250;
$cliente_id = 125;
$url = add_query_arg(
array(
'cliente' => $cliente_id,
),
get_permalink( $pagina_destinazione )
);
echo '<a href="' . esc_url( $url ) . '">Visualizza cliente</a>';
add_query_arg() permette di aggiungere parametri a un URL senza dover concatenare manualmente ?, & e valori. L’URL prodotto dalla funzione non viene automaticamente escapato, quindi quando viene mostrato nell’HTML è opportuno utilizzare esc_url().
Nella pagina di destinazione possiamo recuperare il parametro:
<?php
$cliente_id = isset( $_GET['cliente'] )
? absint( $_GET['cliente'] )
: 0;
if ( $cliente_id ) {
echo 'Cliente richiesto: ' . esc_html( $cliente_id );
}
absint() è particolarmente utile quando sappiamo che il parametro deve essere un numero intero positivo, ad esempio l’ID di un post, un prodotto o un cliente.
Passare più variabili nell’URL
Possiamo naturalmente utilizzare più parametri:
<?php
$url = add_query_arg(
array(
'cliente' => 125,
'provenienza' => 'area-clienti',
'azione' => 'modifica',
),
get_permalink( 250 )
);
echo '<a href="' . esc_url( $url ) . '">Apri cliente</a>';
L’URL risultante sarà simile a:
/dettaglio-cliente/?cliente=125&provenienza=area-clienti&azione=modifica
Nella destinazione:
<?php
$cliente_id = isset( $_GET['cliente'] )
? absint( $_GET['cliente'] )
: 0;
$provenienza = isset( $_GET['provenienza'] )
? sanitize_key( wp_unslash( $_GET['provenienza'] ) )
: '';
$azione = isset( $_GET['azione'] )
? sanitize_key( wp_unslash( $_GET['azione'] ) )
: '';
Il principio importante è semplice:
qualsiasi valore proveniente dall’utente deve essere considerato non affidabile e validato o sanitizzato prima dell’utilizzo.
Passare variabili con POST
GET è perfetto quando il parametro può comparire nell’URL.
Quando invece stiamo inviando i dati di un form possiamo utilizzare POST.
Ad esempio:
<form method="post" action="<?php echo esc_url( get_permalink( 250 ) ); ?>">
<label for="nome_cliente">
Nome cliente
</label>
<input
type="text"
id="nome_cliente"
name="nome_cliente"
value=""
>
<?php
wp_nonce_field(
'fb_invia_cliente',
'fb_cliente_nonce'
);
?>
<button type="submit">
Continua
</button>
</form>
Nella pagina che riceve i dati:
<?php
if ( 'POST' === $_SERVER['REQUEST_METHOD'] ) {
if (
! isset( $_POST['fb_cliente_nonce'] ) ||
! wp_verify_nonce(
sanitize_text_field(
wp_unslash( $_POST['fb_cliente_nonce'] )
),
'fb_invia_cliente'
)
) {
wp_die( 'Richiesta non valida.' );
}
$nome_cliente = isset( $_POST['nome_cliente'] )
? sanitize_text_field(
wp_unslash( $_POST['nome_cliente'] )
)
: '';
echo esc_html( $nome_cliente );
}
Per i form WordPress è buona pratica utilizzare i nonce, ad esempio attraverso wp_nonce_field() e wp_verify_nonce(), per verificare la provenienza della richiesta e ridurre il rischio di richieste CSRF. Un nonce, però, non sostituisce il controllo dei permessi: se l’operazione è riservata a determinati utenti bisogna verificare anche le relative capability.
GET o POST: quale utilizzare?
Dipende dal dato.
Utilizzerei GET per parametri come:
- ID di un elemento;
- filtro;
- ordinamento;
- pagina di provenienza;
- termine di ricerca;
- categoria selezionata.
Utilizzerei POST quando sto inviando:
- un modulo;
- dati che devono essere elaborati;
- valori che non è necessario mostrare nell’URL;
- richieste che comportano operazioni sul sistema.
Una cosa importante: utilizzare POST non significa automaticamente rendere un dato “sicuro”. Anche i valori contenuti in $_POST devono essere controllati.
Utilizzare le Query Variables di WordPress
WordPress possiede un proprio sistema di query variables.
Possiamo recuperare quelle riconosciute da WordPress attraverso:
<?php
$pagina = get_query_var( 'paged', 1 );
Per creare una query variable personalizzata dobbiamo prima comunicarla a WordPress.
Nel functions.php del tema, oppure meglio ancora nel plugin che contiene la funzionalità:
<?php
function fb_custom_query_vars( $vars ) {
$vars[] = 'cliente';
return $vars;
}
add_filter(
'query_vars',
'fb_custom_query_vars'
);
A questo punto possiamo recuperare il valore:
<?php
$cliente_id = absint(
get_query_var( 'cliente' )
);
Questo passaggio è importante perché get_query_var() recupera soltanto le query variables pubbliche riconosciute da WP_Query; una variabile personalizzata deve quindi essere registrata tramite il filtro query_vars.
Questa soluzione diventa particolarmente interessante quando stiamo sviluppando:
- URL personalizzati;
- rewrite rules;
- template dinamici;
- plugin;
- sistemi di ricerca;
- filtri;
- applicazioni costruite sopra WordPress.
Passare una variabile a un template WordPress
Esiste poi una situazione completamente differente.
Non dobbiamo passare il dato a una nuova pagina HTTP, ma semplicemente a un altro file del tema durante la stessa esecuzione PHP.
Da WordPress 5.5 get_template_part() permette di passare direttamente un array di argomenti al template.
Ad esempio:
<?php
$cliente = array(
'id' => 125,
'nome' => 'Mario Rossi',
);
get_template_part(
'template-parts/scheda',
'cliente',
array(
'cliente' => $cliente,
'titolo' => 'Scheda cliente',
)
);
Avremo quindi il file:
template-parts/scheda-cliente.php
All’interno possiamo utilizzare $args:
<?php
$cliente = isset( $args['cliente'] )
? $args['cliente']
: array();
$titolo = isset( $args['titolo'] )
? $args['titolo']
: '';
?>
<h2>
<?php echo esc_html( $titolo ); ?>
</h2>
<?php if ( ! empty( $cliente['nome'] ) ) : ?>
<p>
Cliente:
<strong>
<?php echo esc_html( $cliente['nome'] ); ?>
</strong>
</p>
<?php endif; ?>
Per i temi WordPress moderni questa è generalmente la soluzione che preferisco quando devo trasferire dati a un template-part.
È chiara, leggibile e soprattutto rende immediatamente visibile quali dati stiamo passando al componente.
Utilizzare set_query_var() tra template
Esiste anche un altro metodo storico molto utilizzato nei temi WordPress:
<?php
set_query_var(
'cliente_corrente',
$cliente
);
get_template_part(
'template-parts/scheda',
'cliente'
);
Nel template:
<?php
$cliente = get_query_var(
'cliente_corrente'
);
set_query_var() imposta un valore all’interno delle query variables di WP_Query.
Il metodo continua a essere utilizzabile, ma se dobbiamo semplicemente passare dati a get_template_part(), nelle versioni moderne di WordPress preferisco l’argomento $args della funzione perché rende il codice più esplicito.
Recuperare i dati del post corrente con get_post()
Molto spesso non dobbiamo realmente “passare” una variabile.
L’informazione che ci serve è già contenuta nel post o nella pagina WordPress corrente.
In questo caso entra in gioco:
get_post()
Ad esempio:
<?php
$post = get_post();
if ( $post instanceof WP_Post ) {
echo '<h2>';
echo esc_html( $post->post_title );
echo '</h2>';
}
Possiamo anche indicare direttamente un ID:
<?php
$post_id = 125;
$post = get_post( $post_id );
if ( $post instanceof WP_Post ) {
echo esc_html(
$post->post_title
);
}
get_post() restituisce normalmente un oggetto della classe WP_Post; in alternativa può restituire il post come array associativo o numerico specificando il parametro $output.
Principali variabili disponibili nell’oggetto WP_Post
L’oggetto WP_Post contiene numerose proprietà.
Tra quelle maggiormente utilizzate troviamo:
$post->ID;
$post->post_author;
$post->post_date;
$post->post_content;
$post->post_title;
$post->post_excerpt;
$post->post_status;
$post->post_name;
$post->post_modified;
$post->post_parent;
$post->post_type;
$post->post_mime_type;
$post->comment_count;
Possiamo quindi fare:
<?php
$post = get_post( 125 );
if ( $post ) {
echo esc_html(
$post->post_title
);
echo esc_html(
$post->post_date
);
}
Se invece ci serve un singolo campo possiamo utilizzare anche get_post_field():
<?php
$titolo = get_post_field(
'post_title',
125
);
echo esc_html( $titolo );
WordPress permette con get_post_field() di recuperare direttamente proprietà come post_type, post_status, post_content e altri campi dell’oggetto post.
Recuperare una variabile salvata nei Custom Fields
Quando il valore appartiene a un determinato post, pagina o custom post type, spesso la soluzione migliore non è passarlo nell’URL.
Possiamo salvarlo nei post meta.
Ad esempio:
<?php
update_post_meta(
$post_id,
'_codice_cliente',
'ABC125'
);
E recuperarlo in qualsiasi altra parte del sito:
<?php
$codice_cliente = get_post_meta(
$post_id,
'_codice_cliente',
true
);
echo esc_html(
$codice_cliente
);
get_post_meta() permette di recuperare i metadati associati a uno specifico post, mentre update_post_meta() aggiorna il valore oppure lo crea se non esiste.
È una soluzione ideale per dati come:
- codice prodotto;
- riferimento cliente;
- prezzo personalizzato;
- identificativo esterno;
- stato di lavorazione;
- informazioni aggiuntive di una pagina;
- dati utilizzati da un plugin.
Variabili globali del sito: quando usare le Options
Se il dato non appartiene a un singolo post ma all’intero sito, WordPress offre invece le Options API.
Possiamo salvare:
<?php
update_option(
'fb_codice_azienda',
'AZIENDA001'
);
e recuperare:
<?php
$codice = get_option(
'fb_codice_azienda'
);
Le options sono adatte a impostazioni globali e configurazioni, non per trasferire continuamente dati temporanei tra utenti e pagine. get_option() e update_option() sono infatti le funzioni WordPress dedicate alla lettura e modifica delle opzioni del sito.
Quale metodo utilizzare?
Possiamo riassumere così.
Parametro che può essere presente nell’URL
Usa:
add_query_arg()
$_GET
Dati provenienti da un modulo
Usa:
$_POST
insieme a sanitizzazione e, quando appropriato:
wp_nonce_field()
wp_verify_nonce()
Query personalizzata gestita da WordPress
Usa:
get_query_var()
registrando prima la variabile tramite:
query_vars
Variabile da passare a un template-part
Preferibilmente:
get_template_part(
$slug,
$name,
$args
);
Informazioni appartenenti a un post
Usa:
get_post()
get_post_field()
get_post_meta()
Impostazione globale del sito
Usa:
get_option()
update_option()
Attenzione alla sicurezza delle variabili
Uno degli errori più frequenti nello sviluppo WordPress è utilizzare direttamente ciò che arriva da GET o POST.
Da evitare:
<?php
echo $_GET['nome'];
Meglio:
<?php
$nome = isset( $_GET['nome'] )
? sanitize_text_field(
wp_unslash( $_GET['nome'] )
)
: '';
echo esc_html( $nome );
Sanitizzazione ed escaping svolgono due compiti differenti.
La sanitizzazione cerca di rendere il dato appropriato per l’utilizzo previsto.
L’escaping viene effettuato quando il valore viene mostrato nell’output.
Per questo in WordPress troviamo funzioni differenti come:
sanitize_text_field()
sanitize_key()
absint()
esc_html()
esc_attr()
esc_url()
Se invece il form provoca una modifica dei dati, oltre al nonce bisogna verificare anche che l’utente abbia realmente il permesso di effettuare quell’operazione.
Un esempio completo: passare l’ID di un post a un’altra pagina
Immaginiamo di avere un elenco di articoli e voler aprire una pagina WordPress personalizzata che mostri alcune informazioni sul post selezionato.
Nel primo template:
<?php
$post_id = get_the_ID();
$url = add_query_arg(
'post_id',
$post_id,
get_permalink( 250 )
);
?>
<a href="<?php echo esc_url( $url ); ?>">
Visualizza dettagli
</a>
Nella pagina con ID 250:
<?php
$post_id = isset( $_GET['post_id'] )
? absint( $_GET['post_id'] )
: 0;
if ( ! $post_id ) {
return;
}
$post_selezionato = get_post(
$post_id
);
if ( ! $post_selezionato ) {
echo '<p>Elemento non trovato.</p>';
return;
}
?>
<h2>
<?php
echo esc_html(
$post_selezionato->post_title
);
?>
</h2>
<p>
Pubblicato:
<?php
echo esc_html(
$post_selezionato->post_date
);
?>
</p>
<p>
Tipo:
<?php
echo esc_html(
$post_selezionato->post_type
);
?>
</p>
In poche righe abbiamo quindi:
- recuperato l’ID del post;
- creato dinamicamente l’URL della seconda pagina;
- passato l’ID tramite GET;
- verificato che fosse un intero;
- recuperato il relativo
WP_Post; - utilizzato le sue proprietà.
Evitare le variabili globali quando non servono
Tecnicamente PHP permette di utilizzare:
global $mia_variabile;
ma non dovrebbe diventare la soluzione predefinita per trasferire qualsiasi dato all’interno di WordPress.
Le variabili globali rendono più difficile capire:
- chi modifica il dato;
- da dove arriva;
- quando viene valorizzato;
- quale parte del codice ne dipende.
Quando possibile preferisco passare esplicitamente i dati alle funzioni e ai template.
Il codice diventa più semplice da leggere, testare e mantenere.
Conclusione: passare variabili in WordPress nel modo corretto
Non esiste un solo sistema per passare variabili tra pagine WordPress.
La soluzione corretta dipende dalla durata e dalla natura del dato.
Per valori che devono viaggiare da una pagina all’altra possiamo utilizzare GET o POST; per l’integrazione con il sistema di routing di WordPress possiamo utilizzare le query variables; per i template moderni possiamo passare direttamente un array a get_template_part(); per dati persistenti possiamo utilizzare post meta e Options API.
E spesso non occorre passare nulla: se conosciamo l’ID del contenuto, get_post() ci permette già di recuperare le informazioni che WordPress conserva nel proprio database.
La parte importante non è quindi soltanto riuscire a far arrivare una variabile da un punto A a un punto B.
È scegliere il metodo più semplice, sicuro e coerente con l’architettura di WordPress.
Note sulla modalità di scrittura del post
Questo articolo è stato scritto senza alcun aiuto dai sistemi di intelligenza artificiale, quali OpenAI, ChatGPT e simili.