Javascript 📑

// Comentario en una sola línea
/* Comentario en
varias líneas */

// declara una variable
var ourName
// almacena valores
myNumber = 5
myString = 'myVar'
// declarar variables con el operador de asignación
var myNum = 0
// sumar, restar, multiplicar y dividir
myVar = 5 + 10 // 15
myVar = 12 - 6 // 6
myVar = 13 * 13 // 169
myVar = 16 / 2 // 8
// incrementar o decrecer el valor
i++ // the equivalent of i = i + 1
i-- // the equivalent of i = i - 1;
// decimales
var ourDecimal = 5.7 // float

let obj = {
  name: 'FreeCodeCamp',
  review: 'Awesome',
}
Object.freeze(obj)
obj.review = 'bad' //se ignorará. Mutación no permitida
obj.newProp = 'Test' //se ignorará. Mutación no permitida
console.log(obj)
// { name: "FreeCodeCamp", review: "Awesome"}

// escapar de las comillas literales
var sampleStr = 'Alan dijo: "Pedro está aprendiendo JavaScript".'
// esto imprime: Alan dijo, "Peter está aprendiendo JavaScript".
// concatenar string
var ourStr = 'Yo voy primero. ' + 'Yo soy el segundo.'
// concatenando strings con +=
var ourStr = 'Yo voy primero. '
nuestroStr += 'Vengo segundo.'
// construyendo strings con variables
var ourName = 'freeCodeCamp'
var ourStr = 'Hola, nuestro nombre es ' + ourName + ', ¿cómo estás?'
// añadiendo variables a strings
var anAdjective = 'Impresionante'
var ourStr = 'freeCodeCamp es '
ourStr += anAdjective

'Alan Peter'.length // 10

let str = 'a string'
let splittedStr = str.split('')
// ​​​​​[ 'a', ' ', 's', 't', 'r', 'i', 'n', 'g' ]​​​​​
let joinedStr = splittedStr.join('')
// a string​​​​​

//el primer elemento tiene un índice de 0
var firstLetterOfFirstName = ''
var firstName = 'Ada'
firstLetterOfFirstName = firstName[0] // A
// encontrar el último carácter de un string
var firstName = 'Ada'
var lastLetterOfFirstName = firstName[firstName.length - 1] // a

const person = {
  name: 'Zodiac Hasbro',
  age: 56,
}
// Template literal con interpolación de varias líneas y strings
const greeting = `Hello, my name is ${person.name}!
I am ${person.age} years old.`
console.log(greeting)
// Hello, my name is Zodiac Hasbro!
// I am 56 years old.

var sandwich = ['peanut butter', 'jelly', 'bread'][
  // arrays anidados
  (['Bulls', 23], ['White Sox', 45])
]

var ourArray = [50, 60, 70]
var ourData = ourArray[0] // 50
// modificar un array con índices
var ourArray = [50, 40, 30]
ourArray[0] = 15 // equals [15,40,30]
// acceder a matrices multidimensionales con índices
var arr = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9],
  [[10, 11, 12], 13, 14],
]
arr[3] // [[10,11,12], 13, 14]
arr[3][0] // [10,11,12]
arr[3][0][1] // 11

// reverse() le da la vuelta al array
;[1, 'two', 3].reverse() // ​​​​​[ 3, 'two', 1 ]
// push() añade un elemento al final del array
var arr = [1, 2, 3]
arr.push(4) // arr is now [1,2,3,4]
// pop() para eliminar el último valor del array
var threeArr = [1, 4, 6]
var oneDown = threeArr.pop()
console.log(oneDown) // 6
console.log(threeArr) // [1, 4]
// shift() elimina el primer elemento del array
var ourArray = [1, 2, [3]]
var removedFromOurArray = ourArray.shift()
// [2, [3]].
// unshift() añade un elemento al principio del array
var ourArray = ['Stimpson', 'J', 'cat']
ourArray.shift() // ["J", "cat"]
ourArray.unshift('Happy') // ["Happy", "J", "cat"]

