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

Duplex y Transforms streams

12/48
Recursos

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.

Aportes 242

Preguntas 5

Ordenar por:

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

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);```

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 馃槂.

Aqu铆 est谩 mi soluci贸n, nada extra帽o y haciendo uso de c贸digo normal:

Evidencia:

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);

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:
.
鈥淚t鈥檚 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/

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);

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

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);
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);
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);



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
 *  
 * 
 * 
 * 
 */

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);

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);

My code!

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

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

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

馃槂 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)>

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)

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

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);

Mi soluci贸n al reto

const { Transform } = require("stream")

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

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

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

Mi soluci贸n

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

String.prototype.toCamelCase = function() {
  return this.toLowerCase()
    .replace(/\b(\w)/g, function(match, capture) {
      return capture.toUpperCase();
    })
    .replace(/\s+/g, '');
};

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

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

Mi solucion al reto:

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

function camelText(str) {
	return str
		.toLowerCase()
		.replace(/[^a-zA-Z0-9]+(.)/g, (m, chr) => chr.toUpperCase());
}

const transfromStream = new Transform({
	transform(chunk, encoding, callback) {
		this.push(camelText(chunk.toString()));
		callback();
	}
});
process.stdin.pipe(transfromStream).pipe(process.stdout);

Challenge:

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

const camelize = (str) => {
    return str.replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) => {
        return index == 0 ? 
            word.toLowerCase(): 
            word.toUpperCase();
    }).replace(/\s+/g, '');
}

const transformStream = new Transform({
    transform(chuck, enc, callback) {
        this.push(camelize(chuck.toString()));
        callback();
    }
});


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

Mi solucionn:

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

const toCamel = new Transform({
    transform(chunk, encoding, callback){
        const data = chunk.toString();
        const wordsArray = data.split(' ');
        const camelString = wordsArray.reduce((prev, curr) => {
            return prev + curr[0].toUpperCase() + curr.slice(1);
        }, '');
        this.push(camelString);
        callback();
    }
});

process.stdin.pipe(toCamel).pipe(process.stdout);
const { Transform } = require("stream");

const transformStream = new Transform({
    transform(chunk, enconding, callback) {
        let first = chunk.toString().replace(/ /g, '')
        this.push(chunk.toString().charAt(0).toUpperCase()+first.slice(1));
        callback();
    }
});

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

Reto hecho:

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

String.prototype.replaceAt=function(index, replacement) {
    return this.substr(0, index) + replacement+ this.substr(index + replacement.length);
};

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

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

const toCamelCase = typeChar => {
    const arrayWord = typeChar.toString().split(' ');
    arrayWord[0] = arrayWord[0].toLowerCase();
    for (let i = 1; i < arrayWord.length; i++){
        arrayWord[i] = arrayWord[i].replaceAt(0, arrayWord[i][0].toUpperCase());
        console.log(arrayWord[i][0].toUpperCase());
    }

    return arrayWord.join('');
};

el reto:

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

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

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


const ucwords = (word) => {
    return word.toLowerCase().replace(/[^a-zA-Z0-9]+(.)/g,
        (_, s) => s.toUpperCase());
};
const { Transform } = require('stream');

const transformStream = new Transform({
    transform(chunk, encoding, callback) {
        const camel = chunk
            .toString()
            .trim()
            .split(' ')
            .map(item => cadenaTexto(item))
            .join('');
        this.push(camel)
        callback()
    }
})


function cadenaTexto(cadena) {
    let primeraLetra = cadena.charAt(0).toUpperCase()
    cadena = cadena.slice(1)
    return primeraLetra.concat(cadena)
}

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

Soluci贸n al Reto:

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

const transformStream = new Transform({
    transform(chunk, encoding, callback) {
        this.push(chunk
            .toString()
            .toLowerCase()
            .split(' ')
            .map(item => item[0].toUpperCase() + item.slice(1, item.length))
            .join(''));
        callback();
    }
});

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

Les comparto mi implementaci贸n. Sencilla y pr谩ctica

const {Transform } = require(鈥榮tream鈥);

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

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

Mi soluci贸n aunque no aporte nada nuevo T_T.

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

const transformStream = new Transform({
  transform(chunk, encoding, cb) {
    const strArray = chunk.toString().split(" ");
    let result = "";
    for (let i = 0; i < strArray.length; i++) {
      result += strArray[i].charAt(0).toUpperCase();
      result += strArray[i].slice(1);
    }
    this.push(result);
    cb();
  },
});

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

Escelente reto para hacer operaciones con los Streams!

Mi soluci贸n:

El reto fasilito dirian por ahi en la comunidad de League of legends

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

const transformStream = new Transform({
    transform(chunk, encoding, callback) {
        let camelCase = chunk.toString().split(" ");
        camelCase = camelCase.map(chunk => {
            return chunk[0].toUpperCase() + chunk.substr(1);
        })
        this.push(camelCase.join(""));
        callback();
    }
});


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

M谩s c贸digo pero ya qued贸 el CamelCase

//convertir una frase en CamelCase
const { Transform } = require('stream');

var cadena = [];
var tempUppper = "";
var tempLower = "";
var temp = "";
var cadenaTemp = "";

const camelCase = new Transform({
    
    transform(chunk, cb) {
        const data = chunk.toString();
        
        cadena = data.split(" ");

        for(let i = 0; i < cadena.length; i++){
            
            cadenaTemp = cadena[i];
            for(let j = 0; j < cadenaTemp.length; j++){
                
               if( j === 0){
                    tempUppper = cadenaTemp[j].toUpperCase();
               }else{
                   tempLower = tempLower + cadenaTemp[j];
               }
            }
            temp = temp + tempUppper + tempLower;
            tempLower = "";
            tempUppper = "";
        }
        
        this.push(temp);
        this.push(null);
        return;
    }
});

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

A煤n se puede mejorar, por lo pronto reto cumplido 馃槃

JS Challenge 2021 (04/Oct/2021)

Mi soluci贸n al reto:

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

const transformStream = new Transform({
	transform(chunk, encoding, callback) {
		//Convertir el chunk a string
		let data = chunk.toString();
		/*Separa cada palabra por espacio. Crea un array con cada cadena
    de la palabra*/
		data = data.split(" ");
		/*Recorre cada elemento del array y reemplaza la primer letra 
    por la misma pero en may煤scula*/
		data = data.map((str) =>
			str.replace(str.charAt(0), str.charAt(0).toUpperCase())
		);
		//Reducimos el array a una sola cadena
		const reducer = (accumulator, currentValue) => accumulator + currentValue;
		const camelCase = data.reduce(reducer, "");
		//Push del chunk ya transformado
		this.push(camelCase);
		callback();
	},
});

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

Aqui un ejemplo desglosado usando const identifatorios

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

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

        const toCamelCase = (chunkParameter) => {

            const chunkString = chunkParameter.toString(); // Se convierte a string
            const primeraLetra = chunkString.charAt(0);
            const primeraLetraMayuscula = primeraLetra.toUpperCase();

            const restoDelChunk = chunkString.slice(1);
            const restoDelChunkMinuscula = restoDelChunk.toLowerCase();

            const concat = primeraLetraMayuscula + restoDelChunkMinuscula;

            const stringSinEspacios = concat.replace(/ /g, "");
            return stringSinEspacios;
        }

        this.push(toCamelCase(chunk));

        callback();
    }
})

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

Aqui un gist

Aqu铆 mi soluci贸n al reto:

Prueba del c贸digo:

amigos鈥 intent茅 enviar la cadena desde postman ( ya habiendo creado un server de escucha ) y al final no logr茅 regresar el camelCase como respuesta.

const { Transform } = require('stream')

const stringToCapitalize = str => {
  const eachWord = str.split(' ')
  let joinWords = ''
  eachWord.slice(1, eachWord.length).map(item => (
    joinWords += item[0].toUpperCase() + item.slice(1)
  ))

  return `${eachWord[0]}${joinWords}`
}

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

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

Para este reto lo 煤nico que hice fue obtener el paquete de npm camelCase aqu铆 les dejo el c贸digo:

const { Transform } = require('stream');
const { camelCase } = require('camel-case');
// Use el paquete de NPM camel case para hacer el reto
const transformStream = new Transform({
    transform(chunk, encoding, callback) {
        this.push(camelCase(chunk.toString()))
        callback();
    }
});

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

Mi humilde aporte:


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

function conversor(texto) {
  const cajita = [];

  const separar = texto.split(" ");

  separar.forEach((palabra) => {
    const primeraLetra = palabra[0].toUpperCase();

    palabra = palabra.slice(1)
    const palabraCompleta = primeraLetra.concat(palabra)
    cajita.push(palabraCompleta);
  });
  return cajita.join('');
}

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

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

Listo, utilic茅 un regex para detectar la primer letra de cada palabra.

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

const tStream = new Transform({
  transform(chunk, encoding, callback) {
    //convertir el chunk a texto
    const data = chunk.toString();
    //Separar la cadena de texto por espacios
    data.split(" ").map((word) => {
      this.push(
        word
          .toLowerCase()
          .replace(/\w/, (firstLetter) => firstLetter.toUpperCase())
      );
    });
    
    //callback para finalizar el estream
    callback();
  },
});

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

La informaci贸n la obtuve de aqui:

Este es mi soluci贸n al reto lo m谩s simple que pude:

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

const transformStream = new Transform({
  transform(chunk, encoding, callback) {
    const data = chunk.toString();
    const camelCase = data.split(' ').map((word, index) => {
      if(index === 0){ 
        return word.toLowerCase()
      }
      
      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
      
    })

    this.push(camelCase.join(''))
    callback()
  }
})

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

tha鈥檚 my code

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

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

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

I did it by this way.

Les comparto mi soluci贸n:

const { Transform } = require('stream')

const toCamelCase = string => {
  return string
    .split(' ')
    .map((s, index) => {
      if (index > 0) return s[0].toUpperCase() + s.slice(1).toLowerCase()

      return s.toLowerCase()
    })
    .join('')
}

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

process.stdin.pipe(transformStream).pipe(process.stdout)
const { Transform } = require('stream');

function toCamelCase(frase){
    let fraseModificada = frase.toString().split(' ');
    const upperWords = fraseModificada.map((palabra) => {
        return palabra.charAt(0).toUpperCase() + palabra.slice(1);
    });
    return upperWords.join("");
}

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

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

camel case: hola mundo => holaMundo

function camalcase(str) {
  let arr = str.split(" ");
  return arr
    .splice(0, 1)
    .concat(arr.splice(0).map((word) => word[0].toUpperCase() + word.slice(1)))
    .join("");
}

Challenge:

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

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

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


function toCamelCase (string) {
    let str = string.toLowerCase() //Convierte toda la cadena en min煤sculas
        .split(" ") //convierte la cadena en un array por cada palabra
        .map(word => word.replace(word[0], word[0].toString().toUpperCase())) //Convierte la 1ra letra de cada palabra en may煤scula
        .join(''); //converite el array en cadena

        return str.replace(str[0], str[0].toLowerCase()); //convierte la 1ra letra de la cadena en min煤scula
};

Dure mil a帽os para corregir un error que al final ni apareci贸.

Soluci贸n del Challenge

No me acordaba de los m茅todos de String, pero aqu铆 us茅: split(), charAt() y slice().

Sabiendo que split() me regresar铆a un array, le hice un map() para luego hacer toda la magia dentro y luego el resultado del nuevo array unirlo con Join()

Mi soluci贸n al reto

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

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


process.stdin.pipe(miWritableStream)

// Funci贸n auxiliar para convertir frases en camel case
function toCamelCase(frase){
	return frase
		.split(" ")
		.map((palabra) => palabra[0].toUpperCase() + palabra.slice(1))
		.join("")
}
const { Transform } = require("stream");

/**
 * Capitaliza palabras
 * @param {string} cadena texto a modificar
 * @returns texto Capitalizado
 */
const capitalizar = (cadena) => {
    return cadena.charAt(0).toUpperCase() + cadena.toLowerCase().slice(1)
}

/**
 * Funci贸n que quita espacios, guiones y letras mayusculas entre medio, dejando toda la cadena en formato lowerCase.
 * @param {string} cadena Texto a modificar
 * @returns texto con formato lowerCase
 */
const camelCase = (cadena) => {
    let string = cadena.toLowerCase()
                .replace(/[^A-Za-z0-9]/g, ' ')
                .split(' ')
                .reduce((res, palabra) => res + capitalizar(palabra.toLowerCase()))
    return string.charAt(0).toLowerCase() + string.slice(1);
}

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

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

Soluci贸n implementada con REGEX

const { Transform } = require('stream')
const regex = /( \w)/g;

const transformStream = new Transform({
    transform(chuck, encoding, callback) {
        const chuckCamel = chuck.toString().replace(regex, match => match.toUpperCase().charAt(1))

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

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

Complete el reto

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

const transformStream = new Transform( {
  transform(chunk, encoding,callback) {
    const data = chunk.toString().trim().split(' ');
    let camelCase = data[0].toLowerCase();
	/* el ciclo for cambia las palabras restante con el formato adecuado */. //
    for (let i = 1; i < data.length; i++) {
      camelCase += data[i].charAt(0).toUpperCase() + data[i].slice(1).toLowerCase();
    }
    console.log(camelCase);
    callback();
  }
});

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

Creo que falto mucha mas explicaci贸n conceptual antes de ir al codigo 鈥 Igual es la primera vez que me enfrento a este concepto asi que a la documentaci贸n 馃摉馃弮馃徎鈥嶁檪锔

Hecho con una expresi贸n regular, no me gusta mucho la forma que resolv铆 el primer caracter que al no tener un espacio se lo agregu茅 y luego lo limpi茅 con trim()

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

const transformStream = new Transform({
    transform(chunk, encoding, callback) {
        const data = (' '+chunk.toString()).replace(/ \S/g, x =>  ' '+x[1].toUpperCase());
        this.push(data.trim());
        callback();
    }
});

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

Duplex y Transforms streams


Ambos sirven para simplificar nuestro c贸digo:

  • Duplex:聽implementa los m茅todos write y read a la vez.
const { Duplex } = require('stream')

const duplexStream = new Duplex({
    write(chunk, encoding, cb) {
        console.log(chunk.toString())
        cb()
    },

    read(size) {
        if (this.currentCharCode > 90) {
            this.push(null)
            return
        }

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

duplexStream.currentCharCode = 65
process.stdin.pipe(duplexStream).pipe(process.stdout)
  • Transform:聽es similar a Duplex pero con una sintaxis m谩s corta.
const { Transform } = require('stream')

const transformStream = new Transform({
    transform(chunk, encoding, cb) {
        this.push(chunk.toString().toUpperCase())

        cb()
    }
})

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

aqu铆 mi soluci贸n al reto

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

const transformStream = Transform({
    transform(chunk, encoding, callback){
        let fragment = chunk.toString().split(' ')

        let arr = []
        for(let i = 0; i < fragment.length; i++){
            if(i < 1){
                arr.push(fragment[i].toLowerCase())
            }else{
                arr.push(fragment[i].replace(fragment[i].charAt(0),fragment[i].charAt(0).toUpperCase()))
            }
        }

        this.push(arr.join(''))
        callback()
    }
})

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

En el ejemplo de duplex, no me qued贸 claro cual era la utilidad de implementar el m茅todo write(), porque si no lo implementamos, tenemos el mismo resultado.

donde me percato que toma sentido la implementaci贸n write() es cuando ya termina de pinta el abecedario ahi reci茅n entra a tallar este m茅todo,

驴si quiero acceder a los valores que esta emitiendo el m茅todo read() desde `write(), como podr铆a hacerlo ?

