PHP Paso de datos na URL

Sumario

1 Paso de datos pola URL
- 1.1 Exemplo básico
2 Pasando caracteres especiais na URL
3 Paso dun identificador para consultar datos
4 Paso de datos con Location
5 Exercicio proposto
- 5.1 Solución do exercicio proposto
6 Ideas importantes da unidade

Paso de datos pola URL

Unha forma de pasar información dunha páxina a outra é a través dunha URL.

Cando unha URL leva datos despois do carácter ?, estes datos forman a denominada cadea de consulta ou query string.

Por exemplo:

https://exemplo.test/buscar.php?q=php&idioma=gl

Os datos que aparecen despois do signo ? son parámetros:

q=php&idioma=gl

O formato xeral é:

parametro1=valor1&parametro2=valor2

Este mecanismo emprégase habitualmente co método HTTP GET.

Características importantes dos datos enviados pola URL:

Os valores son visibles na barra de enderezos do navegador.
A URL pode gardarse no historial, nos favoritos ou aparecer en rexistros do servidor.
O usuario pode modificar manualmente os parámetros.
Polo tanto, nunca debemos considerar fiables os datos recibidos mediante $_GET.
Non debemos empregar a URL para enviar contrasinais ou outros datos sensibles.
A lonxitude máxima dunha URL depende do navegador, do servidor web e doutros compoñentes intermedios, polo que é recomendable manter as URL razoablemente curtas.

Vantaxes:

Permite pasar datos dunha páxina a outra sen necesidade dun formulario.
As URL poden gardarse nos favoritos e compartirse.
Resulta apropiado para operacións de consulta ou navegación que non modifican o estado da aplicación.

En PHP os parámetros enviados na URL están dispoñibles no array superglobal $_GET.

Por exemplo, para unha URL:

detalle.php?pelicula=SUPERMAN

podemos obter o valor mediante:

$pelicula = $_GET['pelicula'] ?? '';

Empregamos o operador ?? para proporcionar un valor por defecto no caso de que o parámetro non exista.

Exemplo básico

Arquivo: UD3_paso_var_Ex1_eleccion_pelicula.php

 1 <!DOCTYPE html>
 2 <html lang="gl">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Elección dunha película</title>
 6 </head>
 7 <body>
 8 
 9 <p>
10     Mandamos un nome de película fixo na URL:
11     <a href="UD3_paso_var_Ex1_datos_pelicula.php?pelicula=SUPERMAN">PELÍCULA</a>
12 </p>
13 
14 </body>
15 </html>

Arquivo: UD3_paso_var_Ex1_datos_pelicula.php

 1 <?php
 2 $peliculaRecibida = $_GET['pelicula'] ?? '';
 3 
 4 if (!is_string($peliculaRecibida)) {
 5     $peliculaRecibida = '';
 6 }
 7 
 8 $pelicula = trim($peliculaRecibida);
 9 ?>
10 <!DOCTYPE html>
11 <html lang="gl">
12 <head>
13     <meta charset="UTF-8">
14     <title>Datos da película</title>
15 </head>
16 <body>
17 
18 <p>
19     A película pasada como parámetro na URL é:
20     <strong><?= htmlspecialchars(
21         $pelicula,
22         ENT_QUOTES | ENT_SUBSTITUTE,
23         'UTF-8'
24     ) ?></strong>
25 </p>
26 
27 </body>
28 </html>

Podedes comprobar que, se modificades o valor do parámetro pelicula na URL e cargades de novo a páxina, o novo valor chegará mediante $_GET.

IMPORTANTE: Que un valor apareza na URL non significa que sexa válido. O usuario pode modificalo libremente, polo que sempre debemos validar os datos antes de empregalos e escapar os datos cando os amosamos en HTML.

Pasando caracteres especiais na URL

Os valores dunha URL non se poden construír simplemente concatenando calquera cadea. Determinados caracteres, como os espazos ou caracteres reservados, deben codificarse.

Para codificar un valor individual podemos empregar a función urlencode.

Exemplo:

$pelicula = urlencode('E.T. El extraterrestre');

