Clase 11 - Miércoles, 21 de octubre de 2026 (21 10 26) - Desarrollo de sistemas web frontend
Manual de Estudio Integral: Desarrollo Web Frontend, Estructuras de Datos, JavaScript Avanzado y Proyectos Académicos
1. Introducción General
Contexto del Tema
El desarrollo web frontend moderno exige un dominio profundo de JavaScript como lenguaje de programación dinámico, no solo en la manipulación básica del Document Object Model (DOM), sino también en la gestión de estructuras de datos complejas, el procesamiento de cadenas de texto (strings) y arreglos (arrays), y la integración con entornos de ejecución y servicios externos (APIs REST).
Este manual sistematiza las unidades temáticas relativas a JavaScript 4 y JavaScript 5, abordando la transición operativa desde la manipulación local de datos hasta la comprensión de la arquitectura de objetos globales y el consumo de servicios web. Asimismo, se integran los lineamientos normativos y metodológicos para el desarrollo de los Trabajos Prácticos Obligatorios (TPO1 y TPO2) de la materia.
Importancia y Relevancia
El conocimiento detallado de los métodos de arrays y strings constituye el pilar fundamental para superar evaluaciones técnicas y resolver desafíos reales en el ámbito laboral. La tarea recurrente en el desarrollo frontend consiste en consumir recursos desde una API REST externa, procesar e iterar sobre colecciones de datos (arrays de objetos) y renderizar dichos contenidos dinámicamente en la interfaz de usuario.
Comprender la naturaleza de los entornos de ejecución (el navegador web frente a Node.js) y la infraestructura de objetos globales permite al estudiante redactar código eficiente, escalable y mantenible, sentando las bases para materias avanzadas como Seminario de Profundización y Actualización (enfocada en desarrollo Full Stack y administración de entornos Linux).
2. Marco Conceptual
Definición de Conceptos Clave
- JavaScript (JS): Lenguaje de programación interpretado, multiparadigma y monohilo (single-threaded), utilizado primordialmente para dotar de dinamismo e interactividad a las páginas web.
- Array (Arreglo o Vector): Estructura de datos lineal que almacena una colección ordenada de elementos bajo un único nombre de variable. Los elementos se posicionan mediante índices numéricos enteros basados en cero (0).
- Objeto (Object): Estructura de datos no lineal basada en pares clave-valor (key-value). Permite agrupar atributos (propiedades) y comportamientos (métodos) de una entidad específica.
- Tipo Primitivo: Dato básico que no es un objeto y no posee métodos propios (ejemplos:
string,number,boolean,undefined,null). - Object Wrapper (Envoltorio de Objeto): Mecanismo interno mediante el cual JavaScript envuelve temporalmente un dato de tipo primitivo en un objeto correspondiente (
String,Number,Boolean) para permitir el acceso a propiedades y métodos útiles. - Objeto Global: Objeto predefinido y accesible en cualquier punto del programa sin necesidad de declaración e importación explícita, cuya estructura depende del entorno de ejecución.
- Entorno de Ejecución (Runtime Environment): Infraestructura o contexto donde se ejecuta el código JavaScript (por ejemplo, el navegador web o Node.js), el cual provee objetos y APIs adicionales que extienden las capacidades del lenguaje base.
- API (Application Programming Interface): Conjunto de funciones, métodos y herramientas predefinidas que expone un sistema para permitir la interacción y comunicación con otros programas o componentes.
- API REST (Representational State Transfer): Convención arquitectónica sobre el protocolo HTTP que define reglas para el intercambio de datos entre un cliente (frontend) y un servidor (backend) a través de rutas específicas (endpoints).
- JSON (JavaScript Object Notation): Formato ligero e independiente de texto plano utilizado para el intercambio de datos, estructurado sintácticamente como texto con formato de pares clave-valor.
3. Desarrollo del Tema
3.1. Estructuras de Datos Principales: Arrays u Objetos
En JavaScript, la elección entre utilizar un Array o un Objeto depende directamente de la naturaleza de los datos y de cómo se prevé acceder a ellos.
┌─────────────────────────────────────────┐
│ Estructuras de Datos (JS) │
└────────────────────┬────────────────────┘
│
┌──────────────────────────┴──────────────────────────┐
▼ ▼
┌───────────────────────┐ ┌───────────────────────┐
│ Arrays │ │ Objetos │
├───────────────────────┤ ├───────────────────────┤
│ • Colección ordenada │ │ • Colección de pares │
│ de elementos. │ │ clave-valor. │
│ • Acceso por índice │ │ • Acceso por propiedad│
│ numérico (0, 1, 2) │ │ (punto o corchete). │
│ • Ideal para listas │ │ • Ideal para entidades│
│ homogéneas. │ │ estructuradas. │
└───────────────────────┘ └───────────────────────┘
Arrays (Arreglos)
Un Array es ideal para almacenar colecciones ordenadas donde el criterio de acceso principal es la posición relativa de los elementos.
- Acceso: Se realiza mediante notación de corchetes e índice numérico:
frutas[0]. - Uso común: Listas de nombres, colecciones de productos devueltas por una base de datos, secuencias numéricas.
Objetos LIterales
Un Objeto se utiliza cuando se requiere representar una entidad del mundo real o un conjunto estructurado de datos con atributos bien definidos.
- Estructura: Claves (strings que actúan como identificadores) asociadas a valores (que pueden ser cualquier tipo de dato, incluidos otros objetos o funciones).
- Acceso a datos:
- Notación de punto:
objeto.propiedad(utilizada cuando se conoce el nombre exacto de la clave). - Notación de corchetes:
objeto['propiedad'](utilizada para evaluación dinámica de claves mediante variables).
- Notación de punto:
- Operaciones básicas:
- Agregar/Modificar:
persona.pais = "Argentina"; - Eliminar:
delete persona.edad; - Métodos: Funciones declaradas dentro de un objeto que definen un comportamiento (ejemplo: método de un objeto
perroque ejecuta una instrucción para emitir un sonido).
- Agregar/Modificar:
3.2. El Fenómeno de los Object Wrappers
Ocurre una aparente contradicción técnica al ejecutar código en JavaScript: un dato de tipo string es un tipo primitivo (no un objeto), pero es posible acceder a propiedades y métodos mediante la notación de punto (por ejemplo, "hola".length o "hola".toUpperCase()).
Explicación del Mecanismo
Para facilitar el desarrollo, JavaScript aplica un proceso denominado Object Wrapper:
- Cuando se intenta acceder a una propiedad o método sobre un dato primitivo, JavaScript crea de forma transparente e interna un objeto temporal envoltorio (utilizando constructores internos como
new String(),new Number()onew Boolean()). - El método o propiedad es evaluado sobre dicho objeto envoltorio.
- El objeto temporal es destruido inmediatamente por el entorno de ejecución, devolviendo el resultado primitivo correspondiente.
// Declaración de un dato primitivo
let saludo = "hola";
// Lo que ejecuta internamente JavaScript al invocar un método:
// 1. Envoltorio temporal: let temp = new String(saludo);
// 2. Ejecución del método: let resultado = temp.toUpperCase();
// 3. Destrucción de 'temp' y retorno del valor.
Aclaración para Entrevistas Técnicas: Ante la pregunta "¿En JavaScript todo es un objeto?", la respuesta precisa es NO. Existen tipos de datos primitivos (string, number, boolean, etc.) que no son objetos; sin embargo, JavaScript los procesa temporalmente como si lo fueran mediante object wrappers para exponer un catálogo amplio de métodos.
3.3. Catálogo Exhaustivo de Métodos de Strings
Los métodos de strings son funciones integradas para la manipulación, búsqueda, extracción y transformación de texto.
| Método | Descripción / Comportamiento | Ejemplo / Resultado |
.length | Propiedad que devuelve la cantidad total de caracteres. | "Hola".length \rightarrow 4 |
.charAt(index) | Devuelve el carácter ubicado en la posición especificada. | "Texto".charAt(1) \rightarrow "e" |
.concat(...) | Combina dos o más cadenas de texto. | "Hola ".concat("Mundo") \rightarrow "Hola Mundo" |
.includes(sub) | Devuelve true si la subcadena existe. Es case-sensitive. | "Script".includes("script") \rightarrow false |
.startsWith(sub) | Evalúa si la cadena comienza con la subcadena indicada. | "Frontend".startsWith("Fro") \rightarrow true |
.endsWith(sub) | Evalúa si la cadena finaliza con la subcadena indicada. | "Archivo.pdf".endsWith(".pdf") \rightarrow true |
.indexOf(sub) | Devuelve la primera posición del substring o -1 si no existe. | "Banana".indexOf("a") \rightarrow 1 |
.lastIndexOf(sub) | Devuelve la última posición del substring dentro de la cadena. | "Banana".lastIndexOf("a") \rightarrow 5 |
.replace(old, new) | Reemplaza la primera aparición del texto buscado. | "Hola Mundo".replace("Mundo", "Profe") \rightarrow "Hola Profe" |
.replaceAll(old, new) | Reemplaza todas las apariciones del texto especificado. | "1,2,3".replaceAll(",", "-") \rightarrow "1-2-3" |
.toLowerCase() | Convierte todos los caracteres a minúsculas. | "HOLA".toLowerCase() \rightarrow "hola" |
.toUpperCase() | Convierte todos los caracteres a mayúsculas. | "hola".toUpperCase() \rightarrow "HOLA" |
.trim() | Elimina espacios en blanco en ambos extremos de la cadena. | " hola ".trim() \rightarrow "hola" |
.trimStart() / .trimEnd() | Elimina espacios únicamente al inicio o al final. | " test ".trimStart() \rightarrow "test " |
.slice(start, end) | Extrae una porción. Acepta índices negativos (cuenta desde el final). | "JavaScript".slice(-6) \rightarrow "Script" |
.substring(start, end) | Similar a slice, pero no admite valores negativos. | "JavaScript".substring(0, 4) \rightarrow "Java" |
.split(sep) | Divide el string en un Array utilizando un separador. | "A,B,C".split(",") \rightarrow ["A", "B", "C"] |
.repeat(n) | Devuelve la cadena repetida n veces. | "Ja".repeat(3) \rightarrow "JaJaJa" |
.match(regex) | Busca coincidencias utilizando Expresiones Regulares (Regex). | Devuelve un arreglo con las coincidencias halladas. |
3.4. Catálogo Exhaustivo de Métodos de Arrays (Parte 1)
Los arreglos disponen de métodos para mutar su contenido, extraer fragmentos, agregar o quitar elementos, y transformar su estructura.
Métodos Fundamentales de Arrays
│
┌───────────────────────────┴───────────────────────────┐
▼ ▼
Modificadores No Modificadores
(Mutan el Array) (Generan nuevo valor)
───────────────── ──────────────────────
• push(elem) (Inserta al final) • concat(arr) (Une arreglos)
• pop() (Elimina del final) • join(sep) (Convierte a String)
• unshift(elem)(Inserta al inicio) • slice(s, e) (Copia parcial)
• shift() (Elimina del inicio) • includes(e) (Retorna buleano)
• splice(...) (Modificación compleja) • indexOf(e) (Retorna índice)
Operaciones Elementales
**.length**: Propiedad que retorna el número de elementos.**.push(elemento)**: Agrega uno o más elementos al final del arreglo. Modifica el array original.**.pop()**: Elimina el último elemento del arreglo y lo devuelve. Modifica el array original.**.unshift(elemento)**: Agrega uno o más elementos al inicio del arreglo. Modifica el array original.**.shift()**: Elimina el primer elemento del arreglo y lo devuelve. Modifica el array original.
Operaciones de Combinación y Transformación
**.concat(array2)**: Combina dos o más arreglos. Retorna un nuevo arreglo sin alterar los originales.**.join(separador)**: Une todos los elementos de un array en un únicostring, separados por el delimitador provisto (por ejemplo,","o"/").**.slice(inicio, fin)**: Devuelve una copia de una parte del array dentro de un nuevo arreglo (el límite superior no se incluye).**.splice(inicio, cantidadAEliminar, item1, item2, ...)**: Método versátil que altera el contenido del arreglo original. Permite eliminar elementos a partir de un índice, e insertar nuevos elementos opcionalmente en esa misma posición.**.indexOf(elemento)**/**.lastIndexOf(elemento)**: Buscan la primera o última posición de un elemento dentro del array. Devuelven-1si no lo encuentran.**.includes(elemento)**: Verifica la presencia de un elemento, retornandotrueofalse.
Resumen Parcial: Sección 3.1 a 3.4
- Las estructuras primitivas usan Object Wrappers internamente para operar con métodos sintácticamente similares a los de un objeto.
- El método
.split()transforma unstringen unarray, mientras que.join()realiza la operación inversa, convirtiendo unarrayen unstring. .push()/.pop()operan en el extremo final de un array;.unshift()/.shift()operan en el extremo inicial..slice()crea copias sin mutar;.splice()modifica directamente el array original.
3.5. JavaScript 5: Objetos Globales y Entornos de Ejecución
Un objeto global es una estructura predefinida accesible en cualquier punto del ámbito (scope) sin declaración explícita. Sin embargo, su identidad y propiedades dependen del entorno de ejecución donde corre JavaScript.
┌──────────────────────────────────────────┐
│ Entornos de Ejecución │
└────────────────────┬─────────────────────┘
│
┌──────────────────────────┴──────────────────────────┐
▼ ▼
┌───────────────────────┐ ┌───────────────────────┐
│ Navegador │ │ Node.js │
├───────────────────────┤ ├───────────────────────┤
│ Objeto Global: │ │ Objeto Global: │
│ window │ │ global │
│ │ │ │
│ Incluye Web APIs: │ │ Incluye APIs del OS: │
│ • document (DOM) │ │ • process │
│ • localStorage │ │ • __dirname │
│ • fetch │ │ • Módulos fs, http │
└───────────────────────┘ └───────────────────────┘
Comparación de Entornos
- Navegador Web (Browser):
- Objeto Global Raíz:
window. - Toda variable global declarada con
varo función global se anexa automáticamente como propiedad del objetowindow. - Provee acceso a interfaces para manipular la interfaz gráfica y la ventana activa del navegador.
- Objeto Global Raíz:
- Node.js:
- Motor de ejecución de JavaScript fuera del navegador, basado en el motor V8 de Google Chrome.
- Objeto Global Raíz:
global. - Sustituye la manipulación de la interfaz gráfica por herramientas de interacción con el sistema operativo (sistema de archivos, red, procesos).
Principales Funcionalidades y Web APIs del Objeto window (Navegador)
El objeto window actúa como contenedor global del cual heredan múltiples sub-objetos y utilidades:
**document**: Representa la página web cargada (DOM). Es la puerta de entrada para seleccionar y manipular elementos HTML mediante código.**console**: Objeto global que provee acceso a la consola de depuración del entorno (console.log(),console.error(),console.warn(),console.clear(),console.table()).- Alertas y Diálogos:
alert()(mensaje flotante),prompt()(entrada de texto),confirm()(diálogo de confirmación con retorno buleano). **location**: Contiene la información de la URL activa (window.location.href).**navigator**: Provee información del navegador y del sistema operativo del cliente (navigator.userAgent).**localStorage**/**sessionStorage**: APIs de almacenamiento persistente en el cliente.**history**: Permite interactuar con el historial de navegación de la pestaña (history.back()).- Temporizadores:
setTimeout()(ejecuta código tras un diferimiento) ysetInterval()(ejecuta código en bucles periódicos). **fetch**/**XMLHttpRequest**: Interfaces para realizar solicitudes HTTP asíncronas a servidores remotos.
3.6. Web APIs y Arquitectura de Servicios REST
Concepto de API Web
Una Web API comprende un conjunto de métodos y objetos expuestos por el navegador que no forman parte del lenguaje JavaScript estandarizado (ECMAScript), sino del entorno de ejecución. Ejemplos de esto son la manipulación del DOM, el uso de la consola, las utilidades de almacenamiento y la función fetch().
Definición de Servidor
En arquitectura de software, un servidor puede definirse bajo dos perspectivas complementarias:
- Perspectiva de Hardware: Computadora física o máquina virtual especializada, optimizada para ejecutar software de red de manera ininterrumpida.
- Perspectiva de Software: Proceso o aplicación en ejecución constante (daemon o servicio) que escucha peticiones en un puerto de red específico y genera respuestas bajo un protocolo determinado (principalmente HTTP).
Arquitectura REST y Protocolo HTTP
Una API REST es una convención arquitectónica sobre HTTP que permite la comunicación estructurada entre el cliente (frontend) y el servidor (backend). Las operaciones de lectura, creación, actualización y eliminación de datos (operaciones CRUD: Create, Read, Update, Delete) se gestionan mediante Verbos HTTP:
| Verbo HTTP | Operación CRUD | Acción Esperada en el Servidor |
**GET** | Read (Lectura) | Solicita y obtiene recursos sin modificar el estado del servidor. |
**POST** | Create (Creación) | Envía datos en el cuerpo (body) para crear un nuevo registro. |
**PUT** / **PATCH** | Update (Actualización) | Modifica un recurso existente (total o parcialmente). |
**DELETE** | Delete (Eliminación) | Remueve un recurso especificado mediante un identificador. |
Definición de Endpoint
Un Endpoint es la combinación unívoca de una ruta URL y un verbo HTTP específico exposed por un servidor.
Ejemplo: La URL https://api.ejemplo.com/posts atendida con un verbo GET constituye un endpoint para obtener publicaciones; la misma URL https://api.ejemplo.com/posts atendida con un verbo POST constituye un endpoint distinto cuya función es registrar una nueva publicación.
Intercambio de Datos mediante JSON
El intercambio de información entre frontend y backend se realiza en formato JSON. Un archivo o respuesta JSON es conceptualmente un string en texto plano estructurado bajo reglas sintácticas estrictas (claves entre comillas dobles). JavaScript ofrece métodos globales para convertir estas estructuras:
JSON.stringify(objeto): Convierte un objeto o array de JS a una cadena de texto en formato JSON.JSON.parse(stringJSON): Convierte un string en formato JSON a un objeto o array interactivo de JS.
3.7. Especificaciones de Evaluación Práctica: TPO1 y TPO2
Los Trabajos Prácticos Obligatorios (TPO) representan la instancia de evaluación práctica grupal de la asignatura.
Trabajos Prácticos Obligatorios
│
┌───────────────────────────┴───────────────────────────┐
▼ ▼
TPO1 TPO2
────────────────────────────────── ──────────────────────────────────
• Maquetado e Interfaz Web • Consumo de API REST
• Clonación de "Tienda de Café" • Integración con Fetch / JSON
• Adaptación a temática libre • Dinamismo completo del DOM
• 7 Páginas estáticas • Exposición y defensa final
• Entrega: Penúltima Clase • Entrega: Última Clase
Especificaciones Generales
- Modalidad: Trabajo grupal colaborativo (vía Git y GitHub). Aquellos alumnos inscritos en el régimen de articulaciones quedan eximidos de la modalidad grupal estándar según las pautas de cátedra.
- Despliegue (Deployment): La entrega exige la publicación del sitio web en una plataforma de hosting gratuita (GitHub Pages o Vercel).
- Estructura de Directorios Obligatoria:
- Raíz (
/): Archivos.html(ejemplo:index.html,tienda.html). /styles: Hojas de estilo.css./js: Ficheros de script.js./img: Archivos de imagen organizados./assets: Fuentes tipográficas, iconos y recursos multimedia adicionales.
- Raíz (
TPO 1: Clonación de Interfaz Web y Maquetado Avanzado
- Objetivo: Clonar la estructura maquetada del sitio de referencia ("Tienda de Café"), adaptándola creativamente a una nueva temática elegida por el equipo (por ejemplo: tienda de té, cerveza, vino, mate, etc.).
- Alcance: El sitio debe componerse de 7 páginas independientes (
index,tienda,tutoriales,menú,trabaja con nosotros,franquicias,contacto). - Excepción: La página de
localesqueda excluida del listado obligatorio (o puede resolverse opcionalmente mediante un mapa embebido coniframeu OpenStreetMap). - Requisitos Técnicos:
- Uso de HTML semántico y estructuración limpia del código.
- Uso estricto de Flexbox para el diseño de la maquetación.
- Unidades relativas y diseño adaptable a dispositivos móviles (Mobile Responsive).
- Estilizado con pseudo-clases, combinadores CSS y animaciones en estados de cernido (hover).
TPO 2: Maquetado Dinámico y Consumo de API REST
- Objetivo: Crear una interfaz gráfica funcional seleccionada libremente por el grupo, que consuma e integre datos dinámicos provenientes de una API REST pública (por ejemplo: JSONPlaceholder, APIs de noticias, del clima, de cotizaciones, etc.).
- Requisitos Técnicos:
- Implementación de peticiones HTTP asíncronas utilizando la API Web
**fetch()**. - Procesamiento del JSON recibido e iteración sobre los objetos devueltos.
- Renderizado e inserción dinámica de los contenidos dentro del DOM.
- Inclusión de un archivo
README.mddocumentando el proyecto.
- Implementación de peticiones HTTP asíncronas utilizando la API Web
Directiva de Integridad Académica sobre la Inteligencia Artificial (IA)
El docente enfatiza el uso ético y responsable de las herramientas de asistencia por IA (como ChatGPT):
- El objetivo pedagógico central de la cursada es el desarrollo de habilidades de pensamiento lógico y resolución de problemas.
- La generación automatizada e idéntica de código mediante IA sin comprensión conceptual es detectada en las instancias de evaluación y limita el aprendizaje práctico necesario para superar exámenes finales y pruebas técnicas laborales.
- Se exige que el código entregado sea producido y comprendido íntegramente por los integrantes del grupo.
4. Relaciones entre Conceptos
┌─────────────────────────────────────────────────────────────────────────────────┐
│ ARQUITECTURA DE DATOS Y DOM │
└─────────────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────────┐
│1. PETICIÓN Y CONSUMO (API REST) │
│ • El navegador ejecuta la Web API fetch() desde el objeto global window. │
│ • Se realiza una petición HTTP GET a un Endpoint específico. │
└─────────────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────────┐
│2. RECEPCIÓN Y PARSEO DE DATOS │
│ • El servidor responde con un String plano en formato JSON. │
│ • Mediante JSON.parse() o res.json(), el String se convierte en un Array de │
│ Objetos. │
└─────────────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────────┐
│3. MANIPULACIÓN Y TRANSFORMACIÓN │
│ • Se aplican métodos de Arrays (push, slice, splice) y métodos de Strings │
│ (toUpperCase, replace, trim) para limpiar los datos devueltos. │
└─────────────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────────┐
│4. RENDERIZADO EN PANTALLA │
│ • Se utiliza la API global document (DOM) para seleccionar elementos HTML y │
│ renderizar dinámicamente el resultado final. │
└─────────────────────────────────────────────────────────────────────────────────┘
5. Ejemplos Prácticos
Ejemplo 1: Procesamiento y Limpieza de Cadenas de Texto
Considérese la necesidad de procesar una entrada de usuario mal estructurada antes de enviarla a una base de datos.
// Cadena de texto de entrada con espacios irregulares y delimitadores mixtos
let entradaUsuario = " juan,pedro,maría,sofía ";
// Paso 1: Eliminar espacios en los extremos con trim()
let entradaLimpia = entradaUsuario.trim();
// Resultado: "juan,pedro,maría,sofía"
// Paso 2: Convertir todo a mayúsculas para homogenizar
let entradaMayusculas = entradaLimpia.toUpperCase();
// Resultado: "JUAN,PEDRO,MARÍA,SOFÍA"
// Paso 3: Dividir la cadena en un Array mediante split() usando la coma como separador
let listaNombres = entradaMayusculas.split(",");
// Resultado: ["JUAN", "PEDRO", "MARÍA", "SOFÍA"]
Ejemplo 2: Manipulación Estructurada de un Array mediante splice()
Se requiere gestionar una lista de elementos en un carrito o inventario, sustituyendo elementos intermedios.
let inventario = ["Café Espresso", "Café Latte", "Té Verde", "Jugo Natural"];
// Objetivo: Ubicarse en el índice 2 ("Té Verde"), eliminar 1 elemento y colocar en su lugar dos nuevos productos.
// Parámetros de splice: (índice_inicio, cantidad_eliminar, nuevo_elem1, nuevo_elem2)
inventario.splice(2, 1, "Té Negro", "Submarino");
// Resultado final del array mutado:
// ["Café Espresso", "Café Latte", "Té Negro", "Submarino", "Jugo Natural"]
Ejemplo 3: Interacción con Objetos Globales en el Navegador
Utilización de métodos globales de window para obtener información de entorno y solicitar confirmación interactiva.
// Obtener la URL activa a través de la propiedad location de window
let urlActual = window.location.href;
// Mostrar un diálogo interactivo de confirmación utilizando confirm()
let respuestaUsuario = window.confirm("¿Desea redirigir a la tienda?");
if (respuestaUsuario) {
// Si el usuario presiona OK (true), se registra en consola usando la API console
window.console.log("El usuario aceptó la redirección desde: " + urlActual);
} else {
window.console.warn("Redirección cancelada por el usuario.");
}
6. Errores Comunes y Confusiones
1. Creencia de que los Tipos Primitivos son Objetos
- Confusión: Afirmar que en JavaScript los strings o números son objetos porque poseen la propiedad
.lengtho métodos como.toLowerCase(). - Aclaración: Son tipos primitivos. La posibilidad de invocar métodos proviene del mecanismo interno de Object Wrappers, donde el entorno crea transitoriamente un objeto envoltorio que es destruido inmediatamente tras la ejecución.
2. Mutación Indebida vs. Retorno de Nuevos Valores
- Confusión: Suponer que todos los métodos de arreglos modifican la variable original.
- Aclaración:
- Métodos como
.push(),.pop(),.shift(),.unshift()y.splice()mutan el array original. - Métodos como
.slice(),.concat(),.split()o.join()no mutan el dato original, sino que devuelven un nuevo array, string o valor.
- Métodos como
3. Confusión entre .slice() y .splice() en Arrays
**slice(inicio, fin)**: Extrae una porción. No altera el array original. Recibe posiciones de corte.**splice(inicio, cantidad, [elementos])**: Modifica directamente el array original. Elimina una cantidad de elementos a partir de un índice e inserta nuevos opcionalmente.
4. Uso Incorregible de Rutas de Archivos en Maquetación HTML/CSS
- Confusión: Error recurrente al enlazar archivos CSS o imágenes en proyectos para entrega, provocando la pérdida de estilos tras el despliegue (deployment).
- Aclaración: Se deben verificar meticulosamente las rutas relativas en la estructura de carpetas (por ejemplo,
href="styles/style.css"osrc="img/foto.jpg"), asegurando la concordancia de nombres (respetando minúsculas y mayúsculas).
5. Copia Ciega de Código Generado por Inteligencia Artificial
- Confusión: Utilizar prompts en herramientas de IA para generar maquetados o scripts completos sin revisión manual.
- Aclaración: Genera estructuras genéricas e idénticas entre entregas, privando al alumno de desarrollar la capacidad de depuración técnica requerida para evaluaciones presenciales y el ejercicio profesional.
7. Síntesis y Conclusiones
Resumen Estructurado
SÍNTESIS DEL CURSO
│
┌────────────────────────────────────┼────────────────────────────────────┐
▼ ▼ ▼
JavaScript 4 JavaScript 5 Evaluación
─────────────────────────── ─────────────────────────── ───────────────────────────
• Manipulación de Strings • Entornos de Ejecución • TPO1: Maquetado
y Arrays. (Navegador vs Node). HTML/CSS, Flexbox,
• Tipos primitivos vs. • Objeto global raíz: 7 páginas (Entrega:
Object Wrappers. window / global. 18/11).
• Métodos mutables • Integración de Web • TPO2: Integración
(push, splice) e APIs (document, con API REST vía fetch()
inmutables (slice, concat). console, fetch). (Entrega: 25/11).
Ideas Principales Condensadas
- Doble Naturaleza de los Primitivos: Los tipos de datos primitivos en JS no son objetos, pero operan temporalmente como tales mediante Object Wrappers.
- Versatilidad de Métodos: Los métodos de strings y arrays permiten transformar estructuras de datos complejas. Operaciones de conversión como
.split()y.join()resultan esenciales para conectar datos de texto plano con arreglos. - Dependencia del Entorno: La disponibilidad de los objetos globales está condicionada por el entorno de ejecución:
windowen el navegador provee acceso al DOM y Web APIs;globalen Node.js provee herramientas de nivel de sistema operativo. - Consumo de Servicios REST: El desarrollo frontend moderno se basa en solicitar datos en formato JSON mediante peticiones HTTP asíncronas (
fetch), para luego iterar sobre arreglos de objetos y actualizar dinámicamente el DOM.
8. Preguntas de Repaso
Nivel Básico
- ¿Cuál es la diferencia principal en la forma de acceder a un elemento dentro de un Array frente a un Objeto literal?
- Respuesta: En un Array se accede mediante notación de corchetes e índice numérico basado en cero (
array[0]). En un Objeto se accede mediante la clave de la propiedad, utilizando notación de punto (objeto.propiedad) o corchetes con el nombre de la clave como string (objeto['propiedad']).
- Respuesta: En un Array se accede mediante notación de corchetes e índice numérico basado en cero (
- ¿Qué tipo de dato devuelve el método
**.includes()**aplicado a una cadena de texto o a un arreglo?- Respuesta: Devuelve un valor buleano:
truesi el elemento o subcadena se encuentra presente, ofalseen caso contrario.
- Respuesta: Devuelve un valor buleano:
- ¿Cuál es el nombre del objeto global raíz en el entorno del navegador web?
- Respuesta: El objeto global raíz es
window.
- Respuesta: El objeto global raíz es
Nivel Intermedio
- Explicar el concepto de Object Wrapper en JavaScript y resolver la duda de si "en JavaScript todo es un objeto".
- Respuesta: No todo en JavaScript es un objeto, ya que existen tipos primitivos (
string,number,boolean, etc.). Sin embargo, cuando se intenta acceder a un método sobre un primitivo, JavaScript envuelve el dato en un objeto temporal correspondiente (new String(), etc.) para ejecutar la propiedad o método y luego destruye el envoltorio transitorio.
- Respuesta: No todo en JavaScript es un objeto, ya que existen tipos primitivos (
- Diferenciar la funcionalidad de los métodos
**.slice()**y**.splice()**aplicados sobre arreglos.- Respuesta:
.slice()genera una copia parcial del arreglo sin modificar el array original y recibe índices de inicio y fin..splice()altera el array original, eliminando, reemplazando o insertando elementos a partir de un índice determinado.
- Respuesta:
- ¿Qué diferencia existe entre el objeto global raíz en el navegador web y en Node.js?
- Respuesta: En el navegador el objeto raíz es
windowy contiene APIs orientadas a la interfaz de usuario y al DOM (document,localStorage). En Node.js el objeto raíz esglobaly expone herramientas del sistema operativo, procesos (process) y módulos del servidor (fs,http).
- Respuesta: En el navegador el objeto raíz es
Nivel Avanzado
- Describir los pasos técnicos involucrados en el consumo de un recurso desde una API REST hasta su visualización en el navegador.
- Respuesta:
- El navegador ejecuta la Web API
fetch()apuntando a la URL y verbo HTTP de un endpoint. - El servidor procesa la solicitud y retorna una respuesta con datos en formato JSON (string en texto plano).
- Se parsea el contenido a un objeto o array interactivo de JavaScript.
- Se aplican métodos de iteración o manipulación sobre los datos.
- Se utilizan los métodos del objeto global
document(DOM) para crear o actualizar elementos HTML dinámicamente.
- El navegador ejecuta la Web API
- Respuesta:
- Si un servidor expone la URL
**https://api.tienda.com/productos**, ¿cómo puede la misma URL representar dos endpoints distintos?- Respuesta: Un endpoint se define por la combinación de una URL y un verbo HTTP. La ruta combinada con un verbo
GETconstituye un endpoint destinado a la lectura de productos; esa misma ruta combinada con un verboPOSTconstituye un endpoint diferente dedicado a la creación de un nuevo producto.
- Respuesta: Un endpoint se define por la combinación de una URL y un verbo HTTP. La ruta combinada con un verbo
9. Fechas Importantes y Avisos Académicos
A partir del análisis exhaustivo del contexto de clase e indicaciones de la cátedra, se detallan las fechas, entregas y compromisos académicos organizados cronológicamente:
Cronograma de Evaluaciones y Entregas
- Reunión de Articulaciones con el IFTS 18 / IFTS 1:
- Fecha y Hora: Lunes de clase (21:00 a 21:30 hs).
- Canal: Enlace de Google Meet publicado en el foro institucional.
- Descripción: Espacio informativo y de coordinación para alumnos inscritos en los proyectos de articulación (Frontend y QA). Alumnos mencionados en el listado de cátedra: Mila Sánchez Fanatido, Mar la Coleta, Edgar Montenegro, Matías Sosa, Julián Niegovic, Mariano Loreto, Pablo de Martini, Mario, Lucía.
- Presentación y Defensa Presencial del TPO 1 (Trabajo Práctico Obligatorio 1):
- Fecha: 18 de noviembre (Penúltima clase del cuatrimestre).
- Modalidad: Presencial obligatoria en el instituto.
- Descripción: Exposición grupal del clon maquetado del sitio "Tienda de Café" (adaptado a temática libre). Evaluación directa por el docente con devolución (feedback) e instancia de calificación en el acto.
- Presentación y Defensa Presencial del TPO 2 (Trabajo Práctico Obligatorio 2):
- Fecha: 25 de noviembre (Última clase del cuatrimestre).
- Modalidad: Presencial obligatoria en el instituto.
- Descripción: Exposición y defensa técnica del sitio web dinámico con consumo de una API REST pública mediante la API Web
fetch(). Cierre formal de la cursada.
Indicaciones y Advertencias Específicas de la Cátedra
- Fijación de Fechas Límite: Se establece formalmente la penúltima clase para la entrega del TPO1 y la última clase para el TPO2 con el fin de evitar la acumulación de evaluaciones al cierre del cuatrimestre y cumplir con los plazos administrativos de entrega de actas exigidos por coordinación.
- Aviso sobre Asistencia: Se exige a los alumnos completar el formulario digital de asistencia ("asistencia frontend") provisto en cada clase.
- Prohibición de Entregas Reutilizadas: Se advierte explícitamente que no se aceptarán trabajos prácticos presentados en cuatrimestres o años anteriores sin adaptar; en caso de recibirse, el docente aplicará correcciones específicas y reevaluará la nota.
- Uso Razonable del Tiempo: El docente recomienda enfáticamente no posponer el desarrollo de los proyectos grupales para los últimos días, enfatizando que la nota final pondera directamente el nivel de acabado y el proceso de trabajo colaborativo mediante Git/GitHub.
- Recursos Adicionales: El docente pondrá a disposición en el campus virtual una serie de ejercicios prácticos específicos sobre manipulación de strings y arrays, junto con la plantilla de organización de grupos y los enunciados del TPO1 y TPO2.