Tu primera experiencia con Node.js

1

¿Dónde aprender backend con Node.js actualizado?

2

Todo lo que aprenderás sobre backend con Node.js

3

¿Qué es Node.js?

4

¿Qué es Node.js y para qué sirve?

5

Diferencias entre Node.js y JavaScript

6

Resumen: Diferencias Nodejs y Javascript

7

Instalación de Node.js

8

Arquitectura orientada a eventos

9

Node.js para la web

Manejo y uso de Streams con Node.js

10

Introducción a streams

11

Readable y Writable streams

12

Duplex y Transforms streams

Uso de utilidades de Node.js

13

Sistema operativo y sistema de archivos

14

Administrar directorios y archivos

15

Consola, utilidades y debugging

16

Clusters y procesos hijos

Crea tu primer proyecto en Express.js

17

¿Qué es Express.js y para qué sirve?

18

Creando tu primer servidor con Express.js

19

Request y Response Objects

Aprende a crear un API con REST

20

Anatomía de una API Restful

21

Estructura de una película con Moockaru

22

Implementando un CRUD en Express.js

23

Métodos idempotentes del CRUD

24

Implementando una capa de servicios

Cómo conectarse con librerías externas en Express.js

25

Creación de una BD en MongoAtlas

26

Conexión a MongoAtlas una instancia de MongoDB

27

Conexión con Robot3T y MongoDB Compass a una BD

28

Implementación de las acciones de MongoDB

29

Conexión de nuestros servicios con MongoDB

Conoce como funcionan los Middleware en Express.js

30

¿Qué es un middleware? Capa de manejo de errores usando un middleware

31

Manejo de errores asíncronos y síncronos en Express

32

Capa de validación de datos usando un middleware

33

¿Qué es Joi y Boom?

34

Implementando Boom

35

Implementando Joi

36

Probar la validación de nuestros endpoints

37

Middlewares populares en Express.js

Implementa tests en Node.js

38

Creación de tests para nuestros endpoints

39

Creación de tests para nuestros servicios

40

Creación de tests para nuestras utilidades

41

Agregando un comando para coverage

42

Debugging e inspect

Despliega tu primera aplicación en Express.js

43

Considerando las mejores prácticas para el despliegue

44

Variables de entorno, CORS y HTTPS

45

¿Cómo implementar una capa de manejo de caché?

46

¿Cómo contener tu aplicación en Docker?

47

Despliegue en Now

Conclusiones

48

¿Qué aprendiste en este curso?

No tienes acceso a esta clase

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

Regálate acceso ilimitado a todos los cursos por 1 año a precio especial de Navidad 🎄

Antes: $199

Currency
$149/año
regístrate

termina en:

16D
15H
25M
31S

Readable y Writable streams

11/48
Recursos

Los Readable y Writeable streams tienen los siguientes eventos y funciones respectivamente:

Readable

Eventos

  • data. Se dispara cuando recibe datos.
  • end. Se dispara cuando termina de recibir datos.
  • error. Se dispara cuando hay un error.

Funciones

  • pipe
  • unpipe
  • read
  • push

Writeable

Eventos

  • drain. Se dispara cuando emite datos.
  • finish. Se dispara cuando termina de emitir.
  • error. Se dispara cuando hay un error.

Funciones

  • write
  • end

Recuerda que tienen estos eventos porque los heredan de la clase EventEmitter.

Aportes 52

Preguntas 11

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Si como yo tuvieron problemas entendiendo esta clase, les dejo una buena info (si manejan ingles) sobre streams de node espero les sea útil :3

writable-stream.js

//importamos Writable del módulo de streams
const { Writable } = require('stream')

/**
 * Creamos un nuevo Writable y lo asignamos
 * a la constante writableStream
 */
const writableStream = new Writable({
  defaultEncoding: 'utf8',
  /**
   *
   * @param {*} chunk el buffer de entrada
   * @param {*} encoding la codificación
   * del buffer, si el chunk es un string
   * el enconding es la codificación en
   * caracteres de esa cadena, si la
   * codificación es un buffer esta se puede
   * ignorar
   * @param {*} callback esta función es
   * llamada cuando se complete el
   * procesamiento para el chunk
   * proporcionado.
   */
  write(chunk, encoding, callback) {
    console.log(chunk.toString())
    callback()
  }
})
process.stdin.pipe(writableStream)

readable-stream.js