echo "<a href='detalle.php?pelicula=$pelicula'>PELÍCULA</a>";

Neste caso o espazo en branco codifícase como +.

Para realizar a operación inversa existe urldecode.

Normalmente non será necesario chamar manualmente a urldecode() para os parámetros recibidos mediante $_GET, xa que PHP xa realiza a decodificación da cadea de consulta.

Construíndo unha URL con http_build_query()

Cando temos varios parámetros é preferible non construír a cadea de consulta manualmente.

PHP dispón da función http_build_query(), que xera unha cadea de consulta correctamente codificada a partir dun array.

$parametros = [
    'pelicula' => 'E.T. El extraterrestre',
    'xenero' => 'Ciencia ficción'
];

$query = http_build_query(
    $parametros,
    '',
    '&',
    PHP_QUERY_RFC3986
);

$url = 'UD3_paso_var_Ex1_datos_pelicula.php?' . $query;

Co valor PHP_QUERY_RFC3986 os espazos codifícanse como %20.

Se a URL vai ser inserida posteriormente dentro de HTML, tamén debemos escapar o seu valor para o contexto HTML:

<a href="<?= htmlspecialchars(
    $url,
    ENT_QUOTES | ENT_SUBSTITUTE,
    'UTF-8'
) ?>">PELÍCULA</a>

Exemplo con espazos no nome da película

Arquivo: UD3_paso_var_Ex1_eleccion_pelicula.php

 1 <?php
 2 $parametros = [
 3     'pelicula' => 'E.T. El extraterrestre'
 4 ];
 5 
 6 $query = http_build_query(
 7     $parametros,
 8     '',
 9     '&',
10     PHP_QUERY_RFC3986
11 );
12 
13 $url = 'UD3_paso_var_Ex1_datos_pelicula.php?' . $query;
14 ?>
15 <!DOCTYPE html>
16 <html lang="gl">
17 <head>
18     <meta charset="UTF-8">
19     <title>Elección dunha película</title>
20 </head>
21 <body>
22 
23 <p>
24     Mandamos un nome de película na URL:
25     <a href="<?= htmlspecialchars(
26         $url,
27         ENT_QUOTES | ENT_SUBSTITUTE,
28         'UTF-8'
29     ) ?>">PELÍCULA</a>
30 </p>
31 
32 </body>
33 </html>

Arquivo: UD3_paso_var_Ex1_datos_pelicula.php

 1 <?php
 2 $peliculaRecibida = $_GET['pelicula'] ?? '';
 3 
 4 if (!is_string($peliculaRecibida)) {
 5     $peliculaRecibida = '';
 6 }
 7 
 8 $pelicula = trim($peliculaRecibida);
 9 ?>
10 <!DOCTYPE html>
11 <html lang="gl">
12 <head>
13     <meta charset="UTF-8">
14     <title>Datos da película</title>
15 </head>
16 <body>
17 
18 <p>
19     A película pasada como parámetro na URL é:
20     <strong><?= htmlspecialchars(
21         $pelicula,
22         ENT_QUOTES | ENT_SUBSTITUTE,
23         'UTF-8'
24     ) ?></strong>
25 </p>
26 
27 </body>
28 </html>

A URL xerada será similar a:

UD3_paso_var_Ex1_datos_pelicula.php?pelicula=E.T.%20El%20extraterrestre

O usuario visualizará:

E.T. El extraterrestre

urlencode(), rawurlencode() e urldecode()

urlencode() codifica unha cadea segundo o formato empregado habitualmente nas cadeas de consulta. Os espazos convértense en +.

rawurlencode() emprega unha codificación conforme á RFC 3986. Os espazos convértense en %20.

urldecode() realiza a operación inversa de urlencode().

Exemplo:

$cadea = 'Espero que isto se lea ben';

$cadeaCodificada = urlencode($cadea);

echo $cadeaCodificada;
echo '<br>';
echo urldecode($cadeaCodificada);

Resultado:

Espero+que+isto+se+lea+ben
Espero que isto se lea ben

Paso dun identificador para consultar datos

