Introducción a PHP

Bienvenido a la sección de PHP, en esta sección te encontrarás con todo lo esecial que necesitas saber sobre PHP.

Variables

Una variable en PHP es un contenedor que almacena un valor o una referencia a un valor en memoria. PHP es un lenguaje de tipado débil, lo que significa que las variables no necesitan declarar un tipo específico antes de usarlas, y el tipo se determina dinámicamente en función del valor asignado.

<?php
$nombre = "VoidSec";
?>

Además, en PHP las variables pueden almacenar referencias a otros valores. Es decir, en lugar de almacenar directamente un valor, pueden apuntar a la dirección de memoria de otro dato, como ocurre con los arrays y objetos.

Tipos de datos

PHP tiene varios tipos de datos, que se pueden clasificar principalmente en tipos escalares y tipos compuestos. Seguidamente los explicamos:

Tipos escalares

Los tipos escalares son aquellos que representan un solo valor. En otras palabras, un tipo escalar almacena un valor atómico, es decir, no está compuesto por otros valores, sino que es una unidad indivisible.

Enteros (int, integer): Un entero es un número sin decimales, ya sea positivo o negativo.
1 2 3 4
<?php $numero = 10; $numero = -5; ?>
- Los valores enteros en PHP pueden ser números tanto positivos como negativos.
- No pueden contener decimales.
Flotantes (float, double): Un flotante (o double) es un número que tiene decimales. Los números con decimales son llamados flotantes porque su punto decimal puede "flotar" en cualquier parte del número.
1 2 3 4
<?php $numero = 10.5; $numero = -5.25; ?>
- Los flotantes son útiles para representar valores más precisos, como precios, temperaturas, etc.
- Pueden ser positivos o negativos y tienen decimales.
Cadenas de texto (string): Una cadena (string) es un conjunto de caracteres, como palabras, frases o incluso números representados como texto. Las cadenas son muy utilizadas para trabajar con texto.
1 2 3 4
<?php $texto = "Esto es una cadena de texto"; $texto_2 = "Esto es otra cadena de texto"; ?>
- Las cadenas pueden estar entre comillas dobles ("texto") o simples ('texto'), y pueden contener letras, números y caracteres especiales.
- Se usan mucho para representar nombres, direcciones, mensajes, etc.
Booleanos (bool): Un booleano representa un valor de verdadero o falso (true o false). Se utiliza en condiciones o en estructuras de control de flujo, como if, para tomar decisiones.
1 2 3 4
<?php $esVerdadero = true; $esFalso = false; ?>
- Los booleanos son muy útiles para la lógica de programación, especialmente en comparaciones o validaciones.

Tipos compuestos

Los tipos compuestos son aquellos que pueden almacenar múltiples valores. A diferencia de los tipos escalares que solo almacenan un único valor, los tipos compuestos agrupan varios valores, y esos valores pueden ser de diferentes tipos. En PHP, los tipos compuestos más comunes son arrays y objetos.

Arrays (array): Un array es una estructura de datos que puede almacenar varios valores, los cuales pueden ser de diferentes tipos. Los arrays pueden ser indexados (donde cada valor tiene un índice numérico) o asociativos (donde cada valor está asociado a una clave personalizada).

Array indexado: Los arrays indexados utilizan índices numéricos (por defecto empiezan desde 0).

<?php
$colores = ["rojo", "verde", "azul"];  // Un array indexado
echo $colores[0];  // Salida: rojo
?>

Array asociativo (array): Los arrays asociativos permiten asociar valores a claves personalizadas.

<?php
$persona = [
    "nombre" => "Juan",
    "edad" => 30,
    "ciudad" => "Madrid"
];  // Un array asociativo
echo $persona["nombre"];  // Salida: Juan
?>

Objetos (object): Un objeto es una instancia de una clase. Las clases son plantillas o moldes que definen las propiedades y métodos de los objetos. Los objetos se usan en la Programación Orientada a Objetos (OOP) para agrupar datos y funcionalidades relacionadas.

<?php
class Persona {
    public $nombre;
    public $edad;

    public function __construct($nombre, $edad) {
        $this->nombre = $nombre;
        $this->edad = $edad;
    }

    public function saludar() {
        return "Hola, mi nombre es " . $this->nombre;
    }
}

$persona1 = new Persona("Juan", 30);  // Crear un objeto
echo $persona1->saludar();  // Salida: Hola, mi nombre es Juan
?>

Tipos de variables y referencias

