Patrón Builder

class Ordenador:
    """Un ordenador a medida: dos piezas obligatorias y muchas opcionales."""

    def __init__(self, builder):
        self._procesador = builder.procesador
        self._ram = builder.ram
        self._disco_gb = builder.disco_gb
        self._grafica = builder.grafica
        self._wifi = builder.wifi
        self._sistema = builder.sistema

    @staticmethod
    def builder(procesador, ram):
        return Ordenador.Builder(procesador, ram)

    def __str__(self):
        return (f"{self._procesador}, {self._ram} GB de RAM, {self._disco_gb} GB de disco"
                + (f", gráfica {self._grafica}" if self._grafica else "")
                + (", wifi" if self._wifi else "") + f", {self._sistema}")

    class Builder:
        def __init__(self, procesador, ram):
            self.procesador = procesador             # obligatorios
            self.ram = ram
            self.disco_gb = 512                      # opcionales, con su valor por defecto
            self.grafica = None
            self.wifi = False
            self.sistema = "sin sistema operativo"

        # Cada método devuelve el propio builder: así las llamadas se encadenan
        def disco(self, gb):
            self.disco_gb = gb
            return self

        def con_grafica(self, modelo):
            self.grafica = modelo
            return self

        def con_wifi(self):
            self.wifi = True
            return self

        def con_sistema(self, nombre):
            self.sistema = nombre
            return self

        def build(self):
            """Valida una sola vez, con todo ya elegido, y crea el objeto."""
            if self.ram not in (8, 16, 32, 64):
                raise ValueError(f"RAM no válida: {self.ram} GB")
            if self.grafica and self.ram < 16:
                raise ValueError("con gráfica dedicada hacen falta 16 GB de RAM")
            return Ordenador(self)


oficina = Ordenador.builder("Ryzen 5", 16).build()
juegos = (Ordenador.builder("Core i7", 32)
          .disco(2000)
          .con_grafica("RTX 4070")
          .con_wifi()
          .con_sistema("Windows 11")
          .build())
print(f"Oficina: {oficina}")
print(f"Juegos: {juegos}")
try:
    Ordenador.builder("Celeron", 8).con_grafica("RTX 4090").build()
except ValueError as e:
    print(f"No se crea: {e}")

/** Un ordenador a medida: dos piezas obligatorias y muchas opcionales. */
class Ordenador {
    #procesador; #ram; #discoGb; #grafica; #wifi; #sistema;

    constructor(builder) {          // JavaScript no tiene constructores privados: se crea siempre con el builder
        this.#procesador = builder.procesador;
        this.#ram = builder.ram;
        this.#discoGb = builder.discoGb;
        this.#grafica = builder.grafica;
        this.#wifi = builder.wifi;
        this.#sistema = builder.sistema;
    }

    static builder(procesador, ram) { return new OrdenadorBuilder(procesador, ram); }

