JavaScript O también podemos 

concatenarlos, es decir, obtener uno nuevo que

junta dos strings:
function doble(numero) {
return 2 * numero;
}
"aa" + "bb"
"aabb"
function mitad(numero) {
"sus anaqueles " + "registran todas las combinaciones"
return numero / 2;
"sus anaqueles registran todas las combinaciones"
}

function doble(numero) { O podemos preguntarles si uno comienza con otro:

return 2 * numero;
}

function siguiente(numero) { comienzaCon("una página", "una")

return numero + 1; true
} comienzaCon("la biblioteca", "todos los fuegos")
false
function siguienteDelDoble(numero) {
return siguiente(doble(numero)); function longitudNombreCompleto(nombre, apellido){
} return longitud(nombre + apellido + 1);
}
function cuantoSaleAproximadamente(precio, impuestos) {
return Math.round(precio * impuestos); function gritar(letra){
} return "¡" + convertirEnMayuscula(letra) + "!";
}
function extraer(saldo, monto) {
return Math.max(saldo - monto, 0); function maximo(numero1, numero2) {
} if (numero1 >= numero2) {
return numero1;
en JavaScript contamos con operadores como ===, >=, >, <, <= que } else {
return numero2;
nos dicen si dos valores son iguales, mayores-o-iguales, mayores, etc.
}
la función que nos sirve para redondear un número es Math.round
}
function leGustaLeer(numero) {
function signo(numero) {
return numero >= 20 ;
if (numero === 0) {
}
return 0;
} else if (numero > 0) {
return 1;
} else {
return -1;
 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 function esNumeroDeLaSuerte(numero) {
 Se puede hacer la disyunción lógica entre dos booleanos return numero>0 && numero<100 && numero!==15 ;
}
(or, también conocido en español como o lógico), mediante
el operador ||: unaExpresion || otraExpresion
function medallaSegunPuesto(numero) {
if (numero === 1) {
return "oro";
la función Math.max nos sirvió para implementar un tope inferior. De } else if (numero === 2) {
return "plata";
forma análoga, la función Math.min nos puede servir para
} else if (numero === 3) {
implementar un tope superior.
return "bronce";
} else {
function estaEntre(numero1, numero2, numero3) {
return "nada";
return numero1 > numero2 && numero1 < numero3 ;
}
}
}
function estaFueraDeRango(numero1, numero2, numero3) {
return numero1 < numero2 || numero1 > numero3 ;
}

function esFinDeSemana(dia) {
return dia === "sábado" || dia === "domingo" ;
}

¿Y qué podemos hacer con los strings, además de compararlos?

¡Varias cosas! Por ejemplo, podemos preguntarles cuál es su cantidad
de letras: Además, existen operaciones que sirven para todos los tipos de datos,
por ejemplo:

longitud("biblioteca")  ===: nos dice si dos cosas son iguales

10
longitud("babel")  !==: nos dice si dos cosas son diferentes
5
  function longitud(unString) /* ... */ function escribirCartelito (título, nombre, apellido, cartelcorto){
 // Retorna cuan largo es un string
if (cartelcorto) {
 // Por ejemplo:
 // longitud("hola") return título+ " " + apellido ;
 // 4
 } else {
 function convertirEnMayuscula(unString) /* ... *
return título+ " " + nombre + " " + apellido ;
 // Convierte una palabra en mayúsculas
 // Por ejemplo:
}
 // convertirEnMayuscula("hola")
 // "HOLA" }

 function comienzaCon(unString, otroString) /* ... */
 // Retorna un booleano que nos dice si unString empieza con
otroString function escribirCartelitoOptimo (titulo, nombre, apellido) {
 // Por ejemplo:
return escribirCartelito(titulo, nombre, apellido, longitud(nombre +
 // comienzaCon("hola todo el mundo", "hola todo") apellido) > 15);
 // true
}

function cuantoCuesta (monitor, memoria){

return monitor*60 + memoria*200 + 1000 ;
} function decisionConMoneda(cara, comida1,comida2) {

function meConviene (pulgadas, memoria){ if (cara==="cara"){ return comida1 ;}

return cuantoCuesta (pulgadas, memoria)<6000 && pulgadas>=32 &&
memoria>=8 ;
} else{ return comida2 ;}

function perimetroTriangulo (lado1, lado2, lado3){ }

return lado1 + lado2 + lado3 ;
}

function areaTriangulo (base, altura){

function valorEnvido(carta) {
return (base * altura)/2 ;
}
if (carta>=10 && carta<=12) { return 0;}
function perimetroCuadrado (lado){
return lado*4 ; else if (carta>=1 && carta<=7) { return carta; }
}
else { return "No existe";}
function areaCuadrado (lado){
return lado*lado ;
} }

function estaAfinado (frecuencia){

return frecuencia===440 ;

function estaCerca (frecuencia){

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

function escribirCartelito (título, nombre, apellido){

return título+ " " + nombre + " " + apellido ;

}
function puntosDeEnvidoTotales (carta1, palo1, carta2, palo2) {

if (palo1===palo2) {return valorEnvido(carta1) + valorEnvido(carta2) +

20 ;}

else {return Math.max (valorEnvido(carta1), valorEnvido(carta2));}

function valorCantoTruco (canto) {

if (canto==="truco") {return 2;}

else if (canto==="retruco") {return 3;}

else (canto==="vale cuatro") {return 4;}

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

function funcionEgocentrica() {

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

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

return 5;

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}

 funciones, que siempre retornan algo y no producen ningún

efecto
 procedimientos, que no retornan nada, y producen efectos

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

} }

let mochilaAbierta = true;

function usarCierre () {
 si operamos dos números con +, se suman mochilaAbierta = !mochilaAbierta;
 si operamos dos strings con +, se concatenan }
------------------------------------
 si operamos un string y un número +, se convierte function esMayorDeEdad(edad) {
implícitamente el número a string, y luego se concatenan, al return edad >= 18 ;
igual que antes }
function esMenorDeEdad(edad) {
return !esMayorDeEdad (edad) ;
}
function elefantesEquilibristas(numero){ ----------------------------------------
return numero + " elefantes se balanceaban"; function esPeripatetico (profesión, nacionalidad, kmdcaminata) {
} return (profesión==="filosofo" && nacionalidad==="griego" &&
kmdcaminata > 2) ;
function perimetroCirculo (radio){ }
return 3.14159265358979 * 2 * radio; ------------------------------------
} function gano(cumplioObjetivoSecreto, cantidadDePaisesConquistados) {
return cumplioObjetivoSecreto || cantidadDePaisesConquistados >= 30;
function areaCirculo (radio){ }
return 3.14159265358979 * radio * radio; --------------------------
} function esFinDeSemana (dia){
return dia === "sábado" || dia === "domingo" ;
let pi = 3.14159265358979; }
function perimetroCirculo (radio){ function estaCerrado(esFeriado, dia, horario) {
return pi * 2 * radio; return esFeriado || esFinDeSemana (dia) || !dentroDeHorarioBancario
} (horario) ;
}
function areaCirculo (radio){ -----------------------------------
return pi * radio * radio; function tieneContraste (colorletra, colorfondo){
} return (esTonoClaro(colorletra) && !esTonoClaro (colorfondo)) ||
(esTonoClaro (colorfondo) && !esTonoClaro(colorletra))
function cuentaExtravagante(unNumero) { }
let elDoble = unNumero * 2; -------------------------------------------
if (elDoble > 10) { function xor (A,B){
return elDoble; return (A && !B)||(B && !A) ;
} else { }
return 0; ------------------------------------------
} function pagaConTarjeta(seCobraInteres, tarjeta, efectivoDisponible) {
} return !seCobraInteres && cuotas(tarjeta) >= 3 || efectivoDisponible <
100;
let cargaMaximaEnKilogramos = 300; }
------------------------------
function ascensorSobrecargado(personas) {  precedencia 1) la negación !, 2) seguida de la conjunción && y 3) por
return personas*pesoPromedioPersonaEnKilogramos >= último la disyunción || .
cargaMaximaEnKilogramos;
} function sePuedeConcentrar(bebida, temperatura, estaProgramando){
return bebida==="mate" && temperatura===80 && estaProgramando ||
function aumentarFortuna () { bebida==="té"&& temperatura>=95 && estaProgramando ;
pesosEnMiBilletera = pesosEnMiBilletera * 2; }
}
function sePuedeConcentrar(infusion, temperatura, estaProgramando) {
ATAJOS EN JAVA return infusionATemperaturaCorrecta(infusion, temperatura) &&
x += y; //equivalente a x = x + y; estaProgramando;
x *= y; //equivalente a x = x * y; }
x -= y; //equivalente a x = x - y;
x++; //equivalente a x = x + 1; ----------------------------------------
function altoOacompañado (altura, acompañado){
return altura >= 1.5 || (altura >= 1.2 && acompañado) ;
EJEMPLO: }
let numero = 8; => aca declaras la variable numero y la inicias en 8. function puedeSubirse (altura, acompañado, afección) {
numero = 2; => aca usas esa variable numero que ya sabes que es 8 => return altoOacompañado (altura, acompañado) && !afección;
numero=2 que es igual a 16 numero += 4; => de nuevo usas la }
variable numero pero que ahora vale 16 => numero+=4 que es igual a -----------------------------------
20 return numero; => retorna numero que ahora es 20 para representar a un conjunto de strings, colocamos todos esos
Poner numero *= 2; => Es igual a poner numero= numero *2 => strings que nos interesan, entre corchetes ([ y ]) separados por
numero = 8 *2 => numero= 16 numero +=4 => es igual a poner comas.
numero= numero +4 => numero= 16+4 => numero =20
let seriesFavoritasDeAna = ["Game of Thrones", "Breaking Bad", "House
let lamparaPrendida = true; of Cards"];
let seriesFavoritasDeHector = ["En Terapia", "Recordando el Show de
function apretarInterruptor() { Alejandro Molina"]
lamparaPrendida = !lamparaPrendida; --------------------------------
let pertenencias = ["espada", "escudo", "antorcha"];
//longitud(pertenencias) devuelve 3; function comienzaCon(unString, otroString) /* ... */
// Retorna un booleano que nos dice si unString empieza con otroString
agregar(pertenencias, "amuleto mágico"); // Por ejemplo:
//ahora longitud(pertenencias) devuelve 4 // comienzaCon("hola todo el mundo", "hola todo")
---------------------------------------- // true
let pertenencias = ["espada", "escudo", "antorcha"];
//longitud(pertenencias) devuelve 3; function imprimir(unString) /* ... */
// Imprime por pantalla unString
agregar(pertenencias, "amuleto mágico"); // Por ejemplo:
//ahora longitud(pertenencias) devuelve 4 // imprimir("¡estoy imprimiendo!")
-------------------------------------- // ¡estoy imprimiendo!
function trasladar (lista1, lista2, elemento){
remover(lista1, elemento); function tirarDado() /* ... */
agregar(lista2, elemento); // Retorna un número al azar entre 1 y 6
} // Por ejemplo:
------------------------------- // tirarDado()
posicion(["a", "la", "grande", "le", "puse", "cuca"], "grande"); //devuelve 2 // 5
// tirarDado()
let diasLaborales = ["lunes", "martes", "miercoles", "jueves", "viernes"] // 1
posicion(diasLaborales, "lunes"); //devuelve 0 // tirarDado()
---------------------------------------- // 2
function contiene(lista, elemento){
return posicion (lista, elemento) >= 0; function listasIguales(unArray, otroArray) /* ... */
} // Retorna un booleano que nos dice si dos listas son iguales
-------------------------------- // Por ejemplo:
* posicion en realidad devuelve la posición de la primera aparición del // listasIguales([1, 2, 3], [1, 2, 3])
elemento en la lista. // true
posicion(["qué", "es", "eso", "eso", "es", "queso"], "es") // listasIguales([1, 2, 3], [4, 5, 3])
1 //devuelve 1 porque si bien "es" también está en la posición 4, aparece // false
primero en la posición 1.
function longitud(unStringOLista) /* ... */
// Retorna el largo de un string o una lista
Así como existe una función para averiguar en qué posición está un
// Por ejemplo:
elemento, también puede ocurrir que queramos saber lo contrario:
// longitud("hola")
qué elemento está en una cierta posición. 
// 4
// longitud([5, 6, 3])
Para averiguarlo podemos usar el operador de indexación, // 3
escribiendo después de la colección y entre corchetes [] la posición
que queremos para averiguar: ej: function agregar(unaLista, unElemento) /* ... */
// Inserta unElemento al final de unaLista.
// Este es un procedimiento que no retorna nada pero modifica a unaLista:
// let cancionesFavoritas = ["La colina de la vida", "Zamba por vos"]
mesesDelAnio[0] // agregar(cancionesFavoritas, "Seminare")
"enero" // cancionesFavoritas
["ese", "perro", "tiene", "la", "cola", "peluda"][1] // ["La colina de la vida", "Zamba por vos", "Seminare"]
"perro"
----------------------------------- function remover(unaLista, unElemento) /* ... */
function medallaSegunPuesto(puesto){ // Quita unElemento de unaLista. En caso de que no esté, no hace nada.
let medallas =["oro","plata","bronce"] // Este es un procedimiento que no retorna nada pero modifica a unaLista:
if (puesto<=3&& puesto >=1) { // let listaDeCompras = ["leche", "pan", "arroz", "aceite", "yerba"]
return medallas[puesto-1] // remover(listaDeCompras, "pan")
} else { // listaDeCompras
return "nada" // ["leche", "arroz", "aceite", "yerba"]
}
} function posicion(unaLista, unElemento) /* ... */
---------------------------------------- // Retorna la posición en que se encuentra unElemento en unaLista.
for(let precio of [10, 100, 87 ]) { // Si el elemento no está en la lista, retorna -1
plataEnBilletera = plataEnBilletera - precio // let premios = ["dani", "agus", "juli", "fran"]
} // posicion(premios, "dani")
// 0
function saludar(personas) { // posicion(premios, "juli")
for(let persona of personas) { // 2
imprimir ("hola " + persona ); // posicion(premios, "feli")
} // -1
}
-------------------------------- -----------------------------------------------------
function longitud(unString) /* ... */ -------------------------------------------------------
// Retorna cuan largo es un string
// Por ejemplo: Registros
// longitud("hola")
// 4
let torreEiffel = { nombre: "Torre Eiffel", locacion: "París, Francia",
anioDeConstruccion: 1889 };
function convertirEnMayuscula(unString) /* ... */
// Convierte una palabra en mayúsculas
// Por ejemplo: ¿en qué se diferencia un registro de una lista?
// convertirEnMayuscula("hola")
// "HOLA" 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 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.
------------------------------------------------
function temperaturaDePlaneta(planeta){
return planeta.nombre+" tiene una temperatura promedio de
"+planeta.temperaturaPromedio+" grados";
}
---------------------------------------
Ahora imagina 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...
leeme
{ ruta: "C:\leeme.txt", creacion: "23/09/2004" }
moverArchivo(leeme, "C:\documentos\leeme.txt")
Luego el registro leeme tendrá modificada su ruta:
leeme
{ ruta: "C:\documentos\leeme.txt", creacion: "23/09/2004" }
----------------------------------------------------
function moverArchivo(registro, nuevaRuta)
{ registro.ruta= nuevaRuta ;
} En este ejercicio tenemos que usar la función gananciaTotal, que si
------------------------------------------------------
function esDelMilenioPasado(archivo){
return anio(archivo.creacion) < 2000
}
-----------------------------------------------------
function masDificilDeCocinar(postre, postre1) {
if (longitud (postre.ingredientes) >= longitud (postre1.ingredientes)) {
return postre;}
else {return postre1;}
}
---------------------------------------------
function agregarAPostresRapidos(lista, postre){
if(postre.tiempoDeCoccion <= 60){agregar(lista,postre)}
}
-------------------------------------------------
let menuDelDia = {
platoPrincipal: "bife de lomo",
ensalada: ["papa", "zanahoria", "arvejas"],
postre: { ingredientes: ["queso crema", "frambuesas"], tiempoDeCoccion:
80 }
};
---------------------------------------------------
function endulzarMenu(regMenu){
agregar(regMenu.postre.ingredientes, "azúcar");
}
------------------------------------------------------
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 }
];
function gananciaSemestre(balances) {
return balances[0].ganancia + balances[1].ganancia +
balances[2].ganancia + balances[3].ganancia +
balances[4].ganancia + balances[5].ganancia;
} }
------------------------------------------------
function gananciaTotal4(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;
}
----------------------------------------------------------
function gananciaTotal(balancesDeUnPeriodo) {
let sumatoria = 0;
for (let balance of balancesDeUnPeriodo) {
sumatoria = sumatoria + balance.ganancia;
}
return sumatoria;
}
------------------------------------------------------------
function cantidadDeBalancesPositivos(balancesDeUnPeriodo) {
let cantidad = 0;
for (let balance of balancesDeUnPeriodo) {
if (balance.ganancias > 0){
cantidad = cantidad + 1;
}
}
return cantidad;
}
cantidad es lo que en programación se conoce como contador, una
variable que se incrementa cada vez que hacemos algo dentro de
un for...of o solo aquellas veces que se cumpla una condición.
------------------------------
function gananciaPromedio(periodoBalance){
return (gananciaTotal(periodoBalance))/ longitud(periodoBalance)
}
vemos en el ejercicio 4, toma una lista de balances (a la que llamás
periodoBalance) y nos devuelve un número, que es la suma de las
ganancias de esos balances.
Por otro lado, la función longitud nos "cuenta" cuántos balances hay
en esa lista.
Como la consigna nos pide dividir la suma de las ganancias por la
cantidad de balances, nos alcanza con invocar estas dos funciones
para obtener los datos que necesitamos. Habrá otros casos donde
no contemos con las funciones necesarias y tendremos que
definirlas, accediendo a los campos que correspondan según el caso.
---------------------------------
function gananciaPositiva (balancesDeUnPeriodo){
let sumatoria = 0;
for (let balance of balancesDeUnPeriodo){
if(balance.ganancia > 0){
sumatoria = sumatoria + balance.ganancia;
}
}
return sumatoria;
}
function promedioGananciasPositivas (balancesDeUnPeriodo) {
let promedio = 0 ;
promedio = promedio + (gananciaPositiva (balancesDeUnPeriodo) /
cantidadDeBalancesPositivos (balancesDeUnPeriodo))
return promedio ;
}
Si quisiéramos realizar una función promedio genérica sería algo así:
function promedio(listaDeNumeros) {
return sumatoria(listaDeNumeros) / longitud(listaDeNumeros);
 if (balance.ganancia > 1000){
function sumatoria(listaDeNumeros) { agregar (afortunados,balance)
let sumatoria = 0; }
for (let numero of listaDeNumeros) { }
sumatoria = sumatoria + numero; return afortunados;
} }
return sumatoria;
} function mesesAfortunados(balancesDeUnPeriodo){
-------------------------------------------- return meses(afortunados(balancesDeUnPeriodo));
function agregar(unaLista, unElemento) /* ... */ }
// Inserta unElemento al final de unaLista. ----------------------------------------------
// Este es un procedimiento que no retorna nada pero modifica a una Lista:
// let cancionesFavoritas = ["La colina de la vida", "Zamba por vos"] Capítulo 3: Programación con Objetos
// agregar(cancionesFavoritas, "Seminare")
// cancionesFavoritas
// ["La colina de la vida", "Zamba por vos", "Seminare"]

function ganancias(balancesDeUnPeriodo) {
let ganancia = [];
for (let balance of balancesDeUnPeriodo) {
agregar (ganancia, balance.ganancia)
}
return ganancia;
}
Ahora ya sabemos cómo transformar cada elemento de una lista para
obtener una lista nueva . De esta manera podemos usar promedio con
nuestra lista de balances. Pero, ¿se puede utilizar la
función promedio solo para los balances positivos?
------------------------------------------
function balancesPositivos(balancesDeUnPeriodo) {
let balances = [];
for (let balance of balancesDeUnPeriodo) {
if (balance.ganancia > 0){
agregar(balances,balance)
}
}
return balances;
}
Ahora ya sabemos cómo filtrar una lista. En criollo, aprendimos a
obtener los elementos de una lista que cumplen una condición
determinada. En este caso obtuvimos una nueva lista con los
balances que presentaban una ganancia positiva. 
--------------------------------------
function gananciasDeBalancesPositivos(balancesDeUnPeriodo){
return ganancias(balancesPositivos(balancesDeUnPeriodo));
}

function promedioDeBalancesPositivos(balancesDeUnPeriodo) {
return promedio (gananciasDeBalancesPositivos(balancesDeUnPeriodo));
}
-----------------------------------------------
function maximaGanancia(balancesDeUnPeriodo){
return maximo(ganancias(balancesDeUnPeriodo));
}
----------------------------
function minimaGananciaPositiva (balancesDeUnPeriodo){
return minimo(gananciasDeBalancesPositivos(balancesDeUnPeriodo));
}
--------------------------------------------
En la función meses es necesario mapear, en afortunados filtrar y
en mesesAfortunados tenés que usar las dos anteriores.

function meses (balancesDeUnPeriodo){

let meses = [];
for (let balance of balancesDeUnPeriodo){
agregar(meses, balance.mes)
}
return meses;
}

function afortunados (balancesDeUnPeriodo){

let afortunados = [];
for (let balance of balancesDeUnPeriodo){