Prueba de instalación de PHP desde sintaxis phpinfo();
Al finalizar la sección anterior aclaré que omitiré aquí los pasos de instalación de un servidor (remoto o local) y del intérprete PHP actualizado (ambos, servidor e intérprete, necesarios para ejecutar PHP). Puesto que esa instalación dependerá del tipo de computador disponible y del sistema operativo, recomiendo buscar en tutoriales actualizados para ese proceso.
Dicho lo anterior y una vez instalado el servidor (local o remoto) junto con el intérprete PHP, una forma breve de evaluar que todo esta ejecutándose es ingresado en el navegador la siguiente ruta:
Donde ese archivo index.php (o con cualquier otro nombre) deberá obligatoriamente estar ubicado en la carpeta raíz del servidor activo. El contenido de se archivo deberá ser:
En PHP
<?php
phpinfo();
?>
Lo anterior resulta en un reporte detallado con la versión del intérprete PHP instalado, fecha de versión, equipo usado para la instalación, rutas de carpetas, entre otros. Una alerta: debemos cuidar que ese archivo con ese contenido phpinfo(); NO sea accedido de forma externa, pues contiene información que atacantes podrían usar.
Si la página PHP Versión 8.3.x no es mostrada, entonces lo primero es confirmar que: el servidor esté activo, que el intérprete haya sido previamente instalado, o que la ruta en el navegador sea la correcta (un error sería localhost8000/index.php), -sin los dos puntos delante del número del puerto 8000-, por ejemplo.
Recordemos: para los siguientes ejercicios deberías tener activados el servidor (local o remoto) junto con el intérprete PHP y el archivo con extensión .php. Luego, en la ruta del navegador web debes llamar a ese archivo en la forma localhost:8000/nombreArchivo.php
Introduciendo a la sintaxis PHP
Siempre desde un archivo nombre.php el servidor "leerá" HTML o PHP. En cualquiera de estas formas (luego hablaré de la forma en que podemos nombrar variables -como en $ciudad-):
En .PHP
// SINTAXIS PHP SIMPLE
<?php
$ciudad = "Guayaquil";
echo "<h2>Hola desde PHP para $ciudad</h2>";
?>
// SINTAXIS HTML SIMPLE
<html>
<p>Hola Guayaquil, esto es HTML</p>
</html>Y también de esta forma. ¡Recordemos!, ahora estamos en un archivo .php, donde la sintaxis para comentarios dentro del código corresponde a la forma // comentario....
Ojo con los comentarios en la forma <!-- ... --> para HTML; y // ... para PHP (otras formas de comentar lo explico más adelante).
En .PHP
<!-- SINTAXIS HTML -->
<html>
<p>Hola Guayaquil, esto es HTML</p>
<?php
// SINTAXIS PHP ANIDADA EN TAGS HTML
$ciudad = "Guayaquil";
echo "<h2>Hola desde PHP para $ciudad</h2>";
?>
</html>
Es decir, todo PHP dentro de un archivo con extensión .php debe ir dentro de las etiquetas <?php ?>; y dentro de ese mismo archivo .php también es posible agregar las etiquetas HTML en la forma <html> </html>. Así mismo, si dentro de un archivo .php no existe ninguna etiqueta <?php ?>, entonces el intérprete de PHP solo leerá sintaxis HTML.
En cualquiera de las sintaxis anteriores (con formato o extensión de archivo en la forma .php) el resultado al verlo en el navegador es:
Además, una forma de comentar el código para que el intérprete de PHP ignore esos comentarios pero sí sean visibles para nosotros (siempre desde un archivo con extensión .php y dentro de los tags de PHP) puede hacerse de las siguientes maneras:
En .PHP
<?php
// Eres perla que surgiste
# Del más grande e ignoto mar
/* Si a tus rubias y morenas
Que enloquecen de pasión
Les palpita un corazón */
// SINTAXIS PHP SIMPLE
$ciudad = "Guayaquil";
echo "<h2>Hola desde PHP para $ciudad</h2>";
// Combinando comillas simples y dobles
echo 'Olmedo dijo: "Los hombres hábiles ambicionan convencer"'
;?>
Funciones include() y require()
En esta sección ya he reseñado antes estas funciones. Ambas son especiales para separar contenido de lógica:
- include() da una alerta (E_WARNING) si el archivo incluido esta ausente. Es decir, es un archivo complementario -como elementos visuales- no críticos.
- require() da (E_ERROR) si el archivo incluido esta ausente. Es un archivo requerido o clave (por ejemplo, conexiones a bases de datos) que al no hallarlo detiene el script completo -no se ejecuta nada debajo de ese llamado-.
- Es clave entender que solo el archivo "que pide" (sea mediante include o require) llama de forma oculta a todos al archivo que dará el resultado de ese llamado. Y ese resultado no será conocido por nadie más que por el propio servidor web. En la página web únicamente veremos el resultado. Una forma de verlo es acceder a
Inspector Web > Reddonde únicamente el archivo "que llama" es el archivo en la línea de tiempo de carga.
Una forma de usar una de esas funciones -incluso con paréntesis en la forma include ("llamar-este-archivo.php"); es:
Funciones include_once() y require_once()
Para Wenz y Hauser (2025) "estas dos construcciones de lenguaje primero comprueban si el archivo ya se ha incluido. Si ya se ha incluido, esto no volverá a suceder". El peligro de recargar un archivo que no debería volver a cargarse es que "valores o funciones de las variables pueden sobrescribirse de nuevo [como aquellos valores que otros módulos ya han usado] o puede aparecer un error para las funciones, ya que solo se pueden declarar una vez en el mismo contexto."
Lógicas con include() y require()
En .PHP
<?php
// ARCHIVO QUE LLAMA
// Dato en memoria
$diaSemana = "lunes";
// Condicional
if ($diaSemana === "lunes"){
// Si condición se cumple, llamar a...
include ("llamar-este-archivo.php");
} else {
// Si NO se cumple, mostrar...
echo "No hay nada 😥";
}
?>
<?php
/* ARCHIVO QUE LLAMADO
SOLO SI CONDICIÓN SE CUMPLE */
echo "<h2>Lunes otra vez...</h2>";
?>
Mostrar con PHP, usando comillas dobles o simples, escapando nombres de variables
Diferencia entre echo y print:
En .PHP
<?php
// ECHO
// Muestra lo que ha sido insertado como caracteres
echo "Rock en Guayaquil, yujuu!";
// PRINT
// Es una función
// Muestra un dato que puede ser alojado
// Solo acepta un valor a la vez
// No acepta comas para separar argumentos
$cantidad = print "2";
// Siempre devolverá el valor 1 al ejecutarse
echo $cantidad;
// Muestra 21
?>
// PRINT es útil para usarlo en condicionales terciarios
// Si reemplazo print por echo da error
($cantidad) ? print "Acceso concedido" : print "Denegado";
=== OTRO EJEMPLO ===
// Variable apunta a alfanumerico
$epoca = "Siglo XXI";
// Mostrarmos apuntando a la variable
echo "Bienvenido al $epoca";
// Da Bienvenido al Siglo XXI
=== CUIDADO CON COMILLAS SIMPLES ===
// Apunta a valor
$mensajito = "Holi!!";
// Pero comillas simples
// NO acepta variable
echo '$mensajito PHP 8';
// Da $mensajito PHP 8
=== ESCAPANDO CON COMILLAS DOBLES ===
// Variable apunta a hora
$hora = "10h00";
// Mensaje entre COMILLAS DOBLES
// Escape solo para \$hora
echo "La variable \$hora aloja:\n $hora";
// Da 'La variable $hora aloja: 10h00'
Abriendo y nombrando variables en PHP
PHP no necesita de una palabra clave como var para iniciar una variable. Tan solo requiere preceder el nombre de la variable con el signo dólar $.
PHP es de tipado dinámico: "lee" automáticamente el tipo de dato alojado en una variable. Sin embargo, no siempre esa conversión es precisa. En el ejemplo de abajo, el valor "8" inicia como dato alfanumérico (no es un número) pero el sistema lo cambia a número antes de hacer la multiplicación.
En .PHP
// variable con valor numerico
// Nombrando con más de una palabra
$otro_valor_nuevo = 2000;
$guardarValor = 100;
// Se actualiza variable anterior
// variable con valor alfanumerico (no es número)
// Pero el sistema lo lee como número
$guardarValor = "8";
// Variable con booleano
$existeValor = true;
echo $guardarValor * $guardarValor;
// Resulta en 20
Métodos para definir manualmente y con precisión los tipos de datos
En .PHP
// Establecer tipo de datos
$dato = "Text";
echo gettype($dato);
// Da string
// Confirmar que es un string
echo is_string($dato);
// Da 1
$certeza = true;
echo gettype($certeza);
// Da 1
Luego también es posible asegurarse a que un dato sea convertido a un tipo indicado. Ese cambio puede hacerse mediante 'type casting' o conversión de tipo:
En .PHP
// Convirtiendo un valor con type casting
// Valor alfanumérico
$a = "true";
// Se indica ALOJAR $a en $b pero convertido a booleano
$b = (bool) $a;
// Llamamos al valor convertido
echo $b;
// Da 1 (es booleano)
Variable de variables
Esta es una habilidad un poco rara de PHP, el cual aún no le veo utilidad, excepto por estos ejemplos:
En .PHP
<?php
// Aloja text
$nombre = "Olmedo";
// Es el mismo nombre de variable pero aumentado una $
/* Por lo tanto es otra variable
pero con el nombre relacionado a la anterior */
$$nombre = "Jose Joaquín";
// Muestra primera variable
echo $nombre;
// Olmedo
// Muestra segunda variable
echo $$nombre;
// Jose Joaquín
?>
=== OTRO EJEMPLO ===
/* En esta primera variable
solo se permite una sola palabra */
$x = "aaa";
/* Aqui usamos el mismo nombre
identificador de la primera variable, y le alojamos
un nuevo valor 'bbb' */
$$x = "bbb";
// Invocamos al valor de $x
echo $aaa;
=== OTRO EJEMPLO CON DATO DINAMICO ===
// variables
$saludo_es = "Hola";
$saludo_en = "Hello";
// Ingreso dinámico desde fuera:
// el usuario elije 'en'(english)
// Y se aloja en $idioma
$idioma = "en";
/* Guarda datos combinándo
otro dato para unirlo al primer string */
$nombre_variable = "saludo_" . $idioma;
// Ahora $nombre_variable aloja 'saludo_en'
// VARIABLE DE VARIABLE
// Recordemos: ahora esta variable variable
// toma la PRIMERA palabra de la variable $saludo_en
echo $$nombre_variable;
// PHP busca $saludo_en y muestra "Hello"
/* Sin lo anterior, pudimos también haber creado
una condicional para indicar que, si
$idioma = "en"; entones mostrar 'Hello' */
Vincular por semántica los identificadores de variables puede crear confusión si no es el mismo programador quien luego depure una cantidad excesiva de esas variables.
Sin embargo, el método de variable de variables podría ser más útil si el nombre de la variable es alterada por un dato ingresado por usuario, mediante dato interactivo (también llamado dinámico, como un botón o campo de elección).
Función isset()
Esta función isset() es diferente a usar una condicional tipo if ($valor == true){}, donde usar esa condicional da error si no la halla, porque se sobreentiende que la variable a evaluar debería estar presente en el código. Con isset() solo hay un cambio de flujo hacia un else{} porque isset() retorna false o true según sea el caso.
En .PHP
// Variable apunta a Eci
$ecuador = "Ecu";
// Condicional con isset()
if (isset($ecuador)) {
// Si la variable está, muestra
echo $ecuador;
// Si no está, muestra
} else {
echo "País no existe";
}
// Da Ecu
Función empyt()
En .PHP
// Apunta a valor vacio
$cajita = "";
// Condicion con empty()
if (empty($cajita)) {
echo "Caja vacia";
} else {
echo $cajita;
}
// Da Caja vacia
Función unset()
En .PHP
$caja = "Esta lleno";
echo $caja;
// Da Esta lleno
// Deja variable como no inicializada
unset($caja);
echo $caja;
// Manda error de inexistencia
Asignación por referencia
Para Wenz y Hauser (2025) el método de asignación con referencia es bastante usado en programación con PHP.
En .PHP
$cajita = "con libros";
// La bolsa tiene un nuevo estado de &$cajita
// La referencia a $cajita le antecede un &
/* Dice: Haz que el nombre $bolsa sea
un acceso directo a lo que ya es $cajita" */
$bolsa = &$cajita;
// Cambio de estado
// Ahora la cajita tiene zapatos
$cajita = "con zapatos";
// Invocamos a $bolsa
// con el nuevo estado de &$cajita
echo $bolsa;
// Da con zapatos
/* OJO: Ahora $cajita y $bolsa
son dos nombres que apuntan
al mismo espacio físico
pero con nuevo valor. */
Lo interesante del ejemplo de arriba es que la nueva variable $bolsa es solo un acceso directo para el valor (actualizado) de $cajita. Por lo que mediante el signo & podemos vincular nuevo_nombre con &valor_variable_anterior:
En .PHP
<?php
// Apunta a un valor
$nombre = "Julián";
/* Indicamos que nuevos nombres de variable
conecten a variable ya dada */
$nombre_bonito = &$nombre;
$nombre_de_gato = &$nombre;
$canton_guayaquil = &$nombre;
// ** Solo si deseas actualzar el valor **
// $nombre = "Nuevo Nombre";
// Comprobamos que referencie a $nombre
echo $nombre_bonito;
// Julian
echo $nombre_de_gato;
// Julian
echo $canton_guayaquil;
// Julian
/*
- Qué pasaría si cambiamos el valor de $nombre?
- Los accedos directos mostrarian ese nuevo valor de $nombre */
?>
Sin embargo, desatender la creación de referencias podrían incurrir en grandes errores o actualizaciones no deseadas. Por ejemplo, cuando un programador desconozca que $nombre_bonito es solo una referencia a otro dato de variable, declarada más arriba en el código.
Revisión bibliográfica de PHP 8.3