Trate de simplificar el c贸digo al m谩ximo, espero que les ayude 馃榿

const {Transform} = require("stream")
const transformString = new Transform({
    transform(chunk, encoding, cb){
        let a = chunk.toString().replace("\r\n", "")
        let b = a.split(" ").map(word => word.charAt(0).toUpperCase() + word.slice(1))
        this.push(b.join(''))
        cb()
    }
})
process.stdin.pipe(transformString).pipe(process.stdout)

Les dejo mi solucion al challenge!

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

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

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

Mi solucion:

const { Transform } = require('stream')
const transformStream = new Transform({
  transform(chunk, encoding, callback) {
    let text = chunk.toString().toLowerCase()
    text = text.split(' ')
    text = text.map((word) => {
      return word.charAt(0).toUpperCase() + word.slice(1)
    })
    text = text.join('')
    this.push(text)
    callback()
  },
})
process.stdin.pipe(transformStream).pipe(process.stdout)
gente... yo es que no entiendo muy bien esto que aplicaci贸n tiene en un ambiente de desarrollo real? lo han usado para algo?

Aqui va

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

const transformStream = new Transform({
    transform(chunk, encoding, cb){
        let message = chunk.toString().split(" ");
        let newMessage = [];
        message.forEach((val, ind, arr) => {
            if(ind > 0){
                newMessage.push(message[ind].replace(message[ind][0], message[ind][0].toUpperCase()));
            } else {
                newMessage.push(message[ind]);
            }
        })

        let total = newMessage.join("");
        this.push(total);
        cb();

    }
});

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

