COMANDOS BASICOS CLI

pwd: imprimir el directorio en donde nos encontramos.

ls: imprime archivos o carpetas dentro del cual estamos trabajando.

mkdir carpetaPrueba: crea una carpeta llamada 'carpetaPrueba' en el

directorio que estamos situados. Si queremos crear una carpeta que
lleve espacios en su nombre se debe utilizar comillas. Por ej "PrepCourse
Henry"

cd: para ir hacia el directorio que contiene la carpeta o directorio en

donde nos encontramos. También podemos usarla para movernos entre
carpetas, por ejemplo al usar cd carpetaPrueba cambiamos de la
carpeta actual hacia "carpetaPrueba"

cd ..: devolvernos un directorio.

touch archivo.txt : crea un archivo con nombre "archivo.txt"

rm archivo.txt : elimina el archivo "archivo.txt"

rm -r carpetaPrueba: elimina la carpeta de nombre "carpetaPrueba"

clear: limpiar la terminal.

Help: lista de comandos básicos con sus opciones y argumentos.

Comando -- help: ayuda para lista de comando en específico.

Git init: nunca hacer git init dentro de carpetas del escritorio o
archivos muy grandes ej.: disco duro c.

Un commit no es más que una captura instantánea de los cambios

preparados en ese momento del proyecto. Las instantáneas confirmadas
pueden considerarse como versiones "seguras" de un proyecto.

A continuación de compartimos los comandos más usados con

git:

git init: comando para inicializar un repositorio local.