Un uso moi habitual dos parámetros dunha URL consiste en enviar o identificador dun elemento que queremos consultar.

Por exemplo, poderiamos ter os seguintes produtos:

Código - Nome      - Descrición
1      - Tomates   - Tomates da horta. Ecolóxicos...
2      - Coliflor  - Coliflor da horta. Ecolóxica...

Na páxina que amosa a lista de produtos poderiamos construír enlaces como:

<a href="detalleProduto.php?codigo=1">Tomates</a>
<a href="detalleProduto.php?codigo=2">Coliflor</a>

Na páxina detalleProduto.php recibiremos o parámetro mediante $_GET.

Como o código debe ser un número enteiro positivo, primeiro validaremos o dato:

$codigoRecibido = $_GET['codigo'] ?? '';

if (!is_string($codigoRecibido)) {
    $codigoRecibido = '';
}

$codigo = filter_var(
    $codigoRecibido,
    FILTER_VALIDATE_INT,
    [
        'options' => [
            'min_range' => 1
        ]
    ]
);

if ($codigo === false) {
    die('O código do produto non é válido.');
}

Posteriormente poderiamos realizar a consulta á base de datos empregando PDO e unha consulta preparada:

$stmt = $pdo->prepare(
    'SELECT codigo, nome, descricion, url_imaxe
     FROM produtos
     WHERE codigo = :codigo'
);

$stmt->execute([
    'codigo' => $codigo
]);

$produto = $stmt->fetch(PDO::FETCH_ASSOC);

if ($produto === false) {
    die('O produto non existe.');
}

Ao amosar os datos en HTML escaparemos aqueles valores que poidan conter texto:

<h2><?= htmlspecialchars(
    $produto['nome'],
    ENT_QUOTES | ENT_SUBSTITUTE,
    'UTF-8'
) ?></h2>

<p><?= htmlspecialchars(
    $produto['descricion'],
    ENT_QUOTES | ENT_SUBSTITUTE,
    'UTF-8'
) ?></p>

IMPORTANTE: Un usuario pode cambiar manualmente o valor de codigo na URL.

Polo tanto, se un determinado produto ou recurso só pode ser consultado por certos usuarios, ademais de validar o identificador teremos que comprobar no servidor que o usuario autenticado ten permiso para acceder a ese recurso.

Cambiar GET por POST non soluciona este problema, xa que un usuario tamén pode manipular unha petición POST.

Paso de datos con Location

Podemos redireccionar o navegador mediante a cabeceira HTTP Location:

header('Location: nova_paxina.php');
exit;

Se queremos enviar parámetros na redirección, é preferible construír a cadea de consulta con http_build_query():

$parametros = [
    'nome' => 'Ana',
    'idade' => 20
];

$query = http_build_query(
    $parametros,
    '',
    '&',
    PHP_QUERY_RFC3986
);

header('Location: nova_paxina.php?' . $query);
exit;

A chamada a header() debe realizarse antes de enviar contido ao navegador.

Despois dunha redirección é recomendable empregar exit; para evitar que continúe a execución do script.

Exercicio proposto

Vexamos un exemplo de validación de datos empregando un formulario.

A situación é a seguinte:

Páxina alta_alumno.php

Recolle o nome e a data de nacemento dun alumno.
Envía os datos a procesar_alta.php empregando o método POST.
O nome debe ter un mínimo de 5 caracteres.
O alumno debe ter polo menos 10 anos.
Se se reciben erros desde procesar_alta.php, amósanse nunha lista.

Páxina procesar_alta.php

Comproba que a petición foi realizada mediante POST.
Valida no servidor o nome e a data de nacemento.
Se hai erros, redirecciona de novo a alta_alumno.php enviando os erros na URL.
Para construír a cadea de consulta empregarase http_build_query().
Se todo é correcto, redirecciona á páxina xestion_alumno.php enviando os datos necesarios.

Páxina xestion_alumno.php

Amosa o nome e a data de nacemento do alumno.
Os valores recibidos pola URL deberán tratarse como datos non fiables e escaparse antes de amosalos en HTML.