Mi solucion

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

const transformStream = new Transform({
   transform(chunk, encoding, callbak) {
      // this.push(chunk.toString().toUpperCase());

      //reto
      let dataString = chunk.toString()
      this.push(dataString.slice(0, 1).toUpperCase() + dataString.slice(1));
      callbak();
   }
});

// le pasamos despues de recibir en la linea de comandos a transform que instanciamos despues de la damos salida utilizando de nuevo el pipe pero con la salida
process.stdin.pipe(transformStream).pipe(process.stdout);

Les comparto mi codigo, en este caso utilice un reducer para poder modificar la oracion completa al momento de pasarla a la salida

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

const transformStream = new Transform({
   transform(chunk, encoding, callback) {
      this.push(chunk.toString().split(" ").reduce((str,curr) => str+curr.charAt(0).toUpperCase()+curr.slice(1)));
      callback();
   }
});

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

Esta es mi soluci贸n

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

const transformStream = new Transform({
  transform(chunk, encoding, callback){
    const words = chunk.toString().toLowerCase().split(' ');
    const newWords = words.map((word, index) => {
      return index === 0 ? word : word.replace(word[0], word[0].toUpperCase());
    });
    let finalWord = newWords.join('');
    this.push(finalWord);
    callback();
  }
});

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

Mi solucion: npm install camelCase (pasa de esnake a camelcase)
y optienes esto

