PHP: funciones, formularios y el servidor integrado

Clase 2 de PHP 8.5, todo ejecutado: funciones tipadas, closures con use, un formulario en php -S probado con curl, XSS sin escapar, ?? vs ?: y require.

Serie: curso de PHP 2/6 (principiante). Esta clase es para ti si ya terminaste la clase 1 y ahora te toca armar o arreglar una página pequeña que recibe datos del usuario: el formulario de contacto de un cliente que atiendes como freelancer, el buscador del panel interno en tu primer trabajo en una startup, o la entrega del proyecto web del bootcamp. Al terminar vas a escribir funciones tipadas y closures, levantar un servidor web local con un solo comando, manejar un formulario GET y uno POST, e imprimir lo que escribe el usuario sin abrir un agujero de XSS.

El encargo típico suena así: "¿Puedes arreglar el buscador de esta página vieja en PHP?". Para hacerlo bien necesitas tres cosas que los tutoriales suelen repartir en diez páginas distintas: funciones que rechacen datos incorrectos, una forma de correr la página en tu computadora y la costumbre de escapar cada valor que imprimes. Todo lo de abajo se ejecutó con PHP 8.5.6 en una Mac con Apple Silicon (M1 Pro). Las peticiones HTTP fueron llamadas reales con curl 8.7.1 a php -S en 127.0.0.1, y las rutas de archivo se acortaron a ~/demo/.

Funciones con declaración de tipos

Una función es un bloque de código con nombre que recibe parámetros y puede devolver (return) un valor. Desde la clase 1 empezamos siempre con declare(strict_types=1);, así que los tipos que escribimos se hacen cumplir.

<?php
declare(strict_types=1);

function greet(string $name, string $greeting = "Hello", bool $shout = false): string {
    $msg = "$greeting, $name!";
    return $shout ? strtoupper($msg) : $msg;
}
echo greet("Mina"), "\n";
echo greet("Mina", shout: true), "\n";
echo greet(greeting: "Hi", name: "Ken"), "\n";
Hello, Mina!
HELLO, MINA!
Hi, Ken!
  • string $name es una declaración de tipo del parámetro; : string después de los paréntesis es el tipo de retorno. Usa : void cuando la función no devuelve nada.
  • $greeting = "Hello" es un valor por defecto, que se usa cuando quien llama omite ese argumento.
  • shout: true es un argumento con nombre (named argument, PHP 8.0+). Te permite saltarte los parámetros del medio y vuelve legibles llamadas como greet("Mina", "Hello", true).

Los argumentos con nombre tienen sus propios errores. Estos son los mensajes reales de 8.5.6, cada uno de una llamada de una línea contra la misma greet():

greet(shout: true);
Fatal error: Uncaught ArgumentCountError: greet(): Argument #1 ($name) not passed in ~/demo/e.php:3

greet("A", nme: "B");
Fatal error: Uncaught Error: Unknown named parameter $nme in ~/demo/e.php:5

greet(name: "A", "Hi");
Fatal error: Cannot use positional argument after named argument in ~/demo/e.php on line 5

El último es un error en tiempo de compilación. php -l file.php (lint, una revisión de sintaxis sin ejecutar el archivo) lo detecta antes de que corra nada, así que pásale php -l a cada archivo que toques. Otra consecuencia: en cuanto alguien llama a tu función con argumentos con nombre, renombrar un parámetro rompe esas llamadas. Los nombres de los parámetros ahora forman parte de la interfaz pública de tu función.

Tipos nullable y tipos unión

<?php
declare(strict_types=1);

function findUser(int $id): ?array {
    return $id === 1 ? ["id" => 1, "name" => "Mina"] : null;
}
var_dump(findUser(2));
echo findUser(2)["name"] ?? "guest", "\n";

function formatId(int|string $id): string {
    return is_int($id) ? sprintf("#%05d", $id) : "#" . $id;
}
echo formatId(42), " ", formatId("A-7"), "\n";
echo formatId(1.5), "\n";
NULL
guest
#00042 #A-7