    toString() {
        return `${this.#procesador}, ${this.#ram} GB de RAM, ${this.#discoGb} GB de disco`
            + (this.#grafica ? `, gráfica ${this.#grafica}` : "")
            + (this.#wifi ? ", wifi" : "") + `, ${this.#sistema}`;
    }
}

class OrdenadorBuilder {
    constructor(procesador, ram) {
        this.procesador = procesador;           // obligatorios
        this.ram = ram;
        this.discoGb = 512;                     // opcionales, con su valor por defecto
        this.grafica = null;
        this.wifi = false;
        this.sistema = "sin sistema operativo";
    }

    // Cada método devuelve el propio builder: así las llamadas se encadenan
    disco(gb) { this.discoGb = gb; return this; }
    conGrafica(modelo) { this.grafica = modelo; return this; }
    conWifi() { this.wifi = true; return this; }
    conSistema(nombre) { this.sistema = nombre; return this; }

    /** Valida una sola vez, con todo ya elegido, y crea el objeto. */
    build() {
        if (![8, 16, 32, 64].includes(this.ram)) throw new Error(`RAM no válida: ${this.ram} GB`);
        if (this.grafica && this.ram < 16) throw new Error("con gráfica dedicada hacen falta 16 GB de RAM");
        return new Ordenador(this);
    }
}

const oficina = Ordenador.builder("Ryzen 5", 16).build();
const juegos = Ordenador.builder("Core i7", 32)
    .disco(2000)
    .conGrafica("RTX 4070")
    .conWifi()
    .conSistema("Windows 11")
    .build();
console.log(`Oficina: ${oficina}`);
console.log(`Juegos: ${juegos}`);
try {
    Ordenador.builder("Celeron", 8).conGrafica("RTX 4090").build();
} catch (e) {
    console.log(`No se crea: ${e.message}`);
}

using System;

// Un ordenador a medida: dos piezas obligatorias y muchas opcionales. Inmutable una vez creado.
class Ordenador {
    private readonly string procesador;
    private readonly int ram;
    private readonly int discoGb;
    private readonly string? grafica;
    private readonly bool wifi;
    private readonly string sistema;

    private Ordenador(Builder b) {                       // solo el builder (clase anidada) puede crearlo
        procesador = b.procesador;
        ram = b.ram;
        discoGb = b.discoGb;
        grafica = b.grafica;
        wifi = b.wifi;
        sistema = b.sistema;
    }

    public static Builder Crear(string procesador, int ram) => new(procesador, ram);

    public override string ToString() =>
        
quot;{procesador}, {ram} GB de RAM, {discoGb} GB de disco"
        + (grafica != null ? 
quot;, gráfica {grafica}" : "")
        + (wifi ? ", wifi" : "") + 
quot;, {sistema}";

    public class Builder {
        internal readonly string procesador;             // obligatorios
        internal readonly int ram;
        internal int discoGb = 512;                       // opcionales, con su valor por defecto
        internal string? grafica;
        internal bool wifi;
        internal string sistema = "sin sistema operativo";

        internal Builder(string procesador, int ram) {
            this.procesador = procesador;
            this.ram = ram;
        }

        // Cada método devuelve el propio builder: así las llamadas se encadenan
        public Builder Disco(int gb) { discoGb = gb; return this; }
        public Builder Grafica(string modelo) { grafica = modelo; return this; }
        public Builder ConWifi() { wifi = true; return this; }
        public Builder Sistema(string nombre) { sistema = nombre; return this; }

        // Valida una sola vez, con todo ya elegido, y crea el objeto.
        public Ordenador Build() {
            if (ram is not (8 or 16 or 32 or 64)) throw new InvalidOperationException(
quot;RAM no válida: {ram} GB");
            if (grafica != null && ram < 16) throw new InvalidOperationException("con gráfica dedicada hacen falta 16 GB de RAM");
            return new Ordenador(this);
        }
    }
}

class Program {
    static void Main() {
        Ordenador oficina = Ordenador.Crear("Ryzen 5", 16).Build();
        Ordenador juegos = Ordenador.Crear("Core i7", 32)
            .Disco(2000)
            .Grafica("RTX 4070")
            .ConWifi()
            .Sistema("Windows 11")
            .Build();
        Console.WriteLine(
quot;Oficina: {oficina}");
        Console.WriteLine(
quot;Juegos: {juegos}");
        try {
            Ordenador.Crear("Celeron", 8).Grafica("RTX 4090").Build();
        } catch (InvalidOperationException e) {
            Console.WriteLine(
quot;No se crea: {e.Message}");
        }
    }
}

<?php
/** Un ordenador a medida: dos piezas obligatorias y muchas opcionales. Inmutable una vez creado. */
final class Ordenador {
    private function __construct(
        private string $procesador,
        private int $ram,
        private int $discoGb,
        private ?string $grafica,
        private bool $wifi,
        private string $sistema,
    ) {}

    public static function builder(string $procesador, int $ram): OrdenadorBuilder {
        return new OrdenadorBuilder($procesador, $ram);
    }

    /** Lo usa el builder: PHP no tiene clases anidadas que puedan llamar al constructor privado. */
    public static function desde(OrdenadorBuilder $b): self {
        return new self($b->procesador, $b->ram, $b->discoGb, $b->grafica, $b->wifi, $b->sistema);
    }

    public function __toString(): string {
        return "{$this->procesador}, {$this->ram} GB de RAM, {$this->discoGb} GB de disco"
            . ($this->grafica !== null ? ", gráfica {$this->grafica}" : "")
            . ($this->wifi ? ", wifi" : "") . ", {$this->sistema}";
    }
}

final class OrdenadorBuilder {
    public int $discoGb = 512;                      // opcionales, con su valor por defecto
    public ?string $grafica = null;
    public bool $wifi = false;
    public string $sistema = "sin sistema operativo";

    public function __construct(public string $procesador, public int $ram) {}   // obligatorios

    // Cada método devuelve el propio builder: así las llamadas se encadenan
    public function disco(int $gb): self { $this->discoGb = $gb; return $this; }
    public function grafica(string $modelo): self { $this->grafica = $modelo; return $this; }
    public function conWifi(): self { $this->wifi = true; return $this; }
    public function sistema(string $nombre): self { $this->sistema = $nombre; return $this; }

    /** Valida una sola vez, con todo ya elegido, y crea el objeto. */
    public function build(): Ordenador {
        if (!in_array($this->ram, [8, 16, 32, 64], true)) throw new LogicException("RAM no válida: {$this->ram} GB");
        if ($this->grafica !== null && $this->ram < 16) throw new LogicException("con gráfica dedicada hacen falta 16 GB de RAM");
        return Ordenador::desde($this);
    }
}

$oficina = Ordenador::builder("Ryzen 5", 16)->build();
$juegos = Ordenador::builder("Core i7", 32)
    ->disco(2000)
    ->grafica("RTX 4070")
    ->conWifi()
    ->sistema("Windows 11")
    ->build();
echo "Oficina: $oficina\n";
echo "Juegos: $juegos\n";
try {
    Ordenador::builder("Celeron", 8)->grafica("RTX 4090")->build();
} catch (LogicException $e) {
    echo "No se crea: ", $e->getMessage(), "\n";
}

# En Python se usan sobre todo parámetros con nombre y valores por defecto: cubren casi lo mismo
@dataclass(frozen=True)
class Alumno:
    nombre: str
    email: str = ""
    curso: int = 1


a = Alumno("Ana", curso=2)

# Builders de verdad en las bibliotecas de consultas (SQLAlchemy):
consulta = select(Alumno).where(Alumno.nota >= 5).order_by(Alumno.nota.desc()).limit(10)

# Para montar textos largos, "".join(...) en lugar de sumar en un bucle
linea = ";".join(["Ana", "DAM", "8.5"])

// En JavaScript lo habitual es un objeto de opciones con valores por defecto
function crearOrdenador({ procesador, ram, disco = 512, wifi = false, sistema = "sin sistema operativo" }) {
    return { procesador, ram, disco, wifi, sistema };
}
crearOrdenador({ procesador: "Ryzen 5", ram: 16, wifi: true });

// La plataforma también tiene builders: URL y URLSearchParams montan una dirección paso a paso
const url = new URL("https://api.ejemplo.com/alumnos");
url.searchParams.append("ciclo", "DAM");
url.searchParams.append("orden", "nota");

// Y en Node, los query builders como Knex:
const aprobados = await knex("alumnos").where("nota", ">=", 5).orderBy("nota", "desc").limit(10);

// StringBuilder, el builder de toda la vida
var sb = new StringBuilder().Append("Ana").Append(';').Append("DAM");

// ASP.NET Core arranca con un builder
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
var app = builder.Build();

// Para objetos sencillos, C# tiene inicializadores y argumentos con nombre
var alumno = new Alumno { Nombre = "Ana", Curso = 2 };
var pc = new Ordenador("Ryzen 5", ram: 16, wifi: true);

<?php
// El query builder de Laravel es un builder: se encadena y get() hace de build()
$aprobados = DB::table("alumnos")
    ->where("nota", ">=", 5)
    ->orderBy("nota", "desc")
    ->limit(10)
    ->get();

// Desde PHP 8, los argumentos con nombre evitan muchos builders pequeños
$pc = new Ordenador(procesador: "Ryzen 5", ram: 16, wifi: true);