// el primer parámetro es el índice, el segundo indica el número de elementos a eliminar.
let array = ['today', 'was', 'not', 'so', 'great']
array.splice(2, 2)
// elimina 2 elementos empezando por el tercer elemento
// ['today', 'was', 'great']
// también devuelve un nuevo array que contiene el valor de los elementos eliminados
let array = ['I', 'am', 'feeling', 'really', 'happy']
let newArray = array.splice(3, 2) // ['really', 'happy']
// el tercer parámetro, representa uno o más elementos
function colorChange(arr, index, newColor) {
  arr.splice(index, 1, newColor)
  return arr
}
let colorScheme = ['#878787', '#a08794', '#bb7e8c', '#c9b6be', '#d1becf']
colorScheme = colorChange(colorScheme, 2, '#332327')
// hemos eliminado '#bb7e8c' y añadido '#332327' en su lugar
// colorScheme es ahora igual a ['#878787', '#a08794', '#332327', '#c9b6be', '#d1becf']

// Copia un número determinado de elementos a un nuevo array y deja el array original intacto
let weatherConditions = ['rain', 'snow', 'sleet', 'hail', 'clear']
let todaysWeather = weatherConditions.slice(1, 3)
// todaysWeather es igual a ['snow', 'sleet'];
// weatherConditions sigue siendo igual a ['rain', 'snow', 'sleet', 'hail', 'clear']

let fruits = ['apples', 'pears', 'oranges', 'peaches', 'pears']
fruits.indexOf('dates') // -1
fruits.indexOf('oranges') // 2
fruits.indexOf('pears') // 1, el primer índice en el que existe el elemento

var ourPets = [
  {
    animalType: 'cat',
    names: ['Meowzer', 'Fluffy', 'Kit-Cat'],
  },
  {
    animalType: 'dog',
    names: ['Spot', 'Bowser', 'Frankie'],
  },
]
ourPets[0].names[1] // "Fluffy"
ourPets[1].names[0] // "Spot"

let fruits = ['Banana', 'Orange', 'Apple', 'Mango']
fruits.includes('Mango') // true

// El código ES5 de abajo utiliza apply() para calcular el valor máximo de un array.
var arr = [6, 89, 3, 45]
var maximus = Math.max.apply(null, arr) // 89
// ...arr devuelve un array sin empaquetar. En otras palabras, extiende el array.
const arr = [6, 89, 3, 45]
const maximus = Math.max(...arr) // 89
// [...new Set(arr)] = array de valores únicos
const arr = [1, 2, 2, 3, 3, 4, 5, 5]
const uniq = [...new Set(arr)] // [1,2,3,4,5]
// copiar un array
let thisArray = [true, true, undefined, false, null]
let thatArray = [...thisArray]
// thatArray es igual a [true, true, undefined, false, null]
// thisArray no se modifica y es idéntico a thatArray
// combinar arrays
let thisArray = ['sage', 'rosemary', 'parsley', 'thyme']
let thatArray = ['basil', 'cilantro', ...thisArray, 'coriander']
// thatArray now equals  ['basil', 'cilantro', 'sage', 'rosemary', 'parsley', 'thyme', 'coriander']

const [a, b] = [1, 2, 3, 4, 5, 6]
console.log(a, b) // 1, 2
// acceder a cualquier valor utilizando comas para llegar al índice deseado
const [a, b, , , c] = [1, 2, 3, 4, 5, 6]
console.log(a, b, c) // 1, 2, 5
// recoger el resto de los elementos en un array separado.
const [a, b, ...arr] = [1, 2, 3, 4, 5, 7]
console.log(a, b) // 1, 2
console.log(arr) // [3, 4, 5, 7]

var watchList = [
  {
    Title: 'Inception',
    imdbRating: '8.8',
    Type: 'movie',
  },
  {
    Title: 'Interstellar',
    imdbRating: '8.6',
    Type: 'movie',
  },
  {
    Title: 'The Dark Knight',
    imdbRating: '9.0',
    Type: 'movie',
  },
  {
    Title: 'Batman Begins',
    imdbRating: '7.9',
    Type: 'movie',
  },
]
const rating = watchList.map(function (movie) {
  return { title: movie.Title, rating: movie.imdbRating }
})
/* [ { title: 'Inception', rating: '8.8' }, 
  { title: 'Interstellar', rating: '8.6' }, 
  { title: 'The Dark Knight', rating: '9.0' }, 
  { title: 'Batman Begins', rating: '7.9' } ]  */