Fatal error: Uncaught TypeError: formatId(): Argument #1 ($id) must be of type string|int, float given, called in ~/demo/fn.php on line 14 and defined in ~/demo/fn.php:10
  • ?array es un tipo nullable: un array o null (PHP 7.1+). Es la forma honesta de decir "puede que no encuentre nada". Quien llama tiene que manejar el null, aquí con ??.
  • int|string es un tipo unión (union type, PHP 8.0+): cualquiera de los tipos listados. Fíjate en que el mensaje de error lo imprime como string|int, en el orden que elige PHP, así que no busques ese texto exacto en tu código.
Quieres decir Escribe
exactamente un tipo int $x
"o nada" ?int $x (igual que int|null)
uno de varios int|string $x
no devuelve nada : void
el argumento es opcional int $x = 0 (un valor por defecto)

Closures, use y arrow functions

Un closure (función anónima) es una función sin nombre que puedes guardar en una variable o pasar a otra función. La sorpresa para quien viene de JavaScript o Python: un closure de PHP no ve las variables de afuera a menos que las importes con use.

<?php
$rate = 1.1;
$withTax = fn(int $p): float => $p * $rate;              // arrow fn: captures by value
$counter = 0;
$inc = function () use (&$counter): void { $counter++; };   // by reference
$incCopy = function () use ($counter): int { return $counter + 100; }; // copied now
$inc(); $inc();
echo $withTax(1000), " ", $counter, " ", $incCopy(), "\n";
$rate = 2.0;
echo $withTax(1000), "\n";
echo implode(",", array_map(fn($x) => $x ** 2, [1, 2, 3])), "\n";
1100 2 100
1100
1,4,9
  • Una arrow function fn(...) => expr (PHP 7.4+) captura las variables de afuera automáticamente, por valor y en el momento de crearse. Cambiar $rate después no cambió $withTax(1000).
  • use ($counter) copia el valor cuando se crea el closure. $incCopy() seguía viendo 0 y devolvió 100.
  • use (&$counter) comparte la variable, así que $inc() sí la llevó a 2.

Error típico: el closure que nunca actualiza el total

<?php
$total = 0;
$add = function (int $x) { $total += $x; };
$add(5);
echo $total, "\n";
$fnAdd = fn(int $x) => $total += $x;
$fnAdd(5);
echo $total, "\n";
Warning: Undefined variable $total in ~/demo/cl.php on line 3
0
0

Lo que pasa en realidad: dentro del primer closure, $total es una variable local nueva, de ahí el Warning. La arrow function es más silenciosa pero igual de incorrecta: modificó su propia copia. Solución: function (int $x) use (&$total) { $total += $x; }. Mejor todavía: devuelve un valor y asígnalo afuera, que es más fácil de testear.

Una página web real con un solo comando: php -S

PHP trae un servidor de desarrollo integrado. No necesitas Apache, nginx ni XAMPP para probar una página. En una carpeta con tus archivos:

$ php -S 127.0.0.1:8099 -t .
[Thu Nov 12 15:18:52 2026] PHP 8.5.6 Development Server (http://127.0.0.1:8099) started

127.0.0.1 significa "solo esta computadora". No uses 0.0.0.0 en el Wi-Fi de la oficina o de la cafetería, porque cualquiera en la red podría abrir tus archivos. -t . define la raíz de documentos (document root). Cada petición imprime líneas de log:

[Thu Nov 12 15:18:53 2026] 127.0.0.1:64641 Accepted
[Thu Nov 12 15:18:53 2026] 127.0.0.1:64641 [200]: GET /form.php?q=php+8.5
[Thu Nov 12 15:18:53 2026] 127.0.0.1:64641 Closing

El manual es claro: este servidor es para desarrollo, no para producción. Por defecto atiende una petición a la vez.

Diagrama de flujo. Un navegador o curl envía GET /form.php?q=... o un cuerpo POST a php -S en 127.0.0.1:8099. El servidor ejecuta form.php después de llenar $_GET y $_POST. El script lee la entrada con $_GET['q'] ?? '', así que una clave inexistente no genera warning, la valida y escapa la salida con htmlspecialchars, de modo que la respuesta HTML contiene &lt;script&gt; en vez de un script que se ejecuta. Un camino punteado muestra que hacer echo de la entrada directamente lleva a XSS.
Una petición a través del servidor integrado. PHP llena $_GET y $_POST, tu script los lee con ?? y cada valor pasa por htmlspecialchars antes de llegar al HTML.

Un formulario GET y uno POST

$_GET contiene el query string (?q=...), $_POST contiene el cuerpo de un formulario enviado y $_SERVER['REQUEST_METHOD'] te dice cuál de los dos recibiste. Son superglobales: arrays que PHP llena antes de que arranque tu script. Este es el form.php completo:

<?php
declare(strict_types=1);

function h(string $s): string {
    return htmlspecialchars($s, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
}

$method = $_SERVER['REQUEST_METHOD'];
$q      = $_GET['q'] ?? '';
$name   = trim($_POST['name'] ?? '');
$errors = [];

if ($method === 'POST' && $name === '') {
    $errors[] = 'Name is required.';
}
?>
<!doctype html>
<meta charset="utf-8">
<title>Form demo</title>
<form method="get"><input name="q" value="<?= h($q) ?>"><button>Search</button></form>
<?php if ($q !== ''): ?>
<p>You searched for: <?= h($q) ?></p>
<?php endif; ?>
<form method="post"><input name="name"><button>Send</button></form>
<?php foreach ($errors as $e): ?>
<p class="error"><?= h($e) ?></p>
<?php endforeach; ?>
<?php if ($method === 'POST' && !$errors): ?>
<p>Thanks, <?= h($name) ?>!</p>
<?php endif; ?>

<?= ... ?> es la forma corta de <?php echo ... ?>. La forma if (...): / endif; es la sintaxis de estructuras de control pensada para plantillas. Lo probamos con curl, sin navegador:

$ curl -s -i "http://127.0.0.1:8099/form.php?q=php+8.5"
HTTP/1.1 200 OK
Host: 127.0.0.1:8099
Connection: close
X-Powered-By: PHP/8.5.6
Content-type: text/html; charset=UTF-8

<!doctype html>
...
<form method="get"><input name="q" value="php 8.5"><button>Search</button></form>
<p>You searched for: php 8.5</p>

$ curl -s -d "name=Mina" http://127.0.0.1:8099/form.php | tail -1
<p>Thanks, Mina!</p>

$ curl -s -d "name=" http://127.0.0.1:8099/form.php | grep error
<p class="error">Name is required.</p>

-d envía un POST con cuerpo de formulario. Fíjate en el header X-Powered-By: PHP/8.5.6, que le dice a cada visitante tu versión exacta. En un servidor real configura expose_php = Off en php.ini. Otro detalle: el POST con el nombre vacío igual devolvió 200. Si quieres que el cliente vea que la validación falló, envía tú mismo http_response_code(422).

Escapar la salida: el XSS que aparece sin htmlspecialchars

Esta es la versión que contienen muchas páginas viejas:

<?php
$q = $_GET['q'];
echo "<p>You searched for: $q</p>\n";
$ curl -s -G --data-urlencode 'q=<script>alert(1)</script>' http://127.0.0.1:8099/unsafe.php
<p>You searched for: <script>alert(1)</script></p>

La entrada llegó al HTML sin cambios. En un navegador ese script corre en tu dominio, con las cookies de tus usuarios. Esto es cross-site scripting (XSS). La misma petición a form.php, que usa h():

<p>You searched for: &lt;script&gt;alert(1)&lt;/script&gt;</p>

Los atributos son el caso que la gente olvida. Un valor que cierra la comilla y agrega un manejador de eventos:

$ curl -s -G --data-urlencode 'q=" autofocus onfocus="alert(1)' http://127.0.0.1:8099/form.php | grep input
<form method="get"><input name="q" value="&quot; autofocus onfocus=&quot;alert(1)"><button>Search</button></form>

Sin ENT_QUOTES (o con los valores por defecto de PHP 7, que dejaban pasar la comilla simple) la comilla habría sobrevivido. Desde PHP 8.1 los flags por defecto son ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, pero escribirlos de forma explícita, junto con 'UTF-8', hace que el código sea seguro en cualquier versión y obvio para quien lo revisa. El texto no ASCII pasa intacto: name=민아 <b> volvió como Thanks, 민아 &lt;b&gt;!, y lo mismo vale para eñes y tildes.

Reglas prácticas: escapa en la salida, no en la entrada. Escapa cada valor, incluidos tus propios mensajes de error. htmlspecialchars sirve solo para texto HTML y atributos entre comillas; los contextos de URL, JavaScript y CSS necesitan otras herramientas. La clase 5 cubre esos casos, además de CSRF y sesiones: curso de PHP 5: XSS, CSRF y sesiones. Para ver una limpieza real de estos bugs en código PHP viejo, lee nuestra auditoría de SQLi/XSS en PHP heredado.

Claves que faltan: warnings de $_GET, ?? y ?:

Abre unsafe.php sin ningún q:

$ curl -s http://127.0.0.1:8099/unsafe.php
<br />
<b>Warning</b>:  Undefined array key "q" in <b>~/demo/unsafe.php</b> on line <b>2</b><br />
<p>You searched for: </p>

Dos problemas. La página le muestra un warning al visitante, y la salida real contenía la ruta absoluta completa del archivo en nuestra máquina (aquí la acortamos). Eso filtra la estructura de tu servidor. En producción configura display_errors=Off y log_errors=On. En nuestra prueba, el warning apareció entonces solo en el log del servidor.

La solución es ??, que ya usamos en form.php. Cuidado con el parecido ?: (el operador "Elvis"):

<?php
$x = [];
echo $x['p'] ?: 'default', "\n";
echo $x['p'] ?? 'default', "\n";
$g = ['page' => '0'];
var_dump($g['page'] ?: 1, $g['page'] ?? 1);
Warning: Undefined array key "p" in ~/demo/ex.php on line 3
default
default
int(1)
string(1) "0"
Operador Clave inexistente El valor es null El valor es "0", "", 0
$a['k'] ?? 'd' 'd', sin warning 'd' conserva el valor
$a['k'] ?: 'd' 'd' más Warning 'd' 'd' (falsy)
isset($a['k']) false false true

Para datos de formularios, ?? es casi siempre el correcto: ?page=0 es un valor real, no "falta".

include vs require

include y require insertan otro archivo PHP en ese punto. La diferencia aparece cuando el archivo no existe:

<?php
$which = $_GET['mode'] ?? 'include';
if ($which === 'include') {
    include __DIR__ . '/missing.php';
} else {
    require __DIR__ . '/missing.php';
}
echo "still running after $which\n";
$ curl -s "http://127.0.0.1:8099/inc.php?mode=include"
Warning:  include(~/demo/missing.php): Failed to open stream: No such file or directory in ~/demo/inc.php on line 4
Warning:  include(): Failed opening '~/demo/missing.php' for inclusion (include_path='.:…/share/php/pear') in ~/demo/inc.php on line 4
still running after include

$ curl -s -i "http://127.0.0.1:8099/inc.php?mode=require"
HTTP/1.1 200 OK
...
Warning:  require(~/demo/missing.php): Failed to open stream: No such file or directory in ~/demo/inc.php on line 6
Fatal error:  Uncaught Error: Failed opening required '~/demo/missing.php' (include_path='.:…/share/php/pear') in ~/demo/inc.php:6
Stack trace:
#0 {main}

(Quitamos las etiquetas HTML para que se lea mejor.) include avisó dos veces y siguió ejecutándose. require lanzó un Error y se detuvo. La sorpresa está en la línea de estado: con display_errors encendido, la petición con el error fatal igual dijo 200 OK, porque el texto del warning ya había empezado el cuerpo de la respuesta. Con el servidor arrancado como php -d display_errors=0 -S ..., la misma petición devolvió HTTP/1.0 500 Internal Server Error con el cuerpo vacío. Es una razón más para apagar display_errors fuera de tu propia máquina.

Diagrama de decisión. Pregunta: ¿la página funciona sin este archivo? Si no, usa require_once; si el archivo falta, obtienes un Warning, luego Fatal error Uncaught Error Failed opening required, y el script se detiene, lo que devolvió HTTP 500 con display_errors apagado y todavía 200 con display_errors encendido. Si sí, usa include; un archivo faltante da dos Warnings y el script continúa.
¿include o require? Si falta el archivo, include da Warnings y sigue; require da un Fatal error y se detiene. Con display_errors apagado, el caso de require devolvió HTTP 500.
Situación Usa
Configuración, funciones o clases sin las que la página no puede funcionar require_once
Una parte de la plantilla que se puede omitir sin riesgo (banner, barra lateral) include
Un archivo que podría cargarse dos veces (definiciones de funciones) las variantes _once, para evitar "Cannot redeclare"
Una ruta construida con datos del usuario nunca; elige de una lista fija

Arma las rutas siempre a partir de __DIR__ (el directorio del archivo actual). Un include 'lib.php' relativo depende del directorio de trabajo actual y del include_path, que cambian entre la CLI, el servidor integrado y Apache.

Medimos el tiempo de ida y vuelta de una petición

¿Cuánto tarda una petición al servidor integrado en la misma máquina? Un cliente PHP con la extensión curl, 20 peticiones de calentamiento que no se cuentan y luego 500 peticiones cronometradas por URL, en secuencia, contra 127.0.0.1:8099 (PHP 8.5.6, Apple M1 Pro, OPcache sin ajustar):

<?php
$N = 500;
$ch = curl_init();
curl_setopt_array($ch, [CURLOPT_RETURNTRANSFER => true]);
foreach (['/ping.txt', '/ping.php', '/form.php?q=hello'] as $path) {
    curl_setopt($ch, CURLOPT_URL, "http://127.0.0.1:8099$path");
    for ($i = 0; $i < 20; $i++) curl_exec($ch);                 // warm-up
    $t = [];
    for ($i = 0; $i < $N; $i++) {
        $s = hrtime(true); curl_exec($ch); $t[] = (hrtime(true) - $s) / 1e3;
    }
    sort($t);
    printf("%-18s median %4.0f µs  p95 %4.0f µs\n", $path, $t[$N >> 1], $t[(int) ($N * .95)]);
}
URL Mediana (ejecución 1) p95 (ejecución 1) Mediana (ejecución 2) p95 (ejecución 2)
/ping.txt (archivo estático) 142 µs 267 µs 139 µs 157 µs
/ping.php (echo "pong") 134 µs 180 µs 148 µs 172 µs
/form.php?q=hello (243 bytes) 152 µs 181 µs 155 µs 204 µs

La tabla sale del script completo, que además verifica que cada estado sea 200. El listado abreviado de arriba, ejecutado otra vez más tarde mientras la máquina corría otros trabajos, dio medianas de 159, 167 y 193 µs. Es el mismo panorama, solo con más ruido.

Gráfico de barras con la mediana de ida y vuelta en localhost: el archivo estático ping.txt tardó 142 microsegundos, ping.php, que imprime pong, 134 microsegundos, y form.php con una consulta 152 microsegundos.
Mediana de ida y vuelta de 500 peticiones secuenciales a php -S en 127.0.0.1 tras 20 de calentamiento (ejecución 1). PHP 8.5.6, cliente con la extensión curl, Apple M1 Pro. Arrancar php hello.php desde cero tardó unos 56 ms.

Lo que esto le dice a alguien que empieza:

  • En localhost, una petición HTTP completa más la ejecución de un script PHP pequeño costó unos 0.13–0.15 ms. El archivo estático y el script PHP quedaron dentro del margen de ruido entre sí. El p95 (el 5 % más lento) varió más que la mediana, y por eso reportamos una mediana y no una sola ejecución.
  • Arrancar PHP desde cero es muchísimo más caro. 50 ejecuciones seguidas de php hello.php promediaron unos 56 ms cada una en esta máquina (dos rondas: 57.1 y 55.9 ms; un /bin/echo simple tardó unos 2 ms por arranque, así que casi todo eso es el propio PHP). El proceso del servidor sigue vivo, así que por petición solo se ejecuta tu script.
  • En un hosting real, la latencia de red (decenas de milisegundos) empequeñece ambas cifras. Mide allí antes de optimizar código PHP. La clase 6 lo hace con OPcache y profiling.

Novedad de 8.5: el operador pipe

Ya que ahora escribes funciones pequeñas, vale la pena ver una novedad de 8.5. |> pasa el valor de la izquierda como único argumento del callable de la derecha:

<?php
$slug = "  Hello PHP 8.5 World  "
    |> trim(...)
    |> strtolower(...)
    |> (fn($s) => preg_replace('/[^a-z0-9]+/', '-', $s));
var_dump($slug);
string(19) "hello-php-8-5-world"

trim(...) es la sintaxis de first-class callable (8.1+), que convierte una función en un closure. El operador es sintaxis nueva, así que las versiones anteriores no pueden parsear este archivo (no ejecutamos un PHP más viejo para ver el mensaje exacto). No uses |> en código que tenga que correr en hostings compartidos con versiones antiguas.

Límites honestos y notas de versión

  • Ejecutado: cada fragmento en PHP 8.5.6 CLI y su servidor integrado (SAPI cli-server) en macOS, Apple M1 Pro; HTTP con curl 8.7.1 solo contra 127.0.0.1. No ejecutado: Apache/mod_php, PHP-FPM ni ninguna versión anterior a 8.5. El comportamiento bajo Apache (códigos de estado en errores fatales, include_path) puede ser distinto.
  • Versiones tomadas del manual, sin volver a comprobarlas en builds viejos: tipos nullable 7.1; arrow functions 7.4; argumentos con nombre y tipos unión 8.0; los flags por defecto de htmlspecialchars pasaron a ENT_QUOTES | ENT_SUBSTITUTE en 8.1; first-class callables 8.1; operador pipe 8.5. Los errores fatales de compilación imprimen un Stack trace: en nuestra salida de 8.5 por la nueva opción fatal_error_backtraces (su valor era 1 en nuestro build).
  • Las cifras de ida y vuelta son solo de loopback, secuenciales y con un único cliente. No dicen nada sobre concurrencia. El servidor integrado es de un solo proceso salvo que definas PHP_CLI_SERVER_WORKERS, que no probamos.
  • Los ~56 ms de arranque de la CLI corresponden a este build de Homebrew, que lista 67 módulos. php -n (sin php.ini) listó los mismos 67 y fue igual de lento (57–58 ms). No probamos un build personalizado más pequeño.

Ejercicios

1. Corrige el closure de la sección "Error típico" para que $add(5); $add(7); echo $total; imprima 12.

2. ¿Qué imprime htmlspecialchars('<a href="x">it\'s</a>') en PHP 8.5, y qué cambia con el flag ENT_NOQUOTES?

3. Una página de listado lee $page = $_GET['page'] ?: 1;. ¿Qué pasa con /list.php y con /list.php?page=0, y cómo debería quedar?

Respuestas

1.

<?php
$total = 0;
$add = function (int $x) use (&$total): void { $total += $x; };
$add(5); $add(7);
echo $total, "\n";   // 12

Lo ejecutamos y obtuvimos 12. Sin el &, use ($total) copia el 0 y el $total de afuera nunca cambia.

2. Por defecto: &lt;a href=&quot;x&quot;&gt;it&#039;s&lt;/a&gt;. Con ENT_NOQUOTES: &lt;a href="x"&gt;it's&lt;/a&gt;, que deja pasar ambos tipos de comilla, así que no es seguro dentro de un atributo.

3. Sin page: Warning "Undefined array key" y $page = 1. Con page=0: "0" es falsy, así que $page = 1 en silencio. Usa $page = (int) ($_GET['page'] ?? 1); y luego valida el rango (por ejemplo max(1, $page)).

Lo que sigue

Preguntas frecuentes

¿Cómo pruebo una página PHP en mi computadora sin instalar Apache ni XAMPP?

Usa el servidor de desarrollo integrado: php -S 127.0.0.1:8099 dentro de la carpeta con tus archivos .php, y luego abre http://127.0.0.1:8099/form.php o llámalo con curl. Imprime una línea de log por petición. Es solo para desarrollo; en 127.0.0.1 una petición simple tardó una mediana de unos 0.13 a 0.15 ms en nuestra prueba.

¿Qué diferencia hay entre include y require si el archivo no existe?

include emite dos Warnings (Failed to open stream, Failed opening ... for inclusion) y el script sigue. require emite el Warning y luego un Fatal error (Uncaught Error: Failed opening required ...) y se detiene. Con display_errors apagado, el caso de require devolvió HTTP 500 desde el servidor integrado.

¿Necesito htmlspecialchars si el valor viene de mi propio formulario?

Sí. Cualquiera puede enviar cualquier valor a tu formulario. Hacer echo de $_GET['q'] directamente devolvió <script>alert(1)</script> sin cambios en el HTML; con htmlspecialchars($q, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8') se convirtió en &lt;script&gt;... y un valor que intentaba romper el atributo perdió sus comillas como &quot;.

  • #php
  • #principiante
  • #funciones
  • #closures
  • #formularios
  • #htmlspecialchars
  • #servidor-integrado

t.laboratory

A technical blog that records real problems from the apps, servers and services we build and run — and the code that fixed them.

Acerca de · Apps

↑