Duplex y Transforms streams

Clase 12 de 48 • Curso de Backend con Node.js 2019

Clase anteriorSiguiente clase

Resumen

Ambos sirven para simplificar nuestro código:

Duplex: implementa los métodos write y read a la vez.
Transform: es similar a Duplex pero con una sintaxis más corta.

Marcos Mercado Coca

student•

No es mucho pero es trabajo honesto

const { Transform } = require('stream');


const camelStream = new Transform({
    transform(chunk, callback) {
        const data = chunk.toString();
        data.split(" ").map((word) => {
            this.push(word.charAt(0).toUpperCase() + word.slice(1));
        });
    }
});

process.stdin.pipe(camelStream).pipe(process.stdout);```

Alvaro Armando Chamale Yancis

student•

Esta bien muy simplificado. Solo que no seria camelCase ya que la primer palabra tambien te la coloca como mayuscula. Modificaria tu codigo de esta manera:

data.split(" ").map((word,index) => {
this.push(index === 0 ? word.toLowerCase() : word.charAt(0).toUpperCase() + word.slice(1));
 });

José Pach Delgado

student•

El código ya está bien, de hecho hay dos tipos de camelCase

UpperCamelCase
lowerCamelCase

El primero es el que enuncia el compañero del comentario de abajo.

Juan Carlos García Esquivel

student•

El propósito de tener distintos tipos de streams no solo es simplificar el código, tienen pequeñas diferencias en su objetivo.

Tipos de streams Hay cuatro tipos fundamentales de streams en Node.js

Writable: streams en los que los datos pueden ser escritos.
Readable: streams en los que los datos pueden ser leídos.
Duplex: streams que pueden ser leídos y escritos.
Transform: Duplex streams que pueden modificar o transformar los datos cuando son escritos o leídos.

Mi Reto desglosado

const { Transform } = require('stream')

/** ingresa un string y convierte el primer
 * carácter a mayúscula
 */
const upperFirst = text => {
  //obtiene primer letra y convierte a mayúscula
  let first = text.charAt(0).toUpperCase()
  //el string a partir de la segunda letra
  let rest = text.slice(1)
  //unión primer letra + resto
  return first + rest
}

const transformStream = new Transform({
  transform(chunk, encoding, callback) {
    //la cadena de entrada en string
    const strChunk = chunk.toString()
    //cadena en minúsculas
    const lowerChunk = strChunk.toLowerCase()
    //array separado por espacio en blanco
    const arrayChunk = lowerChunk.split(' ')
    /**
     * creación de un nuevo array con camelCase
     * si  i (index) es 0 se retorna la primer
     * palabra sin cambios, si no se cambia la
     * primer letra de la palabra a mayúscula
     */
    const arrayCamel = arrayChunk.map((word,i)=>{
      return i === 0 ? word : upperFirst(word)
    })
    //se junta el array anterior y listo
    const camelCase = arrayCamel.join('')
    this.push(camelCase)
    //finaliza la el flujo para esta chunk
    callback()
  }
})
process.stdin.pipe(transformStream)
.pipe(process.stdout)

Mi reto simplificado

const { Transform } = require('stream')

const upperFirst = text => {
  return text.charAt(0)
    .toUpperCase()
    .concat(text.slice(1))
}

const transformStream = new Transform({
  transform(chunk, encoding, callback) {
    const camelCase = 
    chunk
    .toString()
    .toLowerCase()
    .split(' ')
    .map((word, index) => {
      return index === 0 ? word : upperFirst(word)
    })
    .join('')
    this.push(camelCase)
    callback()
  }
})

process.stdin.pipe(transformStream)
.pipe(process.stdout)

se puede optimizar más pero no se vería bien en este cuadrito de los aportes, esto lo hago con la finalidad de ayudar un poco a entender el código a los que no entienden muy bien :).

Laura Camila Pregonero

student•

Gracias! :) ya pude comprender un poco más

Juan Carlos García Esquivel

student•

@Laurapregonero super, que bueno que el ejemplo te ayudo :)

Manuel Ojeda

student•

Aquí está mi solución, nada extraño y haciendo uso de código normal:

Evidencia:

José Manuel Velázquez Susunaga

student•

Muy top tu código compañero!!! Gracias:)

Gustavo Gonzalez Montero

student•

Gracias Máster! Excelente!
Muy limpio. realmente no conocía mucho del split y el slice.
Aún me falta practicar bastante. Debes sentirte orgulloso de tu talento!

Victor Martin Ortiz Palacio

student•

Challenge: utilizando el codigo visto en clase.

const { Transform } = require("stream");

String.prototype.capitalize = function () {
  return this.replace(/(?:^|\s)\S/g, (input) => { return input.toUpperCase(); });
};

const transformStream = new Transform({
  transform(chunk, enconding, callback) {
    this.push(chunk.toString().capitalize());
    callback();
  }
});

process.stdin.pipe(transformStream).pipe(process.stdout);

Victor Martin Ortiz Palacio

student•

Codigo corregido:

const { Transform } = require("stream");

String.prototype.toCamelCase = function() {
  return this
      .replace(/\s(.)/g, input => input.toUpperCase())
      .replace(/ /gi, '')
      .replace(/^(.)/, input => input.toLowerCase());
};

const transformStream = new Transform({
  transform(chunk, enconding, callback) {
    this.push(chunk.toString().toCamelCase());
    callback();
  }
});

process.stdin.pipe(transformStream).pipe(process.stdout);

Esta web https://jsperf.com/js-camelcase/5 me sirvio mucho, no solo para ver los distintos casos, sino tambien para saber cual puede ser la mas optima.

David Antonio Garcia Saaib

student•

Esta ha sido mi respuesta favorita

Ulises Rojas González

student•

En mi opinión, es un poco confusa la explicación pues parece que se dice que se dice que Duplex y Transform sirven para lo mismo, sólo que el último tiene una sintaxis más sencilla. A mí me gustó esta explicación: . "It’s important to understand that the readable and writable sides of a duplex stream operate completely independently from one another. This is merely a grouping of two features into an object. . A transform stream is the more interesting duplex stream because its output is computed from its input." . Fuente: https://www.freecodecamp.org/news/node-js-streams-everything-you-need-to-know-c9141306be93/

Bruno Amadori

student•

Si, ese artículo es clave para entender esto bien. Gracias!

Jimmy Buriticá Londoño

student•

Tienes razón, es claro que cada tipo de Stream tiene su razón de ser y se debe usar en el momento que corresponda.

softdynamic sac

student•

Here we go...

const {Transform} = require("stream");

const tranformStream = new Transform({
	transform(chunk, encoding, callback) {
		this.push(chunk.toString().split(" ").map((word) => {
			return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
		}).join(""));
		callback();
	}
})

process.stdin.pipe(tranformStream).pipe(process.stdout);

David Gallego

student•

Lo mismo hice, solo que extraje la parte del camelcase en una funcion para hacer el codigo mas legible :)

const { Transform } = require('stream');

const transformStream = new Transform({
    transform(chunk, encoding, callback) {
        this.push(toCamelCase(chunk.toString()));
        callback();
    }
});

function toCamelCase(str) {
    let wordsCamelCased = str.split(' ').map(word => {
        return word.charAt(0).toUpperCase() + word.slice(1);
    });

    return wordsCamelCased.join('');
}

process.stdin.pipe(transformStream).pipe(process.stdout);

Steven Benjamín Diaz Flores

student•

Un poco de información extra que me ayudo a comprender mejor los Streams node-js-streams-everything-you-need-to-know

Beatriz Pérez Santana

student•

Gracias!! :D

Daniel Páez

student•

Muchacho ahi dejo mi solución al reto y me lógica en un comentario !!! Escucho aportes

/*
Challenge

Usando Streams crea una función en Node que reciba una cadena de texto y la convierta en camel case usando streams.

"hola como estas"
"holaComoEstas"

¿Que quiero?

Una función stringToCamelCase() que cuando reciba un string cualquiera lo convierta en CameCase, usando Streams.

El proceso para hacerlo realidad.

1. Recibo una cadena de texto.
2. Detecto los separadores: espacios en blanco o guiones que separan las palabras.
3. A la primera letra de la palabra que está a la derecha del separador la paso a mayusculas.
4. Creo un nuevo string donde elimino el separador.
5. Retorno la nueva cadena de texto.

Una vez hecho esto creare un WritableStream desde donde consumire los datos y los devolveré transformados.

*/

const {Writable} = require("stream");

function stringToCamelCase(string) {

	//"Hola-soy-una-persona-chevere"
	const whiteSpaceAndLetter = /(?<=[\-. ])\w/g;
	const separatorString = /[\-. ]/g;

	const upperCaseCharacterFound = (characterFound) => characterFound.toUpperCase();

	let stringTransformed = string.replace(whiteSpaceAndLetter, upperCaseCharacterFound);
	stringTransformed = stringTransformed.replace(separatorString, "");
	
	return stringTransformed
}


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

process.stdin.pipe(writableStream);

Kevin Rodolfo cosio sanchez

student•

const {Transform} = require('stream');

const transformStream = new Transform({
    transform(chunk, encoding, callback) {

        let arrayToTransform = chunk.toString().split(' ');
        let stringToCamelCase = '';
        arrayToTransform.forEach(function (element) {
                stringToCamelCase += element.charAt(0).toUpperCase() + element.slice(1)
            }
        )

        this.push(stringToCamelCase);

        callback();
    }

});

process.stdin.pipe(transformStream).pipe(process.stdout);

Steven Benjamín Diaz Flores

student•

Muy buena solución !

Jose Anibal Garcia Giraldo

student•

Yo resolví el reto de esta forma pero me quedó un pequeña duda, en todo caso no me gusta que las cosas funcionen sin saber el porqué de algo y es por que en este caso no tuve que ejecutar el callback para que funcionara, incluso si ejecuto el callback me genera un error. Alguien entiende el porqué? :D

Erik Elyager

student•

La función callback es llamada para indicar que se terminó y que el siguiente "middleware" puede ejecutarse, es algo confuso, tal vez en lugar de llamarlo callback podrías llamarlo next. Me parece raro que te fallé al llamar el callback, no sé que error te pueda dar.

Mira este comentario de stackoverflow para entender mejor cómo funcionan los middlewares, que en esencia es lo que pasa aquí.

Jose Anibal Garcia Giraldo

student•

Muchas gracias!, me quedó todo más claro :D

Alexander Nova Arevalo

student•

const { Transform } = require("stream");

const transformStream = new Transform({
  transform(chunk, enconding, callback) {
    
    let camel = chunk.toString().toLowerCase()
    let tr_camel = camel.split(' ')

    let CamelCase = ''

    for (let index = 0; index < tr_camel.length; index++) {
      CamelCase = CamelCase.concat( tr_camel[index].charAt(0).toUpperCase() + tr_camel[index].slice(1))
    }

    this.push(CamelCase);
    callback();
  }
});

process.stdin.pipe(transformStream).pipe(process.stdout);

Daniel Còrdova

student•



const CamelCaseChallenge = new Transform({
    transform(chunk, encoding, cb){
        this.push(Camel(chunk.toString()));
        cb();
    }
});

//uso del callback
function Camel(str){
    let camelcase = str.split(" ").map((word) => {
        return word.charAt(0).toUpperCase() + word.slice(1);
    });

    return camelcase.join('');
};


process.stdin.pipe(CamelCaseChallenge).pipe(process.stdout);

/**
 * en una nueva funcion realizar lo siguiente:
 * 
 * 1ero = split me guarda por el caracter que detecte y me crea 
 * un array que luego map recorre cada espacio de dicho array de strings
 * donde el chatAt(0) leera en la posicion 0 de cada string 
 * por cada espacio en el array donde en dicha posicion convertira 
 * la letra 0 en mayuscula con toUpperCase(). 
 * 
 * (0 porque se empieza desde 0 en programacion).
 * 
 * 2do = luego se le concatena con slice que toma el valor que va a
 * retirar de la cadena, como split convierte el texto en un slot
 * el slice elimina el slot creado dejandolo void.
 * 
 * 3ero = se retorna todo el proceso con join que unifica los espacios
 * creados en un array que en este caso el array lo creo el split.
 * 
 * OJO>>el join solo combina strings, no se si numeros. 
 * 
 * proceso paso a paso:
 * 
 * parte-1 el texto=
 * hola mundo
 * 
 * ////////////////////////////////////////////////////////////
 * 
 * parte-2 el split trabajando = 
 * split(" ");
 * [hola], [ ], [mundo];
 * 
 *  resultado = ["hola"," ","mundo"] array con un nuevo slot.
 * 
 * ////////////////////////////////////////////////////////////
 * 
 * parte-3 el slice eliminando el espacio del array:
 * slice(1)
 * ["hola"," ","mundo"]
 *    0     1     2
 * ["hola","mundo"]                ["hola","mundo"]
 *     0      2  => termina siendo    0       1
 * 
 * ////////////////////////////////////////////////////////////
 * 
 * parte-4 el join combinando el array de strings :
 * el array:
 * ["hola","mundo"]
 * 
 * join("") => ojo en la documentacion del metodo join el aparece
 * asi join(), lo que significa que unira con todo y
 * "las comas invisibles del array",
 * 
 * el join que contenga algo tipo => join ("/") me va a unir
 * los slot o espacios con el slash.
 * 
 * en este caso:
 * 
 * join("") >> sin separar para que no los una asi sin mas
 * 
 * join("")
 * ["hola","mundo"]
 * 
 * RESULTADO = HolaMundo
 *  
 * 
 * 
 * 
 */

Juan Jose Arcani

student•

Esta es mi solución, tambien pudedo recalcar que el formato de texto donde la primera letra de la primera palabra tambien es mayúscula se llama PascalCase y esta es camelCase

const { Transform } = require('stream');
let data = '';
const transformStream = new Transform( {
  transform(chunk, encoding,callback) {
    data = chunk.toString().trim().split(' ');
    data = data.reduce((total, word) => {
      return total + word.charAt(0).toUpperCase() + word.slice(1)
    }, data[0].toLowerCase())
    console.log(data);
    callback();
  }
});

process.stdin.pipe(transformStream).pipe(process.stdout);

Romel Javier Gomez Herrera

student•

El reto...

const { Transform } = require("stream");

String.prototype.camalize = function camalize() {
  return this.toLowerCase().replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) =>
    chr.toUpperCase()
  );
};

const toCamelCaseStream = new Transform({
  transform(chunk, _, callback) {
    this.push(chunk.toString().camalize());
    callback();
  }
});

process.stdin.pipe(toCamelCaseStream).pipe(process.stdout);

Carlos Enrique Ramírez Flores

student•

My code!

const { Transform } = require('stream');

const capitalizeStream = new Transform({
    transform(chunk, encoding, cb) {
        let string =  chunk
            .toString()
            .trim()
            .split(' ')
            .map( res =&gt;  {
                return typeof res === 'string' ? res.charAt(0).toUpperCase() + res.slice(1) : ''
            })
            .join('');
            
        this.push(string)
        cb();
        
    }
})

process.stdin.pipe(capitalizeStream).pipe(process.stdout);

Gaston Caldera

student•

:) un poco noobster pero ahi vamos

<'use strict'

const { Transform } = require('stream')

const transformStream = new Transform({
    transform(chunk, encoding, callback) {
        this.push(chunk.toString().charAt(0).toUpperCase() + chunk.slice(1).toString().replace(/\s/g, ''))
        callback
    }
})

process.stdin.pipe(transformStream).pipe(process.stdout)>

Fernando Azuaje

student•

mi solucion:

const { Transform } = require('stream')

const toCamelCase = new Transform({
    transform (chunk, encoding, callback) {
        let words = chunk.toString().split(' ')
        let camelWords = ''
        words.forEach(element => {
            let newWord = element.slice(0,1).toUpperCase() + element.slice(1)
            camelWords += newWord
        })
        this.push(camelWords)
        callback()
    }
})


process.stdin.pipe(toCamelCase).pipe(process.stdout)

Steven Benjamín Diaz Flores

student•

Reto: convertir texto cualquiera a CamelCase Resultado: hola amigos como estan => HolaAmigosComoEstan

Juan Fajardo

student•

const { Transform } = require("stream");

const transformStream = new Transform({
  transform(chunk, encoding, callback) {
    const newChunk = chunk.toString();
    const initChar = newChunk.slice(0,1);
    const otherChars = newChunk.slice(1, newChunk.length);
    this.push(initChar.toUpperCase() + otherChars);
    callback();
  }
});

process.stdin.pipe(transformStream).pipe(process.stdout);

Ernesto Vizcaíno Alvarado

student•

Mi solución al reto

const { Transform } = require(&quot;stream&quot;)

function toCamelCase(str) {
  return str
    .split(&quot; &quot;)
    .map(function(word, index) {
      if (index == 0) {
        return word.toLowerCase()
      }
      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
    })
    .join(&quot;&quot;)
}

const transformStream = new Transform({
  transform(chunk, encoding, callback) {
    this.push(toCamelCase(chunk.toString()))
    callback()
  }
})

process.stdin.pipe(transformStream).pipe(process.stdout)