// or...
const rating = watchList.map((movie) => ({
  title: movie.Title,
  rating: movie.imdbRating,
}))
/* [ { title: 'Inception', rating: '8.8' }, 
  { title: 'Interstellar', rating: '8.6' }, 
  { title: 'The Dark Knight', rating: '9.0' }, 
  { title: 'Batman Begins', rating: '7.9' } ]  */

var cat = {
  name: 'Whiskers',
  legs: 4,
  tails: 1,
  enemies: ['Water', 'Dogs'],
}

var myObj = {
  prop1: 'val1',
  prop2: 'val2',
}
var prop1val = myObj.prop1 // val1
var prop2val = myObj.prop2 // val2

var myObj = {
  'Space Name': 'Kirk',
  'More Space': 'Spock',
  NoSpace: 'USS Enterprise',
}
myObj['Space Name'] // Kirk
myObj['More Space'] // Spock
myObj['NoSpace'] // USS Enterprise

var dogs = {
  Fido: 'Mutt',
  Hunter: 'Doberman',
  Snoopie: 'Beagle',
}
var myDog = 'Hunter'
var myBreed = dogs[myDog]
console.log(myBreed) // "Doberman"

let userActivity = {
  id: 23894201352,
  date: 'January 1, 2017',
  data: {
    totalUsers: 51,
    online: 42,
  },
}
userActivity.data.online = 45 // o
userActivity['data'].online = 45 // o
userActivity['data']['online'] = 45

let users = {
  Alan: {
    age: 27,
    online: false,
  },
  Jeff: {
    age: 32,
    online: true,
  },
  Sarah: {
    age: 48,
    online: false,
  },
  Ryan: {
    age: 19,
    online: true,
  },
}
function getArrayOfUsers(obj) {
  let arr = []
  for (let key in obj) {
    arr.push(key)
  }
  return arr
}

// Actualización de las propiedades del objeto
var ourDog = {
  name: 'Camper',
  legs: 4,
  tails: 1,
  friends: ['everything!'],
}
ourDog.name = 'Happy Camper' // o
ourDog['name'] = 'Happy Camper'
// añadir nuevas propiedades
ourDog.bark = 'bow-wow' // o
ourDog['bark'] = 'bow-wow'
// eliminar properties
delete ourDog.bark

var alpha = {
  1:"Z",
  2:"Y",
  3:"X",
  4:"W",
  ...
  24:"C",
  25:"B",
  26:"A"
};
alpha[2]; // "Y"
alpha[24]; // "C"
var value = 2;
alpha[value]; // "Y"

var myObj = {
  top: 'hat',
  bottom: 'pants',
}
myObj.hasOwnProperty('top') // true
myObj.hasOwnProperty('middle') // false

var ourStorage = {
  desk: {
    drawer: 'stapler',
  },
  cabinet: {
    'top drawer': {
      folder1: 'a file',
      folder2: 'secrets',
    },
    'bottom drawer': 'soda',
  },
}
ourStorage.cabinet['top drawer'].folder2 // "secrets"
ourStorage.desk.drawer // "stapler"

// Teniendo en cuenta el siguiente código ES5:
var voxel = { x: 3.6, y: 7.4, z: 6.54 }
var x = voxel.x // x = 3.6
var y = voxel.y // y = 7.4
var z = voxel.z // z = 6.54
// la misma sentencia de asignación con la sintaxis de desestructuración de ES6
const { x, y, z } = voxel // x = 3.6, y = 7.4, z = 6.54
// para almacenar los valores de voxel.x en a, voxel.y en b, y voxel.z en c, también tienes esa libertad
const { x: a, y: b, z: c } = voxel // a = 3.6, b = 7.4, c = 6.54
// Desestructuración de variables de objetos anidados
const a = {
  start: { x: 5, y: 6 },
  end: { x: 6, y: -9 },
}
const {
  start: { x: startX, y: startY },
} = a
console.log(startX, startY) // 5, 6