git add: comando para que nuestro repositorio sepa de la existencia de
un archivo o de sus últimos cambios, no almacena las actualizaciones de
forma definitiva, únicamente las guarda en algo que conocemos como
“Staging Área” (área de montaje o ensayo). Se puede armar como git
add ArchivoEjemplo.js (solo agrega ese archivo) o git add (agrega todos
los archivos modificados de la carpeta donde estas con el punto.

git commit -m "mensaje": comando para almacenar definitivamente

todos los cambios que por ahora viven en el staging área. En el mensaje
ponemos el mensaje que explica los cambios commiteados.

git push: comando para mandar nuestros commits a un servidor

remoto.

git status: ofrece una descripción del estado de los archivos.

git pull: sirve para recibir cambios de repositorio remoto a local.

Recuerda que Git nunca cambiará las versiones seguras de tu proyecto,
a no ser que se lo pidas expresamente. De esta forma, estamos
guardando el estado actual de nuestro proyecto, para volver a visitarlo
de ser necesario y por supuesto para mantenerlo a lo largo del tiempo.

https://github.com/CDEstebanBernal/PrepCourse-Henry.git

JAVASCRIPT
Variables
String: palabras pueden estar con comillas dobles o simples.
Números: números positivos negativos enteros decimales
Booleanos: variables con valor verdadero o falso
Undefine: variables sin valor definido
NULL: variable parecida a undefine, pero definida por el programador
por null
https://developer.mozilla.org/es/docs/Web/JavaScript/
Data_structures#estructuras_y_tipos_de_datos

OPERADORES
https://developer.mozilla.org/es/docs/Web/JavaScript/
Reference/Operators/Operator_Precedence#tabla

OPERADORES DE COMPARACION
La impresión que arrojan los operadores de comparación es un
booleano (verdadero, falso)
= es asignación
== y === es igualdad
===: igualdad estricta, verifica valor y tipo de dato.
==: verifica solo el valor.
//Operaciones de comparación
console.log (4 < 7);
console.log (4 < 1 );
console.log (4 > 4);
console.log (4 == 7);
//Igualdad vs igualdad estricta
console.log (3 == 3);
console.log (3 === 3);
console.log (3 == "3");
console.log (3 === "3");
console.log (7 == "7");
console.log (7 === "7");
//Asignación y asociatividad
var a = 1;
var b = 2;
var c = a = b;
console.log (c);

funciones

Console.log no se debe confundir con return

Console.log: una vez utilizado en la programación de nuestra
app se debe eliminar
Return: fundamental para toda la función ya que es la
instrucción que se va a indicar que valor nos debe devolver.

Nomenclatura
Las nomenclaturas son formas de llamar a las cosas. En programación
existen ciertas reglas sobre las cuales llevamos uniformidad en el código
y nos proporcionan un estándar de trabajo especialmente dentro de
equipos de desarrollo de software.

Existen 3 tipos de nomenclatura principal: camelCase, PascalCase,

snake_case.
camelCase
Este modo de nombrar implica la unión de dos o más palabras sin
espacios entre ellas, pero diferenciadas por una letra mayúscula inicial a
partir de la segunda palabra, por ejemplo: holaMundo /
funcionEdadAños.
PascalCase
Es similar a camelCase pero la primera letra de la frase también se inicia
con mayúscula, al igual que cada palabra. Se mantiene la práctica de no
tener espacios entre palabras y cada palabra siempre empieza con su
primera letra mayúscula. Por ejemplo: HolaMundo / FuncionEdadAños
snake_case
La nomenclatura snake_case es definida de esta forma porque siempre
la usamos sobre el piso. Las letras siempre serán minúsculas y las
palabras están separadas por un guion bajo de esta forma: hola_mundo /
funcion_edad_años

Control de flujo (if/else)

function viajar(destino) {
if(destino === 'Brasil') {
console.log('Gire a la izquierda');
} else if(destino === 'Argentina') {
console.log('Gire a la derecha');
} else {
console.log('Nos perdimos');''
}
};
viajar('Brasil');
viajar('Argentina');
function puedeManejar(edad) {
if(edad >= 18) {
console.log( true );
}
console.log( false );
}

puedeManejar(17);

OBJETO MATH
Math.pow
Este método nos permite potenciar un número. Por ejemplo, 2 elevado al
cubo, sería igual a multiplicar 2 x 2 x 2. Es decir, 8.
El primer número es la base, y el segundo será la potencia.
Math.pow(2, 3);
//8
Math.round & Math.floor & Math.ceil
A veces necesitamos redondear un número decimal, ya que muchas
veces las operaciones matemáticas pueden resultar en números con
coma. Para esto, JavaScript nos ofrece tres métodos
Math.round redondeará el número decimal al entero más próximo. Es
decir que, si tenemos 0.49, el resultado será 0. En cambio, si tenemos
0.50, el resultado será 1.
Math.floor redondeará el número decimal al entero de menor valor. Por
ejemplo, si tenemos el número 5.93, el resultado será 5.
Math.ceil este método, al contrario que el anterior, redondeará un
número al siguiente entero. Por ejemplo, si tenemos 3.27 el resultado
será 4

Math.max & Math.min

Estos dos métodos nos permitirán conocer el valor máximo o mínimo de
un conjunto de números. Por ejemplo, si tenemos los números 1, 2, 3, 4
y 5, el máximo será el 5 y el mínimo el número 1
Math.random
Este último método nos permitirá generar un número aleatorio. Es
importante tener en cuenta que el número que se generará es decimal,
y puede ser cualquiera entre el 0 y el 1.

MOD4. OPERADORES LOGICOS

NEGACION : NOT
CONJUNCION: AND
DISYUNCION: OR
Recordemos la información clave de la video clase...
Existen tres tipos de operadores lógicos: la negación o NOT, la
conjunción o AND, y la disyunción u OR.
Operador Significado Ejemplo Resultado
&& and (5 < 2) && (5 > 3) false
|| or (5 < 2) || (5 >3) true
! not ! (5 < 2) true

1 Las expresiones se evalúan en orden, y la computadora omitirá

cualquier expresión redundante. En una declaración &&, si la primera
expresión es false, la segunda expresión no se evaluará porque AMBAS
expresiones deben ser true.

2 Lo mismo para la declaración ||. Si la primera expresión es verdadero,

la segunda no se evaluará porque solo debe haber una declaración
verdadera para cumplir con los requisitos del operador.

3 Utiliza paréntesis. Como vimos en el segundo ejemplo de la

negación !, utilizamos paréntesis para evaluar PRIMERO lo que estaba
dentro de ellos, y luego aplicamos la negación. Podemos ajustar
cualquier expresión entre paréntesis y se evaluará antes que toda la
expresión en conjunto.
Ejemplo:
//AND
function mayorYMenorYPar(num) {
if( num > 5 && num < 10 && num % 2 === 0 ) console.log(true);
else console.log(false);
};
mayorYMenorYPar(7);
mayorYMenorYPar(8);

// OR
function operadorOr(str) {
if (str === 'Henry' || str.length < 2) console.log(true);
else console.log(false);
}
operadorOr('Henry');
operadorOr('Javascript');
operadorOr('H');

// NOT
function negacion(permiso) {
if (permiso) console.log('Tiene permiso');
}
negacion(true);
negacion(false);

ejemplo compuesto:
function condicionCompleja(num){
if (num > 9 && num % 2===0 || num === 3) console.log(true);
else console.log(false);
};

condicionCompleja(10);
condicionCompleja(6);
condicionCompleja(5);
condicionCompleja(3);

Te compartimos algunos ejemplos para que los pruebes en tu terminal.

Utiliza la función Boolean()e ingresa cualquiera de los siguientes valores

para comprobar cuál es su veracidad:

1 // true
0 // false
-1 // true
true // true
false // false
'string' // true
null // false
undefined // false
[] // true

BUCLES.
Recordemos la información clave de la video clase...
Bucle For
Por un lado, el Bucle For es utilizado cuando sabemos con antelación la cantidad máxima
exacta de pasos que queremos ejecutar. Esta cantidad máxima de pasos se sitúa como
segundo parámetro entre los paréntesis.
for (let i = 0; i < 5; i++) {
suma = suma + i;
console.log('Variable de iteración: ', i);
}
console.log('Variable suma: ', suma);

Bucle while
El Bucle While es usado cuando no tenemos la certeza de cuántos pasos vamos a necesitar
hasta finalizar la ejecución. Por ejemplo, podríamos pensar en una función que siga
agregando +1 hasta llegar a un número determinado.
while(suma < 3) {
suma = suma + 1;
console.log(suma);
};

Expresión Switch
La expresión Switch evalúa una condición. Compara su valor con una instancia case, y
ejecuta declaraciones asociadas a ese case, así como las declaraciones en los case que
siguen.
¡QUIERO SABER MÁS!(OPENS IN A NEW TAB)
Bucle Do-While
El bucle Do-While (hacer mientras) ejecuta una sentencia especificada, hasta que la
condición de comprobación se evalúa como falsa. La condición se evalúa después de
ejecutar la sentencia, dando como resultado que la sentencia especificada se ejecute al
menos una vez.
¡QUIERO SABER MÁS!(OPENS IN A NEW TAB)
Declaración Continue
La declaración continue se utiliza dentro de los Bucles For. Nos permite omitir alguna de
las iteraciones si se cumple una condición específica.
¡QUIERO SABER MÁS!(OPENS IN A NEW TAB)
Break
La declaración break se utiliza dentro de los Bucles For. Nos permite "romper" o finalizar el
bucle con antelación si se cumple una condición específica.
¡QUIERO SABER MÁS!
INTRODUCCION A LOS ARRAY
Los arreglos o arrays son lo que se conoce como objeto global dentro
de Javascript, y que nos permiten guardar y gestionar información. Esto
nos será de gran utilidad cuando queramos almacenar datos.
Dentro de los arreglos existen dos conceptos que pueden parecer
similares, pero son muy diferentes.

 Por un lado tenemos lo que se conoce como elemento. Los

elementos son aquellos datos que hayamos guardado.

 Por otro lado, está el concepto de índice. Los índices no

representan al dato en sí mismo, sino la posición en la que se está
guardando. Un detalle muy importante que hay que destacar es
que, en los arreglos, siempre se comienza a contabilizar las
posiciones desde el número cero, no el uno.

/ Lista de compras
listaDeCompras[3] = 'Tomates';
listaDeCompras[1] = 'Lechuga';
// Ver lista de compras
var elementoDelArray = listaDeCompras[1];
console.log(elementoDelArray);

// Lenght
var nombres = ['Matias', 'Maria', 'Diego', 'Rosa'].length;
console.log(nombres);

Los arreglos, además de ser un tipo de dato, también son un

objeto global dentro de JavaScript. Esto significa que todos los
arreglos están asociados a una serie de métodos. En esta video
clase veremos cuáles son los métodos más utilizados.

Métodos de inserción.

 método push() añade uno o más elementos al final de un arreglo,

y devuelve la nueva longitud del array.

 El método pop() elimina y devuelve el último elemento de un

arreglo.
 El método unshift() agrega uno o más elementos al inicio de un
arreglo, y devuelve la nueva longitud del array.
 El método shift() elimina y devuelve el primer elemento de un
arreglo.
Métodos varios, Método Split y join.

 El método includes() determina si un arreglo incluye o contiene

un elemento específico. Devuelve true o false en cada caso.

 El método every() determina si todos los elementos en un arreglo

satisfacen una misma condición.
 El método split() convierte un string en un arreglo, donde cada
elemento contendrá un sub-string, dependiendo del parámetro
divisor que indiquemos.
 El método join() convierte un arreglo en un string, uniendo todos
los elementos de este en una misma cadena.

Métodos de recorrido.

 El método forEach() nos permite recorrer un arreglo, realizando

alguna acción en para cada elemento.
 El método map() también nos permite recorrer un arreglo y
realizar una acción por cada elemento. La diferencia es que este
método devuelve un nuevo arreglo los elementos modificados.

// PUSH y UNSHIFT
var colores = ['Amarillo', 'Azul'];
colores.push('Rojo');
colores.unshift('Verde');
console.log(colores);

// POP y SHIFT
colores.shift();
colores.pop();
console.log(colores);

// INCLUDES
var pintores = ['Picasso', 'Velázquez', 'Van Gogh', 'Dalí'];
var existeDali = pintores.includes('Dalí');
console.log(existeDali);

// EVERY
var numeros = [ 1, 6, 8, 9, 43 ];
var cumplenCondicion = numeros.every( ( num ) => { num > 5 } );
console.log(cumplenCondicion);

// SPLIT
var palabra = 'Henri';
var palabraSeparada = palabra.split('');
console.log(palabraSeparada);

// JOIN
var palabraArreglada = palabraSeparada.join('');
console.log(palabraArreglada);

// FOREACH
var numeros = [ 1, 2, 3, 4 ];
numeros.forEach( (num) => { console.log(num) } )

// MAP
var numeros = [ 1, 2, 3, 4 ];
var masUno = numeros.map( (num) => { return num + 1 } );
console.log(masUno);

Existe una página web llamada Mozilla Developer en la que podremos

encontrar toda la documentación, información y ejemplos sobre
JavaScript. En esta ocasión te compartimos todos los métodos de
arregl os en JavaScript(opens in a new tab). Podrás encontrar el
listado en la columna izquierda de la página.

Bucles dentro de los arrays

Bucle For

Crea un bucle que consiste en tres expresiones opcionales, encerradas

en paréntesis y separadas por puntos y comas, seguidas de una
sentencia ejecutada en un bucle.

Sintaxis: for ([expresion-inicial]; [condicion]; [expresion-final])sentencia

Ejemplo: Usando for

La siguiente sentencia for comienza mediante la declaración de la

variable i y se inicializa a 0. Comprueba que i es menor que nueve,
realiza las dos sentencias con éxito e incrementa i en 1 después de cada
pase del bucle.

for (var i = 0; i < 9; i++) {

n += i;
mifuncion(n);

Bucle While

Crea un bucle que ejecuta una sentencia especificada mientras cierta

condición se evalúe como verdadera. Dicha condición es evaluada antes
de ejecutar la sentencia.

Sintaxis: while (condicion)

sentencia

Ejemplos

El siguiente bucle while itera mientras n es menor que tres.

n = 0; x = 0;

while (n < 3) {

n ++;

x += n;

Bucle infinito

Esto no es un nuevo tipo de bucle, sino algo que se puede producir en

los que ya aprendimos. Un bucle infinito se produce cuando un bucle
comienza a ejecutarse, pero jamás termina. Esto se debe a que nunca se
llega a la condición de quiebre.

Esto consume muchos recursos de la computadora, por lo que

hay que intentar evitarlos.

/ FOR
var arr = [1, 2, 3, 4, 5];
for (let i = 0; i < arr.length; i++) {
console.log(arr[i]);
}
// WHILE
var arr = [];
while (arr.length < 5) {
arr.push('Camilo');
}
console.log(arr);
METODO FOR OF, MAS SIMPLE QUE EL METODO FOR

El método for...of es una característica introducida en JavaScript a

partir de la especificación ES6 (ECMAScript 2015). Este método se utiliza
para recorrer elementos iterables, como arrays, cadenas de texto, Map,
Set, etc., y permite ejecutar una acción para cada elemento de forma
sencilla y legible.

La sintaxis básica del for...of es la siguiente:

javascriptCopy code

for (variable of iterable) {

// código a ejecutar para cada elemento }

En resumen, el método for...of simplifica el recorrido de elementos en

objetos iterables en JavaScript, proporcionando una sintaxis más clara y
concisa en comparación con otras formas tradicionales de iteración,
como el for clásico o el forEach.

function promedioResultadosTest(resultadosTest) {
// El parámetro "resultadosTest" es un arreglo de números.
// Itera (en un bucle) los elementos del arreglo y devuelve el promedio de las notas.
// Tu código:

Var promedio = 0; //elemento inicial

For(var i of resultadosTest) {

Promedio = promedio + i;
}

Return promedio / resultadosTest.length;

OBJETOS MODULO 6

A diferencia de las matrices que tienen elementos valorados en índices,

los objetos usan un concepto llamado pares de clave:valor.

La clave (key) es el identificador y el valor (value) es el valor que

queremos guardar en esa clave. La sintaxis es "clave: valor". Los objetos
pueden contener muchos pares de clave-valor, deben estar separados
por una coma (importante: sin punto y coma dentro de un objeto).

Las claves son únicas en un objeto, solo puede haber una clave
de ese nombre, aunque, varias claves pueden tener el mismo
valor. Los valores pueden ser cualquier tipo de dato de
Javascript; cadena, número, booleano, matriz, función o incluso
otro objeto.

var deportes = {
conBalon: ['Futbol', 'Basketball', 'Golf'],
sinBalon: ['Boxeo', 'Surf', 'Trekking'],
};
var persona = { nombre: 'Lucas', edad: 26, estudios: { esProgramador:
true } };

Para acceder a la propiedad de un objeto simplemente tenemos que

escribir el nombre del objeto seguido de un punto y el nombre de la
propiedad

Para cambiar el valor de una propiedad simplemente tenemos que

acceder a ella e igualarla al nuevo valor.

Para eliminar propiedades utilizaremos una palabra reservada

llamada delete.

Usa los siguientes códigos para replicar los ejercicios de la video

clase:

// ACCEDER
var persona = { nombre: 'Lucas', edad: 26, estudios: { esProgramador:
true } };

console.log(persona.edad);

// ASIGNAR

var persona = { nombre: 'Lucas', edad: 26, estudios: { esProgramador:

true } };

persona.nombre = 'Martín';

console.log(persona.nombre);

//CREAR

var autos = {};

autos.marcas = ['Ford', 'Audi', 'Ferrari'];

console.log(autos);

//BORRAR

delete autos.marcas;

console.log(autos);

De la misma manera que utilizamos la Dot-Notation o notación

por puntos para acceder o asignar un valor, también podemos
usar Bracket-Notation, o notación por corchetes. Lo único que
cambia es la forma en la que lo escribimos.

Muchas veces nos puede suceder que necesitemos utilizar

una variable externa para guardarla como propiedad en un
objeto. Es importante que en esos casos recordemos
utilizar Bracket-Notation sin comillas para que funcione
correctamente.

// DOT NOTATION
var atuendos = { manos: ['Guantes', 'Anillos'], pies: ['Zapatos',
'Soquetes'] };
// BRACKET NOTATION
atuendos['piernas'] = ['Bermudas', 'Pantalones'];
console.log(atuendos);

Métodos de objetos

El método hasOwnProperty() nos permitirá especificar un

nombre, y verificar si este existe como una propiedad dentro de
un objeto. En cada caso devolverá true o false.

El método Object.keys() devuelve todas las propiedades de un

objeto guardadas en orden dentro de un arreglo.

Otros métodos de objetos:

https://developer.mozilla.org/es/docs/Web/JavaScript/
Reference/Global_Objects/Object

Recorridos en objetos

De la misma manera que podíamos recorrer los elementos de un

arreglo, podemos recorrer las propiedades de un objeto junto
con sus valores.

El bucle For-In nos permite iterar sobre un objeto utilizando dos

variables pivot. Una representa el objeto que recorremos, y la
otra la propiedad en la que se está realizando la iteración.
Utilizando ambos valores podremos acceder al valor de cada
propiedad del objeto.

https://developer.mozilla.org/es/docs/Web/JavaScript/
Reference/Statements/for...in

Contextos en JavaScript

Dentro de este lenguaje de programación existe un objeto

global llamado this. Este nos permite manipular el contexto en
el que las funciones y la información está siendo ejecutada. De
esta forma podremos tener un alcance más preciso dentro de
nuestro código.

https://developer.mozilla.org/es/docs/Web/JavaScript/
Reference/Operators/this

// HAS OWN PROPERTY

var libro = { autor: 'Borges', genero: 'Policial', año: 1990 };
var tienePropiedad = libro.hasOwnProperty('nombre');

console.log(tienePropiedad);

// KEYS
var libro = { autor: 'Borges', genero: 'Policial', año: 1990 };
var todasLasPropiedades = Object.keys(libro);

console.log(todasLasPropiedades);
for (let prop in mundo) {
console.log('Esta es la propiedad: ', prop);
console.log('Este es el valor: ', mundo[prop]);
}

//THIS
var mascota = {
animal: 'Perro',
raza: 'Ovejero Alemán',
amistoso: true,
dueño: 'María López',
info: () => {
console.log('Mi perro es un ' + this.raza);
},
};

MODULO 7 CLASES

Primero de tener en cuenta antes de declarar una clase

debemos saber que su primera letra debe ir en mayuscula.

Las clases tienen 2 sintaxis, constructoras y expresión de

clases.

// FUNCIÓN CONSTRUCTORA
function Auto(puertas, color, marca, año, ruedas) {
this.puertas = puertas;
this.color = color;
this.marca = marca;
this.año = año;
this.ruedas = ruedas;
}
let miPrimerAuto = new Auto(2, 'Rojo', 'Ferrari', 2018, 4);
console.log(miPrimerAuto);
console.log(miPrimerAuto.marca);
// EXPRESIÓN DE CLASE
class Auto {
constructor(puertas, color, marca, año, ruedas) {
this.puertas = puertas;
this.color = color;
this.marca = marca;
this.año = año;
this.ruedas = ruedas;
}
}
let miSegundoAuto = new Auto(4, 'Blanco', 'Fiat', 2015, 4);
console.log(miSegundoAuto);
console.log(miSegundoAuto.marca);

PROTOTIPOS:

 Los prototipos son un mecanismo por el cual todos los

objetos o elementos de Javascript pueden extender sus
propiedades y métodos.
 El proceso en el que los objetos globales de JavaScript le
extienden métodos y propiedades a cualquier tipo de dato
se denomina herencia.

Array.prototype.mayorQueTres = function () {
var arregloModificado = [];
for (var i = 0; i < this.length; i++) {
if (this[ i ] > 3) {
arregloModificado.push(false);
} else {
arregloModificado.push(this[ i ]);
}
}
return arregloModificado;
};

var arreglo = [1, 2, 3, 4, 5];

var nuevoArreglo = arreglo.mayorQueTres();
console.log(nuevoArreglo);
class LatinoAmerica {
constructor() {
this.paises = [ ];
};
};

LatinoAmerica.prototype.agregarPais = function (pais) {

this.paises.push(pais);
};
let continente = new LatinoAmerica();
continente.agregarPais('México');
console.log(continente.paises);

Todos los objetos pueden heredar propiedades y métodos por

medio de un prototipo. Gracias a estos prototipos podremos
acceder al constructor de cualquier objeto para modificarlo.
Expresiones de clase:

extender clases nos va a permitir tener una clase general que

le heredará propiedades y métodos a otras clases. De esta
forma, podremos generar distintas sub-entidades que puedan
mantener sus propias características, pero que compartan algunas
otras generales.
class Persona {
constructor(nombre, edad) {
this.nombre = nombre;
this.edad = edad;
}
saludar() {
console.log(
'Hola, mi nombre es ' + this.nombre + '. Tengo ' + this.edad
);
}
}
let martin = new Persona('Martin', 26);
martin.saludar();
class Programador extends Persona {
constructor(nombre, edad, añosDeExperiencia) {
super(nombre, edad);
this.añosDeExperiencia = añosDeExperiencia;
}
codear() {
console.log(
'Soy ' +
this.nombre +
' . Codeo desde hace ' +
this.añosDeExperiencia +
' años'
);
}
}

let martin = new Persona('Martín', 26);

let programador = new Programador('María', 37, 4);
martin.saludar();
programador.codear();
MODULO 8

Las funciones callback son un tipo de funciones que se pasan

por parámetro a otras funciones, en esta video clase
aprenderemos que son y cómo usarlas a través de algunos
ejemplos.

Supongamos que tenemos una función 1 que recibe por

parámetro a una función 2. Cuando la función 1 ejecuta a la
función 2 en su interior, se produce un proceso llamado
“callback”.

Los callbacks son muy útiles en el mundo de la programación,

nos aseguran que una función no se va a ejecutar antes de que
se complete una tarea, sino que se ejecutará justo después de
que la tarea se haya completado.

unction devuelvoUsuario() {
return 'CAMILO';
}
function devuelvoSaludo() {
return 'Hola';
}
function saludar(cb1, cb2) {
return cb1() + ' ' + cb2();
}
var resultado = saludar(devuelvoSaludo, devuelvoUsuario);
console.log(resultado);