//requerimos el módulo de Readable stream
const { Readable } = require('stream')
//instanciamos un nuevo Readable stream
const readableStream = new Readable()
/**
 * Cuando se ejecuta el método push()
 * los datos son almacenados en el buffer
 * si no se consumen los datos en el buffer 
 * estos se almacenan en la cola interna 
 * hasta que son consumidos
 */
readableStream.push(`${0 / 0}`.repeat(10).concat(' Batman, Batman!'))
/**
 * El stream de lectura se da por terminado
 * cuándo el buffer recibe un null en este caso
 * con el método push(null)
 */
readableStream.push(null)

/**
 * "pipe(writable)" Este método nos permite 
 * encadenar diferentes streams para su 
 * manipulación por medio de cómputos. Lo que
 * hace es recibir un stream
 * de entrada, realiza una operación sobre 
 * dicho stream y devuelve un nuevo stream con
 * dicha transformación.
 * 
 * "stdout" es un writable stream que toma el 
 * buffer y lo muestra en pantalla
 */
readableStream.pipe(process.stdout)

readable-stream-on-demand.js

//importamos el modulo readable
const { Readable } = require('stream')

//instanciamos un nuevo readable stream
const readableStream = new Readable({
  /**
   * constructor
   * @param {*} size tamaño del buffer
   * de lectura este se representa en bytes
   * y el valor por defecto es 16kb para un
   * readable stream y para fs es de 64kb
   * parámetro opcional
   */
  read(size) {
    setTimeout(() => {
      //la letra es mayor que z
      if (this.chartCode > 90) {
        //finalizamos la lectura
        this.push(null)
        return;
      }
      /**
       * agregamos la letra al buffer y después
       * se le suma 1 
       */
      this.push(String.fromCharCode(this.chartCode++))
    }, 100)
  }
})

/**
 * inicializamos el atributo chartCode
 * y le asignamos el valor  ASCII de la letra A
 */
readableStream.chartCode = 65
/**
 * manejamos el stream de lectura y le asignamos
 * un stream de salida por pantalla
 */
readableStream.pipe(process.stdout)

jajajajja NaN NaN Batman!!! Batman!! la mejor parte de la clase

Si les cuesta trabajo entender el process.stdout, cuando corremos un programa en consola tenemos 3 outputs posibles

  • standard input (stdin)
  • standard output (stdout)
  • standard error (stderr)
    .
    El output es lo que mostramos en consola
    el input es el argumento que le damos al programa, todo lo que sigue al programa.js
    El error es un número que regresamos dependiendo del error que queramos mostrar (Puede no ser un número)

Por lo mismo, hice el siguiente programa usando lo que vimos en Readable y Writable, pero el output del Readable se tomará como argumento del Writable. Así:

const  {Writable, Readable} = require( 'stream' );

const  readableStream = new Readable();
readableStream.push(`${0/0} `.repeat(10).concat('Batman! Batman\n'))
readableStream.push(null);
readableStream.pipe(process.stdin);

const  writableStream = new Writable({
    write(chunk, encoding, callback){
        console.log(chunk.toString());
        callback()
    }

});

process.stdin.pipe(writableStream);

#QueTrucazo de NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN Batman, Batman!

Aqui esta el char code que se menciona en la clase

Usó el número 90 porque ese es el código ASCII de la Z, la última letra del abecedario.

Acá hay varios códigos ASCII por si alguno andaba perdido:
https://ascii.cl/

Es bastante confuso, la forma en la que pronuncia readable, casi igual que writable, creo que se pronuncia ridabol, no raidabol, por otro lado pienso que no se está explicando nada, solo pone código en cada clase, pero no explica las cosas, por ejemplo en esta clase está process que es una variable global instancia de EventEmitter, pero en ningún momento la explicó

Esto me recuerda mucho a la clase de terminal.

El pipe en terminal es este signo " | " , en la terminal el std_out , es el output que manda cuando ingresamos un comando. El std_in por lógica el input que le enviamos en los comandos.

¿Nodejs y los servidores en general son una capa de abstración sobre bash?

Todos los streams son instancias de EventEmitter.

No entendí para que el size si nunca lo usa?

me gusto mucho lo de NaN NaN NaN NaN Batman, Batman! no me lo esperaba jjejeje

Aquí la lista de ASCII CODE!
https://ascii.cl/

Podrían hacer un curso de NestJS, el framework con arquitectura similar a Angular para NodeJS?


Eventos write stream