Estas clases son geniales!

Mi soluci贸n:

Les dejo esta lectura para comprender m谩s sobre los streams
https://desarrolloweb.com/articulos/streams-nodejs.html

script del tranforms

Resolvi el challenge de esta manera 馃槂

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

const transformStream = new Transform({
    transform(chunk, encoding, callback){
        wordsArray = chunk.toString().split(' ');
        camelCaseString = "";
        for(let i=0; i<wordsArray.length; i++){
            //String.charAt(n): devuelve el caracter en la posicion n
            //String.slice(n): devuelve la cadena desde la posicion n
            //String.toUpperCase: devuelve la cadena en mayusculas
            //String.toLowerCase: devuelve la cadena en minisculas
            camelCaseString += wordsArray[i].charAt(0).toUpperCase() + wordsArray[i].slice(1).toLowerCase()
        }
        this.push(camelCaseString);
        callback();
    }
});

process.stdin.pipe(transformStream).pipe(process.stdout);
const {
    Transform
} = require('stream');

const camelcaseTransform = new Transform({
    transform(chunk, encoding, callback) {
        const string = chunk.toString().trim().split(' ');
        string.forEach(element => {
            this.push(element.charAt(0).toUpperCase() + element.slice(1));
        });
        callback();
    }
});

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

Mi solucion al reto!

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

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

