JavaScript Academy · Lección

Funciones de fábrica

Cree objetos con estado privado mediante clausuras.

Funciones de fábrica es una lección gratuita de JavaScript Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de JavaScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de JavaScript Academy incluye 4 lecciones en total.

Qué es una función factoría

Una función factoría es cualquier función que devuelve un objeto nuevo. A diferencia de un constructor, se llama normalmente (sin new) y puede utilizar clausuras para mantener un estado privado.

function createUser(name) {
  return {
    name,
    greet: () => "Hi, I am " + name
  };
}
const u = createUser("Ada");
console.log(u.greet()); // "Hi, I am Ada"

Sin la palabra clave new

Las factorías evitan los inconvenientes de new y this. Solo tiene que llamar a la función para obtener un objeto.

function point(x, y) {
  return { x, y };
}
const p = point(3, 4);
console.log(p.x, p.y); // 3 4

Estado privado mediante una clausura

Las variables declaradas en la factoría son privadas. Los métodos del objeto devuelto forman una clausura sobre ellas, igual que en el patrón módulo, pero producen varias instancias.

function createCounter() {
  let count = 0; // private
  return {
    inc: () => ++count,
    get: () => count
  };
}
const c = createCounter();
c.inc();
console.log(c.get()); // 1

Muchas instancias independientes

Cada llamada a la factoría produce un objeto nuevo con su propio estado privado. Esta es la diferencia clave respecto a un módulo singleton.

function createCounter() {
  let n = 0;
  return { inc: () => ++n };
}
const a = createCounter();
const b = createCounter();
console.log(a.inc(), a.inc()); // 1 2
console.log(b.inc());          // 1

Propiedades calculadas

Las factorías pueden derivar valores en el momento de la creación y exponer métodos calculados, manteniendo privadas las entradas.

function rectangle(w, h) {
  return {
    area: () => w * h,
    perimeter: () => 2 * (w + h)
  };
}
const r = rectangle(3, 4);
console.log(r.area());      // 12
console.log(r.perimeter()); // 14

Configuración predeterminada y opcional

Como son funciones normales, las factorías gestionan fácilmente los valores predeterminados y las opciones mediante la desestructuración.

function createButton({ label = "OK", disabled = false } = {}) {
  return { label, disabled };
}
console.log(createButton());             // { label: "OK", disabled: false }
console.log(createButton({ label: "Go" })); // { label: "Go", disabled: false }

Composición en lugar de herencia

Las factorías favorecen la composición: construya un objeto combinando comportamientos en lugar de extender una cadena de clases.

const canFly = (s) => ({ fly: () => s.name + " flies" });
function createBird(name) {
  const self = { name };
  return Object.assign(self, canFly(self));
}
console.log(createBird("Robin").fly()); // "Robin flies"

Comportamiento compartido

Para compartir métodos entre instancias sin crear copias por instancia, defínalos una vez y asígnelos. También puede aceptar el pequeño coste a cambio de la privacidad que proporcionan las clausuras.

const behavior = {
  describe() { return "id " + this.id; }
};
function createItem(id) {
  return Object.assign({ id }, behavior);
}
console.log(createItem(7).describe()); // "id 7"

Devolver también funciones

Una factoría puede devolver una función en lugar de un objeto cuando esa sea la interfaz más clara, manteniendo igualmente el estado privado capturado.

function multiplier(factor) {
  return (n) => n * factor;
}
const triple = multiplier(3);
console.log(triple(5)); // 15

Factoría frente a constructor

Los constructores utilizan new, this y la cadena de prototipos. Las factorías son más sencillas, evitan los errores relacionados con this y proporcionan privacidad real mediante clausuras, a cambio de no compartir métodos mediante un prototipo.

Validación durante la creación

Las factorías pueden validar las entradas y lanzar un error o normalizarlas antes de devolver el objeto, garantizando que todos los objetos producidos sean válidos.

function createAge(value) {
  if (value < 0) throw new Error("age must be >= 0");
  return { value };
}
console.log(createAge(30).value); // 30

Comprobación rápida

Funciones factoría.

Resumen

Las funciones factoría devuelven objetos sin new ni this y utilizan clausuras para mantener un estado privado. Cada llamada produce una instancia independiente y admite propiedades calculadas, configuración predeterminada, composición y validación. Renuncian a compartir métodos mediante prototipos a cambio de sencillez y privacidad real, lo que las convierte en una alternativa clara a los constructores basada en clausuras.

Preguntas frecuentes

¿La lección «Funciones de fábrica» es gratis?

Sí — el texto completo de «Funciones de fábrica» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de JavaScript Academy, actualiza a CoddyKit PRO. El curso de JavaScript Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Funciones de fábrica»?

Cree objetos con estado privado mediante clausuras. Practicas JavaScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar JavaScript Academy?

No se requiere experiencia previa. JavaScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Funciones de fábrica»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de JavaScript Academy?

Sí. Cada lección de JavaScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a JavaScript Academy