Nota: A validación HTML do formulario mellora a experiencia do usuario, pero non substitúe a validación no servidor, xa que a petición pode ser modificada manualmente.

Solución do exercicio proposto

Páxina alta_alumno.php

<?php
$erros = [];

$errosRecibidos = $_GET['erros'] ?? [];

if (is_array($errosRecibidos)) {
    foreach ($errosRecibidos as $erro) {
        if (is_string($erro)) {
            $erros[] = $erro;
        }
    }
}

// Data máxima permitida: hoxe menos 10 anos.
$dataMaxima = (new DateTimeImmutable('today'))
    ->modify('-10 years')
    ->format('Y-m-d');
?>
<!DOCTYPE html>
<html lang="gl">
<head>
    <meta charset="UTF-8">
    <title>Alta de alumno</title>
</head>
<body>

<h2>Alta de alumno</h2>

<?php if ($erros !== []) : ?>
    <ul>
        <?php foreach ($erros as $erro) : ?>
            <li><?= htmlspecialchars(
                $erro,
                ENT_QUOTES | ENT_SUBSTITUTE,
                'UTF-8'
            ) ?></li>
        <?php endforeach; ?>
    </ul>
<?php endif; ?>

<form action="procesar_alta.php" method="post">
    <div>
        <label for="nome">Nome:</label>
        <input
            type="text"
            id="nome"
            name="nome"
            minlength="5"
            required
        >
    </div>

    <div>
        <label for="dataNacemento">Data de nacemento:</label>
        <input
            type="date"
            id="dataNacemento"
            name="dataNacemento"
            max="<?= htmlspecialchars(
                $dataMaxima,
                ENT_QUOTES | ENT_SUBSTITUTE,
                'UTF-8'
            ) ?>"
            required
        >
    </div>

    <button type="submit">Enviar</button>
</form>

</body>
</html>

Páxina procesar_alta.php

<?php

// Esta páxina só debe procesar peticións POST.
if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
    header('Location: alta_alumno.php');
    exit;
}

$erros = [];

$nomeRecibido = $_POST['nome'] ?? '';
$dataRecibida = $_POST['dataNacemento'] ?? '';

// Un usuario pode manipular a petición e enviar arrays en lugar de cadeas.
if (!is_string($nomeRecibido)) {
    $nomeRecibido = '';
}

if (!is_string($dataRecibida)) {
    $dataRecibida = '';
}

$nome = trim($nomeRecibido);
$dataTexto = trim($dataRecibida);

/*
 * Validación do nome.
 * Neste exercicio a regra da aplicación indica que debe
 * ter polo menos 5 caracteres.
 */
if ($nome === '') {
    $erros[] = 'O nome é obrigatorio.';
} elseif (mb_strlen($nome) < 5) {
    $erros[] = 'O nome debe ter polo menos 5 caracteres.';
}

/*
 * Validación da data.
 *
 * O input type="date" envía normalmente a data co formato Y-m-d,
 * pero a petición pode manipularse. Por iso tamén a validamos
 * no servidor.
 */
$dataNacemento = false;

if ($dataTexto === '') {
    $erros[] = 'Debe indicar unha data de nacemento.';
} else {
    try {
        $dataNacemento = DateTimeImmutable::createFromFormat(
            '!Y-m-d',
            $dataTexto
        );
    } catch (ValueError) {
        $dataNacemento = false;
    }

    $errosData = DateTimeImmutable::getLastErrors();

    $dataValida =
        $dataNacemento !== false
        && (
            $errosData === false
            || (
                $errosData['warning_count'] === 0
                && $errosData['error_count'] === 0
            )
        )
        && $dataNacemento->format('Y-m-d') === $dataTexto;

    if (!$dataValida) {
        $erros[] = 'A data de nacemento non é válida.';
        $dataNacemento = false;
    }
}

/*
 * Comprobamos que o alumno teña polo menos 10 anos.
 */
if ($dataNacemento !== false) {
    $hoxe = new DateTimeImmutable('today');
    $dataLimite = $hoxe->modify('-10 years');

    if ($dataNacemento > $dataLimite) {
        $erros[] = 'O alumno debe ter polo menos 10 anos.';
    }
}