// Desestructurar el objeto en un argumento propio de la función.
const profileUpdate = (profileData) => {
  const { name, age, nationality, location } = profileData
}
// también se puede hacer así:
const profileUpdate = ({ name, age, nationality, location }) => {}

const getMousePosition = (x, y) => ({
  x: x,
  y: y,
})
// la misma función reescrita para utilizar esta nueva sintaxis:
const getMousePosition = (x, y) => ({ x, y })

true
false

if (condition is true) {
  // se ejecuta la declaración
}

if (num > 10) {
  return 'Bigger than 10'
} else {
  return '10 or Less'
}

if (num > 15) {
  return 'Bigger than 15'
} else if (num < 5) {
  return 'Smaller than 5'
} else {
  return 'Between 5 and 15'
}

// esta declaración if...
function findGreater(a, b) {
  if (a > b) {
    return 'a is greater'
  } else {
    return 'b is greater'
  }
}
// equivale a este operador ternario
function findGreater(a, b) {
  return a > b ? 'a is greater' : 'b is greater'
}

// esta declaración if...
function findGreaterOrEqual(a, b) {
  if (a === b) {
    return 'a and b are equal'
  } else if (a > b) {
    return 'a is greater'
  } else {
    return 'b is greater'
  }
}
// equivale a este operador ternario
function findGreaterOrEqual(a, b) {
  return a === b ? 'a and b are equal' : a > b ? 'a is greater' : 'b is greater'
}

switch(num) {
  case value1:
    statement1;
    break;
  case value2:
    statement2;
    break;
...
  case valueN:
    statementN;
    break;
}

switch (num) {
  case value1:
    statement1;
    break;
  case value2:
    statement2;
    break;
...
  default:
    defaultStatement;
    break;
}

switch (val) {
  case 1:
  case 2:
  case 3:
    result = '1, 2, or 3'
    break
  case 4:
    result = '4 alone'
}

var ourArray = []
var i = 0
while (i < 5) {
  ourArray.push(i)
  i++
}

var ourArray = []
var i = 0
do {
  ourArray.push(i)
  i++
} while (i < 5)

var ourArray = []
var i = 0
while (i < 5) {
  ourArray.push(i)
  i++
}
// Contar hacia atrás con un bucle For
var ourArray = []
for (var i = 10; i > 0; i -= 2) {
  ourArray.push(i)
}
// Iterar a través de un array
var arr = [10, 9, 8, 7, 6]
for (var i = 0; i < arr.length; i++) {
  console.log(arr[i])
}
// Bucles for anidados
var arr = [
  [1, 2],
  [3, 4],
  [5, 6],
]
for (var i = 0; i < arr.length; i++) {
  for (var j = 0; j < arr[i].length; j++) {
    console.log(arr[i][j])
  }
}

for (let value of myArray) {
  console.log(value)
}

function functionName() {
  console.log('Hello World')
}
functionName() // llamada a la función

function ourFunctionWithArgs(a, b) {
  console.log(a - b)
}
ourFunctionWithArgs(10, 5) // 5

function plusThree(num) {
  return num + 3
}
var answer = plusThree(5) // 8

;(function () {
  console.log('A cozy nest is ready')
})()

const myFunc = function () {
  const myVar = 'value'
  return myVar
}
// se puede reescribir así
const myFunc = () => {
  const myVar = 'value'
  return myVar
}
// y así si no hay cuerpo de la función, y sólo un valor de retorno
const myFunc = () => 'value'
// para pasar parámetros
const doubler = (item) => item * 2

FBPosts.filter(function (post) {
  return post.thumbnail !== null && post.shares > 100 && post.likes > 500
})
// la función anterior se puede reescribir así
FBPosts.filter((post) => post.thumbnail !== null && post.shares > 100 && post.likes > 500)

function howMany(...args) {
  return 'You have passed ' + args.length + ' arguments.'
}
console.log(howMany(0, 1, 2)) // Has pasado 3 argumentos
console.log(howMany('string', null, [1, 2, 3], {})) // Has pasado 4 argumentos.

