One place for hosting & domains

      Nodejs

      Comment installer Node.js sur Ubuntu 20.04


      Introduction

      Node.js est un runtime JavaScript pour la programmation côté serveur. Il permet aux développeurs de créer des fonctionnalités d’arrière-plan évolutives en utilisant JavaScript, un langage que beaucoup connaissent déjà grâce au développement web par navigateur.

      Dans ce guide, nous vous montrerons trois façons différentes d’installer Node.js sur un serveur Ubuntu 20.04 :

      • en utilisant apt pour installer le paquet nodejs à partir du dépôt de logiciels par défaut d’Ubuntu
      • en utilisant apt avec un autre dépôt de logiciels PPA pour installer des versions spécifiques du paquet nodejs
      • en installant nvm, le gestionnaire de versions des nœuds, et en l’utilisant pour installer et gérer plusieurs versions de Node.js

      Pour de nombreux utilisateurs, l’utilisation d’apt avec le repo par défaut sera suffisante. Si vous avez besoin de versions spécifiques plus récentes (ou anciennes) de Node, vous devez utiliser le dépôt PPA. Si vous développez activement des applications Node et que vous devez passer fréquemment d’une version de noeud à l’autre, choisissez la méthode nvm.

      Conditions préalables

      Ce guide présuppose que vous utilisez Ubuntu 20.04. Avant de commencer, vous devez avoir un compte utilisateur non root avec privilèges sudo sur votre système. Vous pouvez apprendre à le faire en suivant le tutoriel de configuration initiale du serveur pour Ubuntu 20.04.

      Option 1 – Installation de Node.js avec Apt à partir des dépôts par défaut

      Ubuntu 20.04 contient une version de Node.js dans ses référentiels par défaut qui peut être utilisée pour fournir une expérience cohérente sur plusieurs systèmes. Au moment de la rédaction de cet article, la version dans les référentiels est la 10.19. Il ne s’agit pas de la dernière version, mais elle devrait être stable et capable de permettre une expérience rapide du langage.

      Pour obtenir cette version, vous pouvez utiliser le gestionnaire de package apt. Rafraîchissez d’abord votre index local de paquets en tapant :

      Installez ensuite Node.js :

      Vérifiez que l’installation a réussi en interrogeant node pour son numéro de version :

      Output

      v10.19.0

      Si le package dans les référentiels répond à vos besoins, c’est tout ce que vous devez faire pour installer Node.js. Dans la plupart des cas, vous voudrez également installer npm, le gestionnaire de package Node.js. Vous pouvez le faire en installant le paquet npm avec apt :

      Cela vous permettra d’installer des modules et des packages à utiliser avec Node.js.

      À ce stade, vous avez installé avec succès Node.js etnpm en utilisant apt et les référentiels de logiciels Ubuntu par défaut. La section suivante montrera comment utiliser un autre dépôt pour installer différentes versions de Node.js.

      Option 2 – Installer Node.js avec Apt en utilisant un PPA NodeSource

      Pour installer une version différente de Node.js, vous pouvez utiliser une PPA (archive personnelle de paquets) maintenue par NodeSource. Ces PPA ont plus de versions de Node.js disponibles que les dépôts officiels Ubuntu. Les Node.js v10, v12, v13 et v14 sont disponibles au moment de la rédaction.

      Tout d’abord, nous allons installer le PPA afin d’avoir accès à ses paquets. Dans votre répertoire d’origine, utilisez curl pour récupérer le script d’installation de votre version préférée, en veillant à remplacer 14.x par la chaîne de caractères de votre version préférée (si elle est différente).

      • cd ~
      • curl -sL https://deb.nodesource.com/setup_14.x -o nodesource_setup.sh

      Reportez-vous à la documentation NodeSource pour plus d’informations sur les versions disponibles.

      Inspectez le contenu du script téléchargé avecnano (ou votre éditeur de texte préféré) :

      Lorsque vous êtes convaincu que le script est sûr, quittez votre éditeur, puis exécutez le script avec sudo :

      • sudo bash nodesource_setup.sh

      Le PPA sera ajouté à votre configuration et le cache local de votre package sera automatiquement mis à jour. Vous pouvez maintenant installer le paquet Node.js de la même manière que vous l’avez fait dans la section précédente :

      Vérifiez que vous avez installé la nouvelle version en exécutant node avec le drapeau de version -v :

      Output

      v14.2.0

      Le paquet NodeSource nodejs contient à la fois le binaire du node et npm, vous n’avez donc pas besoin d’installer npm séparément.

      À ce stade, vous avez installé avec succès Node.js et npm en utilisant apt et le PPA NodeSource. La section suivante montrera comment utiliser le gestionnaire de versions de Node pour installer et gérer plusieurs versions de Node.js.

      Option 2 – Installer Node à l’aide du gestionnaire de versions de Node

      Une autre façon d’installer Node.js qui est particulièrement souple est d’utiliser nvm, le gestionnaire de versions de Node. Ce logiciel vous permet d’installer et de maintenir simultanément plusieurs versions indépendantes de Node.js ainsi que les paquets de Node qui leur sont associés.

      Pour installer le NVM sur votre machine Ubuntu 20.04, visitez la page GitHub du projet. Copiez la commande curl du fichier README qui s’affiche sur la page principale.  Vous obtiendrez ainsi la version la plus récente du script d’installation.

      Avant de transmettre la commande à bash, il est toujours bon de vérifier le script pour s’assurer qu’il ne fait rien que vous n’approuvez pas. Vous pouvez le faire en supprimant le segment | bash à la fin de la commande curl :

      • curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.35.3/install.sh

      Jetez un coup d’œil et assurez-vous que vous êtes à l’aise avec les changements qu’elle apporte. Lorsque vous êtes satisfait, relancez la commande avec | bash en annexe à la fin.  L’URL que vous utilisez changera en fonction de la dernière version du NVM, mais dès à présent, le script peut être téléchargé et exécuté en tapant :

      • curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.35.3/install.sh | bash

      Le script nvm sera alors installé sur votre compte d’utilisateur. Pour l’utiliser, vous devez d’abord créer votre fichier .bashrc :

      Maintenant, vous pouvez demander à NVM quelles versions de Node sont disponibles :

      Output

      . . . v12.13.0 (LTS: Erbium) v12.13.1 (LTS: Erbium) v12.14.0 (LTS: Erbium) v12.14.1 (LTS: Erbium) v12.15.0 (LTS: Erbium) v12.16.0 (LTS: Erbium) v12.16.1 (LTS: Erbium) v12.16.2 (LTS: Erbium) v12.16.3 (Latest LTS: Erbium) v13.0.0 v13.0.1 v13.1.0 v13.2.0 v13.3.0 v13.4.0 v13.5.0 v13.6.0 v13.7.0 v13.8.0 v13.9.0 v13.10.0 v13.10.1 v13.11.0 v13.12.0 v13.13.0 v13.14.0 v14.0.0 v14.1.0 v14.2.0

      C’est une longue liste ! Vous pouvez installer une version de Node en tapant l’une des versions que vous voyez. Par exemple, pour obtenir la version v13.6.0, vous pouvez taper :

      Vous pouvez voir les différentes versions que vous avez installées en tapant :

      nvm list
      

      Output

      -> v13.6.0 default -> v13.6.0 node -> stable (-> v13.6.0) (default) stable -> 13.6 (-> v13.6.0) (default) . . .

      La première ligne indique la version actuellement active (-> v13.6.0), suivie de certains alias nommés et des versions vers lesquelles ces alias pointent. 

      Note : si vous avez également une version de Node.js installée via apt, vous pouvez voir une entrée system ici. Vous pouvez toujours activer la version de Node installée sur le système en utilisant nvm use system.

      En outre, vous verrez des alias pour les différentes versions de support à long terme (ou LTS) de Node :

      Output

      . . . lts/* -> lts/erbium (-> N/A) lts/argon -> v4.9.1 (-> N/A) lts/boron -> v6.17.1 (-> N/A) lts/carbon -> v8.17.0 (-> N/A) lts/dubnium -> v10.20.1 (-> N/A) lts/erbium -> v12.16.3 (-> N/A)

      Nous pouvons également installer une version basée sur ces alias. Par exemple, pour installer la dernière version du support à long terme, erbium, exécutez ce qui suit :

      Output

      Downloading and installing node v12.16.3... . . . Now using node v12.16.3 (npm v6.14.4)

      Vous pouvez passer d’une version installée à l’autre avec nvm use : 

      nvm use v13.6.0
      
      Now using node v13.6.0 (npm v6.13.4)
      

      Vous pouvez vérifier que l’installation a réussi en utilisant la même technique que dans les autres sections, en tapant :

      Output

      v13.6.0

      La version correcte de Node est installée sur notre machine comme nous l’avions prévu. Une version compatible de npm est également disponible.

      Conclusion

      Il y a plusieurs façons de se mettre en route avec Node.js sur votre serveur Ubuntu 20.04. Votre situation déterminera laquelle des méthodes ci-dessus est la mieux adaptée à vos besoins. Si l’utilisation de la version packagée dans le dépôt d’Ubuntu est la méthode la plus simple, l’utilisation de nvm ou d’un PPA NodeSource offre une flexibilité supplémentaire.

      Pour plus d’informations sur la programmation avec Node.js, veuillez vous référer à notre série de tutoriels Comment coder dans Node.js.



      Source link

      How To Deploy a Resilient Node.js Application on Kubernetes from Scratch


      Description

      You may have heard the buzz around Kubernetes and noticed that many companies have been rapidly adopting it. Due to its many components and vast ecosystem it can be quite confusing to find where the path starts to learn it.

      In this session, you will learn the basics of containers and Kubernetes. Step by step, we will go through the entire process of packaging a Node.js application into a Docker container image and then deploying it on Kubernetes. We will demonstrate scaling to multiple replicas for better performance. The end result will be a resilient and scalable Node.js deployment.

      You will leave this session with sufficient knowledge of containerization, Kubernetes basics, and the ability to deploy highly available, performant, and scalable Node.js applications on Kubernetes.

      💰 Use this free $100 credit to try out Kubernetes on DigitalOcean for free!

      About the Presenter

      Kamal Nasser is a Developer Advocate at DigitalOcean. If not automating and playing with modern software and technologies, you’ll likely find him penning early 17th century calligraphy. You can find Kamal on Twitter at @kamaln7 or on GitHub at @kamaln7.

      Resources

      View the slides for this talk, or watch the recording on YouTube (coming soon).

      Transcript of The Commands and Manifests Used

      Be sure to follow along with the recording for an explanation and replace kamaln7 with your own DockerHub username.

      Node App

      1. Create an empty node package: npm init -y
      2. Install express as a dependency: npm install express
      3. index.js

        const express = require('express')
        const os = require('os')
        
        const app = express()
        app.get('/', (req, res) => {
                res.send(`Hi from ${os.hostname()}!`)
        })
        
        const port = 3000
        app.listen(port, () => console.log(`listening on port ${port}`))
        

      Docker

      1. Dockerfile

        FROM node:13-alpine
        
        WORKDIR /app
        
        COPY package.json package-lock.json ./
        
        RUN npm install --production
        
        COPY . .
        
        EXPOSE 3000
        
        CMD node index.js
        
      2. Build the image: docker build -t kamaln7/node-hello-app .

      3. Edit index.js and replace the word Hi with Hello.

      4. Re-build the image and notice Docker re-using previous layers: docker build -t kamaln7/node-hello-app .

      5. Run a container to test it: docker run --rm -d -p 3000:3000 kamaln7/node-hello-app

      6. Look at the running containers: docker ps

      7. Stop the container: docker stop CONTAINER_ID

      8. Push the image to DockerHub: docker push kamaln7/node-hello-app

      Kubernetes

      1. Get worker nodes: kubectl get nodes
      2. Create a deployment: kubectl create deployment --image kamaln7/node-hello-app node-app
      3. Scale up to 3 replicas: kubectl scale deployment node-app --replicas 3
      4. Expose the deployment as a NodePort replica: kubectl expose deployment node-app --port 3000
      5. Look at the newly created service (and the assigned port): kubectl get services
      6. Grab the public IP of one of the worker nodes: kubectl get nodes -o wide
      7. Browse to IP:port to test the service
      8. Edit the service: kubectl edit service node-app
        1. Replace port: 3000 with port: 80
        2. Replace type: NodePort with type: LoadBalancer
      9. Verify that the service was updated: kubectl get service
      10. Run the above command every few seconds until you get the external IP address of the Load Balancer
      11. Browse to the IP of the Load Balancer





      Source link

      Cómo usar búferes en Node.js


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

      Introducción

      Un búfer es un espacio en la memoria (en general, RAM) que almacena datos binarios. En Node.js, podemos acceder a estos espacios de memoria con la clase Buffer incorporada. Los búferes almacenan una secuencia de enteros, de forma similar a una matriz en JavaScript. A diferencia de las matrices, una vez que se crea un búfer, no se puede cambiar su tamaño.

      Es posible que haya utilizado búferes de manera implícita si ya escribió código de Node.js. Por ejemplo, cuando lee de un archivo con fs.readFile(), los datos que se devuelven a la devolución de llamada o promesa son un objeto de búfer. Además, cuando se realizan solicitudes HTTP en Node.js, devuelven flujos de datos que se almacenan temporalmente en un búfer interno cuando el cliente no puede procesarlo todo a la vez.

      Los búferes son útiles cuando se interactúa con datos binarios, habitualmente, en niveles de red inferiores. También le proporcionan la capacidad de manipular datos específicos en Node.js.

      En este tutorial, utilizará el REPL de Node.js para analizar varios ejemplos con búferes, como la creación, la lectura, la escritura y la copia de búferes, así como su utilización para convertir datos binarios y codificados. Al final del tutorial, habrá aprendido a usar la clase Buffer para trabajar con datos binarios.

      Requisitos previos

      Paso 1: Crear un búfer

      En este primer paso, se mostrarán las dos formas principales de crear un objeto de búfer en Node.js.

      Para decidir qué método usar, hágase esta pregunta: ¿quiere crear un búfer nuevo o extraer un búfer de datos existentes? Si va a almacenar datos que aún no recibió en la memoria, es conveniente crear un búfer nuevo. En Node.js, usamos la función alloc() de la clase Buffer para hacerlo.

      Vamos a abrir el REPL de Node.js para verlo por nosotros mismos. En su terminal, ingrese el comando node:

      Verá que la línea de comandos comienza con >.

      La función alloc() toma el tamaño del búfer como su primer y único argumento necesario. El tamaño es un entero que representa la cantidad de bytes de memoria que utilizará el objeto de búfer. Por ejemplo, si quisiéramos crear un búfer de 1 KB (kilobyte), lo que equivale a 1024 bytes, ingresaríamos esto en la consola:

      • const firstBuf = Buffer.alloc(1024);

      Para crear un búfer nuevo, usamos la clase Buffer, globalmente disponible, que contiene el método alloc(). Al proporcionar 1024 como argumento para alloc(), creamos un búfer de 1 KB.

      Por defecto, cuando inicializa un búfer con alloc(), este se completa con ceros binarios como un marcador de posición para datos posteriores. Sin embargo, puede cambiar el valor predeterminado si lo desea. Si quisiéramos crear un búfer nuevo con números 1 en lugar de 0, estableceríamos el segundo parámetro de la función alloc(): fill.

      En su terminal, cree un búfer nuevo en la línea de comandos de REPL con números 1:

      • const filledBuf = Buffer.alloc(1024, 1);

      Acabamos de crear un objeto de búfer nuevo que hace referencia a un espacio en la memoria que almacena 1 KB de números 1. Aunque ingresamos un entero, todos los datos de un búfer son binarios.

      Los datos binarios pueden tener diversos formatos. Por ejemplo, consideremos una secuencia binaria que representa un byte de datos: 01110110. Si esta secuencia binaria representara una cadena en inglés con el estándar de codificación ASCII, sería la letra v. Sin embargo, si nuestro equipo estuviera procesando una imagen, esa secuencia binaria podría contener información sobre el color de un píxel.

      La computadora sabe que debe procesarlos de forma distinta, dado que los bytes se codifican de un modo diferente. La codificación de los bytes es su formato. En Node.js, los búferes utilizan el esquema de codificación UTF-8 por defecto si se inicializan con datos de cadena. En UTF-8, un byte representa un número, una letra (en inglés y en otros idiomas) o un símbolo. UTF-8 es un superconjunto de ASCII, el Código Estadounidense Estándar para el Intercambio de Información (American Standard Code for Information Interchange). ASCII puede codificar bytes con mayúsculas y minúsculas en letras en inglés, los números 0 a 9 y algunos símbolos, como el de exclamación (!) o el de “y” comercial (&).

      Si escribiéramos un programa que solo pudiera funcionar con caracteres ASCII, podríamos cambiar la codificación que utiliza nuestro búfer con el tercer argumento de la función alloc(): encoding.

      Vamos a crear un búfer nuevo de cinco bytes de longitud que almacene únicamente caracteres ASCII:

      • const asciiBuf = Buffer.alloc(5, 'a', 'ascii');

      El búfer se inicializa con cinco bytes del carácter a, utilizando la representación ASCII.

      Nota: De manera predeterminada, Node.js admite las siguientes codificaciones de caracteres:

      • ASCII, representado como ascii
      • UTF-8, representado como utf-8 o utf8
      • UTF-16, representado como utf-16le o utf16le
      • UCS-2, representado como ucs-2 o ucs2
      • Base64, representado como base64
      • Hexadecimal, representado en hex
      • ISO/IEC 8859-1, representado como latin1 o binary

      Todos estos valores se pueden utilizar en funciones de clase Buffer que acepten un parámetro encoding. Por lo tanto, todos estos valores son válidos para el método alloc().

      Hasta ahora, creamos búferes nuevos con la función alloc(). Pero, a veces, podemos querer crear un búfer a partir de datos existentes, como una cadena o una matriz.

      Para crear un búfer a partir de datos preexistentes, usaremos el método from(). Podemos usar esa función para crear búferes a partir de lo siguiente:

      • Una matriz de enteros: los valores enteros pueden ser entre 0 y 255.
      • Un ArrayBuffer: un objeto de JavaScript que almacena una longitud fija de bytes.
      • Una cadena.
      • Otro búfer.
      • Otros objetos de JavaScript que tengan una propiedad Symbol.toPrimitive. Esa propiedad le indica a JavaScript cómo convertir el objeto en un tipo de datos primitivo: boolean, null, undefined, number, string o symbol. Puede obtener más información sobre los símbolos en la documentación de JavaScript de Mozilla.

      Veamos cómo podemos crear un búfer a partir de una cadena. En la línea de comandos de Node.js, ingrese lo siguiente:

      • const stringBuf = Buffer.from('My name is Paul');

      Ahora, tenemos un objeto de búfer creado a partir de la cadena My name is Paul. Vamos a crear un búfer nuevo a partir de otro búfer que creamos anteriormente:

      • const asciiCopy = Buffer.from(asciiBuf);

      Creamos un búfer nuevo asciiCopy que contiene los mismos datos que asciiBuf.

      Ahora que practicamos la creación de búferes, podemos incursionar en la lectura de sus datos.

      Paso 2: Leer de un búfer

      Hay muchas formas de acceder a los datos de un búfer. Podemos acceder a un byte individual de un búfer o podemos extraer todo su contenido.

      Para acceder a un byte de un búfer, pasamos el índice o la ubicación del byte que queremos. Los búferes almacenan datos de forma secuencial como las matrices. También indexan sus datos al igual que las matrices, a partir de 0. Podemos usar la notación de las matrices en el objeto de búfer para acceder a un byte individual.

      Veamos un ejemplo al crear un búfer a partir de una cadena en el REPL:

      • const hiBuf = Buffer.from('Hi!');

      Ahora, leamos el primer byte del búfer:

      Al pulsar INTRO, el REPL mostrará lo siguiente:

      Output

      72

      El entero 72 corresponde a la representación de UTF-8 de la letra H.

      Nota: Los valores de los bytes pueden ser números de 0 a 255, y un byte es una secuencia de 8 bits. Los bits son binarios, por lo tanto, solo pueden tener uno de dos valores: 0 o 1. Si tenemos una secuencia de 8 bits y dos posibles valores por bit, entonces, un byte tiene un máximo de 2⁸ valores posibles, es decir, 256. Como empezamos a contar desde cero, nuestro número más alto es 255.

      Vamos a hacer lo mismo con el segundo byte. Ingrese lo siguiente en el REPL:

      El REPL devuelve 105, que representa la letra i en minúscula.

      Por último, vamos a obtener el tercer carácter:

      Verá el número 33 en el REPL, que corresponde a !.

      Intentemos recuperar un byte de un índice no válido:

      El REPL devolverá lo siguiente:

      Output

      undefined

      Sucede lo mismo que si intentáramos acceder a un elemento de una matriz con un índice incorrecto.

      Ahora que vimos cómo se leen los bytes individuales de un búfer, veremos distintas opciones para obtener todos los datos almacenados en un búfer de una vez. El objeto de búfer viene con los métodos toString() y toJSON(), que devuelven todo el contenido de un búfer en dos formatos diferentes.

      Como lo indica en su nombre, el método toString() convierte los bytes de un búfer en una cadena y la devuelve al usuario. Si usamos este método en hiBuf, obtendremos la cadena Hi!. Vamos a probarlo.

      En la línea de comandos, ingrese lo que se indica a continuación:

      El REPL devolverá lo siguiente:

      Output

      'Hi!'

      Ese búfer se creó a partir de una cadena. Veamos lo que sucede si usamos toString() en un búfer que no se creó a partir de datos de una cadena.

      Vamos a crear un búfer nuevo, vacío, de 10 bytes:

      • const tenZeroes = Buffer.alloc(10);

      Ahora, usaremos el método toString():

      Veremos el siguiente resultado:

      'u0000u0000u0000u0000u0000u0000u0000u0000u0000u0000'
      

      La cadena u0000 es el carácter Unicode de NULL. Corresponde al número 0. Cuando los datos de un búfer no se codifican como una cadena, el método toString() devuelve la codificación UTF-8 de los bytes.

      El método toString() tiene un parámetro opcional: encoding. Podemos usar este parámetro para cambiar la codificación de los datos del búfer que se devuelven.

      Por ejemplo, si quisiéramos obtener la codificación hexadecimal de hiBuf, ingresaríamos lo siguiente en la línea de comandos:

      Esa instrucción da el siguiente resultado:

      Output

      '486921'

      486921 es la representación hexadecimal de los bytes que representan la cadena Hi! En Node.js, cuando los usuarios quieren convertir la codificación de datos de un formato a otro, suelen poner la cadena en un búfer e invocar toString() con su codificación deseada.

      El método toJSON() se comporta de un modo diferente. Independientemente de que el búfer se haya creado a partir de una cadena o no, siempre devuelve los datos como la representación en números enteros del byte.

      Volvamos a utilizar los búferes hiBuf y tenZeroes para practicar el uso de toJSON(). En la línea de comandos, ingrese lo siguiente:

      El REPL mostrará lo siguiente:

      Output

      { type: 'Buffer', data: [ 72, 105, 33 ] }

      Este objeto JSON tiene una propiedad type que siempre será Buffer para que los programas puedan distinguirlo de otros objetos JSON.

      La propiedad data contiene una matriz de la representación en enteros de los bytes. Debe haber observado que 72, 105, y 33 corresponden a los valores que recibimos cuando obtuvimos los bytes individualmente.

      Probemos el método toJSON() con tenZeroes:

      En el REPL, verá lo siguiente:

      Output

      { type: 'Buffer', data: [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] }

      El type es el mismo que indicamos antes. Sin embargo, ahora, los datos son una matriz con diez ceros.

      Ahora que cubrimos las principales formas de leer desde un búfer, vamos a ver cómo se puede modificar su contenido.

      Paso 3: Modificar un búfer

      Un objeto de búfer existente se puede modificar de diversas maneras. De forma similar a la lectura, podemos modificar los bytes de un búfer individualmente con la sintaxis de matriz. También podemos escribir contenido nuevo en un búfer, lo que sustituye los datos existentes.

      Comencemos por ver cómo podemos cambiar los bytes individuales de un búfer. Nuestra variable de búfer hiBuf, contiene la cadena Hi!. Vamos a cambiar cada byte para que contenga Hey en su lugar.

      En el REPL, primero, vamos fijar el segundo elemento de hiBuf en e:

      Ahora, vamos a ver este búfer como una cadena para confirmar que esté almacenando los datos correctos. A continuación, invoque el método toString():

      Se evaluará de la siguiente manera:

      Output

      'Hu0000!'

      Obtuvimos ese resultado extraño porque el búfer solo puede aceptar valores enteros. No podemos asignarle la letra e; en su lugar, debemos asignarle el número cuyo equivalente binario representa e:

      Ahora, al invocar el método toString() de la siguiente manera:

      Obtenemos este resultado en el REPL:

      Output

      'He!'

      Para cambiar el último carácter del búfer, debemos fijar el tercer elemento en el entero que corresponde al byte de y:

      Vamos a confirmar utilizando el método toString() una vez más:

      Su REPL mostrará lo siguiente:

      Output

      'Hey'

      Si intentamos escribir un byte que está fuera del alcance del búfer, se ignorará y el contenido del búfer no cambiará. Por ejemplo, vamos a intentar fijar el cuarto elemento del búfer en o:

      Podemos confirmar que el búfer no se modifica con el método toString():

      El resultado sigue siendo el siguiente:

      Output

      'Hey'

      Si queremos cambiar todo el contenido del búfer, podemos utilizar el método write(). El método write() acepta una cadena que sustituye el contenido de un búfer.

      Vamos a utilizar el método write() para volver a cambiar el contenido de hiBuf a Hi!. En su shell de Node.js, escriba lo siguiente en la línea de comandos:

      El método write() devolvió 3 en el REPL. Esto se debe a que escribió tres bytes de datos. Cada letra tiene un tamaño de un byte, dado que este búfer utiliza la codificación UTF8, que usa un byte para cada carácter. Si el búfer utilizara la codificación UTF-16, que tiene un mínimo de dos bytes por carácter, la función write() hubiera devuelto 6.

      Ahora, verifique el contenido del búfer utilizando toString():

      El REPL producirá lo siguiente:

      Output

      'Hi!'

      Esto es más rápido que tener que cambiar cada elemento byte por byte.

      Si intenta escribir más bytes que los que admite el tamaño de un búfer, el objeto de búfer aceptará únicamente los que pueda admitir. Para ilustrar esto, vamos a crear un búfer que almacene tres bytes:

      • const petBuf = Buffer.alloc(3);

      Ahora, vamos a intentar escribir Cats en él:

      Cuando se evalúa la invocación de write(), el REPL devuelve 3, lo que indica que solo tres bytes se escribieron en el búfer. Ahora, confirme que el búfer contenga los primeros tres bytes:

      El REPL devuelve lo siguiente:

      Output

      'Cat'

      La función write() añade los bytes en orden secuencial, por lo tanto, solo los tres primeros bytes se colocaron en el búfer.

      Ahora, en cambio, vamos a crear un búfer que almacene cuatro bytes:

      • const petBuf2 = Buffer.alloc(4);

      Escriba el mismo contenido en él:

      Luego, agregue un contenido nuevo que ocupe menos espacio que el contenido original:

      Como los búferes escriben de forma secuencial, a partir de 0, si imprimimos el siguiente contenido del búfer:

      Se nos saludará con esto:

      Output

      'Hits'

      Los primeros dos caracteres se sobrescriben, pero el resto del búfer permanece intacto.

      A veces, los datos que queremos en nuestro búfer preexistente no se encuentran en una cadena, sino en otro objeto de búfer. En esos casos, podemos utilizar la función copy() para modificar lo que almacena nuestro búfer.

      Vamos a crear dos búferes nuevos:

      • const wordsBuf = Buffer.from('Banana Nananana');
      • const catchphraseBuf = Buffer.from('Not sure Turtle!');

      Los búferes wordsBuf y catchphraseBuf contienen datos de cadena. Vamos a modificar catchphraseBuf para que almacene Nananana Turtle! en lugar de Not sure Turtle!. Usaremos copy() para obtener Nananana de wordsBuf en catchphraseBuf.

      Para copiar datos de un búfer a otro, utilizaremos el método copy() en el búfer que es la fuente de información. Por lo tanto, dado que wordsBuf contiene los datos de cadena que queremos copiar, debemos copiar de la siguiente manera:

      • wordsBuf.copy(catchphraseBuf);

      El parámetro target en este caso es el búfer catchphraseBuf.

      Cuando lo ingresamos en el REPL, devuelve 15, lo que indica que se escribieron 15 bytes. La cadena Nananana solo utiliza 8 bytes de datos, por lo tanto, nos damos cuenta de inmediato que nuestra copia no funcionó de la manera prevista. Utilice el método toString() para ver el contenido de catchphraseBuf:

      • catchphraseBuf.toString();

      El REPL devuelve lo siguiente:

      Output

      'Banana Nananana!'

      De manera predeterminada, copy() tomó todo el contenido de wordsBuf y lo colocó en catchphraseBuf. Debemos ser más selectivos para nuestro objetivo y copiar únicamente Nananana. Para continuar, vamos a volver a escribir el contenido original de catchphraseBuf:

      • catchphraseBuf.write('Not sure Turtle!');

      La función copy() contiene otros parámetros que nos permiten personalizar los datos que se copian al otro búfer. Esta es una lista de todos los parámetros de esta función:

      • target: este es el único parámetro requerido de copy(). Como vimos en nuestro ejemplo de uso anterior, es el búfer al que queremos copiar.
      • targetStart: este es el índice de los bytes del búfer de destino donde debemos comenzar a copiar. De manera predeterminada, es 0, lo que significa que copia datos desde el principio del búfer.
      • sourceStart: este es el índice de los bytes del búfer de origen de donde debemos copiar.
      • sourceEnd: este es el índice de los bytes del búfer de origen donde debemos dejar de copiar. De manera predeterminada, es la longitud del búfer.

      Por lo tanto, para copiar Nananana de wordsBuf a catchphraseBuf, nuestro target debe ser catchphraseBuf como antes. El targetStart será 0, dado que queremos que Nananana aparezca al principio de catchphraseBuf. El sourceStart debe ser 7, ya que ese es el índice donde Nananana comienza en wordsBuf. El sourceEnd debe continuar siendo la longitud de los búferes.

      En la línea de comandos de REPL, copie el contenido de wordsBuf de la siguiente manera:

      • wordsBuf.copy(catchphraseBuf, 0, 7, wordsBuf.length);

      El REPL confirma que se escribieron 8 bytes. Observe como wordsBuf.length se utiliza como valor del parámetro sourceEnd. Como sucede con las matrices, la propiedad length nos proporciona el tamaño del búfer.

      Ahora, vamos a ver el contenido de catchphraseBuf:

      • catchphraseBuf.toString();

      El REPL devuelve lo siguiente:

      Output

      'Nananana Turtle!'

      ¡Éxito! Pudimos modificar los datos de catchphraseBuf al copiar el contenido de wordsBuf.

      Puede salir del REPL de Node.js si así lo desea. Tenga en cuenta que todas las variables que se crearon dejarán de estar disponibles cuando lo haga:

      Conclusión

      En este tutorial, aprendió que los búferes son asignaciones de longitud fija en la memoria que almacenan datos binarios. Primero, creó búferes definiendo su tamaño en la memoria e iniciándolos con datos preexistentes. Luego, leyó datos de un búfer examinando sus bytes individuales y utilizando los métodos toString() y toJSON(). Por último, modificó los datos almacenados en un búfer cambiando sus bytes individuales y utilizando los métodos write() y copy().

      Los búferes le proporcionan excelente información sobre cómo manipula datos binarios Node.js. Ahora que puede interactuar con búferes, puede observar las distintas maneras en que la codificación de caracteres afecta cómo se almacenan los datos. Por ejemplo, puede crear búferes a partir de datos de cadena que no tengan codificación UTF-8 o ASCII y observar sus diferencias de tamaño. También puede tomar un búfer con UTF-8 y utilizar toString() para convertirlo a otros esquemas de codificación.

      Para obtener más información sobre los búferes en Node.js, puede leer la documentación de Node.js sobre el objeto Buffer. Si desea continuar aprendiendo sobre Node.js, puede regresar a la serie Cómo programar en Node.js o consultar proyectos de programación y configuraciones en nuestra página temática de Node.



      Source link