PHP permite dos tipos de paso de datos: por valor y por referencia. En el paso por valor, se crea una copia del dato y se trabaja sobre ella. En el paso por referencia, las variables apuntan al mismo bloque de memoria, por lo que cualquier cambio realizado afectará al dato original.

Un ejemplo sería:

<?php
$a = 10;
$b = &$a;  // $b es una referencia a $a
$b = 20;    // Cambia tanto $b como $a
echo $a;    // Salida: 20
?>

Operadores

Los operadores aritméticos permiten realizar operaciones matemáticas en PHP. Además de los operadores aritméticos, existen otros tipos de operadores, como los operadores de comparación y los operadores lógicos, que permiten realizar comparaciones y operar con valores booleanos, respectivamente.

Operadores aritméticos

<?php
$a = 5;
$b = 3;
echo $a + $b;  // Suma
echo $a - $b;  // Resta
echo $a * $b;  // Multiplicación
echo $a / $b;  // División
echo $a % $b;  // Módulo (resto de la división)
echo $a ** $b; // Potencia (a elevado a la b)
?>

+ : Suma
- : Resta
* : Multiplicación
/ : División
% : Módulo (resto de la división)
** : Potencia (a elevado a la b)

Operadores de comparación

<?php
$a = 5;
$b = 10;
echo $a == $b;  // Compara si son iguales
echo $a != $b;  // Compara si no son iguales
echo $a < $b;   // Compara si $a es menor que $b
echo $a > $b;   // Compara si $a es mayor que $b
echo $a <= $b;  // Compara si $a es menor o igual que $b
echo $a >= $b;  // Compara si $a es mayor o igual que $b
?>

== : Compara si son iguales
!= : Compara si no son iguales
< : Compara si $a es menor que $b
> : Compara si $a es mayor que $b
<= : Compara si $a es menor o igual que $b
>= : Compara si $a es mayor o igual que $b

Operadores Lógicos

<?php
$a = true;
$b = false;
echo $a && $b;  // Y lógico (ambas condiciones deben ser verdaderas)
echo $a || $b;  // O lógico (al menos una condición debe ser verdadera)
echo !$a;       // Negación lógica (invierte el valor de la condición)
?>

&& : Y lógico (ambas condiciones deben ser verdaderas) (AND)
|| : O lógico (al menos una condición debe ser verdadera) (OR)
! : Negación lógica (invierte el valor de la condición) (NOT)

Operadores de asignación

<?php
$a = 5;
$a += 3;  // Equivalente a $a = $a + 3;
$a -= 2;  // Equivalente a $a = $a - 2;
$a *= 4;  // Equivalente a $a = $a * 4;
$a /= 2;  // Equivalente a $a = $a / 2;
$a %= 3;  // Equivalente a $a = $a % 3;
?>

=: Asignación
+=: Suma y asignación
-=: Resta y asignación
*=: Multiplicación y asignación
/=: División y asignación
%=: Módulo y asignación

Operadores de incremento y decremento

<?php
$a = 5;
echo ++$a;  // Pre-incremento: incrementa antes de usar el valor
echo $a++;  // Post-incremento: usa el valor y luego lo incrementa
echo --$a;  // Pre-decremento: decrementa antes de usar el valor
echo $a--;  // Post-decremento: usa el valor y luego lo decrementa
?>

++$a: Pre-incremento: incrementa antes de usar el valor
$a++: Post-incremento: usa el valor y luego lo incrementa
--$a: Pre-decremento: decrementa antes de usar el valor
$a--: Post-decremento: usa el valor y luego lo decrementa

Operadores de Cadena

<?php
$a = "Hola";
$b = "Mundo";
echo $a . " " . $b;  // Concatena las cadenas
?>

.: Concatena las cadenas

Operadores de Identidad

<?php
$a = 5;
$b = "5";
echo $a === $b;  // Compara si $a y $b son idénticos (mismo valor y tipo)
echo $a !== $b;  // Compara si $a y $b no son idénticos (valor o tipo diferente)
?>

===: Compara si $a y $b son idénticos (mismo valor y tipo)
!==: Compara si $a y $b no son idénticos (valor o tipo diferente)

Operadores de tipo

<?php
// Definición de variables con diferentes tipos de datos
$a = 42;                 // Entero
$b = "Hello, World!";    // Cadena
$c = true;               // Booleano
$d = [1, 2, 3];          // Array
$e = new DateTime();     // Objeto
$f = null;               // Nulo
$g = 3.14159;            // Flotante
$h = "123";              // Cadena numérica