// Al definir funciones dentro de los objetos en ES5, tenemos que utilizar la palabra clave function
const person = {
  name: 'Taylor',
  sayHello: function () {
    return `Hello! My name is ${this.name}.`
  },
}
// Con ES6, se puede eliminar la palabra clave function y los dos puntos
const person = {
  name: 'Taylor',
  sayHello() {
    return `Hello! My name is ${this.name}.`
  },
}

// el método test devuelve true o false si el patrón coincide con una cadena o no
let myString = 'Hello, World!'
let myRegex = /Hello/
let result = myRegex.test(myString)
// extrae las coincidencias de un regex con el método match
let extractStr = "Extract the word 'coding' from this string."
let codingRegex = /coding/
let result = extractStr.match(codingRegex)
// Search and replace
let wrongText = 'The sky is silver.'
let silverRegex = /silver/
wrongText.replace(silverRegex, 'blue') // devuelve "El cielo es azul".
// buscar varios patrones utilizando el operador de alternancia u OR: |
let petString = 'James has a pet cat.'
let petRegex = /dog|cat|bird|fish/
let result = petRegex.test(petString)
// ignora las mayúsculas o minúsculas
let myString = 'freeCodeCamp'
let fccRegex = /freeCodeCamp/i // flag i
let result = fccRegex.test(myString)
// Buscar o extraer un patrón más de una vez
let twinkleStar = 'Twinkle, twinkle, little star'
let starRegex = /Twinkle/gi // a regex can have multiple flags
let result = twinkleStar.match(starRegex)
// El carácter comodín . coincidirá con cualquier carácter, excepto las líneas nuevas.
let exampleStr = "Let's have fun with regular expressions!"
let unRegex = /.un/
let result = unRegex.test(exampleStr)
// Definir los caracteres a coincidir, en este ejemplo todas las vocales en quoteSample
let quoteSample = 'Beware of bugs in the above code; I have only proved it correct, not tried it.'
let vowelRegex = /[aeiou]/gi
let result = quoteSample.match(vowelRegex)
// Coincidir con todos los caracteres en quoteSample (entre a y z)
let quoteSample = 'The quick brown fox jumps over the lazy dog.'
let alphabetRegex = /[a-z]/gi
let result = quoteSample.match(alphabetRegex)
// Coincidir con todos los caracteres entre dos caracteres y números
let quoteSample = 'Blueberry 3.141592653s are delicious.'
let myRegex = /[h-s2-6]/gi
let result = quoteSample.match(myRegex)
// Coincidir con todo lo que no sea un número o una vocal
let quoteSample = '3 blind mice.'
let myRegex = /[^aeiou0-9]/gi
let result = quoteSample.match(myRegex)
// Coincidir con 1 o más apariciones del carácter anterior (* para 0 o más)
let difficultSpelling = 'Mississippi'
let myRegex = /s+/g
let result = difficultSpelling.match(myRegex)
// ? Coincide con 0 o 1 ocurrencia del carácter anterior. Útil para la concordancia perezosa
let text = 'titanic'
let myRegex = /t[a-z]*?i/
let result = text.match(myRegex)
// Buscar patrones al principio de las cadenas
let rickyAndCal = 'Cal and Ricky both like racing.'
let calRegex = /^Cal/
let result = calRegex.test(rickyAndCal)
// Buscar patrones al final de una cadena
let caboose = 'The last car on a train is the caboose'
let lastRegex = /caboose$/
let result = lastRegex.test(caboose)
// \w es igual a [A-Za-z0-9_]
let quoteSample = 'The five boxing wizards jump quickly.'
let alphabetRegexV2 = /\w/g
let result = quoteSample.match(alphabetRegexV2).length
// Coincidir sólo con las h de 3 a 6 letras en la palabra "Oh no"
let ohStr = 'Ohhh no'
let ohRegex = /Oh{3,6} no/
let result = ohRegex.test(ohStr)
// Coincide con la versión en inglés americano (favorite) y en inglés británico (favorite) de la palabra
let favWord = 'favorite'
let favRegex = /favou?rite/
let result = favRegex.test(favWord)
// Los grupos () le permiten reutilizar patrones
let repeatNum = '42 42 42'
let reRegex = /^(\d+)\s\1\s\1$/ // cada 1 representa el grupo (\d+)
let result = reRegex.test(repeatNum)
// Elimina todos los espacios al principio y al final de una cadena
let hello = '   Hello, World!  '
let wsRegex = /^\s+(.*\S)\s+$/
let result = hello.replace(wsRegex, '$1') // devuelve 'Hello, World!'