/*
 * Se hai erros volvemos ao formulario.
 *
 * http_build_query() permite construír correctamente a query string.
 * Neste caso PHP pode representar o array de erros na propia URL.
 */
if ($erros !== []) {
    $query = http_build_query(
        ['erros' => $erros],
        '',
        '&',
        PHP_QUERY_RFC3986
    );

    header('Location: alta_alumno.php?' . $query);
    exit;
}

/*
 * Todo é correcto.
 * Enviamos os datos á seguinte páxina empregando unha query string
 * construída por http_build_query().
 */
$query = http_build_query(
    [
        'nome' => $nome,
        'dataNacemento' => $dataTexto
    ],
    '',
    '&',
    PHP_QUERY_RFC3986
);

header('Location: xestion_alumno.php?' . $query);
exit;

Páxina xestion_alumno.php

<?php
$nomeRecibido = $_GET['nome'] ?? '';
$dataRecibida = $_GET['dataNacemento'] ?? '';

if (!is_string($nomeRecibido)) {
    $nomeRecibido = '';
}

if (!is_string($dataRecibida)) {
    $dataRecibida = '';
}

$nome = trim($nomeRecibido);
$dataNacemento = trim($dataRecibida);
?>
<!DOCTYPE html>
<html lang="gl">
<head>
    <meta charset="UTF-8">
    <title>Xestión do alumno</title>
</head>
<body>

<h2>Alumno rexistrado correctamente</h2>

<p>
    <strong>Nome:</strong>
    <?= htmlspecialchars(
        $nome,
        ENT_QUOTES | ENT_SUBSTITUTE,
        'UTF-8'
    ) ?>
</p>

<p>
    <strong>Data de nacemento:</strong>
    <?= htmlspecialchars(
        $dataNacemento,
        ENT_QUOTES | ENT_SUBSTITUTE,
        'UTF-8'
    ) ?>
</p>

<p>
    <a href="alta_alumno.php">Dar de alta outro alumno</a>
</p>

</body>
</html>

Ideas importantes da unidade

Os parámetros recibidos mediante $_GET deben considerarse sempre datos non fiables.
Empregaremos ?? cando un parámetro pode non existir.
Validaremos os datos segundo as regras da aplicación antes de empregalos.
Para valores numéricos podemos empregar filtros como FILTER_VALIDATE_INT.
Para consultas SQL empregaremos PDO e consultas preparadas; non concatenaremos directamente datos recibidos na consulta SQL.
Para construír cadeas de consulta empregaremos preferentemente http_build_query().
urlencode() ou rawurlencode() permiten codificar valores individuais dunha URL.
Antes de amosar texto non fiable dentro de HTML empregaremos:

htmlspecialchars(
    $dato,
    ENT_QUOTES | ENT_SUBSTITUTE,
    'UTF-8'
);

ENT_QUOTES fai que tamén se convertan as comiñas simples e dobres.
ENT_SUBSTITUTE substitúe por un carácter de substitución as secuencias que non sexan válidas na codificación indicada, evitando problemas con texto mal codificado.
O escapado HTML e a codificación dunha URL son operacións distintas:

htmlspecialchars() prepara texto para o contexto HTML.
urlencode(), rawurlencode() e http_build_query() preparan datos para unha URL.

A validación realizada mediante HTML ou JavaScript non substitúe nunca a validación no servidor.

-- Ángel D. Fernández González -- (2026).

PHP Paso de datos na URL

Sumario

Paso de datos pola URL

Exemplo básico

Pasando caracteres especiais na URL

Construíndo unha URL con http_build_query()

Exemplo con espazos no nome da película

urlencode(), rawurlencode() e urldecode()

Paso dun identificador para consultar datos

Paso de datos con Location

Exercicio proposto

Solución do exercicio proposto

Páxina alta_alumno.php

Páxina procesar_alta.php

Páxina xestion_alumno.php

Ideas importantes da unidade

Menú de navegación

Herramientas personales

Espacios de nombres

Variantes

Vistas

Más

Buscar

Navegación

Herramientas

Imprimir/exportar