One place for hosting & domains

      Cómo crear un nuevo usuario habilitado para sudo en CentOS 8 [Inicio rápido]


      Introducción

      El comando sudo ofrece un mecanismo para conceder privilegios de administrador; normalmente solo está disponible para el usuario root para usuarios normales. Esta guía le mostrará cómo crear un nuevo usuario con acceso sudo en CentOS 8, sin tener que modificar el archivo /etc/sudoers de su servidor. Si desea configurar sudo desde un usuario CentOS existente, pase al paso 3.

      Paso 1: Iniciar sesión en su servidor

      Aplique SSH a su servidor como root user:

      • ssh root@your_server_ip_address

      Utilice la dirección IP de su servidor o el nombre de host en lugar de your_server_ip_address.

      Paso 2: Añadir un nuevo usuario al sistema

      Utilice el comando adduser para añadir un nuevo usuario a su sistema:

      Asegúrese de sustituir sammy​​​ con el nombre de usuario que desea crear.​​

      Utilice el comando passwd para actualizar la contraseña del nuevo usuario:

      Recuerde sustituir sammy​​​ con el usuario que ha creado. Se solicitará dos veces la nueva contraseña:

      Output

      Changing password for user sammy. New password: Retype new password: passwd: all authentication tokens updated successfully.

      Paso 3: Añadir el usuario al grupo wheel

      Utilice el comando usermod para agregar el usuario al grupo wheel:

      De nuevo, asegúrese de sustituir sammy​​​ por el nombre de usuario al que desea conceder privilegios sudo. Por defecto, en CentOS, todos los miembros del grupo wheel tienen acceso sudo completo.

      Paso 4: Probar el acceso sudo

      Para probar que los nuevos permisos sudo funcionan, primero utilice el comando su para cambiar desde el usuario root a la nueva cuenta de usuario:

      Como nuevo usuario, verifique que pueda usar sudo anteponiendo sudo al comando que desee ejecutar con privilegios de súper usuario:

      Por ejemplo, puede listar el contenido del directorio /root, al que normalmente solo puede acceder el root user:

      La primera vez que utilice sudo en una sesión, se le solicitará la contraseña de la cuenta de ese usuario. Introduzca la contraseña para continuar:

      Output

      [sudo] password for sammy:

      Nota: Esto no pide la contraseña root. Introduzca la contraseña del usuario sudo no la contraseña root.

      Si su usuario está en el grupo adecuado e introdujo la contraseña correctamente, el comando que emitió con sudo se ejecutará con privilegios root.

      Conclusión

      En este tutorial de inicio rápido hemos creado una cuenta de usuario y la hemos añadido al grupo wheel para permitir acceso sudo. Para obtener información detallada sobre cómo configurar un servidor de CentOS 8, lea nuestro tutorial Configuración inicial para servidores con CentOS 8.



      Source link

      Cómo crear un servidor web en Node.js con el módulo HTTP


      El autor seleccionó el COVID-19 Relief Fund para que reciba una donación como parte del programa Write for DOnations.

      Introducción

      Cuando visualiza una página web en su navegador, está realizando una solicitud a otro equipo en Internet, que a continuación proporciona la página web como respuesta. Esa computadora con la que está hablando a través de Internet es un servidor web. Un servidor web recibe solicitudes HTTP de un cliente, como su navegador, y proporciona una respuesta HTTP, como una página HTML o JSON desde una API.

      Para que un servidor devuelva una página web, se emplea una gran cantidad de software. Este software generalmente se divide en dos categorías: frontend y backend. El código front-end se refiere a cómo se presenta el contenido, como el color de la barra de navegación y el estilo de texto. El código back-end se encarga de la forma en la que los datos se intercambian, procesan y almacenan. El código que administra las solicitudes de red desde su navegador o se comunica con la base de datos lo gestiona principalmente el código back-end.

      Node.js permite a los desarrolladores usar JavaScript para escribir código back-end, aunque tradicionalmente se usaba en el navegador para escribir código front-end. Al tener el frontend y el backend juntos de esta forma, se reduce el esfuerzo necesario para crear un servidor web, que es el motivo principal por el que Node.js es una opción popular para escribir código back-end.

      En este tutorial, aprenderá cómo construir servidores web usando el módulo http que se incluye en Node.js. Creará servidores web que pueden devolver datos JSON, archivos CSV y páginas web HTML.

      Requisitos previos

      Paso 1: Crear un servidor HTTP básico

      Comenzaremos creando un servidor que devuelve texto sin formato al usuario. Esto cubrirá los conceptos clave necesarios para configurar un servidor, que proporcionará la base necesaria para devolver formatos de datos más complejos como JSON.

      Primero, debemos configurar un entorno de codificación accesible para hacer nuestros ejercicios y los demás en este artículo. En el terminal, cree una carpeta llamada first-servers:

      Luego, acceda a esa carpeta:

      Ahora, cree el archivo en donde se alojará el código:

      Abra el archivo en un editor de texto. Usaremos nano, ya que está disponible en el terminal:

      Comenzaremos cargando el módulo http que es estándar con todas las instalaciones de Node.js. Añada la siguiente línea a hello.js:

      first-servers/hello.js

      const http = require("http");
      

      El módulo http contiene la función para crear el servidor, que veremos más adelante. Si desea obtener más información sobre los módulos en Node.js, consulte nuestro artículo Cómo crear un módulo Node.js.

      Nuestro siguiente paso será definir dos constantes, el host y el puerto a los que se vinculará nuestro servidor:

      first-servers/hello.js

      ...
      const host = 'localhost';
      const port = 8000;
      

      Como mencionamos antes, los servidores web aceptan solicitudes de los navegadores y de otros clientes. Podemos interactuar con un servidor web ingresando un nombre de dominio, que se traduce a una dirección IP mediante un servidor DNS. Una dirección IP es una secuencia única de números que identifica un equipo en una red, como Internet. Para obtener más información sobre los conceptos de nombre de dominio, eche un vistazo a nuestro artículo Una introducción a la terminología DNS, componentes y conceptos.

      El valor localhost es una dirección privada especial que los ordenadores usan para referirse a ellos mismos. Normalmente, es el equivalente a la dirección IP interna 127.0.0.1 y solo está disponible para el equipo local, no para cualquier otra red a la que nos unamos o a Internet.

      El puerto es un número que los servidores usan como endpoint o “puerta” a nuestra dirección IP. En nuestro ejemplo, usaremos el puerto 8000 para nuestro servidor web. Los puertos 8080 y 8000 se usan normalmente como puertos predeterminados en desarrollo, y, en la mayoría de los casos, los desarrolladores los usarán en vez de los otros puertos para los servidores HTTP.

      Cuando vinculamos nuestro servidor a este host y puerto, podremos conectarnos a nuestro servidor visitando http://localhost:8000 en un navegador local.

      Ahora, añadiremos una función especial, que en Node.js llamamos una escucha de solicitudes. Esta función está destinada a gestionar una solicitud HTTP entrante y devolver una respuesta HTTP. Esta función debe tener dos argumentos, un objeto de solicitud y un objeto de respuesta. El objeto de solicitud captura todos los datos de la solicitud HTTP que está entrando. El objeto de respuesta se usa para devolver respuestas HTTP para el servidor.

      Queremos que nuestro primer servidor devuelva este mensaje siempre que alguien acceda a él: "My first server!".

      Ahora agreguemos esa función:

      first-servers/hello.js

      ...
      
      const requestListener = function (req, res) {
          res.writeHead(200);
          res.end("My first server!");
      };
      

      La función normalmente recibe su nombre según lo que hace. Por ejemplo, si creamos una función de escucha de solicitudes para devolver una lista de libros, probablemente la llamaremos listBooks(). Ya que este es un ejemplo, usaremos el nombre genérico requestListener.

      Todas las funciones de escucha de solicitudes en Node.js aceptan dos argumentos: req y res (podemos llamarlos de forma diferente si lo deseamos). La solicitud HTTP que el usuario envía se captura en un objeto Request, que se corresponde con el primer argumento, req. La respuesta HTTP que devolvemos al usuario se forma interactuando con el objeto Response en el segundo argumento, res.

      La primera línea res.writeHead(200); establece el código de estado HTTP de la respuesta. El código de estado HTTP indica si la solicitud HTTP fue gestionada correctamente por el servidor. En este caso, el código de estado 200 se corresponde con "OK". Si está interesado en aprender sobre los diferentes códigos HTTP que sus servidores web pueden devolver con el significado que tienen, nuestra guía Cómo resolver códigos de error HTTP comunes es un buen comienzo.

      La siguiente línea de la función, res.end("My first server"!) ; escribe la respuesta HTTP de vuelta al cliente que la solicitó. Esta función devuelve cualquier dato que el servidor tenga para devolver. En este caso, está devolviendo datos de texto.

      Finalmente, ahora podemos crear nuestro servidor y usar nuestra escucha de solicitudes.

      first-servers/hello.js

      ...
      
      const server = http.createServer(requestListener);
      server.listen(port, host, () => {
          console.log(`Server is running on http://${host}:${port}`);
      });
      

      Guarde y salga de nano pulsando CTRL+X.

      En la primera línea, creamos un nuevo objeto server a través de la función createServer() del módulo http. Este servidor acepta solicitudes HTTP y las pasa a nuestra función requestListener().

      Tras crear nuestro servidor, debemos vincularlo a una dirección de red. Hacemos eso con el método server.listen(). Acepta tres argumentos: puerto, host y una función de llamada que se activa cuando el servidor empieza a escuchar.

      Todos estos argumentos son opcionales, pero es una buena idea indicar explícitamente qué puerto y host queremos que use el servidor web. Cuando se implementan servidores web en entornos diferentes, conocer el puerto y el host en los que se está ejecutando es necesario para establecer el equilibrio de carga o un alias de DNS.

      La función callback registra un mensaje en nuestra consola para que sepamos cuándo el servidor comenzó a escuchar conexiones.

      Nota: Aunque requestListener() no usa el objeto req, debe seguir siendo el primer argumento de la función.

      Con menos de quince líneas de código, ahora tenemos un servidor web. Veámoslo en acción y hagamos una prueba de extremo a extremo ejecutando el programa:

      En la consola, veremos este resultado:

      Output

      Server is running on http://localhost:8000

      Observe que la solicitud desaparece. Esto es porque un servidor Node.js es un proceso largo de ejecución. Solo existe si se encuentra un error que haga que se detenga y se cierre, o si detenemos el proceso de Node.js ejecutando el servidor.

      En una ventana de terminal independiente, nos comunicaremos con el servidor usando cURL, una herramienta CLI para transferir datos hacia y desde una red. Ingrese el comando para realizar una solicitud GET HTTP a nuestro servidor en ejecución:

      • curl http://localhost:8000

      Cuando pulsamos ENTER, nuestro terminal mostrará el siguiente resultado:

      Output

      My first server!

      Ahora hemos configurado y servidor, y tenemos nuestra primera respuesta del servidor.

      Desglosemos lo que sucedió cuando probamos nuestro servidor. Usando cURL, enviamos una solicitud GET al servidor en http://localhost:8000. Nuestro servidor Node.js escuchó las conexiones de esa dirección. El servidor pasó esa solicitud a la función requestListener(). La función devolvió datos de texto con el código de estado 200. El servidor, luego, envió esa respuesta de vuelta a cURL, que mostró el mensaje en nuestro terminal.

      Antes de continuar, vamos a salir de nuestro servidor en ejecución pulsando CTRL+C. Esto interrumpe la ejecución de nuestro servidor, lo que nos lleva de regreso a la línea de comandos.

      En la mayoría de los sitios web que visitamos o las APIs que usamos, las respuestas del servidor son raramente texto sin formato. Obtenemos páginas HTML y datos JSON como formatos de respuesta comunes. En el siguiente paso, aprenderá cómo devolver respuestas HTTP en formatos de datos comunes que encontramos en la web.

      Paso 2: Devolver tipos de contenido diferentes

      La respuesta que devolvemos de un servidor web puede tener varios formatos. Hemos mencionado JSON y HTML, y podemos devolver otros formatos de texto como XML y CSV. Finalmente, los servidores web pueden devolver datos que no son texto, como PDFs, archivos comprimidos, audio y vídeo.

      En este artículo, además del texto sin formato que acabamos de devolver, aprenderá cómo devolver los siguientes tipos de datos:

      Estos tres tipos de datos están basados en texto y son formatos populares para entregar contenido en la web. Muchos lenguajes y herramientas de desarrollo del lado del servidor pueden devolver estos diferentes tipos de datos. En el contexto de Node.js, necesitamos hacer dos cosas:

      1. establecer el encabezado Content-Type en nuestras respuestas HTTP con el valor apropiado.
      2. asegurarnos de que res.end() obtiene los datos en el formato adecuado.

      Veamos esto en acción con algunos ejemplos. El código que escribiremos en esta sección y en las posteriores tienen muchas similitudes con el código que escribimos previamente. La mayoría de los cambios existen en la función requestListener(). Vamos a crear archivos con este “código de plantilla” para hacer que las siguientes secciones sean más fáciles de seguir.

      Cree un nuevo archivo llamado html.js. Este archivo se usará más adelante para devolver texto HTML en una respuesta HTTP. Pondremos el código de la plantilla aquí y lo copiaremos a los otros servidores que devuelven varios tipos.

      En el terminal, ingrese lo siguiente:

      Ahora abra este archivo en un editor de texto:

      Vamos a copiar el “código de la plantilla”. Ingrese esto en nano:

      first-servers/html.js

      const http = require("http");
      
      const host = 'localhost';
      const port = 8000;
      
      const requestListener = function (req, res) {};
      
      const server = http.createServer(requestListener);
      server.listen(port, host, () => {
          console.log(`Server is running on http://${host}:${port}`);
      });
      

      Guarde y salga de html.js con CTRL+X, luego vuelva al terminal.

      Ahora, vamos a copiar este archivo en dos nuevos archivos. El primero archivo será para devolver datos CSV en la respuesta HTTP:

      El segundo archivo devolverá una respuesta JSON en el servidor:

      Los archivos restantes serán para ejercicios posteriores:

      • cp html.js htmlFile.js
      • cp html.js routes.js

      Ahora estamos listos para continuar con nuestros ejercicios. Vamos a comenzar con devolver JSON.

      Presentar JSON

      JavaScript Object Notation, normalmente conocido como JSON, es un formato de intercambio de datos basado en texto. Como su nombre lo indica, se deriva de los objetos JavaScript, pero es un lenguaje independiente, lo que significa que puede ser usado por cualquier lenguaje de programación que pueda analizar su sintaxis.

      Las APIS comúnmente usan JSON para aceptar y devolver datos. Su popularidad se debe al menor tamaño de transferencia de datos que los estándares de intercambio de datos como XML, además de las herramientas que existen para permitir que los programas las analicen sin esfuerzo excesivo. Si desea obtener más información sobre JSON, puede leer nuestra guía sobre Cómo trabajar con JSON en JavaScript.

      Abra el archivo json.js con nano:

      Queremos devolver una respuesta JSON. Ahora, modifiquemos la función requestListener() para devolver al encabezado apropiado todas las respuestas que JSON tiene cambiando las líneas resaltadas de esta forma:

      first-servers/json.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "application/json");
      };
      ...
      

      El método res.setHeader() añade un encabezado HTTP a la respuesta. Los encabezados HTTP son información adicional que puede adjuntarse a una solicitud o respuesta. El método res.setHeader() toma dos argumentos: el nombre del encabezado y su valor.

      El encabezado Content-Type se usa para indicar el formato de los datos, también conocido como tipo de medio, que se envían con la solicitud o respuesta. En este caso, nuestro Content-Type es application/json.

      Ahora vamos a devolver contenido JSON al usuario. Modifique json.js para que tenga este aspecto:

      first-servers/json.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "application/json");
          res.writeHead(200);
          res.end(`{"message": "This is a JSON response"}`);
      };
      ...
      

      Como antes, indicamos al usuario que su solicitud se realizó correctamente devolviendo un código de estado de 200. Esta vez, en la invocación response.end(), nuestro argumento de cadena contiene JSON válido.

      Guarde y salga de jason.js pulsando CTRL+X. Ahora, ejecutaremos el servidor con el comando node:

      En otro terminal, vamos a contactar con el servidor usando cURL:

      • curl http://localhost:8000

      Cuando pulsemos ENTER, veremos el siguiente resultado:

      Output

      {"message": "This is a JSON response"}

      Ahora tenemos una respuesta JSON devuelva, como muchas de las APIs populares con las que creamos aplicaciones. Asegúrese de salir del servidor en ejecución con CTRL+C para poder volver a la solicitud estándar del terminal. Veamos otro formato popular para devolver datos: CSV.

      Presentar CSV

      El formato de archivo Valores separados por coma (CSV) es un estándar de texto que se usa comúnmente para proporcionar datos tabulares. En la mayoría de los casos, cada fila se separa por una nueva línea, y cada elemento de la fila se separa por una coma.

      En nuestro espacio de trabajo, abra el archivo csv.js en un editor de texto:

      Agreguemos las siguientes líneas a nuestra función requestListener():

      first-servers/csv.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "text/csv");
          res.setHeader("Content-Disposition", "attachment;filename=oceanpals.csv");
      };
      ...
      

      Esta vez, nuestro Content-Type indica que se está devolviendo un archivo CSV cuyo valor es text/csv. El segundo encabezado que añadimos es Content-Disposition. Este encabezado indica al navegador cómo mostrar los datos, sobre todo en el navegador o como archivo independiente.

      Cuando devolvemos respuestas CSV, la mayoría de los navegadores modernos descargan automáticamente el archivo, incluso si el encabezado Content-Disposition no se ha establecido. Sin embargo, cuando se devuelve un archivo CSV, deberíamos añadir este encabezado, ya que nos permite establecer el nombre del archivo CSV. En este caso, indicamos al navegador que este archivo CSV es un adjunto y debería descargarse. A continuación, indicamos al navegador que el nombre del archivo es oceanpals.csv.

      Vamos a escribir los datos CSV en la respuesta HTTP:

      first-servers/csv.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "text/csv");
          res.setHeader("Content-Disposition", "attachment;filename=oceanpals.csv");
          res.writeHead(200);
          res.end(`id,name,emailn1,Sammy Shark,shark@ocean.com`);
      };
      ...
      

      Como antes, devolvemos un estado 200/OK con nuestra respuesta. Esta vez, nuestra invocación de res.end() tiene una cadena que es un CSV válido. La coma separa el valor en cada columna y carácter de nueva línea (n) separa las filas. Tenemos dos, una para el encabezado de tabla y una para los datos.

      Probaremos este servidor en el navegador. Guarde csv.js y salga del editor con CTRL+X.

      Ejecute el servidor con el comando Node.js:

      En otro terminal, vamos a contactar con el servidor usando cURL:

      • curl http://localhost:8000

      La consola mostrará esto:

      Output

      id,name,email 1,Sammy Shark,shark@ocean.com

      Si vamos a http://localhost:8000 en nuestro navegador, se descargará un archivo CSV. Su nombre de archivo será oceanpals.csv.

      Salga del servidor en ejecución con CTRL+C para volver a la solicitud estándar del terminal.

      Al haber devuelto JSON y CSV, cubrimos dos casos que son populares para las APIs. Ahora pasemos a cómo datos para los sitios web que las personas visitan en un navegador.

      Presentar HTML

      HTML, o Lenguaje de marcado de hipertexto, es el formato más común usado cuando queremos que los usuarios interactúen con nuestros servidores a través de un navegador web. Se creó para estructurar el contenido web. Los navegadores web se crearon para mostrar contenido HTML y cualquier estilo que añadamos con CSS, otra tecnología web de front-end que nos permite cambiar la estética de nuestros sitios web.

      Volvamos a abrir html.js con nuestro editor de texto:

      Modifique la función requestListener() para devolver el encabezado Content-Type apropiado para una respuesta HTML:

      first-servers/html.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "text/html");
      };
      ...
      

      Ahora devolvamos el contenido HTML al usuario. Añada las líneas resaltadas a html.js para que tenga este aspecto:

      first-servers/html.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "text/html");
          res.writeHead(200);
          res.end(`<html><body><h1>This is HTML</h1></body></html>`);
      };
      ...
      

      Primero añadimos el código de estado HTTP. Luego, invocamos response.end() con un argumento de cadena que contiene un HTML válido. Cuando accedamos a nuestro servidor en el navegador, veremos una página HTML con una etiqueta de encabezado que contiene This is HTML.

      Vamos a guardarla y a salir pulsando CTRL+X. Ahora, ejecutaremos el servidor con el comando node:

      Veremos que server se está ejecutando en http://localhost:8000 cuando nuestro programa se ha iniciado.

      Ahora, vaya al navegador y visite http://localhost:8000. Nuestra página tendrá este aspecto:

      Imagen de la respuesta HTML devuelva desde el servidor de Node.js

      Salgamos del servidor en ejecución con CTRL+C para volver a la solicitud estándar del terminal.

      Es común que HTML se escriba en un archivo, separado del código del servidor como nuestros programas Node.js. A continuación, veamos cómo podemos devolver respuestas HTML desde los archivos.

      Paso 3: Presentar una página HTML desde un archivo

      Podemos presentar HTML como cadenas en Node.js para el usuario, pero es preferible que carguemos los archivos HTML y presentemos su contenido. De esta forma, a medida que el archivo HTML crece, no tenemos que mantener cadenas largas en nuestro código Node.js, manteniéndolo más conciso y permitiéndonos trabajar en cada aspecto de nuestro sitio web de forma independiente. Esta “separación de dudas” es común en muchas configuraciones de desarrollo web, y, por tanto, es bueno saber cómo cargar archivos HTML para que sean compatibles en Node.js.

      Para presentar archivos HTML, cargamos el archivo HTML con el módulo fs y usamos sus datos cuando escribamos nuestra respuesta HTTP.

      Primero, crearemos un archivo HTML que el servidor web devolverá. Cree un nuevo archivo HTML:

      Ahora abra index.html en un editor de texto:

      Nuestra página web será mínima. Tendrá un fondo naranja y mostrará algún texto de bienvenida en el centro. Añada este código al archivo:

      first-servers/index.html

      <!DOCTYPE html>
      
      <head>
          <title>My Website</title>
          <style>
              *,
              html {
                  margin: 0;
                  padding: 0;
                  border: 0;
              }
      
              html {
                  width: 100%;
                  height: 100%;
              }
      
              body {
                  width: 100%;
                  height: 100%;
                  position: relative;
                  background-color: rgb(236, 152, 42);
              }
      
              .center {
                  width: 100%;
                  height: 50%;
                  margin: 0;
                  position: absolute;
                  top: 50%;
                  left: 50%;
                  transform: translate(-50%, -50%);
                  color: white;
                  font-family: "Trebuchet MS", Helvetica, sans-serif;
                  text-align: center;
              }
      
              h1 {
                  font-size: 144px;
              }
      
              p {
                  font-size: 64px;
              }
          </style>
      </head>
      
      <body>
          <div class="center">
              <h1>Hello Again!</h1>
              <p>This is served from a file</p>
          </div>
      </body>
      
      </html>
      

      Esta página web muestra dos líneas de texto: Hello Again! y This is served from a file. Las líneas aparecen en el centro de la página, una sobre otra. La primera línea de texto se muestra en un encabezado, lo que significa que será grande. La segunda línea de texto aparecerá ligeramente más pequeña. Todo el texto aparecerá en blanco y la página web tiene un fondo naranja.

      Aunque no está dentro del alcance de este artículo o serie, si está interesado en aprender más sobre HTML, CSS y otras tecnologías web front-end, puede consultar la guía Primeros pasos con la Web de Mozilla.

      Eso es todo lo que necesitamos para el HTML, así que guarde y cierre el archivo con CTRL+X. Ahora podemos pasar al código del servidor.

      Para este ejercicio, trabajaremos en htmlFile.js. Ábralo con el editor de texto:

      Como tenemos que leer un archivo, comenzaremos importando el módulo fs:

      first-servers/htmlFile.js

      const http = require("http");
      const fs = require('fs').promises;
      ...
      

      Este módulo contiene una función readFile() que usaremos para cargar el archivo HTML. Importamos la variable de promesas de acuerdo con las mejores prácticas del JavaScript moderno. Usamos promesas ya que son sintácticamente más precisas que las invocaciones, que tendríamos que usar si asignamos fs a solo require('fs'). Para aprender más sobre las buenas prácticas de la programación asíncrona, puede leer nuestra guía Cómo escribir código asíncrono en Node.js.

      Queremos que nuestro archivo HTML se lea cuando un usuario solicite nuestro sistema. Comencemos modificando requestListener() para leer el archivo:

      first-servers/htmlFile.js

      ...
      const requestListener = function (req, res) {
          fs.readFile(__dirname + "/index.html")
      };
      ...
      

      Usamos el método fs.readFile() para cargar el archivo. Su argumento tiene __dirname + "/index.html". La variable especial __dirname tiene la ruta absoluta de donde se está ejecutando el código Node.js. Luego, adjuntamos /index.html para que podamos cargar el archivo HTML que creamos antes.

      Ahora, devolvamos la página HTML cuando se cargue:

      first-servers/htmlFile.js

      ...
      const requestListener = function (req, res) {
          fs.readFile(__dirname + "/index.html")
              .then(contents => {
                  res.setHeader("Content-Type", "text/html");
                  res.writeHead(200);
                  res.end(contents);
              })
      };
      ...
      

      Si la promesa fs.readFile() se resuelve correctamente, devolverá sus datos. Usamos el método then() para gestionar este caso. El parámetro contents contiene los datos del archivo HTML.

      Primero establecemos el encabezado Content-Type a text/html para indicar al cliente que estamos devolviendo datos HTML. Luego, escribimos el código de estado para indicar que la solicitud se realizó correctamente. Finalmente, enviamos al cliente la página HTML que cargamos, con los datos en la variable contents.

      El método fs.readFile() puede fallar a veces, de modo que deberíamos gestionar este caso cuando obtengamos un error. Añada esto a la función requestListener():

      first-servers/htmlFile.js

      ...
      const requestListener = function (req, res) {
          fs.readFile(__dirname + "/index.html")
              .then(contents => {
                  res.setHeader("Content-Type", "text/html");
                  res.writeHead(200);
                  res.end(contents);
              })
              .catch(err => {
                  res.writeHead(500);
                  res.end(err);
                  return;
              });
      };
      ...
      

      Guarde el archivo y salga de nano con CTRL+X.

      Cuando se produce un error con una promesa, se rechaza. Gestionamos ese caso con el método catch(). Acepta el error que fs.readFile() devuelve, establece el código de estado a 500 lo que significa que se produjo un error, y devuelve el error al usuario.

      Ejecute nuestro servidor con el comando node:

      En el navegador web, visite http://localhost:8000. Verá esta página:

      Imagen de página HTML cargada desde un archivo en Node.js

      Ahora devolvió al usuario una página HTML desde el servidor. Puede salir del servidor en ejecución con CTRL+C. Verá de nuevo la solicitud del terminal cuando lo haga.

      Cuando escriba un código como este en producción, es posible que no quiera cargar una página HTML cada vez que reciba una solicitud HTTP. Aunque esta página HTML tiene aproximadamente 800 bytes de tamaño, los sitios web más complejos pueden tener megabytes de tamaño. Los archivos grandes pueden tardar más en cargar. Si su sitio espera mucho tráfico, puede ser mejor cargar los archivos HTML al inicio y guardar su contenido. Tras cargarse, puede configurar el servidor y hacer que escuche las solicitudes en una dirección.

      Para demostrar este método, veamos cómo podemos rediseñar nuestro servidor para que sea más eficiente y escalable.

      Presentar HTML de forma eficiente

      En vez de cargar el HTML para cada solicitud, en este paso lo cargaremos una sola vez al principio. La solicitud devolverá los datos que cargamos al inicio.

      En el terminal, vuelva a abrir la secuencia de comandos Node.js con un editor de textos:

      Vamos a comenzar añadiendo una nueva variable antes de crear la función requestListener():

      first-servers/htmlFile.js

      ...
      let indexFile;
      
      const requestListener = function (req, res) {
      ...
      

      Cuando ejecutemos este programa, esta variable tendrá el contenido del archivo HTML.

      Ahora, volvamos a ajustar la función requestListener(). En vez de cargar el archivo, ahora devolverá el contenido de indexFile:

      first-servers/htmlFile.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "text/html");
          res.writeHead(200);
          res.end(indexFile);
      };
      ...
      

      A continuación, cambiamos la lógica de lectura del archivo desde la función requestListener() al inicio de nuestro servidor. Realice los siguientes cambios mientras creamos el servidor:

      first-servers/htmlFile.js

      ...
      
      const server = http.createServer(requestListener);
      
      fs.readFile(__dirname + "/index.html")
          .then(contents => {
              indexFile = contents;
              server.listen(port, host, () => {
                  console.log(`Server is running on http://${host}:${port}`);
              });
          })
          .catch(err => {
              console.error(`Could not read index.html file: ${err}`);
              process.exit(1);
          });
      

      Guarde el archivo y salga de nano con CTRL+X.

      El código que lee el archivo es similar a lo que escribimos en nuestro primer intento. Sin embargo, cuando leemos correctamente el archivo, guardamos el contenido en nuestra variable indexFile global. A continuación, iniciamos el servidor con el método listen(). Lo más importante es que el archivo se cargue antes de ejecutar el servidor. De esta forma, la función requestListener() devolverá seguro una página HTML, ya que indexFile ya no es una variable vacía.

      Nuestro controlador de errores ha cambiado también. Si no se puede cargar el archivo, capturamos el error y lo imprimimos en nuestra consola. A continuación, salimos del programa Node.js con la función exit() sin iniciar el servidor. De esta forma, podemos ver por qué falló la lectura del archivo, resolver el problema e iniciar el servidor de nuevo.

      Ahora hemos creado diferentes servidores web que devuelven varios tipos de datos a un usuario. Hasta ahora, no hemos usado ninguna solicitud de datos para determinar qué deberíamos devolver. Deberemos usar solicitar datos cuando se configuren diferentes rutas en un servidor Node.js, así que veamos cómo funcionan juntos.

      Paso 4: Administrar rutas usando un objeto de solicitud HTTP

      La mayoría de los sitios web que visitamos o APIs que usamos normalmente tienen más de un endpoint, para que podemos acceder a varios recursos. Un buen ejemplo sería un sistema de administración de libros, uno que pueda usarse en una biblioteca. No solo necesitaría administrar los datos de los libros, sino también administrar los datos del autor para facilitar la creación de catálogos y las búsquedas.

      Aunque los datos para libros y autores están relacionados, hay dos objetos diferentes. En estos casos, los desarrolladores de software normalmente codifican cada objeto en endpoints diferentes como una forma de indicar al usuario API con qué tipo de datos está interactuando.

      Crearemos un nuevo servidor para una pequeña biblioteca, que devolverá dos tipos de datos diferentes. Si el usuario va a la dirección de nuestro servidor /books, recibirá una lista de libros en JSON. Si van a /authors, recibirán una lista de información del autor en JSON.

      Hasta ahora, hemos devuelto la misma respuesta a cada solicitud que obtuvimos. Ilustremos esto rápidamente.

      Vuelva a ejecutar nuestro ejemplo de respuesta JSON:

      En otro terminal, vamos a hacer una solicitud cURL como antes:

      • curl http://localhost:8000

      Verá lo siguiente:

      Output

      {"message": "This is a JSON response"}

      Ahora probemos otro comando curl:

      • curl http://localhost:8000/todos

      Tras pulsar Enter, verá el mismo resultado:

      Output

      {"message": "This is a JSON response"}

      No hemos creado ninguna lógica especial en nuestra función requestListener() para gestionar una solicitud cuya URL contiene /todos, de forma que Node.js devuelve el mismo mensaje JSON por defecto.

      Ya que queremos crear un servidor de gestión de una biblioteca en miniatura, ahora separaremos los tipos de datos que se devuelven en base al endpoint al que el usuario accede.

      Primero, salga del servidor en ejecución con CTRL+C.

      Ahora, abra routes.js en su editor de texto:

      Comenzaremos almacenando nuestros datos JSON en variables antes de la función requestListener():

      first-servers/routes.js

      ...
      const books = JSON.stringify([
          { title: "The Alchemist", author: "Paulo Coelho", year: 1988 },
          { title: "The Prophet", author: "Kahlil Gibran", year: 1923 }
      ]);
      
      const authors = JSON.stringify([
          { name: "Paulo Coelho", countryOfBirth: "Brazil", yearOfBirth: 1947 },
          { name: "Kahlil Gibran", countryOfBirth: "Lebanon", yearOfBirth: 1883 }
      ]);
      ...
      

      La variable books es una cadena que contiene JSON para una variedad de objetos de libros. Cada libro tiene un título o nombre, un autor, y el año en que se publicó.

      La variable authors es una cadena que contiene el JSON para diversos objetos de autor. Cada autor tiene un nombre, un país de nacimiento y su año de nacimiento.

      Ahora que tenemos los datos que nuestras respuestas devolverán, vamos a comenzar a modificar la función requestListener() para devolverlas a las rutas correctas.

      Primero, nos aseguraremos de que cada respuesta desde nuestro servidor tenga el encabezado Content-Type correcto:

      first-servers/routes.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "application/json");
      }
      ...
      

      Ahora, queremos devolver el JSON adecuado, dependiendo de la ruta URL que el usuario visite. Crearemos la instrucción switch en la URL de la solicitud:

      first-servers/routes.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "application/json");
          switch (req.url) {}
      }
      ...
      

      Para obtener la ruta URL desde un objeto de solicitud, debemos acceder a su propiedad url. Ahora podemos añadir casos a la instrucción switch para devolver el JSON apropiado.

      La instrucción switch de JavaScrip proporciona una forma de controlar qué código se ejecuta dependiendo del valor de un objeto o expresión JavaScript (por ejemplo, el resultado de operaciones matemáticas). Si necesita una lección o un recordatorio sobre cómo usarlas, eche un vistazo a nuestra guía sobre Cómo usar la instrucción Switch en JavaScript.

      Ahora, agreguemos un caso para cuando el usuario quiera obtener nuestra lista de libros:

      first-servers/routes.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "application/json");
          switch (req.url) {
              case "/books":
                  res.writeHead(200);
                  res.end(books);
                  break
          }
      }
      ...
      

      Establecemos nuestro código de estado a 200 para indicar que la solicitud está bien y devolver el JSON que contiene la lista de nuestros libros. Ahora, vamos a añadir otro caso para nuestro autores:

      first-servers/routes.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "application/json");
          switch (req.url) {
              case "/books":
                  res.writeHead(200);
                  res.end(books);
                  break
              case "/authors":
                  res.writeHead(200);
                  res.end(authors);
                  break
          }
      }
      ...
      

      Como antes, el código de estado será 200, ya que la solicitud está bien. Esta vez, devolvemos el JSON que contiene la lista de nuestros autores.

      Queremos devolver un error si el usuario intenta ir a cualquier otra ruta. agreguemos el caso predeterminado para hacer esto:

      routes.js

      ...
      const requestListener = function (req, res) {
          res.setHeader("Content-Type", "application/json");
          switch (req.url) {
              case "/books":
                  res.writeHead(200);
                  res.end(books);
                  break
              case "/authors":
                  res.writeHead(200);
                  res.end(authors);
                  break
              default:
                  res.writeHead(404);
                  res.end(JSON.stringify({error:"Resource not found"}));
          }
      }
      ...
      

      Usamos la palabra clave default en una instrucción switch para capturar todos los otros escenarios no capturados por nuestros casos previos. Establecemos el código de estado a 404 para indicar que no se encontró la URL que estaban buscando. A continuación, añadimos un objeto JSON que contiene un mensaje de error.

      Probemos nuestro servidor para ver si se comporta como esperamos. En otro terminal, primero vamos a ejecutar un comando para ver si obtenemos nuestra lista de libros:

      • curl http://localhost:8000/books

      Pulse Enter para ver el siguiente resultado:

      Output

      [{"title":"The Alchemist","author":"Paulo Coelho","year":1988},{"title":"The Prophet","author":"Kahlil Gibran","year":1923}]

      Hasta ahora, todo bien. Intentemos lo mismo para /authors. Escriba el siguiente comando en el terminal:

      • curl http://localhost:8000/authors

      Verá el siguiente resultado cuando el comando se complete:

      Output

      [{"name":"Paulo Coelho","countryOfBirth":"Brazil","yearOfBirth":1947},{"name":"Kahlil Gibran","countryOfBirth":"Lebanon","yearOfBirth":1883}]

      Por último, probemos otra URL errónea para asegurarnos de que requestListener() devuelve la respuesta del error:

      • curl http://localhost:8000/notreal

      Al introducir ese comando, se mostrará este mensaje:

      Output

      {"error":"Resource not found"}

      Puede salir del servidor en ejecución con CTRL+C.

      Ahora hemos creado diferentes caminos para que nuestros usuarios obtengan datos diferentes. También hemos añadido una respuesta predeterminada que devuelve un error HTTP si el usuario introduce una URL que no admitimos.

      Conclusión

      En este tutorial, creó una serie de servidores HTTP Node.js. Primero devolvió una respuesta textual básica. Luego, devolvió varios tipos de datos desde nuestro servidor: JSON, CSV y HTML. Desde ahí, pudo combinar la carga de archivos con las respuestas HTTP para devolver una página HTML desde un servidor al usuario, y para crear una API que usó información sobre la solicitud del usuario para determinar qué datos deberían enviarse en su respuesta.

      Ahora está preparado para crear servidores web que pueden gestionar una variedad de solicitudes y respuestas. Con este conocimiento, puede crear un servidor que devuelva muchas páginas HTML al usuario en diferentes puntos finales. También podría crear su propia API.

      Para obtener más información sobre los servidores web HTTP en Node.js, puede leer la documentación sobre Node.js en el módulo http. Si desea seguir aprendiendo sobre Node.js, puede volver a la página de la serie Cómo desarrollar código en Node.js.



      Source link

      Cómo crear elementos de React con JSX


      El autor seleccionó Creative Commons para recibir una donación como parte del programa Write for DOnations.

      Introducción

      En este tutorial, aprenderá a describir elementos con JSX. JSX es una abstracción que le permite escribir sintaxis HTML en su código de JavaScript y le permitirá crear componentes de React similares al marcado HTML estándar. JSX es el lenguaje de creación de plantillas de los elementos de React y, por tanto, es la base para cualquier marcado que React procese en su aplicación.

      Como JSX le permite también escribir JavaScript en su marcado, podrá aprovechar las funciones y métodos de JavaScript, incluyendo asignaciones de matrices y evaluación de cortocircuitos para condicionales.

      Como parte del tutorial, aprenderá a capturar eventos de clic en los botones directamente en el marcado y actualizar instancias cuando la sintaxis no coincida exactamente con el HTML estándar, como por ejemplo con clases CSS. Tras este tutorial, tendrá una aplicación funcional que usa varias funciones de JSX para ver una lista de elementos de escucha de clics incorporado. Es un patrón común en aplicaciones de React que usará a menudo a medida que se familiariza con el marco. También podrá mezclar elementos HTML estándar con JavaScript para ver cómo React le permite crear pequeños conjuntos de código reutilizables.

      Requisitos previos

      Paso 1: Agregar marcado a un elemento de React

      Como ya se dijo, React tiene un lenguaje de marcado especial llamado JSX. Es una mezcla de HTML y de sintaxis de JavaScript que tiene un aspecto similar a este:

      <div>
        {inventory.filter(item => item.available).map(item => (
          <Card>
              <div className="title"}>{item.name}</div>
              <div className="price">{item.price}</div>
          </Card>
          ))
        }
      </div>
      

      Reconocerá algunas funcionalidades de JavaScript como .filter y .map, así como HTML estándar como <div>. Pero hay otras partes que se parecen a HTML y JavaScript, como <Card> y className.

      Es JSX, el lenguaje de marcado especial que proporciona un aspecto de HTML a los componentes de React con el poder de JavaScript.

      En este paso, aprenderá a añadir sintaxis básica de HTML a un elemento de React existente. Para comenzar, añadirá elementos HTML estándar a una función de JavaScript y verá el código compilado en un navegador. Agrupe también elementos para que React pueda compilarlos con un marcado mínimo obteniendo un resultado HTML limpio.

      Para comenzar, cree un nuevo proyecto. En su línea de comandos, ejecute la siguiente secuencia de comandos para instalar un proyecto nuevo usando create-react-app:

      • npx create-react-app jsx-tutorial

      Tras finalizar el proyecto, cambie al directorio:

      En una nueva pestaña o ventana de terminal, inicie el proyecto usando la secuencia de comandos de inicio de Create React App. El navegador actualizará los cambios automáticamente, así que deje que esta secuencia de comandos se ejecute mientras usted trabaja:

      Obtendrá un servidor local activo. Si el proyecto no se abrió en una ventana de navegador, puede encontrarlo en http://localhost:3000/. Si lo ejecuta desde un servidor remoto, la dirección será http://your_IP_address:3000.

      Su navegador cargará una aplicación React incluida como parte de Create React App.

      Proyecto de plantilla de React

      Creará un conjunto completamente nuevo de componentes personalizados, por lo que deberá comenzar eliminando un código de texto estándar para poder tener un proyecto vacío. Empiece abriendo App.js en un editor de texto. Es el componente root que se inserta en la página. Todos los componentes empezarán desde aquí.

      En un nuevo terminal, vaya a la carpeta del proyecto y abra src/App.js con el siguiente comando:

      Verá un archivo como este:

      jsx-tutorial/src/App.js

      import React from 'react';
      import logo from './logo.svg';
      import './App.css';
      
      function App() {
        return (
          <div className="App">
            <header className="App-header">
              <img src={logo} className="App-logo" alt="logo" />
              <p>
                Edit <code>src/App.js</code> and save to reload.
              </p>
              <a
                className="App-link"
                href="https://reactjs.org"
                target="_blank"
                rel="noopener noreferrer"
              >
                Learn React
              </a>
            </header>
          </div>
        );
      }
      
      export default App;
      

      Ahora, elimine el logo de importación de línea desde './logo.svg y todo lo siguiente a la instrucción de return en la función. Cámbielo para que se vuelva null. El código final tendrá el siguiente aspecto:

      jsx-tutorial/src/App.js

      import React from 'react';
      import './App.css';
      
      function App() {
        return null;
      }
      
      export default App;
      

      Guarde y salga del editor de texto.

      Por último, elimine el logo. En la ventana del terminal escriba el siguiente comando:

      No usará este archivo SVG en su aplicación y debería eliminar los archivos que no se usan según va trabajando. Organizará mejor su código a largo plazo.

      Una vez eliminadas estas partes de su proyecto, puede continuar estudiando las facetas de JSX. React compila este lenguaje de marcado y, finalmente, convierte el HTML que ve en una página web. Sin extenderse mucho en los pormenores, React toma el JSX y crea un modelo del aspecto que tendrá su página y, a continuación, crea los elementos necesarios y los añade a la página.

      Eso significa que puede escribir lo que se parece a HTML y esperar que el HTML emitido sea similar. Sin embargo, hay algunas trampas.

      Primero, si mira la pestaña o la ventana en la que se está ejecutando su servidor, verá esto:

      Output

      ... ./src/App.js Line 1:8: 'React' is defined but never used no-unused-vars ...

      Es el linter que le indica que no usa el código de React importado. Al añadir la línea import React de 'react' a su código, importa el código de JavaScript que convierte JSX en un código React. Si no hay JSX, no necesita importar.

      Podemos cambiarlo añadiendo una pequeña cantidad de JSX. Comience sustituyendo null con Hello, World, por ejemplo:

      jsx-tutorial/src/App.js

      import React from 'react';
      import './App.css';
      
      function App() {
        return <h1>Hello, World</h1>;
      }
      
      export default App;
      

      Guarde el archivo. Si ve el terminal con el servidor en ejecución, desaparecerá el mensaje de advertencia. Si entra en su navegador, verá el mensaje como un elemento h1.

      Pantalla de navegador que muestra “Hello, World”

      A continuación, debajo de la etiqueta <h1>, añada una etiqueta de párrafo que contiene la cadena I am writing JSX. El código tendrá el siguiente aspecto:

      jsx-tutorial/src/App.js

      import React from 'react';
      import './App.css';
      
      function App() {
        return(
          <h1>Hello, World</h1>
          <p>I am writing JSX</p>
        )
      }
      
      export default App;
      

      Ya que JSX abarca varias líneas, deberá escribir la expresión entre paréntesis.

      Guarde el archivo. Al hacerlo, verá un error en el terminal que ejecuta su servidor:

      Output

      ./src/App.js Line 7:5: Parsing error: Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...</>? 5 | return( 6 | <h1>Hello, World</h1> > 7 | <p>I am writing JSX</p> | ^ 8 | ) 9 | } 10 |

      Cuando devuelve JSX de una función o instrucción, debe devolver un único elemento. Es posible que ese elemento tenga partes anidadas, pero debe haber un único elemento de nivel superior. En este caso, devuelve dos elementos.

      El ajuste es un cambio de código pequeño. Rodee el código con una etiqueta vacía. Una etiqueta vacía es un elemento HTML sin palabras. Tiene el siguiente aspecto: <></>.

      Vuelva a ./src/App.js en su editor y añada la etiqueta vacía:

      jsx-tutorial/src/App.js

      import React from 'react';
      import './App.css';
      
      function App() {
        return(
          <>
            <h1>Hello, World</h1>
            <p>I am writing JSX</p>
          </>
        )
      }
      
      export default App;
      

      La etiqueta vacía crea un único elemento, pero no se añade al marcado final cuando se compila el código. Esto mantendrá su código limpio y le da a React un único elemento.

      Nota: También podría haber encapsulado el código con un div, en vez de etiquetas vacías, siempre que el código devuelva un elemento. En este ejemplo, una etiqueta vacía tiene la ventaja de no añadir marcado adicional al resultado analizado.

      Guarde el código y salga del archivo. Su navegador se actualizará y mostrará la página actualizada con el elemento de párrafo. Además, cuando se convierte el código, las etiquetas vacías se eliminarán:

      Navegador que muestra marcado y devtools sin etiquetas vacías

      Ya agregó un conjunto de JSX básico a su componente y aprendió cómo deben anidarse todos los JSX en un único componente. En el siguiente paso, añadirá un estilo a su componente.

      Paso 2: Agregar estilos a un elemento con atributos

      En este paso, dará estilo a los elementos de su componente para saber cómo funcionan los atributos HTML con JSX. Existen muchas opciones de estilo en React. Algunas de ellas incluyen escribir CSS en Javascript y otras usan preprocesadores. En este tutorial, trabajará con clases de CSS y CSS importadas.

      Ahora que tiene su código, debe añadir un estilo. Abra App.css en su editor de texto:

      Ya que empieza con un JSX nuevo, la CSS actual se refiere a los elementos que ya no existen. Como no necesita CSS, puede eliminarla.

      Después de eliminar el código, tendrá un archivo vacío.

      A continuación, añada un estilo al centro del texto. En src/App.css, añada el siguiente código:

      jsx-tutorial/src/App.css

      .container {
          display: flex;
          flex-direction: column;
          align-items: center;
      }
      

      En este bloque de código, creó un selector de clase CSS llamado .container y lo utilizó para centrar el contenido usando display:flex.

      Guarde el archivo y salga. El navegador se actualizará, pero no cambiará nada. Antes de poder ver el cambio, deberá añadir la clase CSS a su componente React. Abra el código de JavaScript del componente:

      El código CSS ya se importó con la línea import'. /App.css'. Esto significa que webpack extraerá el código para crear una hoja de estilo final, pero deberá añadir las clases para aplicar CSS a sus elementos.

      En primer lugar, en su editor de texto, cambie las etiquetas vacías <>, a <div>.

      jsx-tutorial/src/App.js

      import React from 'react';
      import './App.css';
      
      function App() {
        return(
          <div>
            <h1>Hello, World</h1>
            <p>I am writing JSX</p>
          </div>
        )
      }
      
      export default App;
      

      En este código, sustituyó las etiquetas vacías, <>, por etiquetas div. Las etiquetas vacías son útiles para agrupar su código sin añadir otras adicionales, pero aquí necesita usar un div porque las etiquetas vacías no aceptan atributos HTML.

      A continuación, deberá añadir el nombre de clase. Es donde JSX comenzará a diferir de HTML. Si desea añadir una clase a un elemento HTML habitual, debería hacerlo como se indica a continuación:

      <div class="container">
      

      Pero, dado que JSX es JavaScript, tiene algunas limitaciones. Una de las limitaciones es que JavaScript tiene palabras clave reservadas. Eso significa que no puede usar determinadas palabras en ningún código de JavaScript. Por ejemplo, no puede crear una variable llamada null porque esa palabra ya está reservada.

      Una de las palabras reservadas es class. React trata esta palabra reservada cambiándola ligeramente. En vez de añadir el atributo class, añadirá el atributo className. Como regla general, si un atributo no funciona como se espera, intente añadir la versión con capitalización Camel. Otro atributo ligeramente diferente es el atributo for que podría usar para las etiquetas. Hay otros casos, pero afortunadamente la lista es bastante corta.

      Nota: En React, los atributos a menudo se denominan_ propiedade_s. Las propiedades son datos que puede pasar a otros componentes personalizados. Se parecen a los atributos excepto que no coinciden con especificaciones de HTML. En este tutorial, las llamaremos atributos, ya que se utilizan principalmente como atributos HTML estándar. Esto servirá para distinguirlas de las propiedades que no se comportan como atributos HTML, que se explicarán más adelante en esta serie.

      Ahora que ya sabe cómo se usa el atributo class en React, puede actualizar su código para incluir los estilos. En su editor de texto, añada className="container" a su etiqueta de apertura div:

      jsx-tutorial/src/App.js

      import React from 'react';
      import './App.css';
      
      function App() {
        return(
          <div className="container">
            <h1>Hello, World</h1>
            <p>I am writing JSX</p>
          </div>
        )
      }
      
      export default App;
      

      Guarde el archivo. Al hacerlo, se volverá a cargar la página y el contenido se centrará.

      Elementos html centrados en un navegador

      El atributo className es único en React. Puede añadir la mayoría de atributos HTML a JSX sin ningún cambio. Como ejemplo, vuelva a su editor de texto y añada un id de saludo a su elemento <h1>. Tendrá el aspecto de HTML estándar:

      jsx-tutorial/src/App.js

      import React from 'react';
      import './App.css';
      
      function App() {
        return(
          <div className="container">
            <h1 id="greeting">Hello, World</h1>
            <p>I am writing JSX</p>
          </div>
        )
      }
      
      export default App;
      

      Guarde la página y vuelva a cargar el navegador. Será igual.

      Hasta ahora, JSX tiene el aspecto de marcado estándar, pero su ventaja es que, aunque se parece a HTML, tiene el poder de JavaScript. Eso significa que puede asignar variables y referenciarlas en sus atributos. Para referenciar un atributo, encapsúlelo entre llaves {}, en vez de comillas.

      En su editor de texto, añada las siguientes líneas resaltadas para hacer referencia a un atributo:

      jsx-tutorial/src/App.js

      import React from 'react';
      import './App.css';
      
      function App() {
        const greeting = "greeting";
        return(
          <div className="container">
           <h1 id={greeting}>Hello, World</h1>
            <p>I am writing JSX</p>
          </div>
        )
      }
      
      export default App;
      

      En este código, creó una variable sobre la instrucción return denominada saludo con el valor de "greeting", y referenció luego la variable en el atributo id de su etiqueta <h1>.

      Guarde el archivo y ciérrelo. La página será la misma, pero con una etiqueta id.

      Página con una etiqueta id resaltada en las herramientas de desarrollador

      Hasta ahora, trabajó con algunos elementos propios, pero también puede usar JSX para añadir muchos elementos HTML y anidarlos para crear páginas complejas.

      Para mostrárselo, creará una página con una lista de emojis. Estos emojis se encapsularán con un elemento <button>. Cuando haga clic en el emoji, obtendrá su CLDR Short Name.

      Para comenzar, deberá añadir algunos elementos más a la página. Abra src/App.js en su editor de texto. Manténgalo abierto durante este paso.

      Primero, añada una lista de emojis añadiendo las siguientes líneas resaltadas:

      jsx-tutorial/src/App.js

      import React from 'react';
      import './App.css';
      
      function App() {
        const greeting = "greeting";
        return(
          <div className="container">
            <h1 id={greeting}>Hello, World</h1>
            <p>I am writing JSX</p>
            <ul>
              <li>
                  <button>
                    <span role="img" aria-label="grinning face" id="grinning face">😀</span>
                  </button>
              </li>
              <li>
                <button>
                    <span role="img" aria-label="party popper" id="party popper">🎉</span>
                </button>
              </li>
              <li>
                <button>
                    <span role="img" aria-label="woman dancing" id="woman dancing">💃</span>
                </button>
              </li>
            </ul>
          </div>
        )
      }
      
      export default App;
      

      Así crea una etiqueta <ul> que contenga una lista de emojis. Cada emoji está en un elemento <li> distinto y está rodeado de un elemento <button>. En el siguiente paso, añadirá un evento a este botón.

      También rodeó el emoji con una etiqueta <span> que tiene algunos atributos más. Cada span tiene el atributo role configurado en el rol img. Esto indicará al software de accesibilidad que el elemento está actuando como una imagen. Además, cada <span> también tiene un atributo aria-label y un id con el nombre del emoji. aria-label le indicará a los visitantes con lectores de pantalla qué se muestra. Usará el id al escribir eventos en el siguiente paso.

      Al escribir código de esta forma, usa elementos semánticos que ayudan a que la página sea accesible y fácil de analizar para los lectores de pantalla.

      Guarde el archivo y ciérrelo. Su navegador se actualizará, y verá lo siguiente:

      Navegador con emojis como lista

      Ahora añada un poco de estilo. Abra el código CSS en su editor de texto:

      Añada el siguiente código resaltado para eliminar el fondo y margen predeterminados de los botones además de aumentar el tamaño de fuente:

      jsx-tutorial/src/App.css

      .container {
          display: flex;
          flex-direction: column;
          align-items: center;
      }
      
      button {
          font-size: 2em;
          border: 0;
          padding: 0;
          background: none;
          cursor: pointer;
      }
      
      ul {
          display: flex;
          padding: 0;
      }
      
      li {
          margin: 0 20px;
          list-style: none;
          padding: 0;
      }
      

      En este código, usó font-size, border y otros parámetros para ajustar el aspecto de sus botones y cambiar la fuente. También eliminó los estilos de la lista y añadió display:flex al elemento <ul> para que sea horizontal.

      Guarde y cierre el archivo CSS. Su navegador se actualizará, y verá lo siguiente:

      Lista con los estilos predeterminados eliminados

      Ya ha trabajado con varios elementos de JSX que se parecen a un HTML normal. Ha agregado clases, ids y etiquetas aria, y ha trabajado con datos como cadenas y variables. Pero React también usa atributos para definir cómo deben responder sus elementos a los eventos de usuario. En el siguiente paso, comenzará a hacer que la página sea interactiva añadiendo eventos al botón.

      Paso 3: Agregar eventos a elementos

      En este paso, añadirá eventos a elementos usando atributos especiales y capturará un evento de clic en un elemento de botón. Aprenderá cómo capturar información del evento para enviar otra acción o usar otra información en el ámbito del archivo.

      Ahora que tiene una página básica con información, debe añadirle algunos eventos. Hay muchos gestores de eventos que puede añadir a elementos HTML. React le proporciona acceso a todos estos. Como su código de JavaScript está unido a su marcado, puede añadir rápidamente los eventos y mantener su código bien organizado.

      Para comenzar, añada el gestor de eventos onclick. Esto le permite añadir un código de JavaScript directamente a su elemento, en vez de añadir una escucha de eventos:

      jsx-tutorial/src/App.js

      import React from 'react';
      import './App.css';
      
      function App() {
        const greeting = "greeting";
        return(
          <div className="container">
            <h1 id={greeting}>Hello, World</h1>
            <p>I am writing JSX</p>
            <ul>
              <li>
                <button
                  onClick={event => alert(event.target.id)}
                >
                  <span role="img" aria-label="grinning face" id="grinning face">😀</span>
                </button>
              </li>
              <li>
                <button
                  onClick={event => alert(event.target.id)}
                >
                    <span role="img" aria-label="party popper" id="party popper">🎉</span>
                </button>
              </li>
              <li>
                  <button
                    onClick={event => alert(event.target.id)}
                  >
                    <span role="img" aria-label="woman dancing" id="woman dancing">💃</span>
                </button>
              </li>
            </ul>
          </div>
        )
      }
      
      export default App;
      

      Como se trata de JSX, usó la capitalización Camel para onclick, lo que significa que la añadió como onClick. Este atributo onClick usa una función anónima para obtener información sobre el elemento sobre el que se hizo clic.

      Añadió una función de flecha anónima que obtendrá el evento del botón pulsado, y el evento tendrá un destino que es el elemento <span>. La información que necesita está en el atributo id al que puede acceder con event.target.id. Puede activar la alerta con la función alert().

      Guarde el archivo. En su navegador, haga clic en uno de los emojis y obtendrá una alerta con el nombre.

      Alerta para serpentina

      Puede reducir una duplicación declarando la función una vez y pasándola a cada acción onClick. Como la función solo se basa en entradas y resultados, puede declararla fuera de la función de componente principal. En otras palabras, la función no necesita acceso al ámbito del componente. La ventaja de mantenerlos separados es que su función de componente es ligeramente más corta, y podría mover la función a un archivo separado después si quisiera.

      En su editor de texto, cree una función denominada displayEmojiName que toma el evento e invoca la función alert() con un id. Luego, pase la función a cada atributo onClick:

      jsx-tutorial/src/App.js

      import React from 'react';
      import './App.css';
      
      const displayEmojiName = event => alert(event.target.id);
      
      function App() {
        const greeting = "greeting";
        return(
          <div className="container">
            <h1 id={greeting}>Hello, World</h1>
            <p>I am writing JSX</p>
            <ul>
              <li>
                <button
                  onClick={displayEmojiName}
                >
                  <span role="img" aria-label="grinning face" id="grinning face">😀</span>
                </button>
              </li>
              <li>
                <button
                  onClick={displayEmojiName}
                >
                    <span role="img" aria-label="party popper" id="party popper">🎉</span>
                </button>
              </li>
              <li>
                  <button
                    onClick={displayEmojiName}
                  >
                    <span role="img" aria-label="woman dancing" id="woman dancing">💃</span>
                </button>
              </li>
            </ul>
          </div>
        )
      }
      
      export default App;
      

      Guarde el archivo. En su navegador, haga clic en un emoji y verá la misma alerta.

      En este paso, añadió eventos a cada elemento. También aprendió cómo JSX usa nombres ligeramente diferentes para los eventos de elementos y empezó a escribir código reutilizable tomando la función y volviendo a usarla en varios elementos. En el siguiente paso, escribirá una función reutilizable que devuelve elementos de JSX, en vez de escribir cada elemento a mano. Esto reducirá aún más la duplicación.

      Paso 4: Asignar datos para crear elementos

      En este paso, aprenderá a usar JSX como marcado simple. Aprenderá a combinarlo con JavaScript para crear un marcado dinámico que reduzca el código y mejore la legibilidad. Volverá a factorizar su código en una matriz que enlazará para crear elementos HTML.

      JSX no lo limita a una sintaxis HTML. También le permite usar JavaScript directamente en su marcado. Ya lo probó antes al pasar funciones a atributos. También utilizó variables para volver a usar datos. Ahora, es momento de crear JSX directamente desde los datos usando el código de JavaScript estándar.

      En su editor de texto, deberá crear una matriz de datos de emoji en el archivo src/App.js. Vuelva a abrir el archivo si lo cerró:

      Añada una matriz que contendrá objetos que tienen el emoji y el nombre del emoji. Tenga en cuenta que los emojis deben ir entre comillas. Cree esta matriz sobre la función App:

      jsx-tutorial/src/App.js

      import React from 'react';
      import './App.css';
      
      const displayEmojiName = event => alert(event.target.id);
      const emojis = [
        {
          emoji: "😀",
          name: "grinning face"
        },
        {
          emoji: "🎉",
          name: "party popper"
        },
        {
          emoji: "💃",
          name: "woman dancing"
        }
      ];
      
      function App() {
      ...
      }
      
      export default App;
      

      Ahora que tiene los datos, puede enlazarlos. Para usar JavaScript dentro de JSX, deberá rodearla con llaves: {}. Es el mismo proceso que cuando añadió funciones a atributos.

      Para crear componentes de React, deberá convertir los datos a elementos JSX. Para ello, asignará los datos y devolverá un elemento JSX. Hay algunas cosas que deberá tener en cuenta al escribir el código.

      En primer lugar, un grupo de elementos debe estar rodeado de un contenedor <div>. En segundo lugar, cada elemento necesita una propiedad especial denominada clave. La clave debe ser un único dato que use React para rastrear los elementos y poder saber así cuando actualizar el componente. La clave se eliminará del HTML compilado, dado que es solo para fines internos. Siempre que trabaje con bucles, deberá añadir una cadena sencilla como clave.

      Le mostramos un ejemplo sencillo que asigna una lista de nombres a un contenedor <div>:

      ...
      const names = [
          "Atul Gawande",
          "Stan Sakai",
          "Barry Lopez"
      ];
      
      return(
          <div>
              {names.map(name => <div key={name}>{name}</div>)}
          </div>
      )
      ...
      

      El HTML resultante tendrá el siguiente aspecto:

      ...
      <div>
          <div>Atul Gawande</div>
          <div>Stan Sakai</div>
          <div>Barry Lopez</div>
      </div>
      ...
      

      Convertir la lista de emojis será similar. El <ul> será el contenedor. Asignará datos y devolverá un <li> con una clave del nombre del emoji. Sustituya los datos con codificación fija en las etiquetas <button> y <span> con información del bucle.

      En su editor de texto, añada lo siguiente:

      jsx-tutorial/src/App.js

      import React from 'react';
      import './App.css';
      
      const displayEmojiName = event => alert(event.target.id);
      const emojis = [
        {
          emoji: '😀',
          name: "test grinning face"
        },
        {
          emoji: '🎉',
          name: "party popper"
        },
        {
          emoji: '💃',
          name: "woman dancing"
        }
      ];
      
      function App() {
        const greeting = "greeting";
        return(
          <div className="container">
            <h1 id={greeting}>Hello, World</h1>
            <p>I am writing JSX</p>
            <ul>
              {
                emojis.map(emoji => (
                  <li key={emoji.name}>
                    <button
                      onClick={displayEmojiName}
                    >
                      <span role="img" aria-label={emoji.name} id={emoji.name}>{emoji.emoji}</span>
                    </button>
                  </li>
                ))
              }
            </ul>
          </div>
        )
      }
      
      export default App;
      

      En su código, asignó sobre la matriz de emojis en la etiqueta <ul> y obtuvo un <li>. En cada <li>, usó el nombre del emoji como propiedad de clave. El botón tendrá la misma función de siempre. En el elemento <span>, sustituya aria-label e id por name. El contenido de la etiqueta <span> debería ser el emoji.

      Guarde el archivo. Su ventana se actualizará y verá los datos. Verá que no está la clave en el HTML generado.

      Navegador con herramientas de desarrollador que muestran HTML actualizada sin propiedades de clave

      La combinación de JSX con JavaScript estándar le proporciona muchas herramientas para crear contenido dinámico, y puede usar cualquier tipo de JavaScript estándar que quiera. En este paso, sustituyó JSX con codificación fija por una matriz y un bucle para crear HTML de manera dinámica. En el siguiente paso, mostrará información de forma condicional usando cortocircuitos.

      Paso 5: Mostrar condicionalmente elementos con cortocircuitos

      En este paso, usará los cortocircuitos para mostrar condicionalmente determinados elementos HTML. Esto le permitirá crear componentes que pueden ocultar o mostrar HTML basándose en información adicional, dando flexibilidad a sus componentes para gestionar múltiples situaciones.

      Hay momentos en los que necesitará que un componente muestre información en algunos casos y no en otros. Por ejemplo, puede querer mostrar solo un mensaje de alerta para el usuario si ciertos casos son verdaderos o mostrar alguna información de cuenta para un administrador que no querría que un usuario normal viese.

      Para ello, usará un cortocircuito. Esto significa que usará una condicional y, si la primera parte es verdadera, devolverá la información en la segunda parte.

      Le mostramos un ejemplo. Si quisiera que solo apareciera un botón si el usuario inició sesión, rodearía el elemento con llaves y añadiría antes la condición.

      {isLoggedIn && <button>Log Out</button>}
      

      En este ejemplo, utiliza el operador &&, que devuelve el último valor si todo es verdadero. De lo contrario, devuelve false, que le indicará a React que no devuelva ningún marcado adicional. Si isLoggedIn es verdadero, React mostrará el botón. Si isLoggedIn es falso, no mostrará el botón.

      Para probarlo, añada las siguientes líneas resaltadas:

      jsx-tutorial/src/App.js

      import React from 'react';
      import './App.css';
      
      ...
      
      function App() {
        const greeting = "greeting";
        const displayAction = false;
        return(
          <div className="container">
            <h1 id={greeting}>Hello, World</h1>
            {displayAction && <p>I am writing JSX</p>}
            <ul>
      ...
            </ul>
          </div>
        )
      }
      
      export default App;
      

      En su editor de texto, creó una variable denominada displayAction con un valor de false. A continuación, rodeó la etiqueta <p> con llaves. Al comienzo de las llaves, añadió displayAction && para crear la condicional.

      Guarde el archivo, y verá que el elemento desaparece en su navegador. Y, lo importante, tampoco aparecerá en el HTML generado. Esto no es lo mismo que ocultar un elemento con CSS. No existirá en el marcado final.

      Navegador con herramientas de desarrollador que no muestran un elemento de párrafo

      Ahora, el valor de displayAction presenta codificación fija, pero también puede almacenar ese valor como estado o aprobarlo como propiedad desde un componente principal.

      En este paso, aprendió a mostrar condicionalmente elementos. Esto le permite crear componentes que se personalizan basándose en otra información.

      Conclusión

      En este momento, creó una aplicación personalizada con JSX. Aprendió a añadir elementos de tipo HTML a su componente, añadir estilos a estos elementos, pasar atributos para crear marcado semántico y accesible, y añadir eventos a los componentes. A continuación, mezcló JavaScript en su JSX para reducir código duplicado y mostrar y ocultar elementos condicionalmente.

      Es la base que necesita para crear componentes futuros. Usando una combinación de JavaScript y HTML, puede crear componentes dinámicos que sean flexibles y permitir que su aplicación crezca y cambie.

      Si desea obtener más información sobre React, consulte nuestra página sobre React.



      Source link