Introducción a JavaScript

1

Fundamentos de JavaScript para Principiantes

2

Instalación y Configuración de JavaScript en Visual Studio Code

3

Instalación y configuración de Visual Studio Code y Node.js en Windows

4

Variables y Buenas Prácticas en JavaScript

5

Tipos de Datos en JavaScript: Primitivos y Complejos

6

Manipulación de Strings en JavaScript: Escritura, Concatenación y Substrings

7

Números y Operaciones Matemáticas en JavaScript

8

Conversión de Tipos en JavaScript: Implícita y Explícita

9

Conversión de Tipos en JavaScript: Explícita e Implícita

Estructuras de Control y Lógica

10

Operadores de Comparación en JavaScript: Igualdad y Desigualdad

11

Operadores Lógicos en Programación: AND, OR y NOT

12

Estructuras Condicionales: Uso de IF, ELSE y ELSE IF en JavaScript

13

Juego de Adivinanza: Programación con Estructuras Condicionales

14

Estructura y uso del condicional Switch en programación

15

Ciclo For: Iteración de Listas y Uso de Console.log en JavaScript

16

Iteración con for-of en JavaScript para arrays y strings

17

Iteración sobre Objetos con forIn en JavaScript

18

Uso del ciclo while para iteración en programación

19

Ciclos doWhile: Estructura y Diferencias con While

Funciones y This

20

Funciones en JavaScript: Cómo Calcular Precios con Descuentos

21

Diferencias entre Funciones y Métodos en JavaScript

22

Funciones Puras e Impuras en Programación: Conceptos y Ejemplos

23

Arrow Functions y Enlace Léxico en JavaScript

24

Scope y Contextos de Ejecución en JavaScript

25

Closures y Ámbito Léxico en JavaScript

26

Fundamentos del Desarrollo Web: Frontend y Backend

Manipulación de Arrays

27

Arrays: Propiedades, Acceso y Creación en Programación

28

Mutabilidad e inmutabilidad en arrays: conceptos y ejemplos prácticos

29

Métodos push y pop para modificar arrays en JavaScript

30

Métodos map y forEach en JavaScript: Uso y Ejemplos Prácticos

31

Métodos Filter y Reduce en JavaScript: Uso y Ejemplos Prácticos

32

Métodos find y findIndex en JavaScript: Uso y ejemplos prácticos

33

Uso del método slice para extraer porciones de un array en JavaScript

34

Uso del Spread Operator en JavaScript: Copia, Combinación y Más

Programación Orientada a Objetos

35

Programación Orientada a Objetos en JavaScript: Conceptos y Práctica

36

Creación y Manipulación de Objetos en JavaScript

37

Función constructora y gestión de instancias en JavaScript

38

Clases en JavaScript: Creación y Uso de Objetos con Sintaxis Moderna

39

Programación Orientada a Objetos en JavaScript: Clases y Prototipos

40

Prototipos y Herencia en JavaScript: Construcción y Uso Práctico

41

Métodos y herencia prototípica en JavaScript

42

Uso de "this" en Clases y Funciones Constructoras

43

Validación de Usuarios en una Red Social: Algoritmo Básico

44

Implementación de la Función Sign-In y Validación de Usuario

Asincronía en JavaScript

45

Programación Síncrona y Asíncrona en JavaScript

46

Promesas en JavaScript: Asincronía y Manejo de Estados

47

Uso de Async/Await para Promesas Asíncronas en JavaScript

48

Peticiones asíncronas con for await en JavaScript

49

Fundamentos de HTTP: Cliente-Servidor y Métodos de Petición

50

Peticiones HTTP en Frontend: Uso de Fetch y Análisis en Network

51

Peticiones HTTP en JavaScript: Fetch, GET, POST y DELETE

52

Envío de Datos al Servidor con JavaScript y Fetch API

53

Eliminar Posts con JavaScript y Delegación de Eventos

54

Manejo de IDs en JavaScript para eliminar artículos del DOM

55

Actualizaciones y Nuevas Funciones en JavaScript

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Peticiones HTTP en JavaScript: Fetch, GET, POST y DELETE

51/55
Recursos

¿Cómo hacer peticiones HTTP escalables en JavaScript?