function textToCamelCase(string) {
    let stringArray = string.split(' ');
    let finalString = '';

    stringArray.forEach(element => {
        let currentString = element.charAt(0).toUpperCase() + element.toLowerCase().slice(1);
        finalString += currentString;
    })

    return finalString;
}

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

creo que la ultima linea deberia ser asi:

duplexStream.pipe(duplexStream);

para que se ejecute el metodo write del mismo duplex 馃槂

Recuerden usar el metodo toLowerCase(), de javascript para convertir el resto de la palabra en minuscula, ya que si colocas toda la palabra en letras mayusculas, retornara todas las letras de la palabra en cuestion en mayusculas.

Esto lo acoto por el hecho de que he visto en los retos colocados por los compa帽eros, que algunos no lo aplicaron, es una recomendacion 馃槃!! Excelente curso hasta ahora!

Implementaci贸n parto el string por espacio, - y _ para soportar palabras como hello-world hello world y hello_world

const { Transform } = require("stream");
const tx = new Transform({
    transform(chunk, enconding, cb) {
        var str = chunk.toString();
        var strUpper = str.trim().split(/[\s-_]+/).map(itm => itm.charAt(0).toUpperCase() + itm.substring(1)).join("");
        this.push(strUpper);
    }
});

process.stdin.pipe(tx).pipe(process.stdout)