// Verificación de tipos con is_*() y demostración de los resultados
echo "¿\$a es un entero? " . (is_int($a) ? 'Sí' : 'No') . "\n";               // Verifica si $a es un entero
echo "¿\$b es una cadena? " . (is_string($b) ? 'Sí' : 'No') . "\n";           // Verifica si $b es una cadena
echo "¿\$c es un booleano? " . (is_bool($c) ? 'Sí' : 'No') . "\n";             // Verifica si $c es un booleano
echo "¿\$d es un array? " . (is_array($d) ? 'Sí' : 'No') . "\n";               // Verifica si $d es un array
echo "¿\$e es un objeto? " . (is_object($e) ? 'Sí' : 'No') . "\n";             // Verifica si $e es un objeto
echo "¿\$f es nulo? " . (is_null($f) ? 'Sí' : 'No') . "\n";                   // Verifica si $f es nulo
echo "¿\$g es numérico? " . (is_numeric($g) ? 'Sí' : 'No') . "\n";             // Verifica si $g es un número
echo "¿\$h es un flotante? " . (is_float($h) ? 'Sí' : 'No') . "\n";            // Verifica si $h es un flotante

// Verificación de cadenas numéricas y su conversión
echo "¿\$h es numérico (como cadena)? " . (is_numeric($h) ? 'Sí' : 'No') . "\n"; // Verifica si $h es numérico

// Convertir cadena numérica a entero y verificar el tipo
$h_int = (int)$h;   // Convierte $h de cadena a entero
echo "Valor de \$h como entero: $h_int\n";
echo "¿\$h_int es un entero? " . (is_int($h_int) ? 'Sí' : 'No') . "\n";  // Verifica si la conversión fue exitosa
?>

is_int($a): Verifica si $a es un entero
is_string($b): Verifica si $b es una cadena
is_bool($c): Verifica si $c es un booleano
is_array($d): Verifica si $d es un array
is_object($e): Verifica si $e es un objeto
is_null($f): Verifica si $f es un valor nulo
is_numeric($g): Verifica si $g es un número
is_float($h): Verifica si $h es un flotante

Condicionales

Las condiciones en PHP se utilizan para ejecutar bloques de código en función de si una expresión es verdadera o falsa. Son fundamentales para controlar el flujo de ejecución de un programa. Las estructuras de control más comunes en PHP son if, else, elseif, y switch.

Condicionales `if`

<?php
if (expresión) {
    // Código que se ejecuta si la expresión es verdadera
}
?>

Pongamos un ejemplo:

<?php
$edad = 18;

if ($edad >= 18) {
    echo "Eres mayor de edad.";
}
?>

Este ejemplo verifica si la variable $edad es mayor o igual a 18. Si es así, se imprime el mensaje "Eres mayor de edad.".

Condicionales `if-else`

<?php
if (expresión) {
    // Código que se ejecuta si la expresión es verdadera
} else {
    // Código que se ejecuta si la expresión es falsa
}
?>

Pongamos un ejemplo:

<?php
$a = 2;
if ($a > 3) {
    echo "El valor de a es mayor que 3";
} else {
    echo "El valor de a no es mayor que 3";
}
?>

Aquí, como $a es 2, la condición no se cumple, por lo que se imprimirá "El valor de a no es mayor que 3".

Condicionales `if-elseif-else`

<?php
if (expresión1) {
    // Código si expresión1 es verdadera
} elseif (expresión2) {
    // Código si expresión2 es verdadera
} else {
    // Código si ninguna expresión es verdadera
}
?>

Pongamos un ejemplo:

<?php
$a = 10;
if ($a > 20) {
    echo "El valor de a es mayor que 20";
} elseif ($a == 10) {
    echo "El valor de a es igual a 10";
} else {
    echo "El valor de a es menor que 10";
}
?>

En este caso, la salida será "El valor de a es igual a 10", ya que la condición elseif ($a == 10) es verdadera.

Condicionales `switch`

<?php
switch (expresión) {
    case valor1:
        // Código si la expresión es igual a valor1
        break;
    case valor2:
        // Código si la expresión es igual a valor2
        break;
    default:
        // Código si ninguno de los valores coincide
}
?>

Pongamos un ejemplo:

<?php
$dia = 2;