Las peticiones HTTP son fundamentales para la interacción con servidores y APIs, un proceso esencial en la creación de aplicaciones web. Implementar estas peticiones de manera eficiente puede marcar una gran diferencia en el rendimiento general de una aplicación. Aquí aprenderás a estructurar un código de JavaScript que permita realizar peticiones como GET, POST y DELETE de forma escalable.

¿Qué estructura necesita una función para realizar peticiones HTTP?

Para gestionar las peticiones HTTP de manera centralizada, utilizaremos la función sendHttpRequest. Esta función se encargará de recibir el método HTTP, la URL y el tipo de datos que se enviarán en la petición.

function sendHttpRequest(method, url, data) {
    return fetch(url, {
        method: method,
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify(data)
    })
    .then(response => response.json());
}

¿Cómo utilizar fetchPost para obtener datos?

La función fetchPost es la encargada de hacer uso de sendHttpRequest para realizar una petición GET que recuperará posts de una URL específica.

async function fetchPost() {
    const responseData = await sendHttpRequest('GET', 'https://jsonplaceholder.typicode.com/posts');
    console.log(responseData);
}

¿Cómo imprimir y manipular datos en el DOM?

Una vez que se obtiene la respuesta del servidor, es crucial mostrar esos datos en la interfaz. Para ello, se utiliza la manipulación del DOM en JavaScript.

const listElement = document.getElementById('post-list');

function renderPosts(posts) {
    for (const post of posts) {
        const postElement = document.createElement('article');
        postElement.className = 'post';

        const postTitle = document.createElement('h2');
        postTitle.textContent = post.title;

        const postBody = document.createElement('p');
        postBody.textContent = post.body;

        postElement.appendChild(postTitle);
        postElement.appendChild(postBody);
        listElement.appendChild(postElement);
    }
}

// Llamar a fetchPost y renderizar los posts en el DOM.
fetchPost().then(responseData => {
    renderPosts(responseData);
});

¿Cómo interactuar con botones para cargar contenido?

Para completar la interacción, necesitamos garantizar que la función fetchPost se ejecute al hacer clic en un botón específico.

const fetchButton = document.getElementById('fetch-button');
fetchButton.addEventListener('click', fetchPost);

Por medio de este proceso, puedes cargar datos desde un servidor y mostrarlos directamente en tu aplicación, manteniendo tus peticiones HTTP organizadas y escalables. A través de la práctica continua, dominarás la manipulación del DOM, el uso del API Fetch y el manejo de promesas, habilidades esenciales para cualquier desarrollador web moderno. ¡Sigue avanzando y mejorando tus habilidades!