El peor curso de platzi lo que mas melesta es que no se hayan tomado el tiempo de realmente preparar algo y lo unico que hicieron fue pasar de un formato escrito a un formato de video por que la informacion la sacan de aqui https://www.freecodecamp.org/news/node-js-streams-everything-you-need-to-know-c9141306be93/ donde ni si quiera cambian los ejemplos. El profesor por mas experiencia que tenga en el campo se nota que no es profesor y lo unico que hace es leer un script. Termino el curso por que es necesario para completar el JSchallenge. Horrible!

En los writeablestreams los eventos mas coumnes son:drain. Se dispara cuando emite datos.
finish. Se dispara cuando termina de emitir.
error. Se dispara cuando hay un error.

las funciones mas comunes son:
write
end

En los readablestreams los eventos mas comunes son los data, que es cuando esta recibiendo datos.
funciones mas comunes:
pipe, unpipe y push

Readble y Writeable Streams: tienen eventos porque heredan de clase EventEmitter

💗💜🤩

:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

alguien sabe que es este error?, lleva como 2 clases y aun no encuentro el error, esto me impide avanzar de buena manera, y quisiera saber como arreglarlo, si alguien sabe que lo provoca sería perfecto

No entiendo porque al asignar el readableStream.currentCharcode = 65 es cuando se ejecuta el metodo read que implementamos en el constructor del Readable stream

NaN NaN NaN NaN NaN NaN NaN baattmaaan battmaaan

Bien. 😃

Eventos de streams

Svelte store eres tu?


Eventos de Read Stream


heredan de EventEmitter

🤣️🤣️🤣️

NaN NaN NaN NaN NaN NaN NaN NaN NaN NaN Batman, Batman!

Apuntes de la clase, espero sea de utilidad.
WriteableStream

ReadableStream

ReadableStreamOnDemand (usando chunks)

Estupenda explicación instructor Guillermo, me gusto bastante los ejemplos de Batman y el alfabeto para poder el funcionamiento de writable y readable.

Sigo asimilando lo de batman…espero olvidarlo en uno o dos dias

Cuando se usa la palabra reservada return, y cuando no?

Por que read() por que la instancia por que no puede solo usar lo metodos y esplicarnos mejor, por que currentCharCode por que pipe, tantas cosas que no se entiende -.-.!

Alguien me puede explicar cómo ese man hizo para sacar el Na, na na na na na na batman, batman! si lo único que puso fue batman, batman!

Readable y Writable streams


Los readable y Writable streams tienen eventos y funciones. Los eventos más comunes son:

  • data (readable)
  • end (readable)
  • error (readable)
  • drain (writable streams)
  • finish (writable streams)
  • error (writable streams)

Y las funciones más comunes son:

  • .pipe() (readable)
  • .unpipe() (readable)
  • .read() (readable)
  • .push() (readable)
  • .write() (writable streams)
  • .end() (writable streams)

⚠ El método Write de un objeto Writable recibe los siguientes parámetro

write(chunk, encoding, callback)

Así:

const { Writable } = require('stream')

const writableStream = new Writable({
    write(chunk, encoding, callback) {
        console.log(chunk.toString())

        callback()
    }
})

process.stdin.pipe(writableStream)

Y con un readable vendría siendo así:

const { Readable } = require('stream')

const readableStream = new Readable()

readableStream.push(`${0/0} `.repeat(10).concat('Batman, Batman!'))
readableStream.push(null)

readableStream.pipe(process.stdout)
const { Readable } = require('stream')

const readableStream = new Readable({
    read(size) {
        setTimeout(() => {
            if (this.currentCharCode > 90) {
                this.push(null)

                return
            }

            this.push(String.fromCharCode(this.currentCharCode++))
        }, 100)
    }
})

readableStream.currentCharCode = 65

readableStream.pipe(process.stdout)

Agregué estos comentarios al código que me ayudaron a entender más la dependencia entre los readble y writable streams. Espero les sirva 😄

Nan Nan Nan Batman Batman jajajajajaj que bueno

algo que por ahi queda entre lineas, es lo siguente:

“lo importante con los writeableStreams es que tienen que estar añadidos a un readableStream”

es decir, para poder escribir un stream, debemos tener primero un stream de lectura… es asi?

Creo que de ahora en adelante no veré el console.log de la misma forma, es un writable stream, esperando para imprimir lo que venga… nice

Morí con lo de Batman! Jajajaja XD

Batman!

Si les costó entender la clase como a mí, les dejo este artículo en español para entender a profundidad los streams 😃

No puedo creer lo mucho que me reí con NaN NaN NaN NaN Batman ljkasassajlkasdjlkajnlksdj XDD ❤️