Ya tenemos las bases de la programación: ya sabemos declarar funciones y procedimientos, usar variables,

tomar decisiones empleando la estructura de control if, hacer tareas múltiples veces.

Sin embargo, en los programas "reales" rara vez trabajamos con tableros y bolitas de colores: la programación va
más allá de eso. ¿Cómo es entonces esto de vivir fuera del tablero?

Para responder esta pregunta, primero nos adentraremos en el mundo de JavaScript, un lenguaje muy popular que
no tiene tablero, pero en el que de todas formas podremos aplicar todo lo visto hasta ahora y descubrir nuevas ideas
y formas de resolver problemas, pero…

¿QUE ES JAVASCRIPT?

- Es un Lenguaje de Programación: Es una herramienta que nos permite darle instrucciones a una computadora o
máquina, a través de un código, que estos códigos están escritos y estructurados de tal forma que siguen una "lógica
de programación", para que al completar dichos códigos la maquina interprete y cumplan las funciones que nosotros
queramos. por ejemplo; "si queremos hacer un programa que sea una calculadora e ingresemos un numero + otro
número el programa cree de manera automática la suma"...

- Es un Lenguaje Interpretado: existen dos tipos de lenguajes (los compilados y los interpretados)

los lenguajes compilados: son aquellos que necesitan de un "programa compilador" que tiene la función de traducir
"todos los códigos" a un lenguaje que otro programa interpreta y lo convierte a lenguaje binario.

Y después están los lenguajes interpretados (como JavaScript; HTML o CSS) NO NECESITAN pasar por un compilador
sino que va directamente a ejecutarse en el navegador, que tiene una herramienta llamada "interprete" que
interpreta el código en tiempo real, es de decir va ejecutando los códigos orden por orden algorítmicamente.

- Es un leguaje Orientado a Objetos: esto significa que en la estructura de JavaScript abarca todas las características
orientado a objetos, es decir, abarca todos los conceptos y todos los lenguajes que tiene un programa de
programación que es orientado a objetos.

- Es un programa Imperativo: esto significa que es un programa que se ejecuta de línea en línea, es decir; primero
ejecuta una instrucción, después otra y así sucesivamente. ósea va paso por paso en la interpretación de códigos.

- Es un lenguaje Case Sensitive (Upper and Lower case): esto significa que es "sensible" a mayúsculas y a minúsculas,
a puntos y comas, etc., por ejemplo que ponemos un código que debe ir escrito "Poner" en la sintaxis del programa y
en su defecto por error ponemos "poner", JavaScript no va a poder leer el código y va a tirar error.

- Esta basado en prototipos , instancias y classless: generalmente cuando se crea un objeto este lo creamos a través
de instancias y classless, y como es un lenguaje basado en prototipos los objetos que podemos crear van a estar
basados en otros objetos que fueron creados previamente por el equipo de desarrollador de JavaScript; o sea; que si
creamos un objetos, ese objeto que creamos va a venir instanciado en un prototipo que venía previamente en
JavaScript.
- Es de Tipado Débil: esto quiere decir que el valor de las variables puede cambiar a lo largo del tiempo, es decir una
variable puede cambiar, puede ser un número y también un texto, etc. o sea que mientras más débil sea el tipado
más flexible va a ser poder cambiar los datos.