Aportes 17

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Tenia problemas para entender porque si la funcion `sendHTTPRequest` espera 3 parametros al brindarle solo 2 funcionaba sin errores. Al parecer en JavaScript, si una función espera 3 parámetros y solo le das 2, el tercero se vuelve `undefined`. Cuando se llama a `sendHTTPRequest` con solo dos parámetros, `data` se vuelve `undefined`. Despues, `JSON.stringify(undefined)` también da `undefined`. En la configuración de `fetch`, si `body` es `undefined`, simplemente no se envía ningún cuerpo en la solicitud. Esto está bien para una solicitud GET, que normalmente no necesita un cuerpo. Por eso, aunque falte el tercer parámetro, el código funciona sin errores y hace la solicitud correctamente. Espero haber ayudado a quien pueda tener mi misma duda.
Me hubiera gustado más que la última parte del código en vez de ser un código copiado lo escribieras desde cero yo entiendo que eso ya lo debes de entender para ver este curso pero no está demás hacer un repaso , igual si hubiera escrito desde cero dividido en dos clases y tendríamos más contenido y mejor explicado
En ocasiones hacen estos brincos tan sorpresivos que no sabemos de donde sacan las cosas!!! es el caso del DOM, si es una secuencaia de segudo modulo debe ser un poco mas clara la explicación, o dejar la ruta para la manupulación del dom, me ha pasado en otros modulos de platzi tbm.. espero tener algo de suerte...
Comparto una variación a la función makeHTTPRequest() para enviar el body únicamente cuando el método sea POST y además, retornar también el status de la petición :) Se puede probar el método GET llamando a la función getRequest() ```js function makeHTTPRequest(method, url, data) { return fetch(url, { method: method, body: method === "POST" ? JSON.stringify(data) : null, headers: { "Content-Type": "application/json", }, }).then((response) => { return response.json().then((data) => ({ status: response.status, data: data, })); }); } async function getRequest() { try { const response = await makeHTTPRequest( "GET", "https://jsonplaceholder.typicode.com/Posts" ); console.log(response); } catch (error) { throw error; } } ```
Esta última serie de clases, a partir de la 45, más o menos, presenta material cuya utilización o vínculo con las clases anteriores no entiendo. Aquí mencionaron ver la clase de manipulación del DOM, pero esa clase es posterior en mi curso de fundamentos de JS en la ruta que me trazaron.
la ruta de aprendizaje de JavaScript esta mal organizada, primero esta este curso y luego está el de manipulación del DOM, aun no sabemos hacer esa parte del código :(
No se debería de mencionar ni de asumir que lo del DOM ya lo sabemos hacer, porque este curso va primero que el curso del manejo del DOM!
![](https://static.platzi.com/media/user_upload/image-de50010e-8984-456d-8c22-25607c2af053.jpg) ![](https://static.platzi.com/media/user_upload/image-5fa12c21-5313-480c-9b6c-684ae1431aa8.jpg) ![](https://static.platzi.com/media/user_upload/image-a77ed1ed-e18d-4a93-9400-9e4769d0a059.jpg)
Comparto el código HTML y JS para tu comodidad, el CSS es a mi estilo. HTML: ```js <style> body { font-family: Arial, sans-serif; display: flex; flex-direction: column; align-items: center; background-color: #f5f5f5; } section { width: 80%; max-width: 600px; margin: 20px auto; padding: 20px; background: white; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); } .form-control { margin-bottom: 15px; } label { display: block; margin-bottom: 5px; font-weight: bold; color: #333; } input, textarea { width: 100%; padding: 8px; border: 1px solid #ddd; border-radius: 4px; font-size: 14px; } button { background-color: #4CAF50; color: white; padding: 10px 20px; border: none; border-radius: 4px; cursor: pointer; font-size: 16px; transition: background-color 0.3s; } button:hover { background-color: #45a049; } .posts { margin-top: 15px; } </style> <section id="new-post"> <form>
<label for="title">Title</label> <input type="text" id="title">
<label for="content">Content</label> <textarea rows="3" id="content"></textarea>
<button type="submit">POST Content</button> </form> </section> <section id="available-posts"> <button>GET Content</button> <section id="posts-container" class="posts"></section> </section> ```\<style> body { font-family: Arial, sans-serif; display: flex; flex-direction: column; align-items: center; background-color: #f5f5f5; } section { width: 80%; max-width: 600px; margin: 20px auto; padding: 20px; background: white; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); } .form-control { margin-bottom: 15px; } label { display: block; margin-bottom: 5px; font-weight: bold; color: #333; } input, textarea { width: 100%; padding: 8px; border: 1px solid #ddd; border-radius: 4px; font-size: 14px; } button { background-color: #4CAF50; color: white; padding: 10px 20px; border: none; border-radius: 4px; cursor: pointer; font-size: 16px; transition: background-color 0.3s; } button:hover { background-color: #45a049; } .posts { margin-top: 15px; } \</style> \<section id="new-post"> \<form> \
\<label for="title">Title\</label> \<input type="text" id="title"> \
\
\<label for="content">Content\</label> \<textarea rows="3" id="content">\</textarea> \
\<button type="submit">POST Content\</button> \</form> \</section> \<section id="available-posts"> \<button>GET Content\</button> \<section id="posts-container" class="posts">\</section> \</section> JS: ```js const listElement = document.querySelector('.posts') const postTemplate = document.querySelector('.single-post') const form = document.querySelector('#new-post form') const fetchButton = document.querySelector('#available-posts button') const postList = document.querySelector('#posts-container') for (const post of listOfPosts) { const postContainer = document.createElement('article') postContainer.id = post.id postContainer.classList.add('post-item') const title = document.createElement('h2') title.textContent = post.title const body = document.createElement('p') body.textContent = post.body const button = document.createElement('button') button.textContent = 'DELETE Content' postContainer.append(title) postContainer.append(body) postContainer.append(button) listElement.append(postContainer) } ```for (*const* post of listOfPosts) { *const* postContainer = document.createElement('article') postContainer.id = post.id postContainer.classList.add('post-item') *const* title = document.createElement('h2') title.textContent = post.title *const* body = document.createElement('p') body.textContent = post.body *const* button = document.createElement('button') button.textContent = 'DELETE Content' postContainer.append(title) postContainer.append(body) postContainer.append(button) listElement.append(postContainer) }
Hi! Aquí están mis notas de esta clase por si alguien le sirve. Expliqué la parte de la manipulación del DOM para que fuera más fácil de comprender. Si creen que algo se puede mejorar, díganme ```js const listElement = document.querySelector(".posts"); //busca el primer elemento con .posts const postTemplate = document.getElementById("single-post"); //selecciona el elemento con ID: single-post const form = document.querySelector("#new-post form"); //busca el primer elemento con ID: .new-post form const fetchButton = document.querySelector("#available-posts button"); const postList = document.querySelector("#posts-container"); function sendHTTPRequest(method, url, data) { return fetch(url, { method: method, //tipo de metodo, qué acción queremos realizar, sea GET, POST u otro body: JSON.stringify(data), //transforma data a Json headers: { "Content-Type": "application/json", //le explica al servidor que la info está en formato Json }, }).then((response) => { //signfica 'después de obtener la respuesta, haz esto...' return response.json(); //convierte la respuesta del servidor en un objeto }); } async function fecthPosts() { const responseData = await sendHTTPRequest( //sendHTTP actúa como fetch "GET", "https://jsonplaceholder.typicode.com/posts" ); console.log(responseData); //para que nos muestre lo que regresa la función const listOfPosts = responseData; //el profe creó otra variable para mantener limpio el servidor for (const post of listOfPosts) { const postContainer = document.createElement("article"); //creamos un elemento article postContainer.id = post.id; //al elemento article le colocamos el mismo id que el id del post postContainer.classList.add("post-item"); //añadimos la clase post-item const title = document.createElement("h2"); //creamos un elemento h2 title.textContent = post.title; //al título, le colocamos el mismo título que el title del post const body = document.createElement("p"); //creamos un elemento p body.textContent = post.body; //rellenamos el contenido con el body del post const button = document.createElement("button"); //creamos un elemento button button.textContent = "DELETE Content"; //le colocamos el contenido 'DELETE Content' al botón postContainer.append(title); //aquí le estamos agregando el title como hijo de postContainer postContainer.append(body); //aquí le estamos agregando el body como hijo de postContainer postContainer.append(button); //aquí le estamos agregando el button como hijo de postContainer listElement.append(postContainer); //Y finalmente, colocamos listElement como hijo de postContainer } } fetchButton.addEventListener("click", fecthPosts); ```
Una de las pocas clases que me toma 2 horas entender por completo. casi que no desgloso todo el código. jajajaj
El método GET es una de las formas en que los navegadores pueden solicitar datos de un servidor web. Utiliza la URL para enviar la solicitud y, por lo general, se utiliza para obtener información sin modificar el estado del recurso en el servidor. En el contexto de JavaScript, se emplea comúnmente con la función `fetch()` para realizar estas peticiones de manera asincrónica. El método GET es fundamental en la interacción con APIs, permitiendo recuperar datos, como publicaciones en un blog, sin necesidad de cambiar la información en el servidor.
El return fetch es algo que no entiendo, no entiendo lo que es el body ni los headers, no entiendo el "Content-Type": "application/json",function sendHTTPRequest(method, url, data) {    return fetch(url, {    method: method,    body: JSON.stringify(data),    headers: {        "Content-Type": "application/json",    },    }).then((response) => {        return response.json();    });} alguien me puede explicar por favor cada cosa de esa funcion por favor ```js function sendHTTPRequest(method, url, data) { return fetch(url, { method: method, body: JSON.stringify(data), headers: { "Content-Type": "application/json", }, }).then((response) => { return response.json(); }); } ```
Gracias Diego! Que buena clase, a modo de sugerencia me gustaría que se desarrolle mas el tema de solicitudes y DOM con algún ejemplo practico!
Vengo del curso de DOM y me vino de perlas esto para intentar yo mismo la manipulación del DOM, recomiendo que lo intentes también solo la inserción de los elementos con su contenido, ya después puedes copiar el código del profe donde le pone los estilos.
Esto es algo nuevo para los que no conoces DOM o no han visto el curso siguiente en la ruta sobre la manipulacion del DOM
Se que es un tema que no se explica en 4 classes t podria ser un curso de http request pero igual buena explicacion corta