¿Por qué esta guía?

Los ejemplos de patrones de este curso están escritos en PHP. Si la sintaxis del lenguaje te frena, los patrones se vuelven el doble de difíciles: estás peleando con el $ y el -> en vez de pensar en el diseño.

Esta guía no enseña a programar desde cero: asume que ya sabés (en Java, JavaScript o Python) y te muestra cómo se escribe lo mismo en PHP moderno (8.x). El bloque principal de cada sección es PHP, con anotaciones sobre cada pieza de sintaxis; cuando ayuda, el selector de lenguaje te deja contrastar con lo que ya conocés.

Cómo usar esta guía

Leé el bloque PHP primero. Si una pieza no te cuadra, cambiá al lenguaje que dominás con el selector y comparás. Las anotaciones explican el por qué.

Tip de lectura: Tocá, enfocá o pasá el mouse sobre las líneas marcadas para ver la anotación.

1 — Variables y tipos

Variables & Types

En PHP toda variable empieza con $. No declarás el tipo: PHP lo infiere del valor y lo cambia si reasignás. Eso lo hace flexible y, a la vez, fácil de equivocar — por eso PHP moderno agrega tipado donde puede.

Los tipos escalares básicos son string, int, float y bool. Dentro de strings con comillas dobles, las variables se interpolan: PHP las reemplaza por su valor. Y hay una trampa clásica que vale aprender desde el día uno: == compara con conversión de tipos, === compara valor y tipo.

Sintaxis — comparada en 4 lenguajes

// Toda variable lleva $. El tipo se infiere del valor.
$nombre = 'Ada';
$edad = 36;          // int
$activo = true;       // bool

$saludo = "Hola, $nombre";  // "Hola, Ada"

// La trampa clásica: == convierte, === no.
var_dump(36 == '36');   // true  (convierte)
var_dump(36 === '36');  // false (valor + tipo)

// Java: el tipo va delante y es fijo de por vida.
String nombre = "Ada";
int edad = 36;
boolean activo = true;

// Interpolación: no hay; se concatena o se usa formatted().
String saludo = "Hola, " + nombre;

// TS: sin $, con let/const y tipos opcionales.
const nombre = 'Ada';
const edad = 36;
const activo = true;

// Interpolación con backticks y ${ }.
const saludo = `Hola, ${nombre}`;

// JS/TS también distingue == de ===, igual que PHP.
console.log(36 === '36');  // false

# Python: sin $, sin declarar tipo.
nombre = 'Ada'
edad = 36
activo = True

# Interpolación con f-strings.
saludo = f'Hola, {nombre}'

# Python: == compara valor; 'is' compara identidad (no tipo).
print(36 == '36')  # False (no convierte)

Nota

Regla práctica: en PHP usá === casi siempre. El == con conversión automática es fuente de bugs sutiles (0 == "texto" daba true antes de PHP 8).

Autoevaluación

En PHP, ¿qué devuelve 0 === "0"?

2 — Strings

Strings

En PHP los strings tienen un detalle que define cómo se comportan: las comillas dobles interpolan variables y procesan escapes (\n, \t); las comillas simples toman el texto casi literal, sin interpolar. Elegir bien evita sorpresas.

Para concatenar, PHP usa el punto . (no +, que es solo aritmético). Y para textos largos o con muchas comillas, el heredoc (<<<) deja escribir bloques multilínea que sí interpolan.

Sintaxis — comparada en 4 lenguajes

// Comillas dobles: interpolan y procesan escapes.
$saludo = "Hola, $nombre\n";

// Comillas simples: literal, NO interpolan.
$crudo = 'Hola, $nombre\n';  // literal: Hola, $nombre\n

// Concatenación: con punto, no con +.
$nombre_completo = $nombre . ' ' . $apellido;

// Heredoc: bloque multilínea que sí interpola.
$mensaje = <<<TEXTO
Hola $nombre,
tu pedido está listo.
TEXTO;

// Java: solo un tipo de comillas; sin interpolación.
String saludo = "Hola, " + nombre + "\n";

// Concatenación con + (en Java sí une strings).
String completo = nombre + " " + apellido;