Es de mucha ayuda repasar la clase de Streams del curso de terminal y linea de comandos del profesor Beco

Aqui mi solucion, un poco larga pero funciona

const {Transform} = require('stream')

const transform = new Transform({
    transform(chunck, encoding, callback){
        // this.push(chunck.toString())
        var texto = chunck.toString()
        this.push("texto original:\n" + texto)

        //realmente no se por que, pero no importa el texto que escriba
        //siempre le suma dos espacios en blanco y pos...
        var textoLength = texto.length - 2;
        this.push("tama帽o:\n" + textoLength + "\n")

        var newText = "";
        var letterToUpperCase = false;
        for(let i = 0; i <= textoLength; i++){
            // this.push(texto.charAt(i) + "\n")
            if(texto.charAt(i) != " "){
                if(letterToUpperCase){
                    newText += texto.charAt(i).toUpperCase();
                    letterToUpperCase = false;
                }else{
                    newText += texto.charAt(i)
                }
            }else{
                //en caso de que la letra leida sea un espacio, la variable
                //letterToUpperCase pasara a ser verdadera para que la
                //siguiente letra sea mayuscula
                letterToUpperCase = true;
            }
        }

        this.push(newText)
        callback()
    }
})

process.stdin.pipe(transform).pipe(process.stdout)
// process.stdin.pipe()```
const { Transform } = require('stream');

const transformStream = new Transform({
    transform(chunk, encoding, callback) {
        this.push(chunk.toString().replace(/(?:^\w|[A-Z]|\b\w)/g, function (word, index) {
            return index == 0 ? word.toLowerCase() : word.toUpperCase();
        }).replace(/\s+/g, ''));
    }
});

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