switch ($dia) {
    case 1:
        echo "Hoy es lunes";
        break;
    case 2:
        echo "Hoy es martes";
        break;
    case 3:
        echo "Hoy es miércoles";
        break;
    default:
        echo "Día desconocido";
}
?>

En este ejemplo, como $dia es 2, la salida será "Hoy es martes". El break se utiliza para salir del bloque switch una vez que se ha encontrado el caso correspondiente.

Condicionales ternarias

<?php
(expresión) ? valor_si_verdadero : valor_si_falso;
?>

Pongamos un ejemplo:

<?php
$a = 5;
echo ($a > 3) ? "Mayor que 3" : "No mayor que 3";
?>

Este ejemplo imprimirá "Mayor que 3" porque la condición a > 3 es verdadera.

Condicionales con operadores lógicos

<?php
$a = 5;
$b = 10;
if ($a > 3 && $b > 5) {
    echo "Ambas condiciones son verdaderas";
}
?>

Aquí, ambas condiciones deben ser verdaderas para que se ejecute el bloque de código, por lo que se imprimirá "Ambas condiciones son verdaderas".

Bucles

Los bucles nos permiten ejecutar un bloque de código repetidamente mientras se cumpla una condición. En PHP, los bucles más comunes son for, while, do-while y foreach.

Bucles `for`

<?php
for (inicialización; condición; incremento) {
    // Código que se ejecuta en cada iteración
}
?>

Pongamos un ejemplo:

<?php
for ($i = 1; $i <= 5; $i++) {
    echo "El valor de i es $i\n";
}
?>

Este ejemplo imprimirá los siguientes valores de $i:

El valor de i es 1
El valor de i es 2
El valor de i es 3
El valor de i es 4
El valor de i es 5

Bucles `while`

<?php
while (condición) {
    // Código que se ejecuta mientras la condición sea verdadera
}
?>

Pongamos un ejemplo:

<?php
$i = 0;
while ($i < 5) {
    echo "El valor de i es: $i<br>";
    $i++;
}
?>

Bucles `do-while`

<?php
do {
    // Código que se ejecuta al menos una vez
} while (condición);
?>

Pongamos un ejemplo:

<?php
$i = 0;
do {
    echo "El valor de i es: $i<br>";
    $i++;
} while ($i < 5);
?>

Este bucle también imprimirá los valores de $i desde 0 hasta 4.

Bucles `foreach`

<?php
foreach ($array as $valor) {
    // Código que se ejecuta en cada iteración
}
?>

Si necesitas tanto el índice como el valor del array:

<?php
foreach ($array as $indice => $valor) {
    // Código que se ejecuta en cada iteración
}
?>

Pongamos ejemplo:

<?php
$colores = ["rojo", "verde", "azul"];
foreach ($colores as $color) {
    echo "El color es: $color<br>";
}
?>

Este bucle imprimirá los valores "rojo", "verde" y "azul".

Funciones

Una función es un bloque de código que realiza una tarea específica y siempre debe devolver un valor (aunque sea NULL por defecto si no se especifica explícitamente un return). Puedes definir tus propias funciones y llamarlas cuando sea necesario.

Definición de funciones

<?php
function nombreDeLaFuncion() {
    // Código que realiza la función
    return $resultado;  // Debe devolver algo
}
?>

Pongamos un ejemplo:

<?php
function saludar() {
    return "¡Hola, mundo!";  // La función devuelve un valor
}

echo saludar();  // Llamada a la función y muestra el valor retornado
?>

Parámetros de funciones

Puedes pasar datos a las funciones utilizando parámetros. Estos valores son utilizados dentro de la función y debe devolverse un valor.

<?php
function saludar($nombre) {
    return "¡Hola, $nombre!";  // La función devuelve un valor
}

echo saludar("Juan");  // Llamada con parámetro
?>

Funciones anónimas

PHP también permite crear funciones sin nombre, conocidas como funciones anónimas. A pesar de ser anónimas, siempre deben devolver un valor si así lo requiere el contexto.

<?php
$saludar = function($nombre) {
    return "¡Hola, $nombre!";  // Función anónima con retorno
};

echo $saludar("Pedro");  // Llamada a la función anónima
?>

Este ejemplo crea una función anónima y la almacena en la variable $saludar.

Funciones recursivas

Una función recursiva es aquella que se llama a sí misma. Son útiles para resolver problemas que pueden dividirse en subproblemas más pequeños, como el cálculo de factoriales o la búsqueda en estructuras de datos como árboles. Y siempre deben retornar un valor.

