
```javascript
const nombre = 'Alejandro';
console.log(nombre.split(''));
console.log([...nombre]);
console.log(Array.from(nombre));
```


Explica este código JavaScript 😎


```javascript
anotherFn();

function anotherFn() {
  console.log(myNumber + myNumber);
}

let myNumber = 4;
```


Determina el resultado del siguiente código


```javascript
function sayHi(name) {
  return `Hi there, ${name}`;
}
console.log(sayHi()); // 🤔?
```


Explica este código JavaScript


```javascript
const value = { number: 10 };

const multiply = (x = { ...value }) => {
  console.log((x.number *= 2));
};

multiply(); //🤔?
multiply(); //🤔?
multiply(value); //🤔?
multiply(value); //🤔?

```

Explica este código JavaScript 🧐


```javascript
const fruits = [
  { id: 1, name: 'Lime', quantity: 3 },
  { id: 2, name: 'Apple', quantity: 2 },
  { id: 3, name: 'Pineapple', quantity: 4 },
];

const count = fruits.some((fruit) => fruit.quantity > 5);
```

¿Cuál es el resultado del siguiente código?


```javascript
const sayHi = () => {
  return (() => 'Hi Javascript!')();
};

console.log(typeof sayHi());
```



```javascript
const frutas = ['Mango', 'Manzana', 'Naranja', 'Pera'];
const { 3: pera } = frutas;
console.log(pera);
```


¿Qué crees que imprime el siguiente código?


```javascript
const fruits = [
  { id: 1, name: 'Lime', quantity: 5 },
  { id: 2, name: 'Apple', quantity: 30 },
  { id: 3, name: 'Pineapple', quantity: 3 },
];

const count = fruits.some((fruit) => fruit.quantity > 5);
```

¿Cuál es el resultado de count?



```javascript
const array = ['a', 'bb', 'ccc'];
const rta = array.map((item) => item.length);
```



```javascript
const timesThree = (num) => num * 3;
```

El código es un ejemplo de...


Analiza determinadamente el siguiente código


```javascript
const banda = 'Coldplay';
const canciones = ['Yellow', 'Fix You', 'Trouble'];
console.log(banda['length']);
console.log(canciones['len' + 'gth']);
```



```javascript
const myPromise = () => Promise.resolve('I have resolved!');
function firstFunction() {
  myPromise().then((res) => console.log(res));
  console.log('second');
}
async function secondFunction() {
  console.log(await myPromise());
  console.log('second');
}
firstFunction();
secondFunction();
```



```javascript
let num = 10;

const increaseNumber = () => num++;
const increasePassedNumber = number => number++;

const num1 = increaseNumber();
const num2 = increasePassedNumber(num1);

console.log(num1); // 🤔
console.log(num2); // 🤔
```


```javascript
const numeros = [1, 2, [3, 4], 5, 6, [7, 8], 9, 0];
console.log(numeros.flat()); // ?
```



```javascript
let greeting;
greetign = {}; // Typo!
console.log(greetign);
```


¿Qué imprime este código JavaScript?


```javascript
function compareMembers(person1, person2 = person) {
  if (person1 !== person2) {
    console.log('Not the same!');
  } else {
    console.log('They are the same!');
  }
}

const person = { name: 'Lydia' };
compareMembers(person);
```


Explica este código JavaScript 😬


```javascript
let name = 'Lydia';

function getName() {
  console.log(name);
  let name = 'Sarah';
}

getName();
```



```javascript
console.log(undefined || '0' || null || (undefined ?? 0));
```



```javascript
const person = {
  name: 'Lydia',
  age: 21,
};

for (const [x, y] of Object.entries(person)) {
  console.log(x, y); //🤔?
}
```


Explica este código JavaScript 🤔


```javascript
var status = '😎';

setTimeout(() => {
  const status = '😍';

  const data = {
    status: '🥑',
    getStatus() {
      return this.status;
    },
  };
  console.log(data.getStatus());
}, 0);
```



```javascript
const nombre = 'Cristian';
nombre = 'Fernando';
console.log(nombre);

const persona = {
  id: 1,
  nombre: 'Cristian',
};

persona.nombre = 'Fernando';
console.log(persona.nombre);
```



```javascript
const getList = ([x, ...y]) => [x, y]
const getUser = user => { name: user.name, age: user.age }

const list = [1, 2, 3, 4]
const user = { name: "Lydia", age: 21 }

console.log(getList(list)) 🤔?
console.log(getUser(user)) 🤔?
```



```javascript
console.log([...'Oscar']);
```



```javascript
//A
const multiplicar = (a) => (b) => a * b;
//B
const test = (nombre, accion) => {
  return accion(nombre);
};
console.log(test('Ana', console.log)); //Ana (por consola)
```