let duck = {
  name: 'Aflac',
  numLegs: 2,
  sayName: function () {
    return 'The name of this duck is ' + this.name + '.'
  },
}
duck.sayName() // Devuelve "El nombre de este pato es Aflac".

// constructor
function Bird(name, color) {
  this.name = name
  this.color = color
}
// crear una nueva instancia de Bird
let cardinal = new Bird('Bruce', 'red')
let duck = new Bird('Donald', 'blue')
// acceder y modificar el objeto blueBird
cardinal.name // Bruce
cardinal.color // red
cardinal.color = green
cardinal.color // green
// comprobar si un objeto es una instancia de un constructor
cardinal instanceof Bird // true
crow instanceof Bird // false
// comprueba las propiedades de los objetos (nombre, color, número de patas)
cardinal.hasOwnProperty('color') // true
cardinal.hasOwnProperty('age') // false
// comprobar las propiedades de un objeto con la propiedad del constructor
cardinal.constructor === Bird // true
// utilizar constructor.prototype para añadir nuevas propiedades a los constructores de objetos
Bird.prototype.cute = true
cardinal.cute // true
crow.cute // true
// añadir más de una propiedad y método a un constructor
Bird.prototype = {
  constructor: Bird, // especificar el constructor
  numLegs: 2, // nueva propiedad
  eat: function () {
    // new method
    console.log('nom nom nom')
  },
  describe: function () {
    // new method
    console.log('My name is ' + this.name)
  },
}
let chicken = new Bird('Dinner', 'brown')
chicken.numLegs // 2
chicken.eat() // nom nom nom
chicken.describe() // My name is Dinner

function Animal() {}
Animal.prototype = {
  constructor: Animal,
  eat: function () {
    console.log('nom nom nom')
  },
}
function Cat(name) {
  this.name = name
}
// hacer que el constructor Gato herede la función eat() de Animal
Cat.prototype = Object.create(Animal.prototype)
let myCat = new Cat('charles')
myCat.eat() // nom nom nom

function Animal() {}
Animal.prototype.eat = function () {
  console.log('nom nom nom')
}
// Constructor Perro
function Dog() {}
// hacer que el constructor de Gog herede la función eat() de Animal
Dog.prototype = Object.create(Animal.prototype)
Dog.prototype.constructor = Dog
Dog.prototype.bark = function () {
  console.log('wof wof!')
}
// el nuevo objeto tendrá tanto el método heredado eat() como su propio método bark()
let beagle = new Dog()
beagle.eat() // "nom nom nom"
beagle.bark() // "Woof!"
// anula un método heredado
Dog.prototype.eat = function () {
  return 'nice meeeeat!'
}
let doberman = new Dog()
doberman.eat() // nice meeeeat!

let bird = {
  name: 'Donald',
  numLegs: 2,
}
let boat = {
  name: 'Warrior',
  type: 'race-boat',
}
// este mixin contiene el método glide
const glideMixin = function (obj) {
  obj.glide = function () {
    console.log('gliding...')
  }
}
// el objeto se pasa al mixin y se le asigna el método glide
glideMixin(bird)
glideMixin(boat)
bird.glide() // "gliding..."
boat.glide() // "gliding..."

function Bird() {
  // en lugar de this.hatchedEgg...
  let hatchedEgg = 10 // private property
  this.getHatchedEggCount = function () {
    // método disponible públicamente que un objeto pájaro puede utilizar
    return hatchedEgg
  }
}
let ducky = new Bird()
ducky.hatchedEgg = 2 // no pasa nada
ducky.getHatchedEggCount // 10