<?php
function factorial($n) {
    if ($n <= 1) {
        return 1;  // Caso base, retorna 1
    } else {
        return $n * factorial($n - 1);  // Llamada recursiva con retorno
    }
}

echo factorial(5);  // Imprime 120
?>

En este ejemplo, la función factorial() se llama a sí misma, pero siempre retorna un valor.

Funciones incorporadas

PHP también tiene muchas funciones incorporadas que puedes utilizar, como strlen() para obtener la longitud de una cadena, array_push() para agregar un elemento a un array, etc. Estas funciones también devuelven un valor.

<?php
$cadena = "Hola";
echo strlen($cadena);  // Devuelve 4, que es la longitud de la cadena
?>

https://www.php.net/manual/es/indexes.functions.php

Request Superglobals

Request Superglobals en PHP

En PHP, los request superglobals son variables predefinidas que permiten acceder a la información proveniente de diversas fuentes externas, como formularios, cookies, URL y más. Estos son accesibles globalmente en todo el script PHP. A continuación, un resumen de los más utilizados:

$_GET: Contiene los datos enviados a través de la URL, generalmente mediante el método HTTP GET. Los valores se envían como parámetros en la cadena de consulta.
Ejemplo: $_GET['nombre'] obtiene el valor de nombre de la URL.
$_POST: Almacena los datos enviados mediante el método HTTP POST, generalmente en formularios. Es más seguro para enviar grandes cantidades de datos que $_GET, ya que no se muestran en la URL.
Ejemplo: $_POST['usuario'] obtiene el valor de usuario de un formulario enviado.
$_REQUEST: Contiene tanto los datos de $_GET, $_POST, como de $_COOKIE. Es un "superglobal" que combina estos tres arrays, pero se recomienda usar $_GET o $_POST específicamente, ya que $_REQUEST puede ser menos seguro.
Ejemplo: $_REQUEST['email'] obtiene el valor del parámetro email de cualquiera de las tres fuentes.
$_SERVER: Almacena información sobre los servidores y el entorno de ejecución, como cabeceras HTTP, información del script, método de petición, etc.
Ejemplo: $_SERVER['HTTP_USER_AGENT'] obtiene el agente de usuario (el navegador).
$_FILES: Contiene los datos de los archivos subidos a través de un formulario HTML con el método POST. Se utiliza para acceder a los detalles de los archivos, como el nombre, tamaño y tipo de archivo.
Ejemplo: $_FILES['archivo']['name'] obtiene el nombre del archivo subido.
$_ENV: Contiene variables de entorno del sistema, como configuraciones de servidor o configuraciones del sistema operativo.
Ejemplo: $_ENV['PATH'] obtiene el valor de la variable de entorno PATH.
$_COOKIE: Almacena los valores de las cookies enviadas por el navegador. Se utiliza para leer los valores de las cookies configuradas previamente.
Ejemplo: $_COOKIE['user'] obtiene el valor de la cookie user.
$_SESSION: Almacena datos sobre una sesión de usuario. Es útil para mantener la información entre diferentes páginas durante una sesión en particular.
Ejemplo: $_SESSION['username'] obtiene el valor almacenado de username en la sesión.

Cada uno de estos superglobales tiene un propósito específico y permite interactuar con la entrada y el entorno del servidor de manera eficiente. Es importante siempre validar y sanitizar los datos provenientes de estas fuentes para evitar riesgos de seguridad, como inyecciones de SQL o XSS.

Introducción a PHP

Variables

Tipos de datos

Tipos escalares

Tipos compuestos

Tipos de variables y referencias

Operadores

Operadores aritméticos

Operadores de comparación

Operadores Lógicos

Operadores de asignación

Operadores de incremento y decremento

Operadores de Cadena

Operadores de Identidad

Operadores de tipo

Condicionales

Condicionales if

Condicionales if-else

Condicionales if-elseif-else

Condicionales switch

Condicionales ternarias

Condicionales con operadores lógicos

Bucles

Bucles for

Bucles while

Bucles do-while

Bucles foreach

Funciones

Definición de funciones

Parámetros de funciones

Funciones anónimas

Funciones recursivas

Funciones incorporadas

Request Superglobals

Request Superglobals en PHP

Condicionales `if`

Condicionales `if-else`

Condicionales `if-elseif-else`

Condicionales `switch`

Bucles `for`

Bucles `while`

Bucles `do-while`

Bucles `foreach`