¿Cuál de las siguientes funciones es una Higher Order Function?


```javascript
[1, 2, 3].map((num) => {
  if (typeof num === 'number') return;
  return num * 2;
});
```



```javascript
function test() {
  let nombre = 'Alex';
  if (true) {
    console.log(nombre);
    let nombre = 'Oscar';
  }
}
console.log(test());
```



```javascript
const person = { name: 'nico', age: 28 };
const newPerson = person;
newPerson.name = 'santi';
console.log(person.name);
```


¿Cuál es resultado de person.name?

```javascript
const settings = {
  username: "lydiahallie",
  level: 19,
  health: 90
};

const data = JSON.stringify(settings, ["level", "health"]);
console.log(data); //🤔?
```


```javascript
const info = {
  [Symbol('a')]: 'b'
}
console.log(info); 🤔?
console.log(Object.keys(info)); 🤔?
```


```javascript
console.log('I want pizza'[0]);
```



```javascript
console.log(typeof ([] + []));
```



```javascript
const profesores = ['Oscar', 'Nico', 'Freddy', 'Christian', 'Angela'];
console.log(profesores.at(1)); //?
console.log(profesores.at(-1)); //?
console.log(profesores.at(10)); //?
console.log(profesores.at(3.8)); //?
console.log(profesores.at(-3.3)); //?
```



```javascript
const set = new Set();

set.add(1);
set.add('Lydia');
set.add({ name: 'Lydia' });

for (let item of set) {
  console.log(item + 2);
}
```



```javascript
let newList = [1, 2, 3].push(4);
console.log(newList.push(5)); //🤔?
```



```javascript
anotherFn();

function anotherFn() {
  console.log(myNumber + myNumber);
}

let myNumber = 8;
```



```javascript
const array = [1, 1, 1, 1, 1];
const rta = array.reduce((total, item) => total + item, 0);
```

¿Cuál es el valor retornado por rta?



```javascript
const arr = [];
console.log(Array.isArray(arr)); // ??
```



```javascript
function getItems(fruitList, ...args, favoriteFruit) {
  return [...fruitList, ...args, favoriteFruit]
}
getItems(["banana", "apple"], "pear", "orange"); //🤔?
```



```javascript
function checkAge(age) {
  if (age < 18) {
    const message = "Sorry, you're too young.";
  } else {
    const message = "Yay! You're old enough!";
  }
  return message;
}
console.log(checkAge(21)); //🤔?
```



```javascript
const persona = {
  id: 1,
  nombre: 'Fernando',
};
persona.nombre = 'Pedro';
console.log(persona.nombre);
```



```javascript
const emojis = ['✨', '🥑', '😍'];
emojis.map((x) => x + '✨');
emojis.filter((x) => x !== '🥑');
emojis.find((x) => x !== '🥑');
emojis.reduce((acc, cur) => acc + '✨');
emojis.slice(1, 2, '✨');
emojis.splice(1, 2, '✨');
```


¿Cuál de estos métodos modifica el array original?


```javascript
const numeros = [1, 2, 3, 4, 5];
numeros.length = 0;
console.log(numeros); // ?
```



```javascript
setInterval(() => console.log('Hi'), 1000);
```



```javascript
let x = 10;
if (true) {
  let y = 20;
  var z = 30;
  console.log(x + y + z);
}
console.log(x + z);
```



```javascript
function sumar(a, b) {
  return a + b;
}
sumar(2, 4);
```


🚀El siguiente código hace referencia a una función de tipo:


```javascript
const test = {
  if: 'Es un condicional',
  let: 'Es una manera de declarar variables',
  for: 'Es un bucle',
};
console.log(test.for); //??
```



```javascript
console.log(typeof ('22' - 0));
```



```javascript
const colorConfig = {
  red: true,
  blue: false,
  green: true,
  black: true,
  yellow: false,
};

const colors = ['pink', 'red', 'blue'];
console.log(colorConfig.colors[1]);
```



```javascript
const one = true || {} || null;
const two = null || 'hello' || '';
const three = 0 || [] || true;
console.log(one, two, three);
```

¿Cuál es la salida del siguiente código?


```javascript
const banda = {
  id: 1,
  nombre: 'Radiohead',
  'tipo de musica': 'Rock',
  albunes: ['Pablo Honey', 'Ok Computer', 'In Rainbows'],
};
console.log(banda['nom' + 'bre']);
```



```javascript
function makeMulti(x) {
  return (y) => x * y;
}

const five = makeMulti(5);
const rta = five(6);
console.log(rta);
```


¿Qué devuelve el siguiente código?