// Texto multilínea: text blocks (Java 15+).
String msg = """
    Hola, tu pedido está listo."";

// TS: backticks interpolan; comillas normales no.
const saludo = `Hola, ${nombre}\n`;

// Concatenación con + (en JS/TS sí une strings).
const completo = nombre + ' ' + apellido;

// Multilínea: los backticks ya lo permiten.
const msg = `Hola ${nombre},
listo.`;

# Python: f-strings interpolan; '' y "" son equivalentes.
saludo = f'Hola, {nombre}\n'

# Concatenación con + (en Python sí une strings).
completo = nombre + ' ' + apellido

# Multilínea: triple comilla.
msg = f'''Hola {nombre},
tu pedido está listo.'''

Nota

Regla rápida: comillas dobles cuando querés interpolar variables; comillas simples cuando querés el texto literal (y de paso son un pelín más rápidas). Para unir strings, siempre el punto . — el + no concatena en PHP.

Autoevaluación

En PHP, ¿qué imprime echo 'Hola $nombre'; (comillas simples)?

3 — Arrays

Arrays

El array es la estructura estrella de PHP, y tiene una particularidad: una sola cosa cubre lo que en otros lenguajes son dos. Un array puede ser indexado (claves numéricas 0, 1, 2…) o asociativo (claves de texto, como un diccionario), o ambas mezcladas.

Se crean con [], las parejas clave-valor usan =>, y se recorren con foreach. Si venís de Java o JS, pensá en el array de PHP como un List y un Map fusionados.

Sintaxis — comparada en 4 lenguajes

// Indexado: claves 0, 1, 2... automáticas.
$colores = ['rojo', 'verde', 'azul'];
echo $colores[0];  // rojo

// Asociativo: las claves las ponés vos, con =>.
$usuario = ['nombre' => 'Ada', 'edad' => 36];
echo $usuario['nombre'];  // Ada

// foreach recorre ambos tipos.
foreach ($usuario as $clave => $valor) {
    echo "$clave: $valor\n";
}

// Java separa lista y mapa en tipos distintos.
List<String> colores = List.of("rojo", "verde");

Map<String, Object> usuario = new HashMap<>();
usuario.put("nombre", "Ada");

for (var e : usuario.entrySet()) { /* ... */ }

// TS: array para lista, objeto/Map para clave-valor.
const colores = ['rojo', 'verde', 'azul'];

const usuario = { nombre: 'Ada', edad: 36 };

for (const [clave, valor] of Object.entries(usuario)) {
    console.log(clave, valor);
}

# Python: list para lista, dict para clave-valor.
colores = ['rojo', 'verde', 'azul']

usuario = {'nombre': 'Ada', 'edad': 36}

for clave, valor in usuario.items():
    print(clave, valor)

Nota

En PHP el orden de inserción se conserva en los arrays asociativos. No es un detalle menor: podés tratarlos como diccionarios ordenados.

Autoevaluación

En PHP, ¿qué los diferencia un array indexado de uno asociativo?

4 — Funciones

Functions

Las funciones se declaran con function. PHP moderno te deja —y conviene— declarar el tipo de cada parámetro y el del valor de retorno. Eso convierte la firma en un contrato verificable: si pasás algo de otro tipo, PHP avisa.

Los parámetros pueden tener valor por defecto, y un tipo puede ser nullable anteponiendo ?: ?string significa "un string o null". Manejar null con cuidado es buena parte de escribir PHP robusto.

Sintaxis — comparada en 4 lenguajes

// Tipos en parámetros y retorno: la firma es un contrato.
function subtotal(int $cantidad, float $precio): float
{
    return $cantidad * $precio;
}

// Valor por defecto: si no se pasa, usa 0.
  function total(float $base, float $envio = 0.0): float
{
    return $base + $envio;
}

// Nullable: ?string = string O null.
function buscarEmail(int $id): ?string
{
    return $id === 1 ? '[email protected]' : null;
}

// Java: tipos obligatorios; sin valores por defecto (se sobrecarga).
double subtotal(int cantidad, double precio) {
    return cantidad * precio;
}

// Nullable: se modela con Optional<String> o anotaciones.
Optional<String> buscarEmail(int id) { /* ... */ }

// TS: tipos opcionales, valores por defecto, y null explícito.
function subtotal(cantidad: number, precio: number): number {
    return cantidad * precio;
}

// string | null es el equivalente de ?string.
function buscarEmail(id: number): string | null { /* ... */ }

# Python: type hints opcionales y valores por defecto.
def subtotal(cantidad: int, precio: float) -> float:
    return cantidad * precio

# Optional[str] es el equivalente de ?string.
def buscar_email(id: int) -> str | None:
    return '[email protected]' if id == 1 else None

Nota

Declarar tipos no es opcional "para los expertos": es lo que vuelve legible un proyecto PHP. La firma te dice qué entra y qué sale sin leer el cuerpo. Lo vas a agradecer al leer los ejemplos de patrones del curso.

Autoevaluación

¿Qué significa el tipo de retorno ?string en una función PHP?

5 — Control de flujo

Control Flow

PHP tiene los condicionales y bucles que ya conocés: if/elseif/else, while, for, foreach. La novedad de PHP 8 que conviene adoptar es match: como un switch, pero compara con === (sin conversión de tipos), devuelve un valor y no necesita break.

La otra cosa a tener clara es la truthiness: qué valores PHP considera "falsos" en una condición. null, 0, 0.0, "", "0" y [] son falsy. Eso explica bugs típicos cuando un 0 legítimo se trata como "vacío".

Sintaxis — comparada en 4 lenguajes

// match (PHP 8): compara con ===, devuelve un valor, sin break.
$etiqueta = match($estado) {
    'created' => 'Pendiente',
    'paid', 'shipped' => 'En curso',
    default => 'Desconocido',
};

// Truthiness: cuidado con los valores falsy.
if (!$cantidad) {  // 0, '', null, [] entran acá
    echo 'Sin cantidad';
}
if ($cantidad === null) { /* explícito */ }

// Java 14+: switch como expresión, con ->.
String etiqueta = switch (estado) {
    case "created" -> "Pendiente";
    case "paid", "shipped" -> "En curso";
    default -> "Desconocido";
};
// Java no tiene truthiness: las condiciones deben ser boolean.

// TS no tiene match; se usa switch o un objeto-mapa.
const etiqueta = { created: 'Pendiente' }[estado] ?? 'Desconocido';

// JS/TS también tiene truthiness: 0, '', null, undefined, NaN.
if (!cantidad) { /* mismo riesgo que PHP con el 0 */ }

# Python 3.10+: match estructural (más potente que el de PHP).
match estado:
    case 'created': etiqueta = 'Pendiente'
    case 'paid' | 'shipped': etiqueta = 'En curso'
    case _: etiqueta = 'Desconocido'

# Python también: 0, '', None, [], {} son falsy.
if not cantidad: # mismo riesgo con el 0

Nota

Ojo con la truthiness: confundir 0 o "" con "no hay dato" es uno de los bugs más comunes en PHP. Cuando lo que querés saber es "¿existe?" o "¿es null?", usá isset() o === null, no if (!$x).

Autoevaluación

En PHP, ¿en qué se diferencia match del viejo switch?

6 — Clases y visibilidad

Classes & Visibility

Las clases en PHP se declaran con class y sus miembros llevan un modificador de visibilidad: public (accesible desde afuera), private (solo dentro de la clase) o protected (la clase y sus hijas). Las propiedades modernas se declaran tipadas.

PHP 8 trae el constructor property promotion: declarás y asignás las propiedades en la misma firma del constructor, ahorrando el ritual repetitivo. Y hay dos operadores que confunden al principio: $this-> accede a miembros de la instancia; self:: (o static::) accede a miembros estáticos de la clase.

Sintaxis — comparada en 4 lenguajes

class Cuenta
{
    public function __construct(private float $saldo = 0) {}

    public function depositar(float $monto): void
    {
        if ($monto <= 0) return;
        $this->saldo += $monto;
    }

    public function saldo(): float { return $this->saldo; }
}

$c = new Cuenta(100);
$c->depositar(50);
echo $c->saldo();  // 150

class Cuenta {
    private double saldo;
    public Cuenta(double saldo) { this.saldo = saldo; }

    public void depositar(double monto) {
        if (monto > 0) this.saldo += monto;
    }
    public double getSaldo() { return saldo; }
}

class Cuenta {
    // TS también tiene promotion vía parámetros con modificador.
    constructor(private saldo: number = 0) {}

    depositar(monto: number): void {
        if (monto > 0) this.saldo += monto;
    }
    getSaldo(): number { return this.saldo; }
}

class Cuenta:
    def __init__(self, saldo: float = 0):
        self._saldo = saldo

    def depositar(self, monto: float) -> None:
        if monto > 0: self._saldo += monto

    def saldo(self) -> float: return self._saldo

Nota

Regla rápida de operadores: $this->algo = miembro de la instancia (este objeto). self::ALGO = miembro estático/constante de la clase (compartido por todas las instancias).

Autoevaluación

En PHP 8, ¿qué hace el constructor property promotion (function __construct(private float $saldo))?

7 — Enums

Enums (PHP 8.1)

Antes de PHP 8.1, un conjunto fijo de valores —los estados de un pedido, los roles de un usuario— se modelaba con constantes sueltas o strings mágicos ('created', 'paid'…), fáciles de escribir mal y sin garantía de validez. Los enums resuelven eso: un tipo con un número cerrado de casos.

Un enum se declara con enum y sus casos con case. Pueden ser puros (solo casos) o respaldados (enum Estado: string), donde cada caso tiene un valor escalar asociado. Y como son tipos, podés usarlos en las firmas: function avanzar(Estado $e) solo acepta un caso válido.

Sintaxis — comparada en 4 lenguajes

// Enum respaldado: cada caso tiene un valor string.
  enum Estado: string
{
    case Pendiente = 'pending';
    case Pagado = 'paid';
    case Enviado = 'shipped';
}

// Como es un tipo, la firma solo acepta casos válidos.
function etiqueta(Estado $e): string
{
    return match($e) {
        Estado::Pendiente => 'En espera',
        Estado::Pagado, Estado::Enviado => 'En curso',
    };
}

$e = Estado::from('paid');  // Estado::Pagado

// Java tiene enums desde siempre (y muy potentes).
enum Estado {
    PENDIENTE, PAGADO, ENVIADO;
}

String etiqueta(Estado e) {
    return switch (e) {
        case PENDIENTE -> "En espera";
        case PAGADO, ENVIADO -> "En curso";
    };
}

// TS: enum nativo, o (mejor) union de literales.
type Estado = 'pending' | 'paid' | 'shipped';

function etiqueta(e: Estado): string {
    switch (e) {
        case 'pending': return 'En espera';
        default: return 'En curso';
    }
}

# Python: módulo enum de la librería estándar.
from enum import Enum

class Estado(Enum):
    PENDIENTE = 'pending'
    PAGADO = 'paid'
    ENVIADO = 'shipped'

# from-value: Estado('paid') devuelve Estado.PAGADO.
e = Estado('paid')

Nota

Los enums matan los strings mágicos. En lugar de comparar contra 'paid' (y rezar para no escribir 'pais'), usás Estado::Pagado: si te equivocás, PHP avisa al instante. Combinados con match, cubrís todos los casos de forma exhaustiva.

Autoevaluación

¿Qué ventaja da declarar function avanzar(Estado $e) con un enum, en vez de function avanzar(string $e)?

8 — Namespaces y use

Namespaces

En un proyecto real hay cientos de clases, y dos podrían llamarse igual (App\Order y Vendor\Order). Los namespaces resuelven eso: agrupan código bajo un prefijo, como carpetas lógicas. Se declaran con namespace al inicio del archivo.

Para usar una clase de otro namespace, la importás con use al inicio del archivo —el equivalente del import de Java/TS o el from … import de Python. El estándar PSR-4 conecta cada namespace con una carpeta, así que el autoloader encuentra la clase sin que la incluyas a mano.

Sintaxis — comparada en 4 lenguajes

// archivo: src/Domain/Order.php
namespace App\Domain;

class Order { /* ... */ }

// ───────────────────────────────────────────
// archivo: src/Http/OrderController.php
namespace App\Http;

use App\Domain\Order;

class OrderController
{
    public function show(): Order
    {
        return new Order();
    }
}

// Java: package + import, la idea es la misma.
package app.domain;
class Order { /* ... */ }

package app.http;
import app.domain.Order;
class OrderController { /* usa Order */ }

// TS: import desde una ruta de archivo (no un namespace lógico).
import { Order } from '../domain/order';

class OrderController {
    show(): Order { return new Order(); }
}

# Python: módulos y paquetes, con from ... import.
from app.domain.order import Order

class OrderController:
    def show(self) -> Order:
        return Order()

Nota

La barra de namespaces es \ (backslash), no /. Y el estándar PSR-4 mapea App\Domain\Order al archivo src/Domain/Order.php — por eso Composer encuentra todo sin require manuales.

Autoevaluación

¿Para qué sirve use App\Domain\Order; al inicio de un archivo PHP?

Para profundizar

Esta guía cubre lo esencial. Para el resto:

Manual oficial de PHP — la referencia completa del lenguaje, en español.
PSR-12 — el estándar de estilo de código que conviene seguir desde el principio.
Con esta base ya podés leer cómodamente los ejemplos de patrones del curso. Si una pieza de sintaxis te frena, volvé a la sección que la cubre.