Les dejo mis notas que me apoyaron en el aprendizaje del curso 馃槃
https://github.com/JasanHdz/backendnodejs/tree/master/notes
No se rindan, 茅xito 馃挭
Mis mejores notas 猸愨瓙猸愨瓙猸

Mi soluci贸n usando reduce

const { Transform } = require('stream')

/*
* Recibe una cadena de texto y la traduce a
* camelCase usando streams
* @param {array} - Array of words
* @return {string} - textoEnCamelCase
*/
function toCamelCase (arrayOfWords) {
  return arrayOfWords.reduce((accum, word) => {
    const firstLetter = word.charAt(0).toUpperCase()
    accum.push(firstLetter + word.slice(1))
    return accum
  }, []).join('')
}

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

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

Mi reto

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

const camelCase = 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(camelCase).pipe(process.stdout);

Mi Solucion

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

const camelize = word => {
    const camelized = (word.charAt(0).toUpperCase() + word.slice(1));
    return camelized;
}

const normalize = text => {
    const words = text.split(' ');
    return words.map(word => camelize(word)).join('');
}

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

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

Mi soluci贸n

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

const camelCase = new Transform({
  transform(chunk, encoding, callback) {
    let text = chunk.toString();
    let elements = text.split(" ");
    let capitalize = elements.map(
      element =>
        element.charAt(0).toUpperCase() + element.slice(1).toLowerCase()
    );
    this.push(capitalize.join(""));
    callback();
  }
});

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

No tan elegante como por palabras pero divertida igual jajaja

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

const transformStream=new Transform({
    transform(chunk,encoding,callback){
        let flag=true;
        let camelCase=[].map.call(chunk.toString(),(char)=>{
            if(flag){
                flag=false;
                return(char.toUpperCase());
            }else{
                if(char==' '){
                    flag=true;
                    return
                }else{
                    return(char.toLowerCase());
                }
            }     
        }).join('');
        this.push(camelCase);
        callback();
    }
})

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

Respuesta al reto

const { Writable } = require('stream')

const writableStream = new Writable({
    write(chunk, encoding, callback) {
        let text = chunk.toString()
        text= text.split(' ')

        text = text.map(item => {
            let result
            result = item.substr(1, item.length+1).toLowerCase()
            result = item.charAt(0).toUpperCase() + result
            return result
        })

        console.log(text.join(''))
        callback()
    }
})

process.stdin.pipe(writableStream)

Un reto muy divertido, Coool!!

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

const transformStream = new Transform({
  transform(chunk, uncoding, callback) {
    let array = chunk.toString().split(' ');
    let camelCase = '';

    for (let index = 0; index < array.length; index++) {
      let element = array[index];
      let firstLetter = element.charAt(0);
      let complement = element.substring(1);
      if (index === 0) {
        firstLetter = firstLetter.toLowerCase();
        
      } else {
        firstLetter = firstLetter.toUpperCase();
      }

      element.replace()

      camelCase += firstLetter + complement;
    }

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

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

Hola, esta es mi soluci贸n al reto:

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

const transformStream = new Transform({
  transform(chunk, encoding, callback){
    const input = chunk.toString();
    let first = input.substring(0,1);
    let body = input.substring(1);
    body = body.toLowerCase();
    let sizeBody = body.length
    let bodyCleanSpace = ""
    for(let i=0; i < sizeBody; i++){
      const character = body.substring(i,i+1)
      if(character != ' '){
        bodyCleanSpace += character;
      }else{
        bodyCleanSpace += body.substring(i+1, i+2).toUpperCase()
        i++
      }
    }
    const codeFirst = first.charCodeAt(0);
    if( !(codeFirst > 65 && codeFirst < 90)){
      first = first.toUpperCase();
    }
    this.push(`${first}${bodyCleanSpace}`)
    callback()
  }
})

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