let funModule = (function () {
  return {
    isCuteMixin: function (obj) {
      obj.isCute = function () {
        return true
      }
    },
    singMixin: function (obj) {
      obj.sing = function () {
        console.log('Singing to an awesome tune')
      }
    },
  }
})()
function Dog() {}
let goodBoy = new Dog()
// asignar el método singMixin al objeto goodBoy
funModule.singMixin(goodBoy)
goodBoy.sing() // Cantando con una melodía impresionante

class Book {
  constructor(title, author, year) {
    this.title = title
    this.author = author
    this.year = year
  }
  getSummary() {
    return `${this.title} was written by ${this.author} in ${this.year}`
  }
  getAge() {
    const years = new Date().getFullYear() - this.year
    return `${this.title} is ${years} years old`
  }
}
book = new Book('Book One', 'John Doe', 2016)
book.getSummary() // Book One fue escrito por John Doe en 2016
book.getAge() // Book One tiene 3 años

class Book {
  constructor(author) {
    this._author = author
  }
  // getter
  get writer() {
    return this._author
  }
  // setter
  set writer(updatedAuthor) {
    this._author = updatedAuthor
  }
}
const lol = new Book('anonymous')
console.log(lol.writer) // anonymous
lol.writer = 'wut'
console.log(lol.writer) // wut

class Book {
  constructor(title, author, year) {
    this.title = title
    this.author = author
    this.year = year
  }
  static sayHi() {
    return 'Hi!'
  }
}
Book.sayHi() // Hi!

class Book {
  constructor(title, author, year) {
    this.title = title
    this.author = author
    this.year = year
  }
  getSummary() {
    return `${this.title} was written by ${this.author} in ${this.year}`
  }
}
class Magazine extends Book {
  constructor(title, author, year, month) {
    super(title, author, year)
    this.month = month
  }
  sayHi() {
    return 'Hi!'
  }
}
mag = new Magazine('Mag', 'People', 2019, 'jan')
mag.getSummary() // Mag was written by People in 2019
mag.sayHi() // Hi!

// podemos elegir qué partes de un módulo o archivo cargar en un archivo determinado.
import { function } from 'file_path'
// ¡También podemos importar variables de la misma manera!
// Importar todo desde un archivo
import * as name_of_your_choice from 'file_path'

const capitalizeString = (string) => {
  return string.charAt(0).toUpperCase() + string.slice(1)
}
export { capitalizeString } // Exportar funciones.
export const foo = 'bar' // Exportar variables.
// Como alternativa, si quieres comprimir todas las declaraciones de exportación en una sola línea, puede hacer esto:
const capitalizeString = (string) => {
  return string.charAt(0).toUpperCase() + string.slice(1)
}
const foo = 'bar'
export { capitalizeString, foo }
// Utilizar la exportación por defecto si sólo se exporta un valor de un archivo.
// También se utiliza para crear un valor de reserva para un archivo o módulo
export default function add(x, y) {
  return x + y
}
// y para importar
import add from 'math_functions'
add(5, 4) // devolverá 9

async function firstAsync() {
  return 23
}
firstAsync().then(alert) // 23

async function firstAsync() {
    let promise = new Promise((res, rej) => {
        setTimeout(() => res("Now it's done!"), 1000)
    });
    // espera hasta que la promesa nos devuelva un valor
    let result = await promise;
    // "¡Ahora está hecho!"
    alert(result);
    }
};
firstAsync();

function firstAsync() {
  let promise = Promise.resolve(10);
  let result = await promise; // Syntax error
}

async function sequence() {
  await promise1(50) // Espera 50ms...
  await promise2(50) // ...luego espera otros 50ms.
  return 'done!'
}

async function sequence() {
  await Promise.all([promise1(), promise2()])
  return 'done!'
}

async function parallel() {
  // Inicia un temporizador de 500ms de forma asíncrona...
  const wait1 = promise1(50)
  // ...lo que significa que este temporizador ocurre en paralelo.
  const wait2 = promise2(50)
  // Espera 50ms para el primer temporizador...
  await wait1
  // ...para lo cual este temporizador ya ha terminado.
  await wait2
  return 'done!'
}