- Es un lenguaje dinamico: es decir que la variable NO se ajusta al dato, si no que el dato se ajusta a la variable,
ejemplo si creamos una variable lo que hacemos es indicarle directamente a la variable que dato va a ir, ejemplo:
(num1(la variable) = 15(el dato)) , como vemos la variable se adapta al dato y pasa a valer 15;(num1 = 15) o si
decimos; (num1(la variable) = texto (el dato); num1 pasa a ser "texto"...

y JavaScript es una tecnología creada por ECMASCRIPT.. que tiene distintas versiones, versión 5.1, y 6, 7, 8...etc. que
tiene ES.NEXT que son las nuevas actualizaciones de JavaScript a futuro y que están en desarrollo..

¿QUE ES UN EDITOR DE TEXTO?

Un editor de texto es un "programa" que nos ayuda a escribir los códigos que vamos a utilizar para que JavaScript los
ejecute; de forma más efectiva, estos puede ser el: Visual Studio Code, Atom , Sublime text 3, etc o incluso el block
de notas, aunque no es nada recomendable porque los editores de textos te permiten diferenciar códigos con
colores, ver funciones, etc. y ver si hay algún error, es más fácil escribir código, se identan (ordenan)
automáticamente, se tabulan(es dejar espacios al principio) automáticamente, etc.

¿PARA QUE SE USA JAVASCRIPT?

- Dinamismo en los sitios Web (facilita el dinamismo en los sitios web cuando se configuran con javascript)

- servidor en NodeJS

- tecnologias Frontend como Angular , react o Vue.JS

otros usos:

- INTELIGENCIA ARTIFICIAL

- MOBILE APPS

- DESKTOP APP, etc.

Siempre que aprendamos un lenguaje de programación nuevo, nos vamos a topar con un pequeño detalle: tienen
una sintaxis diferente. La buena noticia es que el cambio no será tan terrible como suena, así que veamos nuestra
primera función JavaScript:
En JavaScript En Gobstones

function doble(numero){ function doble(numero){

return 2 * numero ; return ( 2 * numero )

} }

Notamos que los paréntesis ( ) en el return no son necesarios en JavaScript, y que la última línea la terminamos con
punto y coma ( ; ).

REPASANDO LAS FUNCIONES:

Ahora que aprendimos algo muy importante en la programación, veamos en profundidad conceptos que ya
aprendimos en el capítulo anterior, en JavaScripts:

Declaración de Funciones:

Las funciones en JavaScript se declaran mediante la palabra reservada function, y su cuerpo va entre llaves { y }:
Toda función debe tener al menos un retorno, que se expresa mediante return.

function nombreDeLaFuncion ( parametro1, parametro2, parametro3, etc…)

{ # Aca se declara la función return … ; # }

LOS PARAMETROS EN LAS FUNCIONES

Recordemos que los parámetros son los datos que ingresamos entre los paréntesis ( ), los parámetros se usan
para mandar valores a las funciones. Una función trabajará con los parámetros para realizar las acciones. Por decirlo
de otra manera, los parámetros representa los valores de entrada que recibe una función. Por poner un ejemplo
sencillo de entender, una función que realizase una suma de dos números tendría como parámetros a esos dos
números. Los dos números son la entrada, así como la salida o retorno sería el resultado de la suma.

function Suma (numero1, numero2) {

return numero1 + numero2 ;

Como podemos ver en el ejemplo, para definir en la función un parámetro tenemos que poner el nombre de la
variable que va a almacenar el dato que le pasemos. Esa variable, que en este caso se llama numero1 y numero2,
tendrá como valor el dato que le pasemos a la función cuando la llamemos. Además, la variable donde recibimos el
parámetro tendrá vida durante la ejecución de la función y dejará de existir cuando la función termine su ejecución.

¿QUE ES LLAMAR UNA FUNCION?

Es cuando utilizamos una función que habíamos creado, para llamar a una función que tiene parámetros se coloca
entre paréntesis el valor del parámetro, si son varios los separamos con la coma ( , ). Para llamar a la función del
ejemplo habría que escribir:

Suma( 3, 9) # Ponemos los valores dentro de las paréntesis separados con la coma ( , ) #

11 # la función retorna el resultado de la ecuación #

 Los parámetros pueden recibir cualquier tipo de datos, numérico, textual, booleano o un objeto. Realmente no
especificamos el tipo del parámetro, por eso debemos tener un cuidado especial al definir las acciones que
realizamos dentro de la función y al pasarle valores, para asegurarnos que todo es consecuente con los tipos de datos
que esperamos tengan nuestras variables o parámetros.

¿QUE HACEN LOS RETURNS?

Estamos aprendiendo acerca del uso de funciones en Javascript y en estos momentos quizás ya nos hayamos dado
cuenta de la gran importancia que tienen para hacer programas más o menos avanzados. Seguiremos aprendiendo
cosas sobre funciones y en concreto que con ellas también se puede devolver valores. Además, veremos algún caso
de uso interesante sobre las funciones que nos puede aclarar un poco el ámbito de variables locales y globales.

Las funciones en Javascript también pueden retornar valores. De hecho, ésta es una de las utilidades más
esenciales de las funciones, que debemos conocer, pero no sólo en Javascript sino en general en cualquier lenguaje
de programación. De modo que, al invocar una función, se podrá realizar tareas y ofrecer un valor como salida.

Por ejemplo, una función que calcula la multiplicación de un número por 2 tendrá como entrada a ese número y
como salida tendrá el valor resultante de dicha multiplicación de ese número. La entrada de datos en las funciones la
vimos anteriormente sobre parámetros de las funciones. Ahora tenemos que aprender acerca de la salida ( los
returns). Veamos un ejemplo de una función que calcula la multiplicación de un número por 2 . La función recibirá el
numero o valor de entrada en el parametro y retornará el valor x .

function doble(numero){ # Cuando definimos una función en el parámetro ponemos el texto o el numero

return 2 * numero ; que va a representar el valor de entrada para que el operador vaya hacer el

} cálculo matemático según la expresión que definamos y va a retornar el valor de

salida de dicho cálculo #

Cuando llamamos a la función; lo hacemos de la siguiente manera:

doble( 3 ) # En este ejemplo el numero 3 es el valor de entrada(argumento) que la función va a calcular #

6 # En este ejemplo el 6 es el retorno (return) o valor de salida que da la función( porque 2 * 3 = 6 ) #

Cuando creamos una función, al igual que un procedimiento, la misma función que creamos también puede ser
usada dentro de otra función, dentro de un procedimiento o un programa. Y como una función opera gracias a las
expresiones que le otorgamos es por eso que una función puede encapsular expresiones dentro de otras funciones,
pero veamos un ejemplo…

function doble(numero) { # definimos la primera función y le damos la siguiente

return 2 * numero; expresión matemática que retorna un valor x #

} # Esto es encapsular una expresión #

Function siguienteDelDoble(numero) { # definimos la segunda función y le damos la siguiente expresión

return doble(numero) + 1 ; usando la primera función como parte de la expresión #

} # Esto es encapsular una función dentro de otra y por lo tanto también se

Encapsula una expresión dentro de otra expresión. #

O incluso algo mejor…

function doble(numero) { # Encapsulamos la expresión dentro de la primera función #

return 2 * numero;

function siguiente(numero) { # Encapsulamos la primera función dentro de la segunda función #

return doble(numero) + 1 ;

function siguienteDelDoble(numero) { # Encapsulamos la primera función y segunda función dentro de

return siguiente( doble(numero) ) ; la tercera función #

Si prestamos atención al encapsular una función lo que encapsulamos también es la expresión matemática que da
un valor que va hacer usado por la segunda expresión matemática que a su vez el valor que resulta va a ser usado por
la tercera expresión matemática. Toda función debe tener al menos un retorno, que se expresa mediante return.

EL OBJETO MATH. EN JAVASCRIPT

Además de los operadores matemáticos +, -, / y *, existen muchas otras funciones matemáticas comunes, algunas
de las cuales ya vienen con JavaScript y están listas para ser usadas, es decir que cuando trabajamos con Javascript,
es posible realizar gran cantidad de operaciones matemáticas de forma nativa, sin necesidad de librerías externas,
para ello, haremos uso del objeto Math, que es un objeto interno de Javascript que tiene incorporadas ciertas
constantes y métodos (funciones) para trabajar matemáticamente.

Sin embargo, la sintaxis de estas funciones matemáticas es apenitas diferente de lo que veníamos haciendo hasta
ahora: hay que prefijarlas con Math..

Por ejemplo, la función que nos sirve para redondear un número es Math.round; que lo podemos definir de la
siguiente manera:

function cuantoSaleAproximadamente(precio, impuestos) {

return Math.round(precio * impuestos);

Como hemos visto anteriormente, es muy común necesitar métodos para redondear números y reducir el número
de decimales o aproximar a una cifra concreta. Para ello, de forma nativa, Javascript proporciona los siguientes
métodos de redondeo:
Math.round(x) Devuelve el valor x con redondeo ( el entero más cercano )

Math.ceil(x) Devuelve el valor x con redondeo superior ( el entero más alto )

Math.floor(x) Devuelve el valor x con redondeo inferior ( el entero más bajo )

Math.fround(x) Devuelve el valor x con redondeo ( flotante con precisión simple )

Veamos las diferencias de utilizar los diferentes métodos anteriores para redondear un número decimal y los
resultados obtenidos:

// Redondeo natural, el más cercano (o sea pone un tope superior o inferior depende del caso)

Math.round(3.75); // 4 ( 3.75 esta mas cerca del 4 por eso el tope es superior)

Math.round(3.25); // 3 ( 3.25 esta mas cerca del 3, por eso el tope es inferior )

Math.round(3.50); // 4 ( 3.50 cuando da un valor medio va a ir al tope superior o sea 4)

Math.round(3.49); // 3 ( 3.49 esta mas cerca del 3, por eso el tope es inferior )

// Redondeo superior (el más alto o sea pone un tope superior)

Math.ceil(3.75); // 4

Math.ceil(3.25); // 4

// Redondeo inferior (el más bajo o sea pone un tope inferior)

Math.floor(3.75); // 3

Math.floor(3.25); // 3

// Redondeo con precisión

Math.round(3.123456789); // 3 ( en este ejemplo Math.round va a redondear el numero o sea sin decimales )

Math.fround(3.123456789); // 3.1234567165374756 ( Hace un redondeo preciso con decimales)

// Truncado (sólo parte entera)

Math.trunc(3.75); // 3

Math.round(-3.75); // -4

Math.trunc(-3.75); // -3

Math es uno de los objetos globales u objeto incorporado estándar de JavaScript y puede ser utilizado en cualquier
lugar donde puedas usar JavaScript. Contiene constantes útiles como π y el número de Euler, además de funciones
como floor(), round() y ceil(). Math es un objeto incorporado que tiene propiedades y métodos para constantes y
funciones matemáticas. No es un objeto de función. Math funciona con el tipo Number . No funciona con BigInt (en-
US).

LAS FUNCIONES MATH.MAX Y MATH.MIN

En la librería de Math podemos encontrar las funciones Math.max y Math.min pero ¿que hacen?

La función Math. max() retorna el mayor de cero o más números dados como parámetros de entrada, o NaN si
cualquier parámetro no es un número y no puede ser convertido en uno. Por ejemplo: si necesitamos una función
que diga cuánta plata queda en tu cuenta (que tiene un cierto saldo) y si extraes un cierto monto de la plata que te
queda en tu saldo; seria

// el saldo es $100 y el monto a extraer, $30

extraer(100, 30)

70

//quedan $70 ($100 - $30 = $70) en tu cuenta.

Pero cuando no queremos quedarnos en negativo, si el monto a extraer es mayor al saldo, nuestro saldo debe
quedar en cero. Por ejemplo, si en nuestra cuenta queda el saldo de $100 y queremos extraer el monto de $150

// el saldo es $100 y el monto a extraer, $150

extraer(100, 150)

//Ups, quisimos sacar más plata de la que teníamos.

//Nos quedamos con $ 0 en tu cuenta.

Como ves, esto es casi una resta entre saldo y monto, con la salvedad de que estamos poniendo un tope inferior:
no puede dar menos de cero. Por lo tanto, podemos ver que extraer devuelve el máximo entre la resta saldo –
monto y pone cero ( 0 ) cuando ese monto es mayor al saldo que tenemos, o sea no pone números negativos, ya que
en el ejemplo tendría que dar $ - 50 pero en este caso le pusimos un tope mínimo a la función extraer para que no
de – 50 y de 0 , ya que 0 es mayor que – 50.

Si quieres entender pensa que 60 es mayor que 50, 50 es mayor que 40, 40 es mayor que 10, 10 es mayor que 5 , 5
es mayor que 0, 0 es mayor que -1 , -1 es mayor que -10, - 10 es mayor que -50 y asi, en negativo.

Math.max(100 - 30, 0)

70 // da el máximo entre 70 y 0, que es 70

Math.max(100 - 120, 0)

0 // da el máximo entre -20 y 0, que es 0

Si queremos declarar la función del ejemplo, lo hacemos de la siguiente forma:

function extraer(saldo, monto) {

return Math.max(saldo - monto, 0); # En donde saldo y monto representan los valores de entrada y el resultado

} va a ser comparado con el 0, y va a retornar el mayor valor entre el resultado y 0 #

En resumen, la función Math.max es una función que devuelve el valor mayor de una lista de valores numéricos
pasados como parámetros. Si se pasa un valor no numérico (un texto, etc) como parámetro, Math. max() devolverá
NaN

// el saldo es $100, el monto a extraer, $plata

extraer(100, plata)

NaN

Por el contrario, la función Math.min retorna el número con menor valor o de cero. Le puedes pasar cualquier
cantidad de argumentos.

Math.min(7, 2, 9, -6);

// devuelve -6

Como ves, la función Math.max nos sirvió para implementar un tope inferior. De manera semejante, la función
Math.min nos puede servir para implementar un tope superior.

OPERADORES DENTRO DE LAS FUNCIONES

Recordemos que un operador es un elemento de código que realiza una operación en uno o más elementos de
código que contienen valores. Los elementos de valor incluyen variables, constantes, literales, propiedades,
devoluciones de procedimientos, Function y Operator y expresiones.

Tipos de operadores:

Hay varios tipos de operadores:

1_ Los operadores aritméticos o matemáticos realizan cálculos familiares en valores numéricos, incluido el
desplazamiento de los patrones de bits. Por ejemplo:

4+5

10 - 5

8*9

10 / 5

2_ Los operadores de comparación comparan dos expresiones y devuelven un valor Booleano que representa el
resultado de la comparación. Por ejemplo:

// para cualquier tipo de dato

"hola" === "hola"

"hola" !== "chau"

// para números

4 >= 5 4 <= 5

4 < 5 4 > 5

3_ Los operadores de concatenación unen varias cadenas “strings” en una sola.

4_ Los operadores lógicos y bit a bit combinan valores Booleanos o numéricos y devuelven un resultado del mismo
tipo de datos que los valores. Por ejemplo:

true && false

true || false

! false

Los elementos de valor que se combinan con un operador se denominan operandos de ese operador. Los
operadores combinados con elementos de valor forman expresiones, salvo el operador de asignación, que forma una
instrucción.

OPERADORES LOGICOS O DE COMPARACION

Como ya habíamos visto los operadores de comparación comparan dos expresiones y devuelven un valor Booleano
(true/false) que representa la relación de sus valores. Hay operadores para comparar valores numéricos, operadores
para comparar cadenas y operadores para comparar objetos. Por ejemplo El operador de comparación ( == )
comprueba si sus dos operandos son iguales y devuelve un resultado booleano. A diferencia del operador de
igualdad estricta ( === ), es que este convierte y compara operandos que son de diferentes tipos.

Como ves, en JavaScript contamos con operadores como ===, >=, >, <,<= que nos dicen si dos valores son iguales,
mayores-o-iguales, mayores, etc. Los vamos a usar bastante …

function esDiaFavorito(diaDelMes) {

return diaDelMes === 1 ;

Y cuando lo llamamos va a dar;

esDiaFavorito(13)

false

esDiaFavorito(1)

true

Cuando hacemos una comparación tengamos en cuenta el orden de lo que queremos comparar, es decir que si una
función está definida de la siguiente manera;
function esDiaFavorito(diaDelMes) {

return diaDelMes === 1 ;

Prestemos atención que entre las paréntesis ( parámetro ) va a ingresar el parámetro que vamos a comparar en la
función, si desplegamos el código podemos ver;

function esDiaFavorito(diaDelMes) { return diaDelMes === 1; }

# Este valor va a ser comparado por el # Con este valor; que es el

operador que va a ser un valor random # # valor que ponemos como true#

# Cuando ambos valores dan iguales va a dar true y si son diferentes false #

No es lo mismo comparar diaDelMes = 1 que comparar 1 = diaDelMes, prestemos atención.

TABLA DE COMPARACION

SÍMBOLO SIGNIFICADO EJEMPLO

= Igual que A=B

> Mayor que A>B

< Menor que A<B

>= Mayor o igual que A >= B

<= Menor o igual que A <= B

<> Distinto que A <> B

OPERADORES LOGICOS

Recordemos que los operadores lógicos se usan para comparar dos valores Booleanos y devolver un resultado
verdadero, falso o nulo. Los operadores lógicos también se denominan operadores Booleanos. Ahora miremos a los
booleanos con un poco más de detalle:

Se pueden negar, mediante el operador ( ! ): !hayComida

Se puede hacer la conjunción lógica entre dos booleanos ( and, también conocido en español como y lógico),
mediante el operador ( && ) ; hayComida && hayBebida

Se puede hacer la disyunción lógica entre dos booleanos ( or ), también conocido en español como o lógico),
mediante el operador ( || ) : unaExpresion || otraExpresion

Como ya sabemos se pueden combinar ambas expresiones con ambos operadores; ¿que quiere decir esto? veamos
algunos ejemplos;

function estaEntre( numero1, numero2, numero3) {

return (( numero1 > numero2 ) && ( numero1 < numero3 ));

}
Si llamamos a la función;

estaEntre(3, 1, 10) # porque 3 esta entre 1 y 10

true

estaEntre(90, 1, 10) # porque 90 no esta entre 1 y 10

false

En la lógica booleana, se puede definir el comportamiento de un operador con una tabla de verdad donde A y B son
las expresiones o valores de verdad a ser operados y el símbolo ^ representa la conjunción. Cada celda tiene una V si
representa verdadero o F si representa falso.

Por ejemplo, supongamos que una casa consume poca energía si se usa el aire acondicionado a 24 grados y tiene al
menos 5 lamparitas bajo consumo.

Podemos representar las expresiones de la siguiente forma:

A: En la casa se usa el aire acondicionado a 24 grados

B: La casa tiene al menos 5 lamparitas bajo consumo

A ^ B: La casa consume poca energía

Como indicamos, la casa consume poca energía (A^B) cuando tanto A como B son verdaderos. Esto se puede
representar mediante la siguiente

tabla de verdad:

A B A^B

V V V

V F F

F V F

F F F

En el mundo de la lógica estas expresiones se llaman proposiciones.

Declaremos la función para ver que veamos como hacer:

function consumePocaEnergia(temperatura, lamparitas) {

return ((temperatura === 24) && (lamparitas >= 5));

Si llamamos a la función en la consola:

consumePocaEnergia(18, 1)

false
consumePocaEnergia(24, 5)

true

Pero… ¿qué cosas pueden ser una proposición? Sólo hace falta que porten un valor de verdad, es decir, cualquier
expresión booleana puede ser una proposición.

¿Y si basta con que una de varias condiciones se cumpla para afirmar que una expresión es verdadera? Podemos
utilizar otro de los operadores que ya conocés, ¡la disyunción lógica! O sea el or( || ).

Recordá que se lo representa con el símbolo || y también se lo conoce como el operador or. En el famoso juego
T.E.G., un jugador puede ganar de dos formas: cumpliendo su objetivo secreto o alcanzando el objetivo general de
conquistar 30 países.

function gano(cumplioObjetivoSecreto, cantidadDePaisesConquistados) {

return cumplioObjetivoSecreto || cantidadDePaisesConquistados >= 30;

Y si llamamos a la función en la consola veremos:

gano(false,30)

true

gano(true, 31)

true

gano(false, 20)

false

Otro ejemplo de la combinación de los operadores:

function estaFueraDeRango(cant1, cant2, cant3) {

return (( cant1 < cant2) || ( cant1 > cant3 ));

¿QUE ES UN METODO?

En programación, cuando veamos la palabra "MÉTODO" (method en inglés) normalmente se trata de un CONJUNTO
DE INSTRUCCIONES DE CÓDIGO agrupadas dentro de una función para realizar una tarea especifica.

Los métodos de programación sirven para agrupar instrucciones de código y luego este conjunto de instrucciones
pueden ser llamadas cuantas veces sean necesarias simplemente haciendo la "llamada al método", esto nos permite
reutilizar código y resolver problemas cada vez más complejos gracias al aumento de abstracción sobre un problema.

En este curso vamos a usar diferentes method que van a ser los siguientes:
convertirEnMayuscula(unString)

Es una versión simplificada del método "toUpperCase( )" que devuelve el valor de la cadena convertida a
mayúsculas. El método toUpperCase( ) no afecta al valor de la cadena en sí mismo. Por ejemplo:

convertirEnMayuscula("hola")

"HOLA"

comienzaCon(unString, otroString)

Es una versión simplificada del método startsWith() que indica si una cadena de texto comienza con los caracteres
de una cadena de texto concreta, devolviendo true o false según corresponda, en resumen dice si un String empieza
con otro String. Por ejemplo:

comienzaCon("aprendiendo a programar","aprendiendo")

true

comienzaCon("aprendiendo a programar","programar")

false

longitud(unString)

Es una versión simplificada de length( ). La función LENGTH se utiliza para manipular series de caracteres de todos
los tipos de datos de serie de caracteres (BIT, BLOB y CHARACTER) y devuelve un valor de numero entero que
proporciona el número de elemento de source_string. Ejemplo:

longitud("hola")

imprimir(unString)

Es una versión simplificada de console.log que es un método que muestra o “imprime” un mensaje en la consola,
recibe como argumento uno o más objetos. Cada objeto se evalúa y se concatena en una string separada por
espacios. Es decir que el console.log es un comando que usamos en el Editor de Texto y nos permite escribir un texto
y mostrarlo en la consola. Esto es muy útil cuando creamos aplicaciones para ver mensajes de error, que comandos
se ejecutan y cuales no, etc.

Por Ejemplo:

imprimir("¡estoy imprimiendo!")

¡estoy imprimiendo!
Sin embargo, sólo podemos escribir strings y, una vez que escribimos en la pantalla, no hay vuelta atrás: no hay forma
de retroceder o deshacer. Por lo tanto vamos a usar este método para mostrar una estructura de códigos dentro de la
consola y ver si funciona esa estructura de comandos. Para declarar una estructura de códigos, solamente creamos
una función, por ejemplo:

function versosMartinFierro() {

imprimir("Aquí me pongo a cantar");

imprimir("Al compás de la vigüela;");

imprimir("Que el hombre que lo desvela");

imprimir("Una pena extraordinaria");

return 0;

Si llamamos a la función en la consola nos daría:

versosMartinFierro()

Aquí me pongo a cantar

Al compás de la vigüela;

Que el hombre que lo desvela

Una pena extraordinaria

=> 0

Otro ejemplo:

function funcionEgocentrica() {

imprimir("soy una función que imprime por pantalla");

imprimir("y estoy por devolver el valor 5");

return 5;

Si llamamos a la función nos va a dar:

funcionEgocentrica()

soy una función que imprime por pantalla

y estoy por devolver el valor 5

=> 5

agregar(unaLista, unElemento)
Es una versión simplificada del metodo push( , ). El método push() añade uno o más elementos al final de un array y
devuelve la nueva longitud del array, o sea que inserta un Elemento al final de una Lista. Este es un procedimiento
que no devuelve nada pero modifica a una Lista.

¿QUE ES UN STRING?

En cualquier lenguaje de programación, un String es una secuencia de caracteres usado para representar el texto.
En JavaScript, un String es uno de los valores primitivos y el objeto String es un envoltorio alrededor de un String
primitivo. El objeto String se utiliza para representar y manipular una secuencia de caracteres.

Un String o cadena de caracteres es un tipo de dato que se utiliza para almacenar textos, no es una variable primitiva
como el int, el bool o el float, sino que es un conjunto de variables primitivas tipo carácter.

Muchas veces queremos escribir programas que trabajen con texto o queremos saber cuántas palabras hay en un
libro, o convertir minúsculas a mayúsculas, o saber en qué parte de un texto está otro. Para este tipo de problemas
tenemos los Strings, también llamados cadenas de caracteres:

"Ahora la bebé tiene que dormir en la cuna"

'El hierro nos ayuda a jugar'

"¡Hola Miguel!"

Como se observa, todos los strings están encerrados entre comillas simples o dobles. ¡Da igual usar unas u otras!
Pero sé consistente: por ejemplo, si abriste comilla doble, tenés que cerrar con comilla doble. Además, un string
puede estar formado por (casi) cualquier carácter: letras, números, símbolos, espacios, etc.

Cuando usamos los Strings en la function tenemos que colocar las comillas ( “ “ ), pero en una function, dentro de
los parametros NO.

¿Y qué podemos hacer con los strings? Por ejemplo, compararlos, como a cualquier otro valor:

function esFinDeSemana(dia) {

return (dia === "sabado") || (dia === "domingo");

Si llamamos a la función;

esFinDeSemana("sábado")

true

esFinDeSemana("martes")

false

¿Y qué podemos hacer con los strings, además de compararlos? ¡Varias cosas! Por ejemplo, podemos preguntarles
cuál es su cantidad de letras:

function longitudNombreCompleto(nom1,segnom2,apellido){

return longitud(nom1 + " " + segnom2 + " " + apellido);

}
 Recuerda que longitud es el metodo lenght( ) y realiza la tarea de manipular series de caracteres de todos los tipos
de datos de serie de caracteres y devuelve un valor de numero entero.

Ahora si llamamos a la función;

longitudNombreCompleto("Cosme", "Miguel", "Fulanito")

21 // El método lenght no solo cuenta las letras(strings) si no también los espacios//

longitudNombreCompleto("biblioteca")

10

O también podemos concatenarlos, es decir, obtener uno nuevo que junta dos strings:

function concatenar(aa, bb) {

return ' aa ' + ' ' + ' bb ' ;

Cuando llamamos a la función;

concatenar( 'sus anaqueles ', ' registran todas las combinaciones ' )

' sus anaqueles registran todas las combinaciones '

Si prestamos atención, cuando llamamos a la función, debemos colocar las mismas comillas ( ‘ ‘ )que utilizamos
para definir la función, por eso te aclaramos de nuevo; si abriste comilla doble, tenés que cerrar con comilla doble.

Tené en cuenta que los signos de admiración "¡" y "!" (al igual que los espacios y otros signos de puntuación) son
strings y que los strings se pueden concatenar usando el operador de suma ( + ).

Por ejemplo;

function gritar( nombre ) {

return "¡" + convertirEnMayuscula(nombre) +"!";

En este ejemplo aclaramos que convertirEnMayuscula( ) es una versión simplificada de toUpperCase, que es un tipo
de method en JavaScript. Ahora si llamamos a esta función, la que habíamos declarado en el ejemplo; quedaría:

gritar(“miguel”)

"¡MIGUEL!"

O con los espacios también:

function escribirCartelito(titulo, nombre, apellido){

return titulo + " " + nombre + " " + apellido;

}
Si llamamos a la funcion nos daría:

escribirCartelito("Dra.","Ana","Pérez")

"Dra. Ana Pérez"

También podemos utilizar el operador + de una forma diferente, concatenando un string y un número. Es decir que:

si operamos dos números con + , se suman

si operamos dos strings con + , se concatenan

si operamos un string y un número +, el número se convierte implícitamente a string, y luego se concatenan, al igual
que antes, por ejemplo si creamos la función:

function elefantesEquilibristas(cantidad) {

return cantidad + " " + "elefantes" + " " + "se" + " " + "balanceaban";

Despues si llamamos a la función tenemos;

elefantesEquilibristas(3)

"3 elefantes se balanceaban"

En donde vemos que la palabra cantidad va a representar el valor de entrada o parámetro, que luego va a poder ser
cambiado por el argumento o valor concreto, o sea el (3) en este ejemplo. Y el número 3 se convierte implícitamente
en un string, y luego se concatenan. Es decir que el número no va a representar un valor con el que se pueda hacer
una suma si no que representa una palabra dentro de un string.

LA CONDICION DEL IF( )

Recordemos que la alternativa condicional evalúa el valor de verdad de una expresión booleana, que actúa de
condición y según se cumpla o no, realiza una acción determinada. Como vemos en el ejemplo utilizamos la
alternativa condicional para realizar una acción específica cuando se cumple una condición y para cuando debemos
elegir entre dos acciones diferentes (según se cumpla o no).

Es importante aclarar que dentro de las condiciones del if (lo que va entre paréntesis) puede albergar cualquier tipo
de dato o expresión ya sea numérica, comparativa o booleana , también parámetros e incluso una función o metodos
. En JavaScript mantiene la misma estructura por lo que si queremos crear una función que retorne el máximo entre
dos números. Por ejemplo, el máximo entre 4 y 5 es 5, y el máximo entre 10 y 4, es 10.

Lo podemos hacer de la siguiente forma;

function cualNumeroEsMayor(numero1, numero2) {

if (numero1 > numero2) {

return numero1 ;

} else {

return numero2; }

}
 Como vemos en el ejemplo utilizamos la alternativa condicional para realizar una acción específica cuando se
cumple una condición; y también para cuando debemos comparar entre dos condiciones diferentes (según se cumpla
o no). Para entender esto podemos desplegar el código y leer lo siguiente:

if (numero1 > numero2) { return numero1 ; } else { return numero2; }

Si el parámetro numero1 es mayor al parámetro numero2 retornar el valor numero1; de otro modo retornar el
valor numero2.

Es importante recordar bien que dentro de las condiciones del if (lo que va entre paréntesis) puede albergar
cualquier tipo de datos ya sea expresiones numéricas, comparativas o booleanas, también parámetros e incluso una
función o metodo. Por ejemplo si queremos saber el valor de las cartas de truco cuando jugamos al envido teniendo
como condición que:

_ todas las cartas del 1 al 7, inclusive, valen su numeración

_ las cartas del 10 al 12, inclusive, valen 0

_ no se juega con 8s ni con 9s

Asumiendo que sólo vamos a recibir cartas con valores dentro de los rangos del 1 al 7 y del 10 al 12

function valorEnvido(carta) {

if ( (carta) >= 1 && (carta) <= 7) {

return carta ;

} else {

return 0

Si desplegamos el código podemos visualizar:

{ if ( (carta) >= 1 && (carta) <= 7) return carta ; } else { return 0 } }

# condición # # 1° acción si se cumple la condición# # 2° acción si la primera es false #

Acá podemos leer que si la carta es mayor o igual a 1 Y carta(mismo valor) es menor o igual que 7, retornar carta; de
otro modo si no se cumplen las condiciones como verdaderas o si una da un valor falso, retornar 0.

Si llamamos a la función tenemos:

valorEnvido(12)

valorEnvido(3)

Si seguimos con el ejemplo anterior y queremos calcular cuántos puntos de envido suma un jugador.

Sabiendo que:

_ Si las dos cartas son del mismo palo, el valor del envido es la suma de sus valores de envido más 20.

_ De lo contrario, el valor del envido es el mayor valor de envido entre ellas.

Recordámos que para obtener el número más grande entre dos números tenemos la función Math.max.

function puntosDeEnvidoTotales(tanto1, carta1, tanto2, carta2){

if ( carta1 === carta2) {

return valorEnvido(tanto1) + valorEnvido(tanto2) + 20 ;

} else {

return Math.max(valorEnvido(tanto1),valorEnvido(tanto2) )

Si llamamos a la función nos daría:

puntosDeEnvidoTotales(1,"espadas",4,"espadas")

25

puntosDeEnvidoTotales(2,"copas",3,"bastos")

Para entender este ejemplo vamos a verlo de otra forma, cambiando los parámetros por los argumentos asi;

function puntosDeEnvidoTotales(1, espadas, 4, espadas){

if ( espadas === espadas) {

return valorEnvido(1) + valorEnvido(4) + 20 ;

} else {

return Math.max(valorEnvido(1),valorEnvido(4) )

Ahora podemos analizar como lo hace un operador:

if ( espadas === espadas) { return valorEnvido(1) + valorEnvido(4) + 20 ; } else {returnMath.max

(valorEnvido(1),valorEnvido(4) )

En donde leemos que dice el código; Si “espadas” es igual a “espadas” (valor que da true en este ejemplo), retornar

La suma del envido 1 + envido 4 + 20 ; o sea 1 + 4 + 20 = 25 … Como esta condición se cumple; ya no es necesario
realizar la segunda accion, por lo tanto el operador termina de ejecutar este comando en el punto y coma y entrega
el retorno que es 25.

Por el otro lado tenemos:

if ( copas === bastos) { return valorEnvido(2) + valorEnvido(3) + 20 ; } else {returnMath.max

(valorEnvido(2),valorEnvido(3) )

En donde leemos que dice , Si “copas” es igual a “bastos” (condición que ya da false porque no son iguales),
entonces el operador pasa directamente a la segunda condición; que se lee retornar el valor máximo entre el envido
2 y el envido 3, por lo que se retorna el 3.
 Si seguimos con el siguiente ejercicio de contar el truco, en donde cuando se juega al truco, los equipos oponentes
alternativamente pueden subir la apuesta. Por ejemplo, si un jugador canta truco, otro jugador puede cantarle
retruco. Obviamente, los puntos que están en juego son cada vez mayores y podemos ver las siguientes condiciones;

Canto Puntos en juego

truco 2

retruco 3

vale cuatro 4

Declaramos la función de la siguiente manera:

function valorCantoTruco(canto) {

if ( canto === "truco") {

return 2 ; }

if( canto === "retruco") {

return 3 ; }

if( canto === "vale cuatro") {

return 4

En el ejemplo anterior vemos como se combinan diferentes tipos de datos, con diferentes operadores y también
con Strings, ya que todos estos datos son variables que la computadora procesa para dar un valor concreto o tarea
especifica.

Veamos más ejemplos:

function cuidadoSegun(dia) {

if (dia === "lunes") {

return "fertilizar";

} else if (dia === "viernes") {

return "fumigar";

} else {

return "regar";

Como vemos, podemos combinar 2 estructuras de códigos if…else en una misma función, por lo tanto podemos
resolver un problema con varias condiciones, para entender mejor desplegamos el código y veamos;
{ if (dia === "lunes") { return "fertilizar"; } else if (dia === "viernes") { return "fumigar"; } else { return "regar"; } }

Si el dia es “Lunes” retornar “fertilizar”; de otro modo, Si el dia es “Viernes” retornar "fumigar"; SI NO SE CUMPLEN
LAS 2 CONDICIONES ANTERIORES, retornar "regar".

Si prestamos atención, podemos ver que el signo punto y coma ( ; ) separa una condición de otra. Es decir, donde
colocamos el punto y coma, le estamos diciendo al operador que aquí finaliza la primera tarea, y si no se cumple esa
condición o sea si da un resultado false, entonces que continue por la siguiente condición hasta el siguiente punto y
coma, y si la segunda condición también da false entonces que ejecute la última condición. Por eso cuidado donde
ponemos los puntos y comas y la sintaxis. Tambien vemos que la acción va entre las llaves { } .

Entonces cuando llamamos a la función, el operador va a calcular las diferentes alternativas con el valor de entrada
de esta forma:

cuidadoSegun(viernes)

"fumigar"

cuidadoSegun("lunes")

"fertilizar"

cuidadoSegun("domingo")

"regar"

Aquí pudimos ver que en casos donde tengamos varias alternativas condicionales podemos combinar if / else /
if /else; sin embargo el primer else no es tan necesario; ya que al poner if con su return , la computadora ya sabe
que hay una condición con una acción condicional que debe analizar y que tiene que dar un valor true, en caso
contrario si el valor de la primera condición da false, omite la acción y pasa directamente a la segunda condición
como ya habíamos mencionado anteriormente, entonces en problemas donde tengamos múltiples alternativas
condicionales podemos omitir el else; ya que un solo if con su return presenta en si mismo una condición cuyo valor
esta condicionado a dar true para que se retorne la condición, para entender mas esta lógica, veamos un ejemplo;

function medallaSegunPuesto(num1)

if (num1 === 1) {

return "oro";

} if (num1 === 2) {

return "plata";

} if (num1 === 3) {

return "bronce";

} else {

return "nada"

}
Si desplegamos el código podemos ver con claridad que podemos poner todas las condiciones que queramos;

{if (num1 === 1) { return "oro";} if (num1 === 2) { return "plata"; } if (num1 === 3) { return "bronce";} else {return

# 1° condición con su retorno # # 2° condición con su retorno # # 3 ° condición con su retorno # # 4° condición

"nada"}}

con su retorno se aplica solo si las condiciones anteriores no se cumplieron, es decir no dieron valor true #

En donde podemos leer Si el parámetro num1 es igual a 1 retornar “oro” ; si el parámetro num1 es igual a 2
retornar “plata”; si el parámetro num1 es igual a 3 retornar “bronce” , de otro modo … si no se cumplen los
anteriores retornar “nada”. Entonces vemos que omitimos los else y la computadora igual analiza las condiciones
establecidas.

También tenemos que recordar que la condición del if, es decir lo que colocamos dentro de las
paréntesis( if(condición) ) puede llevar tanto una expresión aritmética como cualquier tipo de expresión, de todas
formas la computadora va a usarla como una condición comparativa para retornar algo, por ejemplo si queremos
crear un cartelito que tenga la opción de poner solo el título y el apellido, sin el nombre o si queremos que tenga la
opción de escribir título, nombre y apellido debemos crear una función de forma que tenga 4 parámetros:

1. el título;

2. el nombre;

3. el apellido;

4. un booleano que nos indique si queremos un cartelito corto con sólo título y apellido, o uno largo, es decir nos de
a elegir entre una alternativa o la otra alternativa, o sea una condición.

Para ello lo hacemos de la siguiente forma:

function escribirCartelito(titulo, nombre, apellido, quiereCorto){

if(quiereCorto){

return titulo + " " + apellido;

} else {

return titulo + " " + nombre + " " +apellido;

En donde podemos ver que quiereCorto es la condición booleana que nos va a determinar si se retorna la 1°
expresión cuando ponemos true, o si se retorna la 2° expresión cuando ponemos false. Si llamamos a la función
quedaría:

escribirCartelito("Lic.","Tomás","Peralta",true)

"Lic. Peralta" // con true aclaramos que si quiere cartelito corto, damos ok a la condición establecida

escribirCartelito("Lic.","Tomás","Peralta",false)

"Lic. Tomás Peralta" // con false aclaramos que no queremos cartelito corto, si no largo.

Mas problemas con Strings, por ejemplo: Hay veces en las que tenemos difíciles decisiones que tomar en nuestras
vidas (cuando nos preguntamos, si comer pizzas o empanadas), y no tenemos más remedio que dejarlas libradas a la
suerte. Es allí que tomamos una moneda y decimos: si sale cara, comemos pizzas, si no, empanadas.
function decisionConMoneda(moneda, comida1, comida2){

if ( moneda === "cara" ){

return comida1 ;

} else if (moneda === “ceca”) {

return comida2 ;

Ahora cuando llamamos a la función sale:

decisionConMoneda("cara","pizzas","empanadas")

"pizzas"

decisionConMoneda("ceca","pizzas","empanadas")

"empanadas"

Es importante aclarar que cuando en las condiciones declaramos una expresión literal o argumento, como en este
ejemplo ( moneda === "cara" ) o (moneda === “ceca”), si escribimos otro nombre la función va a dar error
undefined, por ejemplo:

decisionConMoneda("asado","pizzas","empanadas")

error undefined

En este ejemplo da error undefined porque la palabra asado no esta definida en la función literalmente. Solo están
definidas las palabras cara y ceca.

COMO RETORNAR BOOLEANOS DE FORMA PRACTICA

En el ejemplo anterior usamos la lógica booleana para retornar un String en concreto, o sea combinamos ambos
operadores para que nos retorne un “texto” deseado, ¿y como hacemos si queremos que nos retorne un valor
booleano o sea un valor false/true?

Ahora que ya vimos cómo escribir la alternativa condicional, es momento de un pequeño recordatorio: si usás
adecuadamente las expresiones booleanas, ¡no es necesario utilizar esta estructura de control!

Supongamos que queremos desarrollar una función esMayorDeEdad, que nos diga si alguien tiene 18 años o más.
Una tentación es escribir lo siguiente:

function esMayorDeEdad(edad) {

if(edad >= 18) {

return true ;

} else {

return false;

}
 Si interpretamos la estructura de códigos podemos ver que se lee; Si edad es mayor o igual que 18, retornar true,
pero si no, retornar false. Y estaría bien hecha, pero este if … else es totalmente innecesario, dado que la expresión
edad >= 18 ya utiliza un operador de comparación >= que nos da un valor booleano; es decir que si escribimos:

function esMayorDeEdad(edad) {

return edad >= 18 ;

Cuando llamamos a la función, nos da;

esMayorDeEdad(21)

true

esMayorDeEdad(15)

false

Porque como ya vimos antes, cuando presentamos cierta comparación, el operador lo que hace es calcular
automáticamente un valor booleano, y si no recibe otra directiva o acción especifica, va a retornar solamente ese
valor. Pero veamos más ejemplos:

function esNumeroDeLaSuerte(num1) {

return(num1 > 0) && (num1 < 100) && ( num1 !== 15);

Nuevamente si leemos el código va a decir;

Retornar como true si el parametro( num1) es un numero mayor a 0 Y si es un numero menor que 100 Y

NO ES IGUAL (!==) que el numero 15.

Entonces si llamamos a la función; va darnos:

esNumeroDeLaSuerte( 20 )

true

esNumeroDeLaSuerte( 15 )

false

¿Porque el numero 15 da false y 20 true? Porque utilizamos una estructura de códigos utilizando el operador lógico
&& y los operadores de comparación (<, >, !== ), este último operador ( !== )calcula si dos valores son distintos y nos
retorna un valor true cuando son distintos y da un valor false cuando son iguales, nuevamente leamos el código para
poder entender mejor;

return(num1 > 0) && (num1 < 100) && ( num1 !== 15);

Retornar como verdadero (recuerda que para que sea un valor true con un operador lógico && todos los valores que
se calculan tienen que dar verdadero) si el parámetro (num1) es mayor a cero Y es menor que 100 Y no es igual que
el número 15.

El numero 20 cumple con todos los requisitos para que de verdadero, porque 20 es mayor que 0, y es menor que
100 y no es el 15.
 Pero el 15 da falso, porque aunque 15 sea mayor que 0 y menor que 100; NO ES DIFERENTE QUE 15 , si no que son
iguales y por este valor falso, en la estructura de códigos de un operador lógico && un valor falso nos va a dar false.

Mas ejemplos serian; supongamos que queremos saber si la tecla central de un piano está cerca de estar afinado.
Esto ocurre cuando está entre 437Hz y 443Hz, pero NO es exactamente 440Hz.

function estaCerca(frecuencia) {

return frecuencia >= 437 && frecuencia <= 443 && frecuencia !== 440

Nuevamente podemos ver que tenemos 3 condiciones que deben cumplirse para que de true. Si alguna no se
cumple da false, por eso si llamamos a la función tendriamos;

estaCerca(443)

true // está en el rango 437-443

estaCerca(442)

true // ídem caso anterior

estaCerca(440)

false //está en el rango, pero es exactamente 440

estaCerca(430)

false //está fuera del rango

Como acabamos de ver, en JavaScript existen números, booleanos y strings:

Tipo de dato Representa Ejemplo Operaciones

Números cantidades 4 9 47 +, -, *, %, <, etc

Boolean valores de verdad true, false ||, &&,!, etc

Strings texto "hola" longitud, comienzaCon, etc

Además, existen operaciones que sirven para todos los tipos de datos, por ejemplo:

=== : nos dice si dos cosas son iguales (es igual)

!== : nos dice si dos cosas son diferentes (no es igual)

Por ejemplo si queremos que nos retorne un valor booleano true/false en el siguiente problema:

 Cuando presionamos una tecla de un piano, éste produce un sonido que tiene una cierta frecuencia. Y
cuando presionamos la central del piano, si está afinado, vamos a escuchar una nota cuya frecuencia es
440Hz.
function estaAfinado(frecuencia) {

return frecuencia === 440;

Si llamamos a la función nos daría:

estaAfinado(440)

true

estaAfinado(500)

false

Es importante usar las operaciones correctas con los tipos de datos correctos, por ejemplo, no tiene sentido sumar
dos booleanos o hacer operaciones booleanas con los números. Si usas operaciones que no corresponden, cosas
muy raras y malas pueden pasar. Por ejemplo;

5+6 (está bien, los números se pueden sumar)

5 === 6 (está bien, todas las cosas se pueden comparar)

8>6 (está bien , los números se pueden ordenar)

! true (está bien, los booleanos se pueden negar)

false / true (no está bien, ¡los booleanos no se pueden dividir!)

Veamos mas ejemplos de operaciones con numero; supongamos que queremos comprar una computadora nueva, y
nos gustaría saber cuánto nos va a salir. Sabemos que:

_ Los monitores cuestan $60 por cada pulgada

_ La memoria cuesta $200 por cada GB

_ El precio base estimado del resto de los componentes es de $1000

La expresión aritmética es la siguiente;

function cuantoCuesta(pulgada, memoria) {

return ( pulgada * 60 ) + ( memoria * 200) + 1000 ;

Entonces si llamamos a la función no daría:

cuantoCuesta(25, 8)

4100
 También podemos invocar la función que creamos con su expresión aritmética y crear una nueva función para
calcular si conviene comprar o no la computadora, es decir; en caso que queremos saber si una computadora me
conviene teniendo en cuenta las siguientes CONDICIONES. Esto ocurre cuando:

_ Sale menos de $6000, y

_ tiene al menos un monitor de 32 pulgadas, y

_ tiene al menos 8GB de memoria

function meConviene(pulgadas, memoria) {

return cuantoCuesta(pulgadas,memoria) <= 6000 && pulgadas >= 32 && memoria >= 8;

} # 1° CONDICION # Y #2° CONDICION# Y #3° CONDICION#

Como ya habíamos visto para que de un valor true todas las condiciones tienen que ser verdaderas; y si una
condición da false el valor va a ser false, por eso si llamamos a la función podemos ver;

meConviene(25, 8)

false // porque el monitor es demasiado chico( una condición false da false)

meConviene(42, 12)

true // cumple las tres condiciones

Pero ¿porque podemos usar un mismo parámetro para todas las cuentas?

Esto se debe a que las funciones encapsulan expresiones y si prestamos atención a la función
cuantoCuesta(pulgada,memoria) encapsula estos valores con una expresion para dar un resultado o valor que va a
ser usado como un valor más con los demás valores; veamos:

cuantoCuesta(pulgadas,memoria) <= 6000 && pulgadas >= 32 && memoria >= 8;

#Esta función encapsula una expresión #se compara con #se usa el mismo parámetro #se usa el otro
q que nos va a dar un valor x # este valor# para comparar estos valores# parámetro para

estos valores#

El resultado de todas las comparaciones individuales se vuelven a comparar con el operador lógico && si todas son
verdaderas da true, si uno es falso da false.

En definitiva, cuando usamos una función dentro de otra función, los datos o valores de entrada(parámetros)
pueden ser reutilizados por la expresión de esa función porque esos datos son usados en un calculo diferente dentro
de una expresión diferente que va a retornar( recordemos que cada función tiene un return) un valor x, que va a ser
utilizado como un valor o dato individual dentro de la otra función.

¿Y los procedimientos?

Cuando vimos el método console.log, construimos una function llamada versosMartinFierro() que se ejecutaba con
el sólo fin de imprimir(console.log) por pantalla. Y por ello, tuvimos que devolver un valor cualquiera. ¿No te huele
mal?

Además, hagamos memoria: cuando queremos reutilizar código, podíamos declarar:

Funciones: siempre retornan algo y no producen ningún efecto.

Procedimientos: que no retornan nada, y producen efectos o realizan acciones.

Entonces versosMartinFierro(), no es una función... ¡sino un procedimiento! ¿Cómo se declaran procedimientos en

JavaScript?

¡De la misma forma que las funciones!: usando la palabra clave function.

Por ejemplo:

function(procedure) versosMartinFierro() {

console.log("Aquí me pongo a cantar");

console.log("Al compás de la vigüela;");

console.log("Que el hombre que lo desvela");

console.log("Una pena extraordinaria");

#IMPORTANTE# Aclaramos que console.log es un método que muestra o “imprime” un mensaje en la consola,
recibe como argumento uno o más objetos y que no se coloca la palabra procedure al lado de function.

Esto puede ser un poco perturbador: JavaScript no diferencia funciones de procedimientos: todos pueden tener
efectos y todos pueden o no tener retorno. Vos sos responsable de escribir una function que tenga sentido y se
comporte o bien como un procedimiento (sin retorno y con efecto) o bien como una función (con retorno y sin
efecto).

Si empezás a mezclar funciones con retornos y efecto, funcionará, pero tu código se volverá de a poco más difícil de
entender. Esto nos va a pasar mucho en JavaScript: que puedas hacer algo no significa que debas hacerlo!.

¿Y el program?

Ahora bien, más allá de que podamos consultar el resultado de una función a través de la consola, también
aprendimos anteriormente que los programas tienen un punto de entrada: el program. ¿Dónde quedó?

La respuesta es tan simple como sorprendente: en JavaScript todo lo que escribamos fuera de una function será,
implícitamente, dicho punto de entrada. Por ejemplo, si queremos un programa que imprime por pantalla el clásico

"Hola, mundo!"

, lo podremos escribir así:

console.log("Hola, mundo!");

O si queremos un programa que tire tres veces los dados e imprima sus resultados, podemos escribirlo así:

console.log ("Tirando dados");

console.log ("La primera tirada dio“ + tirarDado());

console.log ("La segunda tirada dio"+tirarDado());

console.log ("La tercera tirada dio"+tirarDado());

¿Ooooups, y el resultado? ¿Dónde está lo que imprimimos por pantalla? ¿Es que nuestro programa no anduvo?

No, para nada, es que simplemente no te estamos mostrando lo que sale por pantalla .

¿Por qué? ¿Porque somos malvados? Bueno, quizás en parte , pero tenemos además una buena razón: cuando
escribís programas reales, es muy, muy frecuente que no sea fácil ver lo que console.log imprime, por decenas de
motivos. Entonces, como rara vez vas a poder ver a tiempo lo que se imprime en la pantalla, terminan siendo una
técnica poco útil.

VARIABLES

En programación, una variable está formada por un espacio en el sistema de almacenaje(memoria principal de una
computadora) y un nombre simbólico (un identificador) que está asociado a dicho espacio. Ese espacio contiene una
cantidad de información conocida o desconocida, es decir un valor. El nombre de la variable es la forma usual de
referirse al valor almacenado: esta separación entre nombre y contenido permite que el nombre sea usado
independientemente de la información exacta que representa. El identificador, en el código fuente de la
computadora puede estar ligado a un valor durante el tiempo de ejecución y el valor de la variable puede por lo
tanto cambiar durante el curso de la ejecución del programa.

En definitiva, podemos decir que una variable es un elemento de datos con nombre cuyo valor puede cambiar
durante el curso de la ejecución de un programa. Cuando definimos una variable tenemos que tener en cuenta los
siguientes requisitos:

1_ El nombre de la variable debe seguir el convenio de denominación de un identificador (carácter alfabético o

número y el signo de subrayado) es decir, que siempre escribimos como la definimos primeramente o sea no puede
cambiar la sintaxis.

2_ Cuando se define más de una variable en una sola declaración, el nombre debe ir separado por comas(como
cuando separamos los parámetros que son variables). Cada declaración de variable debe finalizar con un signo de
punto y coma(como cuando ponemos el punto y coma en el if, if/else, etc).

3_Los nombres de variables no pueden coincidir con una palabra reservada. Por ejemplo NO le podemos poner como
nombre identificador a una variable function, program, etc.

Nota: Los identificadores y nombres en el lenguaje de script no distinguen entre mayúsculas y minúsculas. Por lo
tanto, abc es lo mismo que ABC.

En programación una variable puede ser utilizada en un proceso repetitivo: esto es que podemos asignárles un
valor en un proceso, para luego utilizarlas en otro proceso, y más adelante volver a asignarle un nuevo valor para más
tarde utilizarla de la misma manera(como hacemos con los parámetros por ejemplo). Procedimientos de este tipo
son conocidos con el nombre de iteración.

Aunque los nombres de variables y los identificadores deben ser exclusivos, resulta válido declarar una variable
local con el mismo nombre que una variable global o con el mismo nombre que una variable local definida en otra
función. Pero ojo! Las mayúsculas y minúsculas en los nombres de las variables de Javascript importan. No es lo
mismo una variable llamada precio que una variable llamada Precio, ya que pueden contener valores diferentes.

Los nombres de parámetros de una definición de función se consideran variables locales. Los datos que se pasan
a una función se pasan según el valor.

Para resumir las variables nos permiten nombrar y reutilizar valores. Similar a cómo los procedimientos y funciones
nos permiten dar nombres y reutilizar soluciones a problemas más pequeños. Por ejemplo, si hacemos...

let primerMes = "enero"

estamos asignándole el valor "enero" a la variable primerMes. En criollo, estamos dándole ese valor a la variable.
¿Qué es let?

La instrucción let es una palabra clave en JavaScript que se utiliza para declarar variables con un alcance de bloque,
esto significa que la variable solo está disponible dentro del bloque de código en el que se ha declarado y no está
disponible fuera de él, opcionalmente, puede ser inicializada (la variable) con algún valor.

let te permite declarar variables limitando su alcance (scope) al bloque, declaración, o expresión donde se está
usando. Es decir, si miramos en el ejemplo le estamos declarando a la variable primerMes el valor "enero", es decir,
la variable primerMes solamente va a valer "enero", no puede valer “febrero” ni “marzo”, etc; porque declaramos su
valor y lo establecemos como un valor fijo dentro del (scope) al bloque, que puede entenderse como el alcance que
una variable tendrá en tu código. En otras palabras, el scope decide a qué variables tienes acceso en cada parte del
código. Veamos ejemplos para entender:

let pi = 3.14159265358979;

function perimetroCirculo(radio){

return(2 * pi * radio);

Otro ejemplo de uso:

function areaCirculo(radio){

return (pi * radio * radio);

Como vemos en el ejemplo con el instructor let estamos declarándole a la variable pi el valor de
3.14159265358979; o sea que decimos que pi vale o es igual a 3.14159265358979. Y dentro del bloque de códigos la
variable va a valer solo ese valor, por lo que el scope decide a qué variables tienes acceso en cada parte del código.

En el ejemplo podemos ver que gracias a que declaramos la variable pi con un valor concreto no tuvimos que
escribir el número cada vez que teníamos que usarlo y ¡nuestro programa quedó mucho más entendible!

Ya que vas entendiendo cómo se asignan las variables, te traemos algo para pensar: ¿qué pasa si intento usar una
variable a la que nunca le asigné un valor?

Por ejemplo si tenemos esta función definida:

function sumaSinSentido() {

return numero + 8;

Si llamamos a la función:

sumaSinSentido()

ReferenceError: numero is not defined

Nos sale el error ReferenceError: numero is not defined que nos avisa que la variable numero no está declarada
dentro de la función.

Entonces, ¿es necesario darle valor a nuestras variables antes de usarlas?

¡Sí!

Cuando declarás una variable tenés que darle un valor inicial, lo cual se conoce como inicializar la variable.

¿QUE SON LAS VARIABLES GLOBALES Y LOCALES?

Las variables pueden ser globales o locales:

VARIABLES GLOBALES:

Son las variables declaradas directamente en el programa con la palabra clave let, y pueden ser utilizadas desde
cualquier function, es decir que toda variable es global a no ser que esté declarada dentro de una definición de
función. Las variables globales resultan visibles y disponibles para todas las sentencias de un script. Por ejemplo:

let pi = 3.14159265358979; # Declaramos de forma global la variable pi con un valor concreto y podemos usarla

dentro de cualquier función #

En esta función …. O en esta otra función…..

function perimetroCirculo(radio){ function areaCirculo(radio){

return(2 * pi * radio); return (pi * radio * radio);

} }

De esta forma declaramos una variable Global. Una variable global que se usa en una función puede ser
modificada por la función. Veamos mas ejemplos de variables globales:

let pesoMaximoEquipajeEnGramos = 5000 ;

Declaramos la variable en el programa y la podemos usar en la siguiente funcion o en otra…

function puedeLlevar(pesoEquipaje){

return pesoEquipaje <= pesoMaximoEquipajeEnGramos ;

O también podemos declarar varias variables de forma global y la usamos en una sola funcion…

let pesoPromedioPersonaEnKilogramos = 120

let cargaMaximaEnKilogramos = 300

function ascensorSobrecargado(cantidadPersonas){
 return pesoPromedioPersonaEnKilogramos * cantidadPersonas > cargaMaximaEnKilogramos;

VARIABLES LOCALES

Son las variables declaradas dentro de una función (por eso son locales) y sólo resultan visibles y disponibles dentro
de la función en la que están definidas. Por ejemplo si declaramos la variable elDoble dentro de la función
cuentaExtravagante:

function cuentaExtravagante(unNumero) {

let elDoble = unNumero * 2;

if (elDoble > 10) {

return elDoble;

} else {

return 0;

Tenemos que tener un particular cuidado: las variables locales sólo se pueden utilizar desde dentro de la function en
cuestión. Si quiero referenciarla desde un programa:

let elCuadruple = elDoble * 4;

Kaboom, ¡se romperá!

Es decir que cuando declaramos una variable de forma local dentro de una función, NO podemos usarla dentro de un
programa.

Sin embargo, las variables declaradas con la palabra clave let de forma global dentro de una función SI pueden
volver a ser declaradas, de otro modo las variables no serían tan interesantes si no se pudieran modificar, por
ejemplo:

let pesosEnMiBilletera = 500 # Declaramos la variable de forma global #

Creamos una función con la cual vamos a modificar la variable creada:

function aumentarFortuna() {

pesosEnMiBilletera = pesosEnMiBilletera * 2;

Consulto en la consola nuevamente la variable Global y:

pesosEnMiBilletera

1000
 Entonces primero usamos la palabra clave let, y asignamos un valor a la variable y con la función pudimos actualizar
nuestra variable para que apunte al nuevo valor como queríamos. Algunas veces en programación, necesitaremos
actualizar una variable dependiendo de ciertos datos que recibamos. Podemos usar let y la función para lograr esto.

Pero tenemos que prestar especial cuidado cuando asignamos un valor dentro de una función puesto que una
variable solo puede tener un valor, entonces cada vez que le asignamos uno nuevo dentro de una funcion,
perdemos el anterior. Miremos el siguiente ejemplo para entender mejor:

function cuentaExtravagante() { function cuentaExtravagante() {

let numero = 8; let numero = 8;

numero *= 2; 8 *= 2;

numero += 4; 16 += 4;

return numero; return 20;

Aca podemos ver que numero = 20 porque numero va adquiriendo un nuevo valor que es el resultado del valor de la
ecuación anterior, por eso cada ecuación es separada con un punto y coma que indica el final de la ecuación
matemática. Si desplegamos el código lo veremos con más claridad:

let numero = 8 ; numero *= 2 ; numero += 4 ; return 20;

Aca declaramos Aca decimos que numero Aca decimos que numero Aca solo pedimos

que numero vale 8 # es el resultado de la # vale 20 porque adopta el # que se retorne el

multiplicación de 8 * 2=16 valor de la ecuación anterior valor de numero,

y suma 4, o sea 16+4= 20 o sea 20.

Actualizaciones como duplicar, triplicar, incrementar en uno o en una cierta cantidad son tan comunes que JavaScript
presenta algunos atajos:

x += y; //equivalente a x = x + y;

x *= y; //equivalente a x = x * y;

x -= y; //equivalente a x = x - y;

x++; //equivalente a x = x + 1;

Si prestamos atención las variables se asignan mediante el signo igual(=) :

pesosEnMiBilletera = 65;

diasQueFaltanParaElVerano = 7;

En ocasiones las asignaremos un nuevo valor usando el valor anterior:

pesosEnMiBilletera = pesosEnMiBilletera * 2;

diasQueFaltanParaElVerano = diasQueFaltanParaElVerano - 1;

La asignación anterior se puede compactar combinando el signo (=) y la operación:

pesosEnMiBilletera *= 2;

diasQueFaltanParaElVerano -= 1;

Las variables también pueden ser de longitud:

Fija.- Cuando el tamaño de la misma no variará a lo largo de la ejecución del programa. Todas las variables, sean del
tipo de dato que sean tienen longitud fija, salvo algunas excepciones —como las colecciones de otras variables
(arrays) o las cadenas(Strings).

Variable.- Cuando el tamaño de la misma puede variar a lo largo de la ejecución. Típicamente colecciones de datos
en su mayoría

TIPOS DE DATOS DE VARIABLES

Debido a que las variables contienen o apuntan a valores de tipos determinados, las operaciones sobre las mismas
y el dominio de sus propios valores están determinadas por el tipo de datos en cuestión. Algunos tipos de datos
usados:

1_Tipo de dato lógico o valores Booleanos (verdadero/1 o falso/0).

2_Tipo de dato entero (números reales , sin decimales).

3_Tipo de dato de coma flotante (números reales, con decimales).

4_Tipo de dato carácter (> , < , ¡ , etc).

5_Tipo de dato cadena(cadena de textos o “Strings”).

LOGICA BOOLEANA CON VARIABLES

Siguiendo con las variables, también podemos combinarlas con los operadores logicos, recordemos cuales eran:

Hay tres tipos de operadores lógicos: conjunción &&, que es verdadero si todas sus proposiciones son verdaderas;
disyunción ||, que es verdadero si alguna de sus proposiciones es verdadera; y ! negación, not o complemento lógico
y sirve para negar un valor booleano. Por ejemplo si tengo el booleano representado por tieneHambre, el
complemento será !tieneHambre

¿Y esto para qué sirve? Por ejemplo, para modelar casos de alternancia como prender y apagar una luz:

let lamparaPrendida = true;

function apretarInterruptor() {

lamparaPrendida = !lamparaPrendida;

Si llamamos a la variable dentro de la consola podemos ver su modificacion:

lamparaPrendida

true

apretarInterruptor()

lamparaPrendida

false

Otro ejemplo, puede ser:

let mochilaAbierta = true;

function usarCierre() {

mochilaAbierta = !mochilaAbierta;

Si lo probamos en la consola confirmaremos como la funcion usarCierre() cambia el valor de la variable

mochilaAbierta

mochilaAbierta

=> true

usarCierre()

mochilaAbierta

=> false

usarCierre()

mochilaAbierta

=> true

Pero con el operador de ! negación no solo podemos negar el valor de una variable, también nos puede servir para
reutilizar la lógica de una función que ya tenemos definida.

Por ejemplo, si contamos con una función esPar, basta con negarla para saber si un número es impar.

function esImpar(numero) {

return !esPar(numero);

}
Mas ejemplos:

function esMayorDeEdad(edad) {

return edad >= 18;

function esMenorDeEdad(edad) {

return !esMayorDeEdad(edad);

Cada una de las funciones representa un estado de dos posibles: ser mayor o ser menor de edad. No se puede ser
ambos al mismo tiempo y tampoco se puede evitar pertenecer a alguno de los dos grupos. Es decir, ¡siempre sos uno
u otro! Por eso decimos que son complementarios y que juntos forman el conjunto universal.

Con esto también podemos resolver problemas mas complejos, por ejemplo supongamos que necesitamos hacer
algunos trámites en el banco, pero como es feriado está cerrado. Para evitar que vayamos de manera errada, vamos
a definir una función que nos ayude a ir al banco a la hora y día correcto .

Sabemos que el banco está cerrado cuando:

 Es feriado, o
 Es fin de semana, o
 No estamos dentro del horario bancario( de 10 a 15 hs)

Primero resolvemos el problema en subtareas, por lo tanto hacemos la siguiente función y resolvemos el problema
del horario bancario:

function dentroDeHorarioBancario(horario) {

return horario >= 10 && horario <= 15;

} # Aca podemos leer que el horario es mayor o igual que 10 y el horario es menor o igual que 15 #

Definimos la segunda función para resolver el problema de los fines de semanas:

function esFinDeSemana(dia) {

return dia === "sábado" || dia === "domingo";

} # Aca podemos leer que es fin de semana es dia igual a sábado O dia igual a domingo #

Con la tercera función resolvemos el problema de avisarnos que el banco esta cerrado:

function estaCerrado(esFeriado, dia, horario) {

return esFeriado || esFinDeSemana(dia) || !dentroDeHorarioBancario(horario);

}
Si llamamos a la función en la consola podemos ver:

estaCerrado(false, "sábado", 10)

true //Porque es fin de semana

estaCerrado(true, "lunes", 10)

true //Porque es feriado

estaCerrado(false, "martes", 20)

true //Porque no está dentro del horario bancario

estaCerrado(false, "jueves", 11)

false // Se puede ir al banco porque no es feriado(false), no es fin de semana( es jueves) y

esta dentro del horario bancario

Si queremos definir la función tieneContraste que recibe como argumentos el color de la letra y el color del fondo
de la página y retorna si la página tiene contraste.

Para empezar ya contamos con la función esTonoClaro que toma un color por parámetro y retorna si es claro.

Que nos indica si:

esTonoClaro("rojo")

false

esTonoClaro("blanco")

true

Entonces usando esa función podemos declarar la siguiente función:

function tieneContraste(letra,fondo){

return esTonoClaro(fondo) !== esTonoClaro(letra) || esTonoClaro(letra) !== esTonoClaro(fondo)

Ahora pensemos cómo sería la tabla de verdad que representa el comportamiento de la función que acabás de hacer.
La proposición es esTonoClaro, y el valor de verdad que porte dependerá de cada color que esté evaluando. El
booleano final resultará de operar estos colores mediante tieneContraste:
la letra tiene tono claro el fondo tiene tono claro tiene contraste

true || true false

true || false true

false || true true

false || false false

Ahora si probamos la funcion tieneConstraste en la consola podemos ver;

tieneContraste("amarillo", "beige")

false

tieneContraste("azul", "violeta")

false

tieneContraste("blanco", "negro")

true

Ahora cambiemos las proposiciones la letra tiene tono claro y el fondo tiene tonoclaro por proposiciones

genéricas A y B. Además, representemos la operación que realiza tiene contraste con el símbolo ⊻. Lo que
obtenemos es... ¡una nueva tabla!

A B A ⊻B

V V F

V F V

F V V

F F F

Este comportamiento existe como un operador dentro de la lógica y se lo denomina xor o disyunción lógica
excluyente. A diferencia del and, or y not, el xor no suele estar definido en los lenguajes. Sin embargo, ahora que
sabés cómo funciona, si alguna vez lo necesitás podés definirlo a mano.

Hagamos una función xor para entender el concepto mejor:

function xor (A, B) {

return (A &&!B) || (B && !A)

PRECEDENCIA DE OPERADORES

La precedencia de operadores determina el orden en el cual los operadores son evaluados uno respecto del otro.
Los operadores con mayor precedencia se convierten en los operandos de los operadores con menor precedencia.
Esto es que cuando una expresión matemática tiene varios operadores, sabemos que las multiplicaciones y divisiones
se efectuarán antes que las sumas y las restas; por ejemplo :
5 * 3 + 8 / 4 – 3 = 14

(15) + (2) – 3 = 14

Entonces vemos en el ejemplo que las multiplicaciones y las divisiones se realizaron como una ecuación individual y
después se sumo y resto el resultado, a este orden determinado se la denomina precedencia.

En programación ocurre lo mismo con los operadores con los operadores lógicos, veamos la siguiente función:

function pagaConTarjeta(seCobraInteres, tarjeta, efectivoDisponible) {

return !seCobraInteres && cuotas(tarjeta) >= 3 || efectivoDisponible < 100;

pagaConTarjeta(true, "crédito", 320)

false

Analicemos este concepto en profundidad, tenemos:

pagaConTarjeta(true, "crédito", 320)

return !seCobraInteres && cuotas(tarjeta) >= 3 || efectivoDisponible < 100;

false

false && true || =

false || false = false

pagaConTarjeta(false, "crédito", 80)

return !seCobraInteres && cuotas(tarjeta) >= 3 || efectivoDisponible < 100;

true

true && true =

true || true = true

pagaConTarjeta(true, "debito", 215)

return !seCobraInteres && cuotas(tarjeta) >= 3 || efectivoDisponible < 100;

false

false && false =

false || false = false

pagaConTarjeta(true, "debito", 32)

return !seCobraInteres && cuotas(tarjeta) >= 3 || efectivoDisponible < 100;

false

false && false =

false || true = true

TABLA DE VERDAD

Operandos AND(&&) OR( || )

V V V V

V F F V

F V F V

F F F F

Si prestaste atención a la función anterior, habrás notado que la operación con mayor precedencia es la negación!,
por lo que se resuelve primero, seguida de la conjunción && y por último la disyunción ||.¿Pero qué pasa si quiero
alterar el orden en que se resuelven?

Al igual que en matemática, podemos usar paréntesis para agrupar las operaciones que queremos que se realicen
primero. Veamos el siguiente problema:

Delfi se puede concentrar cuando programa y toma infusiones, pero no cualquier infusión. Tiene que ser mate a
exactamente 80ºC o té que esté a por lo menos 95ºC.

function sePuedeConcentrar(infusion, temperatura, programa) {

return (( infusion === "mate" && temperatura === 80) || ( infusion === "té" && temperatura >= 95)) &&

estaProgramando;

¿Y si delegamos? Podríamos separar la lógica de la siguiente manera:

function infusionATemperaturaCorrecta(infusion, temperatura) {

return (( infusion === "mate" && temperatura === 80) || ( infusion === "té" && temperatura >= 95));

# Despues podemos usar la función que creamos y resolver la otra función:

function sePuedeConcentrar(infusion, temperatura, estaProgramando) {

return infusionATemperaturaCorrecta(infusion, temperatura) && estaProgramando;

}
 Veamos otro ejemplo de problema para entender mejor;

En un parque de diversiones de la ciudad instalaron una nueva montaña rusa y nos pidieron ayuda para que le
digamos a las personas si pueden subirse o no antes de hacer la fila. Los requisitos para subir a la atracción son:

1_Alcanzar la altura mínima de 1.5m (o 1.2m si está acompañada por una persona adulta).

2_No tener ninguna afección cardíaca.

function puedeSubirse(altura, compania, afeccion) {

return ( altura >= 1.5 || ( altura >= 1.2 && compañía )) && !afeccion ;

Si llamamos a la función en la consola;

puedeSubirse(1.7, false, true)

false // no puede subirse

// porque aunque tiene mas de 1.5m,

// tiene una afección cardíaca

¿QUE ES UN ARRAY EN PROGRAMACION?

Dentro de la informática y de la programación, nos encontramos con diferentes conceptos más técnicos que es
normal que si no somos programadores web, no estemos habituados a utilizarlos. Uno de ellos, es array, que es, por
resumirlo muy mucho, un tipo de dato estructurado o un conjunto de elementos.

Sabemos que es un concepto técnico y que igual, como usuario de a pie puede que no te interese. Pero te contamos
qué significa…¡por si las moscas!

El array, dentro de la programación, se refiere a un tipo de dato estructurado que almacena datos, del mismo tipo y
relacionados. Los elementos que conforman pueden ser de tipo simple o compuesto, como en el caso de vectores o
listas. Los datos que almacena el array son conocidos como elementos y, al número de estos elementos que hay
dentro del array, se les denomina rango del vector o tamaño. Asimismo, para acceder a ellos, se utiliza un índice. Es
decir, un número que indica la posición del elemento concreto ubicado en el array.

¿Para qué se utiliza a la hora de programar?... Dentro de la programación este tipo de dato nos permite guardar
datos para luego acceder a ellos.

¿QUE SON LAS LISTAS?

En programación, las listas son los arrays que son las estructuras de datos que nos permiten almacenar la
información de manera ordenada. Ayudan a organizar adecuadamente los datos para resolver problemas más
complejos o para hacerlo de una manera más eficiente.

Estructuras de datos: Listas

Las listas, como otras estructuras en programación, también nos permiten almacenar múltiples datos. Es el caso de
variables como ENTRADA y SALIDA, que son -y siempre han sido- ¡listas! A partir de ahora las listas pasan a estar
disponibles, como una estructura más, dentro del laboratorio.
 Normalmente una lista podría crecer en tamaño dinámicamente, pero, debido a que nuestro laboratorio tiene un
espacio muy limitado, hemos mantenido su tamaño fijo. No obstante, las listas del laboratorio siguen siendo muy
útiles para almacenar y procesar datos fácilmente, gracias a sus comandos especiales: sacar y poner.

Supongamos que queremos representar al conjunto de nuestras series favoritas. ¿Cómo podríamos hacerlo?

Fácil, usamos la palabra clave let para declarar una variable que contenga los Elementos, de la siguiente manera:

let seriesFavoritasDeAna = ["Game of Thrones","Breaking Bad","House of Cards"];

#elemento 0# , #elemento 1# , #elemento 2#

let seriesFavoritasDeHector = ["En Terapia","Recordando el Show de Alejandro Molina"]

#elemento 0# , #elemento 1#

Como ves, para representar a un conjunto de strings, colocamos todos esos strings que nos interesan, entre
corchetes ( [ y ] ) separados por comas. Lo que acabamos de ver es cómo modelar fácilmente conjuntos de cosas.
Mediante el uso de corchetes ( [ ] ), en JavaScript contamos con una manera simple de agrupar esos elementos en
listas.

¿Acaso hay una cantidad máxima de elementos? ¡No, no hay límite! Las listas pueden tener cualquier cantidad de
elementos. Y no sólo eso, sino que además, el orden es importante. Por ejemplo, no es lo mismo

["hola","mundo"]

que

["mundo", "hola"]

Ambos tienen los mismos elementos, pero en posiciones diferentes.

listasIguales(["hola", "mundo"], ["mundo", "hola"])

false

listasIguales(["hola", "mundo"], ["hola", "mundo"])

true

Pero, ¿sólo podemos crear listas de strings? ¿Y si quiero, por ejemplo, representar los números de la lotería que
salieron la semana pasada? ¿O las tiradas sucesivas de un dado? ¿O si salió cara o ceca en tiradas sucesivas de una
moneda?

Creamos las variables con la palabra clave let y colocamos los números o booleanos;

let numerosDeLoteria = [2, 11, 17, 32, 36, 39];

let tiradasDelDado = [1, 6, 6, 2, 2, 4];

let salioCara = [false, false, true, false];

Como ves, también podemos representar conjuntos de números o booleanos, de igual forma: escribiéndolos entre
corchetes y separados por comas. Podemos tener listas de números, de strings, de booleanos, etc. ¡Incluso
podríamos tener listas de listas! Y no sólo eso, sino que además pueden contener cualquier cantidad de elementos:
uno, dos, quince, cientos.

¿Podremos entonces tener listas vacías, es decir, que no tengan elementos? ¡Por supuesto!
 Declaramos la variable en el programa de forma global y lo probamos en la consola:

let unaListaVacia = []

en la consola:

unaListaVacia

[]

Por el momento ya sabemos qué cosas podemos representar con listas, y cómo hacerlo. Pero,¿qué podemos hacer
con ellas?

Empecemos por lo fácil: saber cuántos elementos hay en la lista. Esto lo podemos hacer utilizando el método o
función length, de forma similar a lo que hacíamos con los strings.

Si realizamos las siguientes consultas en la consola:

length([])

=> 0

length(numerosDeLoteria)

=> 6

length([4, 3])

=> 2

Las listas son muy útiles para contener múltiples elementos. ¡Pero hay más! También podemos agregarle elementos
en cualquier momento, utilizando el método o función push, que inserta un Elemento al final de una Lista. Este es un
procedimiento que no devuelve nada pero modifica a una Lista, por ejemplo:

// Declaramos la array con la palabra clave let y creamos la lista

let cancionesFavoritas = ["La colina de la vida","Zamba por vos"]

// agregamos el elemento "Seminare" a la lista cancionesFavoritas con el método push asi:

push(cancionesFavoritas,"Seminare")

// ahora miramos la lista en la consola y vemos que tiene un elemento más.

cancionesFavoritas

["La colina de la vida","Zamba por vos","Seminare"]

Otro ejemplo de agregar un elemento a una lista:

length(pertenencias)

3 // el método length devuelve el numero 3 de la variable pertenencias; que son

[ "espada","escudo","antorcha"];
push(pertenencias,"ballesta");

//ahora el metodo push inserta un elemento más a la variable pertenencias por lo que si consultamos de nuevo la
variable en la consola podremos ver.

pertenencias

=> ["espada","escudo","antorcha","ballesta"]

Además, tenemos el método remove de JavaScript que elimina un nodo del DOM por completo. Esto quiere decir
que ya no aparecerá como un elemento del DOM una vez eliminado, por lo que no se verá en el navegador.

Creamos la variable listaDeCompras con la lista que queramos con la palabra clave let

let listaDeCompras = ["leche","pan","arroz","aceite","yerba"]

// removemos "pan” con el método remove

remove(listaDeCompras,”pan")

// "pan" ya no está en lista de compras

listaDeCompras

["leche","arroz","aceite","yerba"]

Ahora que conocemos los métodos push y remove podemos crear un procedimiento que traslade elementos de una
lista y la colocamos en otra lista; para esto hacemos lo siguiente:

let Lista1 = [ 1 , 2 , 3 ];

let Lista2 = [ 4 , 5 ];

No olvidemos que tenemos:

push(lista, elemento): agrega elemento al final de lista.

remove(lista, elemento): saca elemento de lista.

Para crear el procedimiento hacemos lo siguiente(recordemos que para definir un procedimiento en JavaScript lo
hacemos usando la palabra reservada function):

function trasladar(Lista1, Lista2, elemento) {

push(Lista2, elemento); remove(Lista1, elemento);

}
Si llamamos a las listas en el teclado nos daría:

Lista1

[1, 2, 3]

Lista2

[4, 5]

trasladar(Lista1, Lista2, 2);

Lista1

[1, 3]

Lista2

[4, 5, 2]

Hasta ahora anduvimos agregando, quitando y consultando longitudes. ¿Qué más podemos hacer con las listas?

¿QUE ES EL INDEXOF?

Otra cosa que podemos hacer con las listas es saber en qué posición se encuentra un elemento. Para ello utilizamos
el método indexOf() que retorna el primer índice en el que se puede encontrar un elemento dado en el array, ó
retorna -1 si el elemento no está presente, es decir; nos dice en qué posición se encuentra un Elemento dentro de
una Lista. Si el elemento no está en la lista, devuelve -1 y siempre va a contar desde la posición 0 en adelante, para
entender esto veamos ejemplos:

indexOf (["a", "la", "grande", "le", "puse", "cuca"], "grande");

// posición 0, 1, 2, 3, 4, 5

let diasLaborales = ["lunes", "martes", "miercoles", "jueves", "viernes"]

indexOf(diasLaborales, "lunes")

Como ves, lo curioso de esta función es que pareciera devolver siempre uno menos de lo esperado. Por ejemplo, la
palabra "grande" aparece tercera, no segunda; y "lunes" es el primer día laboral, no el cero. ¿Es que los creadores de
JavaScript se equivocaron?

¡No! Se trata de que en JavaScript, al igual que en muchos lenguajes, las posiciones de las listas arrancan en 0: el
primer elemento está en la posición 0, el segundo en la 1, el tercero en la 2, y así.

Si buscamos un elemento que no está en la lista, indexof() nos retornara -1, veamos:

indexof(diasLaborales, "osvaldo")

=> -1

Si definimos una función que nos diga si una lista tiene elementos o no; lo podemos hacer de la siguiente forma:

function contiene(lista, elemento){

return indexof(lista, elemento) !==(-1)

}
Si llamamos a la función en la consola podemos ver:

contiene([1, 6, 7, 6], 7)

true

contiene([1, 6, 7, 6], 6)

true

contiene([], 7)

false

contiene([8, 5], 7)

false

Así como existe una función para averiguar en qué posición está un elemento, también puede ocurrir que queramos
saber lo contrario: qué elemento está en una cierta posición.

Para averiguarlo podemos usar el operador de indexación, el operador de indexación son los corchetes y lo
escribimos después de la colección y entre corchetes [] la posición que queremos para averiguar de la siguiente
manera:

Supongamos que tenemos la siguiente lista:

let mesesDelAnio = [“enero”,”febrero”,”marzo”,”abril”]

Si buscamos en la consola que elemento está en la posición [0], nos va a dar:

mesesDelAnio[ 0 ]

"enero"

Porque la posición de los elementos de una lista arranca de 0, ahora si le decimos que elemento está en la posición 3,
lo podemos hacer de la siguiente forma:

mesesDelAnio[ 3 ]

“abril”

La búsqueda la podemos hacer tanto con el nombre de la lista, como con la lista en si:

["ese","perro","tiene","la","cola","peluda"] [1]

"perro"

El número que le pases, formalmente llamado índice, debe ser menor a la longitud de la lista, de otro modo si le
pedimos un elemento que está en una posición igual o mayor al tamaño de la lista, vas a obtener undefined.

No parece algo terrible, pero el problema es que con undefined no podemos hacer nada realmente útil. Así que la
advertencia es: ¡no te pases de índice!

["ese","perro","tiene","la","cola","peluda"][6]

Undefined
Recuerda que las listas comienzan a contar de la posición 0.

Ahora bien sabiendo que las listas pueden ser creadas con la palabra clave let, podemos usarlas dentro de cualquier
función que queramos, lo hacemos de la siguiente forma:

// Primero creamos la variable con una la lista especifica, puede ser de forma global( en el programa) o de forma
local(dentro de la misma función)

let listaMedallas = ["oro", "plata", "bronce"];

//Después declaramos la función de la siguiente forma y definimos la lista dentro de la función.

function medallaSegunPuesto(puesto){

if (puesto >= 1 && puesto <= 3){

return listaMedallas[puesto - 1]

}else {

return "nada";

¿Por qué ponemos listaMedallas[puesto - 1]?

Porque recordemos que la lista empieza a contar desde la posición 0, cuando definimos la lista tenemos las
siguientes posiciones:

let listaMedallas = ["oro", "plata", "bronce"];

// posición = 0, 1, 2

Tenemos que restar una posición, o sea – 1 (posición) colocando listaMedallas[puesto - 1] y obtendremos:

listaMedallas[puesto - 1] = ["oro", "plata", "bronce"];

puesto = 1 ; 1 – 1 = 0

puesto = 2 ; 2 – 1 = 1

puesto = 3 ; 3 – 1 = 2

Y al declarar la condición de la función como :

if (puesto >= 1 && puesto <= 3)

Estamos declarando que Si el puesto es mayor o igual a 1 Y el puesto es menor o igual a 3, entonces el operador se
va a manejar entre esas posiciones solamente, el 1, 2 y 3, porque los tres valores cumplen con la directiva de
posición, es decir que 1, 2 y 3 van a dar un valor true( recordemos que tenemos el operador lógico && y que da true
cuando todos dan true) porque 1, 2 y 3 son mayores o iguales con la posición que buscamos.
¿QUE ES LA ITERACION?

En programación, Iteración es la repetición de un segmento de código dentro de un programa de computadora.

Puede usarse tanto como un término genérico (como sinónimo de repetición) como para describir una forma
específica de repetición con un estado mutable, por ejemplo el repeat() que nos permite iterar un ciclo las veces que
queramos. Le decimos ciclo a la estructura de códigos que van dentro del repeat, en el solo ponemos una instrucción
especifica(un ciclo) por ejemplo Poner(Rojo) Mover(Norte) y en la condición del repeat (lo que va dentro de los
paréntesis) la cantidad de vueltas o iteraciones que deseemos, por ejemplo ser 5 veces. Entonces el comando
repeat(5) va a repetir o iterar 5 veces el mismo ciclo de Poner(Rojo) Mover(Norte), cuando termina el primer ciclo,
vuelve a empezar del comienzo y repite el ciclo nuevamente hasta completar las 5 veces. Lo hace en forma de bucle.

¿QUE ES EL BUCLE FOR?

La instrucción for nos permite repetir una instrucción o una instrucción compuesta un número especificado de
veces. Es decir que como con la instrucción repeat() el for nos permite reejecutar esas instrucciones las veces que
queramos. El cuerpo de una instrucción for se ejecuta cero o más veces hasta que una condición opcional sea false.

El bucle for es un ciclo exacto, esto significa que nos permite configurarlo de manera tal que realice la cantidad de
iteraciones o repeticiones que nosotros le digamos.

Importante el ciclo exacto siempre se rige de una variable, es decir que siempre colocamos una variable que va a
mandar los valores que van a ser utilizados dentro del ciclo. La sintaxis de for es la siguiente:

for( inicialización de la variable; condición que le ponemos a la variable; incremento de la variable) {

// Acá van las instrucciones de códigos y lo que este acá dentro de las llaves { } va a ser 1 ciclo que for va a
r repetir o iterar las veces que le digamos.

Este es un ejemplo para que se entienda donde va ubicado cada variable de control; no se tipea la palabra
inicialización; condición ; incremento:

for( inicialización ; condición ; incremento ) {

// instrucciones del código por ejemplo:

Console.log( “String” )

Pasos para configurar el bucle for

Primero:

Inicialización de la variable: cuando usamos el bucle for lo primero que hacemos es inicializar una variable, esta
variable puede ser declarada dentro del for( de forma local) o también podemos usar una variable ya declarada fuera
del for( de forma global). Después especificamos el valor de la variable para tomarlo de punto de referencia dentro
del inicio del bucle con la letra ( i ), esta i representa la palabra iterador NO inicio, y se conoce como la variable de
control.

Es decir, le indicamos a for el punto de partida señalando el comienzo de la variable x y que comience a trabajar
desde esta variable. Esta inicialización va a ser determinada una sola vez, y después esta variable va a ir cambiando
por el incremento que le pongamos, por ejemplo:

for( let i = 0 ; i < 10 ; i ++ ) { // Aquí primero declaramos la variable con let y le decimos que el iterador

console.log (“Hola Mundo”) ; comienza de la posición 0, o sea i = 0 //

Segundo Paso

Condición que le ponemos a la variable: La condición va a controlar cuantas veces se va a repetir el bucle, es decir
que si le ponemos i < 10 por ejemplo; le estamos indicando a la computadora que las instrucciones puestas en la
estructura del ciclo se sigan repitiendo tantas veces se cumplan con la condición establecida, en este caso se van a
repetir un numero de veces que sean menores a 10.

for( let i = 0 ; i < 10 ; i ++ ) { // i < 10 Aquí le estamos condicionando al ciclo a que se repitan un numero de

console.log (“Hola Mundo”) ; // veces mientras sean comenzando del 0 y el numero sea menor que 10.

incremento de la variable: En esta parte del código le estamos indicando a la computadora que cuando realiza un
ciclo le vaya sumando o restando el valor a la cantidad de iteradores del inicio. Es decir que cuando finaliza el primer
ciclo, regresa a la variable de Inicialización de nuevo y le va a cambiar el valor a esta variable incrementando o
decrementando su valor inicial; respetando siempre la condición establecida previamente. Veamos un ejemplo de
como trabajaría el operador.

for( let i=0 ; i < 10 ; i ++ )

//inicializamos la variable en 0 ; // le ponemos la condición que se // le indicamos que se incremente el

repita siempre y cuando no llegue valor de la variable al finalizar el ciclo

a 10 // poniendo ++ ( a modo de ejemplo)//

Para el segundo retorno la variable let i = 0 pasa a valer let i = 1 ; para el tercer retorno pasa a valer let i = 2 y así
sucesivamente hasta llegar a let i = 9, porque 9 es el ultimo valor que nos permite la condición < 10, porque 10 ya es
igual a 10 y no menor.

Este bucle repetitivo va a generar que la instrucción del ciclo se cumpla 10 veces.

for( let i = 0 ; i < 10 ; i ++ ) { // Con esta estructura del for la directiva del código que esta en las llaves { }

console.log (“Hola Mundo”) ; // se va a imprimir la palabra “Hola Mundo” 10 veces.

}
 Es importante aclarar que cuando la condición da un valor falso, como ya vimos en el ejemplo, se termina el
proceso del bucle.

¿QUE ES EL FOR … OF?

Es una estructura de Javascript y nos permite que dentro de la ejecución del bucle tengamos acceso al elemento
que estemos tratando.

for…of es una versión simplificada de for que nos permite trabajar de una manera menos compleja de la que
veníamos viendo, al for…of lo vamos a utilizar para recorrer objetos iterables. Los objetos iterables que conocemos
hasta el momento son las cadenas(strings) y los arrays(Listas).

La sentencia for...of ejecuta un bloque de código para cada elemento de un objeto iterable, como lo son: String ,
Array , objetos similares a array (por ejemplo, arguments or NodeList ), TypedArray , Map, Set e iterables definidos
por el usuario.

let cadena = “Hola Mundo” ; // la variable cadena es un objeto iterable porque tiene strings.

let miArrays = [ ‘gato’ , ‘perro’ , ‘conejo’ ]; // la variable miArrays es un objeto iterable porque tiene elementos.

La sintaxis del for … of se declara de la siguiente forma:

for( let variable of objetoIterable ) {

# Estructura de códigos del ciclo #

ejemplo: console.log( variable )

Si creamos una Lista la instrucción for va a recorrer y analizar cada elemento de esa lista aplicando la tarea que se
quiera definir. Por ejemplo:

Imaginémonos que tenemos una lista con los precios de los productos que compramos en el supermercado y
queremos restar cada uno de ellos a la variable plataEnBilletera. Usando for … of podemos hacerlo así:

Declaramos la variable plataEnBilletera con un valor especifico:

let plataEnBilletera = 500

Despues, usamos el for…of para restar los precios de los productos de la siguiente forma.

for( let precio of [ 10, 100, 87]) {

plataEnBilletera = plataEnBilletera – precio

En donde vemos que plataEnBilletera es una variable que se va modificando a medida que recorremos los precios.

Si teníamos $500 en nuestra billetera, después de completar los ciclos del for nos van a quedar $303 porque:

1_ Al principio plataEnBilletera era 500 y el primer precio de la lista es 10. Luego de hacer el primer ciclo se

resta 500 – 10 a plataEnBilletera y queda 490.

2_ A los 490 que quedaron en nuestra billetera, se realiza nuevamente el ciclo y le restamos el segundo precio de la
lista: 100.Ahora plataEnBilletera es 390.

3_ El último ciclo del for va a restar el último precio a restar que es 87, por lo que, al hacer 390 - 87, la variable

plataEnBilletera terminará teniendo el valor de 303.

Si prestamos atención, cuando declaramos la variable precio ésta después recibe la información de of [ 10, 100, 87]
en cada ciclo que el bucle da. Si lo queremos graficar veremos que en el primer ciclo precio recibe de of [ 10,],
después en el segundo ciclo precio recibe de of [ 100,] y en el tercer ciclo precio recibe de of [ 87].

Pero no solo podemos hacer operaciones matemáticas, también podemos imprimir palabras, por ejemplo; si
tenemos el siguiente array:

let misAnimales: [ “perro” , “gato”, “conejo”, “hamster”];

Podemos unir palabras con la siguiente formula:

function comentario(misAnimales) {

for(let animal of misAnimales) { # Acá pasa lo mismo que con la variable precio, pero acá la variable animal

console.log ("lindo " + animal); recibe de la lista misAnimales los elementos que están en esta #

Si llamamos a la variable en la consola, veremos:

comentario( [ “perro” , “gato”, “conejo”, “hamster”] );

lindo perro

lindo gato

lindo conejo

lindo hámster

Sabiendo esto si queremos crear el procedimiento saludar que recibe una lista de personas e imprime un saludo con
"hola" para cada una de ellas, lo hacemos de la misma forma:

Creamos la variable personas que va a contener los elementos que representan los nombres de las personas que
vamos a saludar:

let listaDeNombres = [ “Homero”,”Marge”]

después creamos el procedimiento saludar; recuerda que para invocar un procedimiento en JavaScript usamos la
palabra reservada function al igual que usamos para crear una función;

function saludar(listaDeNombres) {

for ( let nombre of listaDeNombres) {

console.log( "hola " + nombre) ;

}

Cuando llamamos al procedimiento en la consola la variable nombre que declaramos en el mismo for y que al
principio esta vacía va a recibir los elementos( nombres) al realizar los ciclos, que ponemos en la variable
listaDeNombres de esta forma:

Saludar( [ “Homero”,”Marge”])

hola Homero

hola Marge

¿QUE ES UN REGISTRO EN PROGRAMACION?

Un registro, en programación, es un tipo de dato estructurado formado por la unión de varios elementos bajo una
misma estructura. Estos elementos pueden ser, o bien datos elementales (entero, real, carácter,...), o bien otras
estructuras de datos. A cada uno de esos elementos se le llama campo. Por ejemplo:

Si llamamos en la consola a las siguientes variables, nos daría:

estatuaDeLaLibertad

{nombre:"Estatua de la Libertad",locacion:"Nueva York, Estados Unidos deAmérica",anioDeConstruccion:1886}

#campo# #campo# #campo#

cristoRedentor

{nombre:"Cristo Redentor",locacion:"Rio de Janeiro, Brasil",anioDeConstruccion:1931}

Entonces vemos que un registro es una variable que almacena una estructura de datos en la que almacenamos un
conjunto de elementos no necesariamente del mismo tipo, estos datos son estructurados y definidos por los
programadores y permiten almacenar diferentes tipos de datos en la variable.

¿Para qué sirve un registro en programación?

La función principal es guardar información de manera ordenada. Además, lo más normal es aplicar tablas, con el fin
de obtener cualquier dato de dicho registro almacenado. Por el hecho de que de esta forma un programador tiene la
opción de enviar la solicitud, modificar o solo mostrar algún dato.

Claro, de modo en específico, con dichos registros, por ello nada más se enlaza la posición de la línea o el campo.
Por supuesto, el registro es válido para cualquier lenguaje de programación, puesto que todos cuentan con un
apuntador de registros. Entonces, lo usual es escribir en el código, el comando que vincula una web, con la ruta del
registro. En resumen, para declarar de una manera más simple.

Para crear un registro usamos la palabra clave let, si la misma que usamos para crear variables; porque en definitiva
un registro también es una estructura de datos que va almacenar una variable; por ejemplo:
let torreAzadi = { nombre: "Torre Azadi", locación : "Teherán, Irán", anioDeConstruccion :1971 };

#campo 1# #campo 2# #campo 3#

let monumentoNacionalALaBandera = { nombre: "Monumento Nacional a la Bandera", locacion:"Rosario,Argentina

#campo 1# #campo 2#

anioDeConstruccion: 1957 };

#campo 3#

¿Recuerdas que para crear listas lo hacíamos con los corchetes [ ]? , bueno para crear registros lo hacemos con las
llaves { } . Los monumentos que vemos en el ejemplo están representados como registros, y cada una de sus
características (nombre, locación, año de construcción) son campos del registro. Por cierto, ¡podemos crear registros
de cualquier cosa, con los campos que queramos!

Por ejemplo, podríamos almacenar un libro de modo que cada campo del registro fuese alguna característica: su
título, su autor, su fecha de publicación, y más.

Los registros, al igual que las listas, son una estructura de datos porque nos permiten organizar información. Pero
¿en qué se diferencia un registro de una lista?

En las listas podemos guardar muchos elementos de un mismo tipo que representen una misma cosa (por ejemplo,
todos números, o todos strings). No existen límites para las listas: pueden tener muchos elementos, ¡o ninguno!

En un registro, sin embargo, vamos a guardar información relacionada a una única cosa (por ejemplo, un
monumento o una persona), pero los tipos de los campos pueden cambiar. Por ejemplo, el nombre y la ubicación de
un monumento son strings, pero su año de construcción es un número.

Cuando consultamos los registros existentes en la consola, veremos algo parecido a lo siguiente:

tajMahal

{nombre: "Taj Mahal", locacion: "Agra, India", anioDeConstruccion: 1653 }

Esta consulta es porque estábamos viendo al registro tajMahal completo, incluyendo todos sus campos.

Pero también se puede consultar por un campo particular, escribiendo el nombre del registro (la variable que
guarda todos los datos del registro) que queremos consultar seguido de un punto( . ) con el nombre del campo que
queremos ver de la siguiente forma:

(el nombre de la variable(registro) , punto( . ) el nombre del campo:

tajMahal.locacion

"Agra, India"

tajMahal.anioDeConstruccion

1653
Si queremos definír una función llamada por ejemplo temperaturaDePlaneta que reciba como argumento un registro
de planeta y retorne un string que indique su nombre y su temperatura promedio lo hacemos de la siguiente
manera:

Creamos las variables con los registros de los planetas con la palabra clave let y los campos de estos:

let mercurio = { nombre: "Mercurio", temperaturaPromedio: 67, tieneAnillos: false }

let venus = { nombre: "Venus", temperaturaPromedio: 462, tieneAnillos: false }

let tierra = { nombre: "Tierra", temperaturaPromedio: 15, tieneAnillos: false }

let marte = { nombre: "Marte", temperaturaPromedio: 32, tieneAnillos: false }

let jupiter = { nombre: "Júpiter", temperaturaPromedio: 1200, tieneAnillos: false }

let saturno = { nombre: "Saturno", temperaturaPromedio: -139, tieneAnillos: true }

let urano = { nombre: "Urano", temperaturaPromedio: -218, tieneAnillos: false }

let neptuno = { nombre: "Neptuno", temperaturaPromedio: -360, tieneAnillos: false }

Creamos un parametro que va a contener y va a ser reemplazado los nombres de los registros en la función:

function temperaturaDePlaneta ( planetas ) {

return planetas . nombre + " tiene una temperatura promedio de " + planetas . temperaturaPromedio + "
grados";

En este ejemplo la función temperaturaDePlaneta tiene como parámetro ( ) la variable planetas entre los parentesis
que representa el valor de entrada o argumento( que van a ser los nombres de los planetas que pusimos cuando
creamos los registros) y cuando se colocan, van a llamar al retorno del campo del registro(de cada planeta), es decir
va a invocar el campo(.nombre) y el campo(.temperatura) del registro.

Lo que queda es que se le suman las oraciones “strings” de " tiene una temperatura promedio de " y “ grados".
Para graficarlo mejor veamos lo siguiente:

Tenemos el registro jupiter y sus campos; por ejemplo:

let jupiter = { nombre: "Mercurio", temperaturaPromedio: 1200, tieneAnillos: false }

Entonces cuando pedimos el retorno, lo que nos va a retornar es el “string” del registro.campo asignado; de esta
forma; jupiter.nombre:

function temperaturaDePlaneta(jupiter) {

return jupiter. nombre + " tiene una temperatura promedio de " + jupiter. temperaturaPromedio + " grados";

return “Júpiter” 1200

 El parámetro planetas va a ser reemplazado con el nombre del registro jupiter que creamos anteriormente y va a
retornar el ”String” o el elemento del campo que le asignamos en el registro y se le va sumar( + ) el string que
queramos concatenar para completar la oración, de esta forma:

function temperaturaDePlaneta(jupiter) {

return jupiter. nombre + " tiene una temperatura promedio de " + jupiter. temperaturaPromedio + " grados";

return ”Júpiter” + " tiene una temperatura promedio de " + 1200 + " grados"

Por eso cuando llamamos a la función en la consola va a retornarnos lo siguiente:

temperaturaDePlaneta(mercurio)

"Mercurio tiene una temperatura promedio de 67 grados"

¿QUE ES UNA RUTA?

En informática, una ruta (path, en inglés) es la forma de referenciar un archivo informático o directorio en un
sistema de archivos de un sistema operativo determinado. Una ruta señala la localización exacta de un archivo o
directorio mediante una cadena de caracteres concreta.

¿Como modificar campos de Registros?

Por el momento estuvimos creando y consultando registros. ¿No sería interesante poder modificarlos?

La sintaxis para modificar campos de registros es muy similar a lo que hacemos para cambiar los valores de las
variables. Por ejemplo, para cambiar la temperatura de un planeta:

saturno.temperaturaPromedio = -140 ;

Ahora imaginá que tenemos un registro para representar un archivo, del que sabemos su ruta(dónde está
guardado) y su fecha de creación. Si queremos cambiar su ruta podemos hacer...

Primero tenemos el archivo con sus correspondientes campos y elementos;

leeme

{ ruta: "C:\leeme.txt", creacion: "23/09/2004"}

Después aplicamos la función moverArchivo para cambiar la ruta;

moverArchivo(leeme, "C: \ documentos \ leeme.txt" )

Luego el registro leeme tendrá modificada su ruta:

leeme
{ruta : "C: \ documentos \ leeme.txt" , creacion:"23/09/2004"}

Si queremos definir el procedimiento moverArchivo, que recibe un registro y una nueva ruta y modifica el archivo con
la nueva ruta, lo podemos hacer de la siguiente forma:

function moverArchivo ( registro, nuevaRuta) {

registro . ruta = nuevaRuta

¿Que hicimos acá? Bueno ¿te acordas que podemos darle un nuevo valor a la variable? ¿Como hacíamos esto?

De la siguiente forma; cuando declaramos una variable usamos la palabra reservada let, y le damos un valor a la
variable, por ejemplo:

let casaGuiraldez = “Familia Sanchez”;

lo que hicimos es decirle a la variable casaGuiraldez que almacene el dato “Familia Sanchez”, ahí le declaramos ese
valor y casaGuiraldez tiene solamente ese dato(por el momento). Pero después si necesitamos, podemos cambiarle
el valor a la variable casaGuiraldez y para esto solamente sobrescribimos el nuevo dato que queramos, o sea

casaGuiralez = “Familia Perez”; # No es necesario escribir de nuevo let ya que la variable casaGuiraldez ya esta

declarada, si ponemos de nuevo let para volver a declarar la misma variable da error #

Ahora la variable casaGuiraldez va a almacenar el nuevo valor o dato que le estamos declarando, o sea “Familia
Perez”; y el dato “Familia Sanchez” se va a borrar porque le sobrescribimos el nuevo valor por encima.

Si después le sobrescribimos otro valor, por ejemplo:

casaGuiralez = “Familia Ortiz”;

Nuevamente la variable va a cambiar de valor y el dato “Familia Perez” va a ser borrado y reemplazado por el
nuevo dato que ahora es “Familia Ortiz”; y así las veces que necesitemos. La variable va a tomar siempre el ultimo
dato o valor que le asignamos y los datos anteriores van a ser borrados del sistema.

Ahora bien, en el ejemplo tenemos la estructura de código:

registro . ruta = nuevaRuta

Lo que estamos haciendo acá es indicarle a la computadora que del registro que queramos y aclarando el campo
ruta, le vamos a sobrescribir o reemplazar por el valor nuevaRuta , lo que la computadora va hacer es lo siguiente;
primero el registro esta asi:

leeme { ruta: "C:\leeme.txt", creacion: "23/09/2004"}

nombre #1°campo# #2°campo#

del registro

Si buscamos el campo ruta del registro o archivo leeme nos daría:

leeme.ruta

C:\leeme.txt
Si buscamos el campo creacion del registro o archivo leeme nos daría:

leeme.creacion

23/09/2004

Ahora bien, si vemos la estructura de códigos de la función lo que le decimos a la computadora en este ejemplo es:

registro . ruta = nuevaRuta

leeme.ruta = nuevaRuta

C:\leeme.txt = C: \ documentos \ leeme.txt

En este ejemplo a igual que las variables el campo del registro ruta va a ser sobrescrito por el nuevo valor por lo que
al final tenemos:

leeme

{ruta : "C: \ documentos \ leeme.txt" , creacion:"23/09/2004"}

El campo creación queda igual porque solamente sobrescribimos el campo ruta, lo demás no se cambió. Ahora que
vimos los procesos, paso por paso, podemos entender lo que hacemos al final:

function moverArchivo ( leeme, C: \ documentos \ leeme.txt) {

leeme . ruta = C: \ documentos \ leeme.txt

Por eso después de aplicar la función moverArchivo, el registro leeme tendrá modificada su ruta:

leeme

{ruta : "C: \ documentos \ leeme.txt" , creacion:"23/09/2004"}

En el ejemplo que vimos modificamos la ruta del registro, pero no utilizamos su fecha de creación. ¡Usémosla!

Si queremos saber si un archivo es del milenio pasado, por ejemplo, lo que ocurre cuando su año es anterior a 2000.
Primeramente, tenemos que crear una función que nos retorne el año que queramos:

----------------------------------

PREGUNTAR…………..

funcion anio(fecha) {

return ------

anio("04/11/1993")

1993
----------------------------

Después creamos la función que va a tomar la función anio y nos va a retornar el valor booleano que queramos;

function esDelMilenioPasado(archivo){

return anio(archivo.creacion) < 2000

Lo que estamos escribiendo es:

function esDelMilenioPasado({ruta:"D:\fotonacimiento.jpg",creacion:"14/09/1989"}) {

return anio( {ruta:"D:\fotonacimiento.jpg",creacion:"14/09/1989"} )

1989 < 2000

} return true

Entonces cuando colocamos el archivo como parámetro nos daría:

esDelMilenioPasado({ruta:"D:\fotonacimiento.jpg",creacion:"14/09/1989"})

true

Combinando listas con registros:

Un poco más atrás te contamos la diferencia entre listas y registros. ¡Pero eso no significa que no podamos usar
ambas estructuras a la vez!

Por ejemplo, una lista puede ser el campo de un registro. Mirá estos registros de postres, de los cuales sabemos
cuántos minutos de cocción requieren y sus ingredientes:

let flanCasero = { ingredientes: ["huevos","leche","azúcar","vainilla"], tiempoDeCoccion: 50 }

let cheesecake = { ingredientes: ["frambuesas","queso crema"], tiempoDeCoccion: 80 }

let lemonPie = { ingredientes: ["jugo de limón","almidón de maíz","leche","huevos","azúcar","frutillas"],

tiempoDeCoccion: 65 }

Entonces vemos que dentro de un registro puede haber una lista y si buscamos el campo del registro.ingredientes
por ejemplo, lo que nos retorna es la lista completa:

flanCasero.ingredientes

=> ["huevos","leche","azúcar","vainilla"]

cheesecake.ingredientes

=> ["frambuesas","queso crema"]

lemonPie.ingredientes

=> ["jugo de limón","almidón de maíz","leche","huevos","azúcar","frutillas"]

 Presta atención que siempre va un punto ( . ) entre el nombre del registro y el campo de la lista. O también nos
puede retornar solamente el campo del registro, por ejemplo:

lemonPie.tiempoDeCoccion

=> 65

Entonces si queremos crear una función que recibe dos registros de postres como argumentos y retorna el que
tiene más ingredientes de los dos. Lo hacemos de la siguiente forma:

Usamos el método length que nos va a retornar la cantidad de elementos que tienen cada uno de los registros:

function masDificilDeCocinar(postre1,postre2){

if ( length (postre1. ingredientes) >= length (postre2. ingredientes)) {

return postre1}

else{

return postre2

Lo que en el ejemplo anterior te mostramos fue que en un registro puede tener una lista entre sus campos. ¿Y al
revés? ¿Podemos tener una lista de registros?

¡Sí! Así como trabajamos con listas de números, booleanos, strings o más listas, también podemos listar registros. Se
puede hacer todo lo que hacías antes, como por ejemplo remover usando el método remove, saber su Longitud con
length o preguntar por el elemento de cierta posición utilizando el operador de indexación o sea los corchetes [].

Para declarar una lista con registros dentro, usamos la palabra clave let y lo hacemos de la siguiente forma:

let postresFavoritos =

[ {ingredientes: ["galletitas","dulce de leche","crema"],tiempoDeCoccion:20},

{ingredientes: ["huevos","leche","azúcar","vainilla"],tiempoDeCoccion:50},

{ingredientes: ["queso crema","frambuesas"],tiempoDeCoccion:80},

{ingredientes: ["jugo de limón","almidón de maíz","leche","huevos"],tiempoDeCoccion:65} ]

let monumentosDeAmerica =

[ {nombre:"Monumento Nacional a la Bandera",locacion:"Rosario, Argentina",anioDeConstruccion:1957},

{nombre:"Estatua de la Libertad",locacion:"Nueva York, Estados Unidos de América",anioDeConstruccion:1886},

{nombre:"Cristo Redentor",locacion:"Rio de Janeiro, Brasil",anioDeConstruccion:1931} ]

Recuerda que la diferencia entre listas y registros es que las listas van entre corchetes ([ ]) y los registros entre las
llaves ({ }). Además, los registros tienen campos: y las listas tienen elementos.
 Aquí vemos que una lista puede tener múltiples registros dentro de ella y cada registro pasa a ser un solo elemento
de la lista, es decir que, si tenemos una lista con 3 registros, no importa cuantos campos tengan los registros, solo
pasa a ser un elemento más de la lista y va a tener 3 elementos, o si tenemos solo un registro tiene un solo elemento.

Otra cosa importante que tenemos que tener en cuenta es que cuando tenemos listas con registros como
elementos, no se puede acceder a los campos como veníamos viendo, es decir que si intentamos buscar el campo
locacion de la lista monumentosDeAmerica por ejemplo;

monumentosDeAmerica .locacion

undefined

Aquí vemos que nos da un error undefined porque si miramos bien la lista, esta contiene 3 campos con la palabra
locacion adentro, por lo que la computadora no sabe que locación tiene que mostrar.

Para acceder a los campos que están dentro los registros de las listas, tenemos que tener en cuenta que cada
registro es un solo elemento, por lo que lo hacemos usando el operador de indexación [ ], entre el nombre de la lista
y la ubicación del campo que queremos acceder, para entender mejor lo vemos de la siguiente forma:

monumentosDeAmerica[0].nombre

“Monumento Nacional a la Bandera”

monumentosDeAmerica [0].locacion

“Rosario, Argentina”

monumentosDeAmerica[1].nombre

"Estatua de la Libertad"

monumentosDeAmerica [1].locacion

"Nueva York, Estados Unidos de América"

postresFavoritos[3].ingredientes

["jugo de limón","almidón de maíz","leche","huevos"]

De esta forma podremos ingresar a los campos de los registros que están dentro de las listas, también podemos
utilizar el método push para agregar mas registros a la lista o removerlos, por ejemplo;

Supongamos que tenemos una lista con los siguientes registros;

let postresFavoritos = [ {ingredientes:["galletitas","dulce de leche","crema"],tiempoDeCoccion:20} ,

{ingredientes:["huevos","leche","azúcar","vainilla"],tiempoDeCoccion:50} ,

{ingredientes:["queso crema","frambuesas"],tiempoDeCoccion:80} ,

{ingredientes:["jugo de limón","almidón de maíz","leche","huevos"],tiempoDeCoccion:65} ] ;

Y queremos añadirle otro registro a la lista de postresFavoritos; con la siguiente consigna “Si el tiempo de cocción es
de una hora o menos, se agrega el registro a la lista”. por ejemplo:

Creamos el nuevo registro con la palabra clave let:

let flanCasero= { ingredientes:[ "5 huevos","Medio litro de leche","200 gramos de azúcar","crema chantilly" ] ,
tiempoDeCoccion:35 } ;
Y después creamos una función que va a agregar el nuevo registro a la lista de postresFavoritos de esta forma:

function agregarAPostresRapidos(listaPostres,registro) {

if (registro.tiempoDeCoccion <= 60){

push (listaPostres,registro);}

La lista de postres que tenemos creada (postresFavoritos) va a ser usada como parámetro para insertar el nuevo
registro que creamos, y el nuevo registro (flanCasero) va a ser usado para ingresar a la lista, lo que quedaría de la
siguiente forma:

function agregarAPostresRapidos(postresFavoritos,flanCasero) {

if (flanCasero.tiempoDeCoccion <= 60){

push (postresFavoritos,flanCasero);}

Si despues probamos en la consola, veremos lo siguiente:

postresFavoritos

=> [{ingredientes:["galletitas","dulce de leche","crema"],tiempoDeCoccion:20},

{ingredientes:["huevos","leche","azúcar","vainilla"],tiempoDeCoccion:50},

{ingredientes:["queso crema","frambuesas"],tiempoDeCoccion:80},

{ingredientes:["jugo de limón","almidón de maíz","leche","huevos"],tiempoDeCoccion:65}]

agregarAPostresRapidos(postresFavoritos,flanCasero)

=> undefined

postresFavoritos

=> [{ingredientes:["galletitas","dulce de leche","crema"],tiempoDeCoccion:20},

{ingredientes:["huevos","leche","azúcar","vainilla"],tiempoDeCoccion:50},

{ingredientes:["queso crema","frambuesas"],tiempoDeCoccion:80},

{ingredientes:["jugo de limón","almidón de maíz","leche","huevos"],tiempoDeCoccion:65},

{ingredientes:["5 huevos","Medio litro de leche","200 gramos de azúcar","crema chantilly"],tiempoDeCoccion:35}]

Aquí vemos en la consola que nuestro nuevo registro se agregó a la lista postresFavoritos.

¿Te acordás cuando vimos que una lista podía estar compuesta por otras listas? ¡Con los registros aplica la misma
idea! Es decir que podemos tener registros dentro de registros.

Si tenemos alguna estructura de datos compleja, puede ocurrir que no alcance con representarla únicamente
mediante strings, números, booleanos y listas, sino que necesitemos otro registro dentro.
Supongamos que mediante un registro queremos modelar un menú completo: consiste en un plato principal , los
vegetales de la ensalada que acompaña , y un postre como lo veníamos trabajando, es decir, sigue siendo un
registro.

Por ejemplo, el siguiente es un menú con bife de lomo como plato principal, una ensalada de papa, zanahoria y
arvejas como acompañamiento y un cheesecake de postre. Como el registro es un poco extenso, y para que sea más
legible, lo vamos a escribir de la siguiente forma:

let menuDelDia = {

platoPrincipal: "bife de lomo",

ensalada: ["papa", "zanahoria", "arvejas"],

postre: { ingredientes: ["queso crema", "frambuesas"], tiempoDeCoccion: 80 } } ;

Si queremos acceder al campo ensalada del registro menuDelDia lo podemos hacer de la siguiente forma como ya
vimos:

menuDelDia. ensalada

["papa", "zanahoria", "arvejas"]

Pero también podemos acceder al campo ingredientes del registro postre del registro menuDelDia de la siguiente
forma:

menuDelDia.postre.ingredientes

["queso crema","frambuesas"]

¡No te olvides de los puntos para separar los registros!

Usando el ejemplo anterior también podemos crear un procedimiento que recibe como parámetro un registro menú
y le agrega(push), azúcar a los ingredientes de su postre. Si ya tiene azúcar, no importa... ¡le agrega más!

Para esto primero creamos el registro menuDelDia de la siguiente forma con la palabra clave let:

let menuDelDia = {

platoPrincipal: "bife de lomo",

ensalada: ["papa", "zanahoria", "arvejas"],

postre: { ingredientes: ["queso crema", "frambuesas"], tiempoDeCoccion: 80 }

};

Después creamos el procedimiento así:

function endulzarMenu(menu){

push ( menu.postre.ingredientes, "azúcar");

Si buscamos en la consola podemos ver lo que hicimos:

menuDelDia.postre.ingredientes

=> ["queso crema","frambuesas"] // Primero tenia esta lista dentro del registro//

endulzarMenu(menuDelDia) // Aplicamos el procedimiento con el registro que queremos agregar//

=> undefined

menuDelDia.postre.ingredientes

=> ["queso crema","frambuesas","azúcar"] //Al final de la lista vemos que se agrego el elemento al registro//

Si tenemos la siguiente lista con los registros para representar los balances de cada mes y guardarlos. Por ejemplo,
para el último semestre del año pasado registró los siguientes:

let balancesUltimoSemestre = [

{ mes: "julio", ganancia: 50 },

{ mes: "agosto", ganancia: -12 },

{ mes: "septiembre", ganancia: 1000 },

{ mes: "octubre", ganancia: 300 },

{ mes: "noviembre", ganancia: 200 },

{ mes: "diciembre", ganancia: 0 },

];

¿podemos saber la ganancia de todo un semestre? Obvio, solo tenemos que sumar las ganancias de todos los
balances, y escribimos el siguiente código:

function gananciaSemestre(balances) {

return balances[0].ganancia + balances[1].ganancia +

balances [2].ganancia + balances [3].ganancia +

balances [4].ganancia + balances [5].ganancia;

¿Qué hicimos aquí?

Recuerdas que una lista no tiene campos, si no elementos; en este caso cada registro de la lista es un elemento, y
cuando contamos elementos de la lista lo hacemos partiendo desde 0. Para entender mejor lo graficamos de esta
forma:

let balancesUltimoSemestre =

[ { mes: "julio", ganancia: 50 }, { mes: "agosto", ganancia: -12 }, { mes: "septiembre", ganancia: 1000 },… etc} ]

# Elemento 0 # # Elemento 1 # # Elemento 2 #

balances[0].ganancia balances[1].ganancia balances[2].ganancia ...etc

Ahora bien para poder acceder al campo del registro que está en una lista, tenemos que hacerlo de la siguiente
forma:

balancesUltimoSemestre[0].ganancia

50

balancesUltimoSemestre[1].ganancia

-12

balancesUltimoSemestre[2].ganancia

1000

Primero colocamos el nombre de la lista que en este ejemplo es balancesUltimoSemestre y después colocamos
entre corchetes [] la posición del elemento dentro de la lista que parte de 0, con el campo que queremos retornar.

Recuerda que la palabra balances es un parámetro que se usa de forma general y va a representar el argumento o
valor concreto de la variable con la que definimos la lista que en este ejemplo se llama balancesUltimoSemestre.

Si usamos la función nos daría:

gananciaSemestre(balancesUltimoSemestre)

=> 1538

Porque la función va a sumar todos los campos(ganancia) de los registros de la lista balancesUltimoSemestre,
como esta especificada en la estructura de códigos.

Pero siguiendo con el ejemplo anterior, no podemos usar esta función si la lista tiene más o menos elementos de la
que queremos calcular, por ejemplo, si tenemos los balances del primer trimestre de este año.

let balancesPrimerTrimestre = [

{ mes: "enero", ganancia: 80 },

{ mes: "febrero", ganancia: 453 },

{ mes: "marzo", ganancia: 1000 }

];

NO podemos usar la función que creamos porque esta lista solo tiene 3 elementos y la función espera que se sumen
6 elementos(contando con el elemento 0), por lo tanto si usamos la función nos daría un error de la siguiente forma:

gananciaSemestre(balancesPrimerTrimestre)

balances[2].ganancia + balances[3].ganancia +

TypeError: Cannot read property 'ganancia' of undefined

Este error nos marca porque la computadora tiene la función de sumar 6 elementos en total y la lista solo tiene 3
elementos, por lo que no puede encontrar los otros elementos que le faltan para procesar.
De la misma forma si tenemos una lista con mas elementos de lo que espera la funcion, nos va a dar error.

Por lo tanto, podemos deducir que:

La función gananciaSemestre anterior tiene varios problemas:

 Es muy repetitiva y tediosa de escribir. ¡Tenemos que hacer muchas sumas a mano!
 No es genérica, como bien dice su nombre, sólo sirve para sumar las ganancias de 6 balances:
 Si la lista tiene más de seis balances, sólo suma los primeros; si tiene menos, no funciona (¿te acordáis
cuando te dijimos que si te ibas de índice cosas malas podían ocurrir?

Lo que nos gustaría es poder sumar las ganancias de todos los balances de una lista, sin importar cuántos haya
realmente; queremos una función gananciaTotal, que pueda sumar balances de cualquier período de meses:
semestres, cuatrimestres, trimestres, etc.¡Qué difícil!

Ahora que sabemos la función que necesitamos (gananciaTotal), razonemos cómo hacerla...Vamos de a poquito: si
la lista no tuviera elementos, ¿cuánto debería ser la sumatoria? ¡0! Es decir, si tenemos una lista vacía como este
ejemplo:

let balancesDeUnPeriodo

Creamos una variable con la palabra clave let dentro de la función que va a representar el valor inicial de la
sumatoria o sea el 0, de esta forma:

let balancesDeUnPeriodo

function gananciaTotal0(balances) {

let sumatoria = 0;

return sumatoria;

Si buscamos en la consola esta sumatoria no daría:

gananciaTotal0(balancesDeUnPeriodo)

=> 0

Nos da el numero 0 porque la lista balancesDeUnPeriodo no tiene ningún elemento que sumar y solamente retorna
el valor de la variable sumatoria. Ahora bien..

¿Y si tuviera exactamente 1 elemento? Sería... 0.... ¿más ese elemento? ¡Exacto!

let balancesDeUnPeriodo = [ { mes: "julio", ganancia: 4550 } ];

# Aquí tenemos 1 elemento

el elemento 0#
function gananciaTotal1(balances) {

let sumatoria = 0;

sumatoria = sumatoria + balances[0].ganancia;

// 0 + 4550 //

return sumatoria; }

Si buscamos en la consola podemos ver:

gananciaTotal1(balancesDeUnPeriodo)

=> 4550

¿Y si tuviera 2 elementos? Es decir, si tuviéramos una lista con 2 elementos, por ejemplo;

let balancesDeDosMeses = [ { mes: "julio", ganancia: 4550 },

{ mes: "agosto", ganancia: 6704 } ];

function gananciaTotal(balancesDeUnPeriodo) {

let sumatoria = 0;

sumatoria = sumatoria + balancesDeUnPeriodo[0].ganancia;

sumatoria = sumatoria + balancesDeUnPeriodo[1].ganancia;

return sumatoria;

Si Buscamos en la consola podemos ver:

gananciaTotal(balancesDeDosMeses)

=> 11254

¿Y si tuviera 4 elementos?

let balancesDelUltimoPeriodo = [

{ mes: "enero", ganancia: 80 },

{ mes: "febrero", ganancia: 453 },

{ mes: "marzo", ganancia: 10005 },

{ mes: "Abril", ganancia: 10000 } ];

function gananciaTotal(balancesDeUnPeriodo) {

let sumatoria = 0;

sumatoria = sumatoria + balancesDeUnPeriodo [0]. ganancia;

sumatoria = sumatoria + balancesDeUnPeriodo [1]. ganancia;

sumatoria = sumatoria + balancesDeUnPeriodo [2]. ganancia;

sumatoria = sumatoria + balancesDeUnPeriodo [3]. ganancia;

return sumatoria ;

gananciaTotal(balancesDelUltimoPeriodo)

=> 20538

¿Y si la lista tuviera cualquier cantidad de elementos? Si seguimos repitiendo este patrón, veremos que una
sumatoria de una lista siempre arranca igual, con let sumatoria = 0, y termina igual, devolviendo la variable local
sumatoria (return sumatoria).

function gananciaTotalN(unPeriodo) {

let sumatoria = 0; // esto siempre está

//... etc

return sumatoria; //esto siempre está

Lo que cambia son las acumulaciones (sumatoria = sumatoria + ...); que necesitamos una por cada elemento de la
lista. Dicho de otra forma, tenemos que visitar cada elemento del mismo, sin importar cuántos tenga. Pero, ¿cómo
hacerlo? ¿No te suena conocida esta idea de repetir algo muchas veces?

Lo que tenemos que hacer, entonces, es repetir la operación de acumular varias veces, una por cada elemento de la
lista. Para esto podemos usar el bucle for … of que va a ir recorriendo los elementos de la lista y haciendo la
sumatoria:

function gananciaTotal(balancesDeUnPeriodo) {

let sumatoria = 0;

for (let balance of balancesDeUnPeriodo) {

sumatoria = sumatoria + balance.ganancia;

return sumatoria;

Recuerda que para usar el for … of, necesitamos crear una variable que en este ejemplo se llama balance, que va a
recibir uno por uno los elementos de la lista balancesDeUnPeriodo , lo que va a recibir balance es un registro en
concreto, y no una lista como tal, y de ahí puede acceder al campo(.ganancia) de ese registro, y sacar el valor de la
ganancia, después de recibir ese valor va a ir sumando con la variable sumatoria, y la variable sumatoria va a ir
cambiando con la suma a medida que se produzca el bucle del for…of y de la suma de esos valores al final va a
retornar la variable sumatoria con un valor concreto.

Como ves, el for...of nos permite visitar y hacer algo con cada elemento de una lista; en este caso, estaremos
visitando cada balance de balancesDeUnPeriodo. Más específicamente creamos funciones que con el for … of nos
sirve para filtrar y/o transformar los elementos de una lista. Incluso si tenemos la siguiente lista con los siguientes
registros negativos, por ejemplo:

let gananciaTotalDeMeses= [

{ mes: "enero", ganancia: 2 },

{ mes: "febrero", ganancia: 10 },

{mes: "marzo", ganancia: -20 } ];

function gananciaTotal(balancesDeUnPeriodo) {

let sumatoria = 0;

for (let balance of balancesDeUnPeriodo) {

sumatoria = sumatoria + balance.ganancia;

return sumatoria;

Si buscamos en la consola podemos ver:

gananciaTotal(gananciaTotalDeMeses)

=> – 8

Podemos ver que el numero que nos da es negativo, porque 10 + 2 – 20 = – 8

Y sabiendo esto, también podemos hacer comparaciones con los registros de las listas, por ejemplo, si quisiéramos
saber cuántos balances fueron positivos, es decir, aquellos en los que la ganancia fue mayor a cero lo podemos hacer
de la siguiente manera. Supongamos que tenemos la siguiente lista:

let gananciaTotalDelAnio = [

{ mes: "Enero", ganancia: 2 },

{ mes: "Febrero", ganancia: 10 },

{ mes: "Marzo", ganancia: -20 },

{ mes: "Abril", ganancia: 0 },

{ mes: "Mayo", ganancia: -10 },

];

En donde tenemos 2 meses que tienen ganancias negativas, y 2 meses con ganancias positivas y un mes con ganancia
0, entonces podemos crear una función que solo cuente la cantidad de meses que tienen ganancias positivas, y filtre
las otras ganancias , para esto lo podemos hacer de la siguiente forma:
function cantidadDeBalancesPositivos(balancesDeUnPeriodo) {

let cantidad = 0;

for (let balance of balancesDeUnPeriodo) {

if (balance.ganancia > 0) { cantidad = cantidad + 1;}

} return cantidad;

En este código vemos que la variable balance que recibe los campos(.ganancia) de la lista balancesDeUnPeriodo,
se pone como condición que si la ganancia es mayor a 0, se retorne la cantidad(de elementos que hay de la lista)

¿Porque se pone cantidad + 1?

Esto se pone porque los elementos son contados desde 0(cantidad = 0). Es decir en el primer bucle se va a verificar
si la condición del if da true y si da true va a sumar el elemento a la variable cantidad por lo que cantidad pasa a valer
1, en el segundo bucle nuevamente se mira la condición del if y si da true, nuevamente se le suma 1 a la variable
cantidad, y si da false la condición del if, se va a saltear y pasa al siguiente elemento, y asi hasta terminar el bucle;

gananciaTotalDelAnio =[{ mes: "Enero", ganancia: 2 },{ mes: "Febrero", ganancia: 10 },{ mes: "Marzo", ganancia :-20},

true true false

cantidad = 0 + 1 = 1 cantidad = 1 + 1 = 2 # Aca salta porque dio false#

{ mes: " Abril ", ganancia: 0 }, { mes: "Mayo", ganancia: 10 }, { mes: "Junio", ganancia : 15} ]

false true true

# Aca salta porque dio false# cantidad = 2 + 1 = 3 cantidad = 3 + 1 = 4

Entonces vemos que cada vez que en la condición del if da un valor true, cantidad va a ir sumando 1 (+1), por lo que
cuando termina de dar el bucle, termina contando solamente los registros que dieron positivos o dieron true y los
registros que dieron false, se saltea del bucle.

Entonces, siguiendo con el ejemplo, si colocamos la función en la consola podemos ver :

cantidadDeBalancesPositivos(gananciaTotalDelAnio)

=> 2 // Porque hay 2 elementos con balance positivo en esta lista //

O si tenemos esta lista:

let gananciaTotalDelAnio = [

{ mes: "Enero", ganancia: 2 },

{ mes: "Febrero", ganancia: 10 },

{ mes: "Marzo", ganancia: 4 },

{ mes: "Abril", ganancia: 0 },

{ mes: "Mayo", ganancia: -10 },

];
En la consola nos va a dar:

cantidadDeBalancesPositivos(gananciaTotalDelAnio)

=> 3 // Porque hay 3 elementos con balance positivo en esta lista, no se cuenta la lista que tiene 0 porque

en la condición del if pusimos mayor a 0 y no mayor o igual a 0 //

¿Cómo calcular el promedio de los balances en una funcion?

Ya podemos calcular una sumatoria de ganancias y también crear contadores, ahora vamos a calcular promedios.
¿Qué es un promedio? Veámoslo con un ejemplo:

En un grupo de 3 personas, Felipe de 3, Delfina de 8 y Eli de 10 años, la edad promedio es de 7 años.

Porque 3 + 8 + 10 es igual a 21, dividido la cantidad de gente en el grupo (3 personas) da 7.

Entonces para crear una función que nos muestre el promedio de las ganancias, primero tenemos que crear la
función que nos muestre el total de las ganancias y dividir eso con la longitud de los valores usando length, lo
hacemos de la siguiente manera:

1_Primero creamos la función que en este ejemplo lo llamamos gananciaTotal y nos retorna la sumatoria de la
ganancia total de todos los balances:

function gananciaTotal(balancesDeUnPeriodo) {

let sumatoria = 0;

for (let balance of balancesDeUnPeriodo) {

sumatoria = sumatoria + balance.ganancia;

return sumatoria;

Después usamos esa función para que nos de los valores que necesitamos y poder dividir esos valores con la longitud
de los balances de la siguiente forma:

function gananciaPromedio(balances){

return gananciaTotal(balances) / length(balances)

Ahora bien, si tenemos la siguiente lista con los registros que mostramos:

let balancesDelUltimoPeriodo = [

{ mes: "enero", ganancia: 80 },

{ mes: "febrero", ganancia: 453 },

{ mes: "marzo", ganancia: 10005 },

 { mes: "Abril", ganancia: 10000 } ];

Si buscamos en la consola la ganancia total, nos daría lo siguiente:

gananciaTotal(balancesDelUltimoPeriodo)

=> 20538

Si a la misma lista le buscamos la longitud(length), no va a dar :

length(balancesDelUltimoPeriodo)

=> 4

Bueno para saber el promedio, la función gananciaPromedio divide esos valores y nos retorna el promedio:

function gananciaPromedio(balancesDelUltimoPeriodo){

return gananciaTotal(balancesDelUltimoPeriodo) / length(balancesDelUltimoPeriodo)

20538 / 4 = 5134.5

Si buscamos en la consola nos muestra:

gananciaPromedio(balancesDelUltimoPeriodo)

=> 5134.5

Ahora también si queremos saber la ganancia promedio de los balances positivos. Podemos combinar todas las
funciones que aprendimos hasta ahora; para esto primero creamos la lista con todos los balances del periodo:

let gananciaTotalDelAnio = [ { mes: "Enero", ganancia: 2 }, { mes: "Febrero", ganancia: 10 },

{ mes: "Marzo", ganancia: 4 }, { mes: "Abril", ganancia: 0 },

{ mes: "Mayo", ganancia: -10 }, { mes: "Junio", ganancia: 21 },

{ mes: "Julio", ganancia: - 8 }, { mes: "Agosto", ganancia: 21 } ];

Después usamos la función que nos permite separar la cantidad de balances positivos de los negativos y nos indica
cuantos balances positivos tenemos de un periodo:

function cantidadDeBalancesPositivos(balancesDeUnPeriodo) {

let cantidad = 0;

for (let balance of balancesDeUnPeriodo) {

if (balance.ganancia > 0) { cantidad = cantidad + 1;}

} return cantidad;

Si buscamos en la consola nos daría:

cantidadDeBalancesPositivos(gananciaTotalDelAnio)// Recuerda que en la consola va el nombre de la lista//

=> 5

Después tenemos que crear la función gananciaPositiva, que es la suma de las ganancias de los balances positivos:

function gananciaPositiva(balancesDeUnPeriodo){

let sumatoria = 0 ;

for(let balance of balancesDeUnPeriodo){

if (balance.ganancia >0)

{sumatoria = sumatoria + (balance.ganancia)}

} return sumatoria;

Si buscamos la funcion en la consola nos da la sumatoria de las ganancias de los balances positivos solamente, no
toma las ganancias negativas ni las que tienen 0:

gananciaPositiva(gananciaTotalDelAnio)

=> 58

Ahora que tenemos la cantidad y la sumatoria, podemos crear la función que va hacer el promedio de las ganancias
positivas de la lista:

function promedioGananciasPositivas(balancesDeUnPeriodo){

return gananciaPositiva(balancesDeUnPeriodo) / cantidadDeBalancesPositivos(balancesDeUnPeriodo);

Finalmente si probamos en la consola la función promedioGananciasPositivas nos va a retornar:

promedioGananciasPositivas (gananciaTotalDelAnio)

=> 11.6

Como podés ver todos los promedios se basan en el mismo principio. Sumar una cantidad determinada elementos
y dividir el resultado por esa cantidad. Si quisiéramos realizar una función promedio genérica sería algo así:

function promedio(listaDeNumeros) {

return sumatoria(listaDeNumeros) / longitud(listaDeNumeros);

function sumatoria(listaDeNumeros) {
 let sumatoria = 0;

for (let numero of listaDeNumeros) {

sumatoria = sumatoria + numero;

return sumatoria;

¡Pero nosotros no tenemos una lista de números sino de registros! ¿Y entonces?

Lamentablemente no se puede usar la función promedio con nuestra lista de registros. Lo que necesitamos es una
lista que tenga solo las ganancias de cada balance. Para ello debemos transformar, o mapear, cada elemento de la
lista.

function ganancias(balancesDeUnPeriodo) {

let ganancias = [ ]

for (let balance of balancesDeUnPeriodo) {

push (ganancias, balance.ganancia);

return ganancias;

ACLARACION: Como vemos en el ejemplo primero debemos declarar una variable(ganancias) que va a recibir una
lista, que al principio va a estar vacía y después al recorrer el bucle for/of nos va a retornar la misma
variable(ganancias) con la lista que le pedimos; es decir primero declaramos en la misma función con la palabra clave
let ganancias = [ ] (Aquí la lista está vacía), y después al terminar los ciclos nos va a retornar(return) la misma
variable(ganancias) con la lista que le pedimos que le saque a la lista balancesDeUnPeriodo.

Siguiendo con nuestra lista con los mismos registros, y si buscamos en la consola vamos a poder ver:

ganancias(gananciaTotalDelAnio)

=> [2,10,4,0,-10,21,-8,21] // Nos retorna una lista con todas las ganancias de los registros de la lista(positivos,

negativos y los que dieron 0//

Con la programación se puede hacer cualquier cosa, o casi. Ya hicimos una función para poder saber la cantidad de
balances positivos (cantidadDeBalancesPositivos), ahora vamos a ver cómo podemos hacer para saber cuáles son
esos balances.

Podemos crear una función a la que le vamos a llamar balancesPositivos que toma los balances de un período y
devuelve una lista con aquellos cuya ganancia fue mayor a cero. Pero va a descartar de la lista los balances que
dieron negativo y cero. Es decir con esta función vamos a obtener una nueva lista con los balances que presentaban
una ganancia positiva solamente.
function balancesPositivos(balancesDeUnPeriodo) {

let balances = [];

for (let balance of balancesDeUnPeriodo) {

if( balance.ganancia > 0 ) {

push( balances, balance ) }

}return balances;

Nuevamente para este ejemplo, primero tenemos que crear una variable con una lista vacía ( let balances = []; )
que va a recibir al finalizar el bucle, todos los registros que dieron positivos solamente (return balances), prestemos
atención que dentro de la acción del if(lo que va entre las llaves { } ), se agrega a la variable balances solamente los
registros completos del elemento balance.

Es decir, la lista balancesDeUnPeriodo le va a a entregar al elemento balance, todos los registros y como hay una
condición y una accion con el if ( condicion ) lo que va a retornar es esa accion solamente con la condición
establecida. ¿Cuál es la condición? Que entregue solamente los registros/elementos con ganancia mayor a cero( o
sea registros positivos) y estos registros positivos que se agreguen a la lista balances.

Una vez finalizado el bucle que nos retorne dicha lista(balances).

Ahora si buscamos la función en la consola nos va a dar una lista con los registros solamente de los balances
positivos, se va a eliminar los negativos y los que dieron 0;

balancesPositivos(gananciaTotalDelAnio)

=>[{mes:"Enero",ganancia:2},{mes:"Febrero",ganancia:10},

{mes:"Marzo",ganancia:4},{mes:"Junio",ganancia:21},

{mes:"Agosto",ganancia:21}]

Ahora que tenemos la función ganancias y balancesPositivos podemos utilizar la función promedio genérica para
saber cuál es el promedio de ganancia de los balances positivos.

Primero vamos a crear la función gananciasDeBalancesPositivos y luego usarla junto a promedio para definir
promedioDeBalancesPositivos.

Para poder tener la lista que recibe por parámetro promedio, primero vamos a tener que definir
gananciasDeBalancesPositivos. Esta función primero filtra los balances positivos y luego los mapea a ganancias.
Recordá que función hace cada una de estas cosas.

Tenemos entonces la función ganancias(balancesDeUnPeriodo):

function ganancias(balancesDeUnPeriodo) {

let ganancias = [ ]

for (let balance of balancesDeUnPeriodo) {

push (ganancias, balance.ganancia);

}
 return ganancias;

Que nos retorna las ganancias totales del año:

ganancias(gananciaTotalDelAnio)

=> [2,10,4,0,-10,21,-8,21] // Nos retorna una lista con todas las ganancias de los registros de la lista(positivos,

negativos y los que dieron 0//

Y también tenemos la función balancesPositivos :

function balancesPositivos(balancesDeUnPeriodo) {

let balances = [];

for (let balance of balancesDeUnPeriodo) {

if( balance.ganancia > 0 ) {

push( balances, balance ) }

}return balances;

Que filtra los balances del año y nos retorna una lista con los registros que fueron positivos del año:

balancesPositivos(gananciaTotalDelAnio)

=>[{mes:"Enero",ganancia:2},{mes:"Febrero",ganancia:10},

{mes:"Marzo",ganancia:4},{mes:"Junio",ganancia:21},

{mes:"Agosto",ganancia:21}]

Si combinamos estas dos funciones podemos agarrar una lista con todos los registros del año y filtrar o mapear
solamente los registros que son positivos. ¿Cómo lo combinamos? Bueno para ello vamos a usar una función como
parámetro de otra función de la siguiente forma:

A la funcion ganancias(balancesDeUnPeriodo) le vamos a colocar como parámetro la función

balancesPositivos (balancesDeUnPeriodo) y quedaría de la siguiente forma:

ganancias( balancesPositivos(balancesDeUnPeriodo) )

// le ponemos la función balancesPositivos(balancesDeUnPeriodo) como parámetro dentro de ganancias//

¿Que hace la computadora con esta combinación de funciones?

Si tenemos esta lista por ejemplo;

let gananciaTotalDelAnio = [

{ mes: "Enero", ganancia: 2 },

{ mes: "Febrero", ganancia: 10 },

{ mes: "Marzo", ganancia: 4 },

 { mes: "Abril", ganancia: 0 },

{ mes: "Mayo", ganancia: -10 },

];

ganancias( balancesPositivos(balancesDeUnPeriodo) ) Nos va a retornar una lista con todas las ganancias positivas
de esta lista y va a trabajar de la siguiente forma:

function ganancias (balancesPositivos(gananciaTotalDelAnio)) {

let ganancias = [ ]

for (let ListaDeBalance of balancesPositivos(gananciaTotalDelAnio))

let nuevaLista = [];

for (let listaDeRegistros of gananciaTotalDelAnio) {

if( listaDeRegistros.ganancia > 0 ) {

push ( nuevaLista, listaDeRegistros ) }

} return nuevaLista; => [ { mes: "Enero", ganancia: 2 },

{ mes: "Febrero", ganancia: 10 },

} { mes: "Marzo", ganancia: 4 } ];

push (ganancias, ListaDeBalance.ganancia);

return ganancias; => [2,10,4]

ganancias( balancesPositivos(gananciaTotalDelAnio) )

=> [2,10,4]

Y usando estas dos funciones, también podemos crear una función nuevamente que nos retorne solamente esos
valores:

function gananciasDeBalancesPositivos (balancesDeUnPeriodo) {

return ganancias( balancesPositivos(balancesDeUnPeriodo)) ;

Y si buscamos esa función en la consola nos va a retornar esos valores:

gananciasDeBalancesPositivos(gananciaTotalDelAnio)

=> [2,10,4]

Ahora ya tenemos la función que nos retorna las ganancias de los balances positivos de la lista; nos faltaría usar esa
función y combinarla nuevamente con la función promedio genérico que ya habíamos visto:

function promedio(listaDeNumeros) {
 return sumatoria(listaDeNumeros) / longitud(listaDeNumeros);

¿Cómo hacemos esto? De la siguiente forma:

Vamos a definir una función que la vamos a llamar promedioDeBalancesPositivos que recibe una lista con los
balances de un periodo, por ejemplo, la lista gananciaTotalDelAnio y nos va a retornar el promedio de las ganancias
de los balances positivos de esa lista:

function promedioDeBalancesPositivos (balancesDeUnPeriodo) {

return promedio( gananciasDeBalancesPositivos (balancesDeUnPeriodo));

¿Como funciona la función promedioDeBalancesPositivos?

La función promedioDeBalancesPositivos (balancesDeUnPeriodo) funciona de la siguiente forma:

Supongamos que tenemos la siguiente lista con los siguientes registros:

let gananciaTotalDelAnio = [

{ mes: "Enero", ganancia: 2 },

{ mes: "Febrero", ganancia: 10 },

{ mes: "Marzo", ganancia: 4 },

{ mes: "Abril", ganancia: 0 },

{ mes: "Mayo", ganancia: -10 },

];

La función primeramente va a mapear los registros de la lista uno por uno y va a ir descartando los registros
negativos y que dieron 0 de la siguiente forma:

¿Como Trabaja la función?

function promedioDeBalancesPositivos (balancesDeUnPeriodo) {

return promedio ( gananciasDeBalancesPositivos (gananciaTotalDelAnio)) {

ganancias (balancesPositivos(gananciaTotalDelAnio)) {

let ganancias = [ ]

for (let ListaDeBalance of balancesPositivos(gananciaTotalDelAnio))

let nuevaLista = [];

for (let listaDeRegistros of gananciaTotalDelAnio) {

if( listaDeRegistros.ganancia > 0 ) {

push ( nuevaLista, listaDeRegistros ) }

} return nuevaLista; => [ { mes: "Enero", ganancia: 2},

{ mes: "Febrero", ganancia: 10 },

 } { mes: "Marzo", ganancia: 4 } ];

push (ganancias, ListaDeBalance.ganancia); }

return ganancias ; => [2,10,4]

return sumatoria(listaDeNumeros) / longitud(listaDeNumeros)

[2 + 10 + 4] / length: [ 3 ] => 5.333333333333333

Lo que hicimos fue una operación compleja en la que encapsulamos las funciones para que de a poco nos vaya
dando valores que van a ser reutilizados para que nos den nuevos valores; si buscamos esta función en la consola nos
daría:

promedioDeBalancesPositivos (gananciaTotalDelAnio)

=> 5.333333333333333

Ahora vamos a crear una nueva función, valorMaximo, que nos permite conocer cuál es el mayor valor en una lista
de números. Por ejemplo:

valorMaximo([5, 8, 10, 42, 87, 776])

776

Para crear esta función hacemos uso del spread operator, pero…

¿QUE ES EL SPREAD OPERATOR?

La sintaxis extendida o spread syntax, más conocida como el spread operator; permite a un elemento iterable tal
como un arreglo o cadena ser expandido en lugares donde cero o más argumentos (para llamadas de función) o
elementos (para Array literales) son esperados, o a un objeto ser expandido en lugares donde cero o más pares de
valores clave (para literales Tipo Objeto) son esperados, por ejemplo:

function sum(x, y, z) {

return x + y + z;

let numeros = [1, 2, 3];

console.log(sum( ... numeros));

// Expected output: 6

console.log(sum.apply(null, numeros));

// Expected output: 6

El operador Spread son los 3 puntos suspensivos ( . . . ) que colocamos en la función y nos permite expandir o
distribuir los elementos de un array o objeto en las partes del código donde se admitan esos elementos; vamos a ver
ejemplos para entender esto:

Supongamos que tenemos el siguiente array o lista con los siguientes elementos:

let lista1 = [1 ,2 ,3];

Si quisiéramos copiar este array, lo podemos hacer de la siguiente forma usando el spread operator:

let lista1Copia = [ … lista1];

Con el spread operator podemos distribuir los elementos de la lista1 en la lista1Copia, ya que esperamos que
lista1Copia contenga los elementos separados o distribuidos de lista1 con la coma , y como spread operator sirve
para expandir elementos, termina distribuyendo los mismos elementos en la copia de la siguiente forma:

let lista1Copia = [ . . . lista1 ] ;

Lo que realizamos aquí fue como si estuviéramos poniendo los mismos elementos separados con comas. Si
realizamos una impresión de lista1Copia, lo que nos muestra es lo siguiente:

console.log(lista1Copia);

lista1Copia

=> [1,2,3]

Entonces vemos que lista1Copia contiene los mismos elementos que lista1, ya que el spread operator nos expande
los elementos del array lista1 con comas.

Tambien podemos unir dos arrays con el spread operator de la siguiente forma, por ejemplo si tenemos 2 listas con
numeros, podemos unir ambas listas en un solo array con los elementos expandidos y distribuidos con comas, asi:

let lista1 = [1, 2, 3];

let lista2 = [4, 5, 6];

let listaResultante = [ … lista1, … lista2];

Si buscamos en la consola nos daría:

listaResultante

[1, 2, 3, 4, 5, 6]

Y también podemos añadir mas elementos a la listaResultante si quisiéramos de la siguiente forma:

let listaResultante = [ … lista1, … lista2, 7, 8, 9];

Y nos daría:

listaResultante

[1, 2, 3, 4, 5, 6, 7, 8, 9]
Ahora bien, también podemos usar el Spread Operator para crear la función valorMaximo que agarra una lista y
retorna el máximo valor de la lista de la siguiente forma:

function valorMaximo(numero){

return Math.max(...numero)

Si tenemos la siguiente lista:

let listaDeNumeros = [5, 8, 10, 42, 87, 776]

Y buscamos en la consola la funcion valorMaximo, nos va a retornar:

valorMaximo( [5, 8, 10, 42, 87, 776] )

776

O podemos buscar directamente la lista:

valorMaximo(listaDeNumeros)

=> 776

Del mismo modo podemos crear la función valorMinimo, que nos retorna el mínimo valor de la lista:

function valorMinimo(numero) {

return Math.min(...numero)

Si tuviéramos la siguiente lista de números:

let listaDeNumeros2 = [5, 8, 10, 42, 87, 776, 1002, -32]

Y buscamos en la consola la función valorMinimo, nos retorna el valor mínimo de la lista, así:

valorMinimo(listaDeNumeros2)

=> -32

Estas funciones podemos combinarlas con la función ganancias para que nos diga cuál es la ganancia más alta entre
los balances de un período de tiempo, de la siguiente forma:

function maximaGanancia(balances){

return valorMaximo(ganancias(balances))

¿Qué hicimos acá? Bueno ¿te acordas lo que hace la función ganancias? La función ganancias nos devuelve una lista
con las ganancias de un periodo:

function ganancias(balancesDeUnPeriodo) {

let ganancias = []
 for (let balance of balancesDeUnPeriodo) {

agregar(ganancias, balance.ganancia);

return ganancias; => [2,10,4] // La función ganancias nos retorna esta lista//

Asi que supongamos que tenemos la siguiente lista:

let balancesDelAnio = [

{ mes: "Marzo", ganancia: 5 },

{ mes: "Junio", ganancia: 15 },

{ mes: "Julio", ganancia: - 8 },

{ mes: "Agosto", ganancia: - 4 },

{ mes: "Noviembre", ganancia: 0 },

{ mes: "Diciembre", ganancia: 20 },

];

La función ganancias nos va a retornar esta lista:

ganancias(balancesDelAnio)

=> [5,15,-8,-4,0,20]

Porque recordemos que la función ganancias va a retornar una lista con todos los campos.ganancia que le pasemos,
tanto los positivos como los negativos y los 0. Así funciona la función ganancias:

function ganancias(balancesDelAnio) {

let ganancias = []

for ( let balance of balancesDelAnio ) {

agregar(ganancias, balance.ganancia);

return ganancias; => [5,15,-8,-4, 0, 20] // La función ganancias nos retorna esta lista//

Bien ahora que recordamos como funciona la función ganancias, vamos a ver cómo trabaja con la función
valorMaximo dentro de la función maximaGanancia:

function maximaGanancia(balancesDelAnio){

return valorMaximo(ganancias(balancesDelAnio)) {

let ganancias = []

for ( let nuevaListaDeRegistros of balancesDelAnio ) {

 agregar(ganancias, nuevaListaDeRegistros.ganancia);

return ganancias; => [5,15,-8,-4, 0, 20] // La función ganancias nos retorna esta nueva lista//

} return Math.max(...ganancias) ;

} => [5,15,-8,-4, 0, 20] => 20 // Este es el resultado de la función maximaGanancia//

Si probamos en la consola la función maximaGanancia nos retorna :

maximaGanancia(balancesDelAnio)

=> 20

También podemos crear una función que nos de el valorMinimo de la siguiente forma:

function minimaGanancia(balances){

return valorMinimo(ganancias(balances));

Si probamos en la consola esta función nos retorna una lista que nos entrega la ganancia mínima de todos los
balances, los positivos y los negativos, quedaría algo así:

minimaGanancia(balancesDelAnio)

=> - 8 // Nos -8 porque esta función no tiene un tope inferior//

¿Y como hacemos si queremos que esta función solamente nos entregue las ganancias positivas?

Bueno para ello, tenemos que filtrar o mapear la lista (balancesDelAnio) por ejemplo, de la siguiente forma:

function minimaGananciaPositiva(balancesDeUnPeriodo){

return valorMinimo(gananciasDeBalancesPositivos(balancesDeUnPeriodo));

function minimaGananciaPositiva(balancesDeUnPeriodo){

return valorMinimo(gananciasDeBalancesPositivos (balancesDeUnPeriodo) )

gananciasDeBalancesPositivos (balancesDeUnPeriodo) {

ganancias( balancesPositivos(balancesDeUnPeriodo)) ;

balancesPositivos(balancesDeUnPeriodo) {

let nuevaLista = [];

for (let listaDeRegistros of balancesDeUnPeriodo) {

if(listaDeRegistros .ganancia > 0 ){

 agregar(nuevaLista, listaDeRegistros)}

}return nuevaLista; => [ {mes:"Marzo",ganancia:5},

{mes:"Junio",ganancia:15},

{mes:"Diciembre",ganancia:20} ]

let ganancias = []

for (let balances of otraNuevaLista) {

agregar(ganancias, balances.ganancia);

return ganancias; => [5,15,20]

return valorMinimo(gananciasDeBalancesPositivos ( [5,15,20] )

return Math.min(...[5,15,20] );

} => 5

Si buscamos la función en la consola nos va a dar:

minimaGananciaPositiva(balancesDelAnio)

=> 5

Hay que aclarar que la explicación del ejemplo es de modo que podamos visualizar como trabaja la computadora, y
para esto desplegamos cada función con sus respectivos códigos, por lo que cuando programemos las estructuras de
códigos cada función se tiene que realizar por separado y NO todas juntas como se muestra aquí. Recuerda que una
función puede encapsular una o varias expresiones, pero cada función se realiza a modo de subtarea.

Por Último veamos más ejemplos de funciones y veamos la diferencia entre mapear e iterar: Recuerda que Mapear
es recorrer una lista o registro y mapearla o transformala; por ejemplo:

Si queremos crear una lista con registro de meses y queremos modificarla a que solo nos muestre la lista de meses, lo
hacemos de la siguiente manera:

let listaDeMeses = [

{ mes: "enero", ganancia: 870 },

{ mes: "febrero", ganancia: 1000 },

{ mes: "marzo", ganancia: 1020 },

{ mes: "abril", ganancia: 2300 },

{ mes: "mayo", ganancia: -940 },

{ mes: "junio", ganancia: 1060 },

{ mes: "julio", ganancia: 2400 },

{ mes: "agosto", ganancia: -2700 }

];
function meses(listaDeRegistros) {

let meses = [];

for (let elementoRegistro of listaDeRegistros) {

agregar(meses, elementoRegistro.mes);

return meses ;

Si buscamos en la consola podemos ver:

meses(listaDeMeses)

=> ["enero","febrero","marzo","abril","mayo","junio","julio","agosto"]

Entonces vemos que en el ejemplo mapeamos la lista con los registros y lo transformamos en una nueva lista.

Ahora vamos a ver otro ejemplo en el que filtramos aquellos registros que tuvieron una ganancia mayor a $1000:

let listaDeMeses = [ { mes: "enero", ganancia: 870 }, { mes: "febrero", ganancia: 1000 },

{ mes: "marzo", ganancia: 1020 }, { mes: "abril", ganancia: 2300 },

{ mes: "mayo", ganancia: -940 }, { mes: "junio", ganancia: 1060 },

{ mes: "julio", ganancia: 2400 }, { mes: "agosto", ganancia: -2700 } ];

function mesesAfortunados(listaDeRegistros) {

let meses = [];

for (let elementoRegistro of listaDeRegistros) {

if (elementoRegistro.ganancia > 1000) {

agregar(meses, elementoRegistro);

return meses ;

Si buscamos en la consola vamos a ver solamente los meses con los registros positivos y que superaron a 1000:

mesesAfortunados(listaDeMeses)

[{mes:"marzo",ganancia:1020},{mes:"abril",ganancia:2300},{mes:"junio",ganancia:1060},{mes:"julio",ganancia:2400]
 Por último, podemos combinar ambas funciones para mapear una lista con registros y obtener solamente los meses
que tuvieron una ganancia mayor a 1000:

let listaDeMeses = [ { mes: "enero", ganancia: 870 }, { mes: "febrero", ganancia: 1000 },

{ mes: "marzo", ganancia: 1020 }, { mes: "abril", ganancia: 2300 },

{ mes: "mayo", ganancia: -940 }, { mes: "junio", ganancia: 1060 },

{ mes: "julio", ganancia: 2400 }, { mes: "agosto", ganancia: -2700 } ];

function mesesAfortunadosFinal(listaDeRegistros) {

return meses (mesesAfortunados (listaDeRegistros) )

Nuevamente vamos a desplegar la función con los códigos para entender como trabaja la misma:

function mesesAfortunadosFinal(listaDeRegistros) {

return meses (mesesAfortunados (listaDeRegistros) )

let meses = [];

for (let elementoRegistro of listaDeRegistros) {

if (elementoRegistro.ganancia > 1000) {

push(meses, elementoRegistro);

return meses ; => [ {mes:"marzo", ganancia:1020} ,

} {mes:"abril", ganancia:2300} ,

{mes:"junio", ganancia:1060} ,

{mes:"julio", ganancia:2400} ]

let meses = [];

for (let elementoRegistro of listaDeRegistros) {

if (elementoRegistro.ganancia > 1000) {

push(meses, elementoRegistro);

return meses ; => ["marzo","abril","junio","julio"]

}
Al final si buscamos la función en la consola nos daría:

mesesAfortunadosFinal(listaDeMeses)

=> ["marzo","abril","junio","julio"]