```javascript
let nombre = 'Cris';
let edad = 25;
console.log('Mi nombre es %s y tengo %d', nombre, edad);
```



```javascript
const banda = {
  id: 1,
  nombre: 'Radiohead',
  'tipo de musica': 'Rock',
  albunes: ['Pablo Honey', 'Ok Computer', 'In Rainbows'],
};
banda.vocalista = undefined;
console.log('vocalista' in banda);
delete banda['tipo de musica'];
console.log('tipo de musica' in banda);
```



```javascript
function fruits() {
  if (true) {
    var fruit1 = 'Apple';
    let fruit2 = 'Kiwi';
    const fruit3 = 'Banana';
  }
  console.log(fruit1);
  console.log(fruit2);
  console.log(fruit3);
}

fruits();
```



```javascript
const food = ['🍕', '🍫', '🥑', '🍔'];
const info = { favoriteFood: food[0] };

info.favoriteFood = '🍝';

console.log(food);
```



```javascript
function getAge(...args) {
  console.log(typeof args);
}

getAge(21);
```



```javascript
const nombres = ['Ana', 'Sofia', 'Carmen', ...['Cris']];
const [, , , miNombre] = nombres;
console.log(miNombre['length']);
```



```javascript
var nombre = 'Camila';
let apellido = 'Rodriguez';
const edad = 25;
const getDatosPersonales = () => {
  console.log(nombre);
  console.log(apellido);
  console.log(edad);
};
console.log(getDatosPersonales());
```



```javascript
function sum(num1, num2 = num1) {
  console.log(num1 + num2);
}
sum(10); //🤔?
```



```javascript
console.log('hola'.split('').reverse().join('')); // ?
```



```javascript
const num = parseInt("7*6", 10);
console.log(num); //?
```


```javascript
const fruits = [
  { id: 1, name: 'Kiwi', quantity: 5 },
  { id: 2, name: 'Banana', quantity: 30 },
  { id: 3, name: 'Pineapple', quantity: 3 },
];

const count = fruits.some((fruit) => fruit.quantity > 30);
```



```javascript
const getName = (obj) => {
  obj.name ??= 'Sin Nombre';
  return obj;
};
console.log(getName({}));
```



```javascript
const f = (arr) => Array.isArray(arr) && !arr.length;
console.log(f([1, 2, 3])); //?
console.log(f([0])); //?
console.log(f([])); //?
```



```javascript
let Alimento = function (comida) {
  this.comida = comida;
};

Alimento.prototype.comerHoy = () => console.log('Hoy toca comer:', this.comida);
const alimento = new Alimento('ensalada');

alimento.comerHoy(); //❓
```



```javascript
'use strict';

function myFunction() {
  return (pi = 3.1416);
}

console.log(myFunction());
```


¿Cuál es resultado de myFunction?


```javascript
// primera función
function sumar(a, b) {
  return a + b;
}

// segunda función
const sumar = (a, b) => {
  return a + b;
};
```



```javascript
const user = { name: 'Lydia', age: 21 };
const admin = { admin: true, ...user };

console.log(admin); //🤔?
```



```javascript
let objeto1 = { valor: 10 };
let objeto2 = objeto1;
let objeto3 = { valor: 10 };
console.log(objeto1 == objeto2);
console.log(objeto1 == objeto3);
objeto1.valor = 15;
console.log(objeto2.valor);
console.log(objeto3.valor);
```



```javascript
const one = false || {} || null;
const two = null || false || '';
const three = [] || 0 || true;
console.log(one, two, three); // 🤔?
```



```javascript
const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"];

for (let item in myLifeSummedUp) {
  console.log(item); //🤔?
}

for (let item of myLifeSummedUp) {
  console.log(item); //🤔?
}
```


```javascript
let a = 3;
let b = new Number(3);
let c = 3;

console.log(a == b);
console.log(a === b);
console.log(b === c);
```



```javascript
const output = `${[] && 'Im'}possible!
You should${'' && `n't`} see a therapist after so much JavaScript lol`;
```



```javascript
console.log(Number(2) === Number(2)); //🤔?
console.log(Boolean(false) === Boolean(false)); //🤔?
console.log(Symbol('foo') === Symbol('foo')); //🤔?
```




```javascript
console.log(`${((x) => x)('I love')} to program`);
```



```javascript
function greeting() {
  throw 'Hello world!';
}

function sayHi() {
  try {
    const data = greeting();
    console.log('It worked!', data);
  } catch (e) {
    console.log('Oh no an error!', e);
  }
}

sayHi();
```



```javascript
const name = "Lydia"

console.log(name()) 🤔?
```



```javascript
console.log(typeof null == 'object'); // ?
```



```javascript
console.log(typeof typeof 1);
```