Basic Data Structure - Josej2r/JavaScript_Algorithms_and_Data_Structures_Certification GitHub Wiki

Basic Data Structure

Introduction to the Basic Data Structure Challenges

Los datos se pueden almacenar y acceder de muchas maneras diferentes, tanto en JavaScriptt como en otros idiomas. Esta sección le enseñará cómo manipular matrices, así como acceder y copiar la información dentro de ellas. También le enseñará cómo manipular y acceder a los datos dentro de los objetos de JavaScript, utilizando la notación de punto y paréntesis. Cuando haya terminado con esta sección, debe comprender las propiedades básicas y las diferencias entre matrices y objetos, así como cómo elegir cuál usar para un propósito determinado.

Upcoming Lessons

Use an Array to Store a Collection of Data

El siguiente es un ejemplo de la implementación más simple de una estructura de datos de matriz. Esto se conoce como una matriz unidimensional, lo que significa que solo tiene un nivel o que no tiene otras matrices anidadas dentro de ella. Observe que contiene booleanos, cadenas y números, entre otros tipos de datos válidos de JavaScript:

let simpleArray = ['one', 2, 'three', true, false, undefined, null];
console.log(simpleArray.length);
// logs 7

Todos los arreglos tienen una propiedad de longitud, que como se muestra arriba, se puede acceder fácilmente con la sintaxis Array.length. Una implementación más compleja de una matriz se puede ver a continuación. Esto se conoce como una matriz multidimensional o una matriz que contiene otras matrices. Tenga en cuenta que esta matriz también contiene objetos JavaScript, que examinaremos muy de cerca en nuestra próxima sección, pero por ahora, todo lo que necesita saber es que las matrices son capaces de almacenar objetos complejos.

let complexArray = [
  [
    {
      one: 1,
      two: 2
    },
    {
      three: 3,
      four: 4
    }
  ],
  [
    {
      a: "a",
      b: "b"
    },
    {
      c: "c",
      d: "d"
    }
  ]
];

Hemos definido una variable llamadaa yourArray. Complete la declaración asignando una matriz de al menos 5 elementos de longitud a la variable yourArray. Su matriz debe contener al menos una cadena, un número y un booleano.

El código con la solución se encuentra aquí:Download

Access an Array's Contents Using Bracket NotationPassed

La característica fundamental de cualquier estructura de datos es por supuesto, la capacidad no solo de almacenar datos, sino también de poder recuperar esos datos por comando. Entonces, ahora hemos aprendido cómo crear una matriz, comencemos a pensar en cómo podemos acceder a la información de esa matriz.

Cuando definimos una matriz simple como se ve a continuación, hay 3 elementos en ella:

let ourArray = ["a", "b", "c"];

En una matriz, cada elemento de la matriz tiene un índice. Este índice se duplica como la posición de ese elemento en la matriz y cómo lo referencia. Sin embargo, es importante tener en cuenta que las matrices de JavaScript están indexadas a cero, lo que significa que el primer elemento de una matriz está realmente en la posición cero, no el primero. Para recuperar un elemento de una matriz podemos encerrar un índice entre paréntesis y agregarlo al final de una matriz, o más comúnmente, a una variable que hace referencia a un objeto de matriz. Esto se conoce como notación de corchetes. Por ejemplo, si queremos recuperar la "a" de nuestra matriz y asignarla a una variable, podemos hacerlo con el siguiente código:

let ourVariable = ourArray[0];
// ourVariable equals "a"

Además de acceder al valor asociado con un índice, también puede establecer un índice en un valor utilizando la misma notación:

ourArray[1] = "not b anymore";
// ourArray now equals ["a", "not b anymore", "c"];

Para completar este desafío, establezca la segunda posición de myArray a lo que desee, además de "b".

El código con la solución se encuentra aquí:Download

Add Items to an Array with push() and unshift()

La longitud de una matriz, como los tipos de datos que puede contener, no es fija. Las matrices se pueden definir con una longitud de cualquier número de elementos, y los elementos se pueden agregar o eliminar con el tiempo; en otras palabras, las matrices son mutables. En este desafío, veremos dos métodos con los que podemos modificar mediante programación una matriz: Array.push() y Array.unshift().

Ambos métodos toman uno o más elementos como parámetros y agregan esos elementos a la matriz a la que se llama el método: el método push() agrega elementos al final de la matriz, y unshift() agrega elementos al principio. Considera lo siguiente:

let twentyThree = 'XXIII';
let romanNumerals = ['XXI', 'XXII'];

romanNumerals.unshift('XIX', 'XX');
// now equals ['XIX', 'XX', 'XXI', 'XXII']

romanNumerals.push(twentyThree);
// now equals ['XIX', 'XX', 'XXI', 'XXII', 'XXIII']Notice that we can also pass variables, which allows us even greater flexibility in dynamically modifying our array's data.

Hemos definido una función, mixedNumbers, a la que estamos pasando una matriz como argumento. Modifique la función usando push() para agregar 'I', '2', 'three' al comienzo de la matriz y '7', 'VIII','9' al final para la matriz devuelta contenga representaciones de los números 1-9 en orden.

El código con la solución se encuentra aquí:Download

Remove Items from an Array with pop() and shift()

Tanto push() como unshift() tienen métodos correspondientes que son opuestos funcionalmente: pop() y shift(). Como ya habrá adivinado, en lugar de agrgar, pop() elimina un elemento del final de una matriz, mientras que shift() elimina un elemento del principio de la matriz. La diferencia clave entre pop() y shift() y sus primos push() y unshift(), es que ninguno de los métodos toma parámetros, y cada uno solo permite que una matriz sea modificada por un solo elemento a la vez.

Vamos a ver:

let greetings = ['whats up?', 'hello', 'see ya!'];

greetings.pop();
// now equals ['whats up?', 'hello']

greetings.shift();
// now equals ['hello']

También podemos devolver el valor del elemento eliminado con cualquier método como este:

let popped = greetings.pop();
// returns 'hello'
// greetings now equals []

Hemos definido una función, popShift, que toma una matriz como argumento y devuelve una nueva matriz. Modifique la función, usando pop() y shift(), para eliminar el primer y último elemento de la matriz de argumentos, y asigne los elementos eliminados a sus variables correspondientes, de modo que la matriz devuelta contenga sus valores.

El código con la solución se encuentra aquí:Downloand

Remove Items Using splice()

Ok, entonces hemos aprendido, cómo eliminar elementos desde el principio y el final de las matrices usando shift() y pop(), pero ¿qué sucede si queremos eliminar un elemento de algún lugar en el medio?.¿ o eliminar más de un elemento a la vez?. Bueno ahí es donde entra splice(). splice() no permite hacer exactamente eso: eliminar cualquier número de elementos consecutivos de cualquier parte de una matriz.

splice() puedo tomar hasta 3 parámetros, pero por ahora, nos centraremos en solo los primeros 2. Los primeros dos parámetros de splice() son enteros que representar índices o posiciones de la matriz que splice() está siendo exhortó a. Y recuerde, las matrices están indexadas a cero, por lo que para indicar el primer elemento de una matriz, usaríamos 0. El primer parámetros de splice() representa el índice en la matriz desde el cual comenzara a eliminar elementos, mientras que el segundo parámetro indica el número de elementos a eliminar. Por ejemplo:

let array = ['today', 'was', 'not', 'so', 'great'];

array.splice(2, 2);
// remove 2 elements beginning with the 3rd element
// array now equals ['today', 'was', 'great']

splice() no solo modifica la matriz a la que se está llamando, sino que también devuelve una nueva matriz que contiene el valor de los elementos eliminados:

let array = ['I', 'am', 'feeling', 'really', 'happy'];

let newArray = array.splice(3, 2);
// newArray equals ['really', 'happy']

Inicializamos una matriz arr. Use splice() para eliminar elementos de arr, de modo que solo contenga elementos que sumen el valor de 10.

El código con la solución se encuentra aquí:Download

Add Items Using splice()

¿Recuerdas en el último desafío que mencionamos que splice() puede tomar hasta tres parámetros? Bueno, puede usar el tercer parámetro, compuesto por uno o más elementos, para agregar a la matriz. Esto puede ser increíblemente útil para cambiar rápidamente un elemento, o un conjunto de elementos, por otro.

const numbers = [10, 11, 12, 12, 15];
const startIndex = 3;
const amountToDelete = 1;

numbers.splice(startIndex, amountToDelete, 13, 14);
// the second entry of 12 is removed, and we add 13 and 14 at the same index
console.log(numbers);
// returns [ 10, 11, 12, 13, 14, 15 ]

Aquí comenzamos con una serie de números. Luego pasamos lo siguiente a splice().El índice en el que comenzará e eliminar elementos (3), el número de elementos que se eliminarán (1) y los elementos (13,14) que se insertarán en ese mismo índice. Tenga en cuenta que puede haber cualquier número de elementos (separados por comas) después de amountToDelete, cada uno de los cuales se inserta.

Hemos definido una función, htmlColorNames, que toma una matriz de colores HTML como argumento. Modifique la función usando splice() para eliminar los dos primeros elementos de la matriz y agregue 'DarkSalmon' y 'BlanchedAlmond' en sus respectivos lugares.

El código con la solución se encuentra aquí:Download

Copy Array Items Using slice()

El siguiente método que cubriremos es slice(). slice() en lugar de modificar una matriz, copias o extractos, copias o extractos, un número dado de elementos a una nueva matriz, dejando intacta la matriz a la que se llama .slice() solo toma 2 parámetros, el primero es el índice en el que comenzara la extracción , y el segundo es el índice en el que se detiene la extracción (la extracción se realizará hasta, pero sin incluir el elemento en este índice). Considera esto:

let weatherConditions = ['rain', 'snow', 'sleet', 'hail', 'clear'];

let todaysWeather = weatherConditions.slice(1, 3);
// todaysWeather equals ['snow', 'sleet'];
// weatherConditions still equals ['rain', 'snow', 'sleet', 'hail', 'clear']

En efecto, hemos creado una nueva matriz extrayendo elementos de una matriz existente.

Hemos definido una función, pronóstico, que toma una matriz como argumento. Modifique la función usando slice() para extraer información de la matriz de argumentos y devolver una nueva matriz que contenga los elementos 'warm' y 'sunny'.

El código con la solución se encuentra aquí:Download

Copy an Array with the Spread Operator

Mientras que slice() nos permite ser selectivos sobre qué elementos de una matriz copiar, entre varias otras tareas útiles, el nuevo operador de propagación de ES6 nos permite copiar fácilmente todos los elementos de una matriz, en orden, con una sintaxis simple y altamente legible. La sintaxis de propagación simplemente se ve así: ...

En la práctica, podemos usar el operador de propagación para copiar una matriz así:

let thisArray = [true, true, undefined, false, null];
let thatArray = [...thisArray];
// thatArray equals [true, true, undefined, false, null]
// thisArray remains unchanged, and is identical to thatArray

Hemos definido una función, copyMachine, que toma arr ( una matriz) y num (un número) como argumentos. Se supone que la función devuelve una nueva matriz compuesta de copias numéricas de arr. Hemos hecho la mayor parte del trabajo por usted, pero aún no funciona del todo bien. Modifique la función usando la sintaxis de propagación para que funcione correctamente. (pista: otro método que ya hemos cubierto podrías ser útil aquí).

El código con la solución se encuentra aquí:Download

Combine Arrays with the Spread Operator

Otra gran ventaja del operador de propagación es la capacidad de combinar matrices o insertar todos los elementos de una matriz en otra, en cualquier índice. Con sintaxis más tradicionales, podemos concatenar matrices, pero esto solo nos permite combinar matrices al final de una y al comienzo de otra. La sintaxis extendida hace que la siguiente operación sea extremadamente simple:

let thisArray = ['sage', 'rosemary', 'parsley', 'thyme'];

let thatArray = ['basil', 'cilantro', ...thisArray, 'coriander'];
// thatArray now equals ['basil', 'cilantro', 'sage', 'rosemary', 'parsley', 'thyme', 'coriander']

Utilizando la sintaxis de propagación, acabamos de lograr una operación que habría sido más compleja y más detallada si hubiéramos utilizado los métodos tradicionales.

Hemos definido una función spreadOut() que devuelve la variable sentence. Modifique la función utilizando el operador de propagación para que devuelva la matriz ['learning', 'to', 'code', 'is', 'fun'].

El código con la solución se encuentra aquí:Download

Check For The Presence of an Element With indexOf()

Dado que las matrices se pueden cambiar, o mutar en cualquier momento, no hay garantía sobre dónde estará un dato en particular en una matriz, o si ese elemento aún existe. JavaScript nos proporciona otro método incorporado, indexOf(), que nos permite verificar rápida y fácilmente la presencia de un elemento en una matriz .indexOf() toma un elemento como parámetro, y cuando se llama, devuelve la posición, o índice, de ese elemento, o -1 si el elemento no existe en la matriz.

Por ejemplo:

let fruits = ['apples', 'pears', 'oranges', 'peaches', 'pears'];

fruits.indexOf('dates'); // returns -1
fruits.indexOf('oranges'); // returns 2
fruits.indexOf('pears'); // returns 1, the first index at which the element exists

indexOf() puede ser increíblemente útil para verificar rápidamente la presencia de un elemento en una matriz. Hemos definido una función, quickCheck, que toma una matriz y un elemento como argumentos. Modifique la función usando indexOf() para que devuelva true si el elemento pasado existe en la matriz o false si no existe.

El código con la solución se encuentra aquí:Download

Iterate Through All an Array's Items Using For Loops

A veces, cuando se trabaja con matrices, es muy útil poder recorrer cada elemento para encontrar uno a más elementos que podamos necesitar, o elementos que podamos necesitar, o manipular una matriz en función de qué elementos de datos cumplen un determinado conjunto de criterios. JavaScript ofrece varios métodos integrados que cada uno itera sobre las matrices de maneras ligeramente diferentes para logar resultados diferentes ( como every(), forEach(), map(), etc), sin embargo, la técnica que es más flexible y nos ofrece la mayor cantidad de control es un bucle simple.

Considera lo siguiente:

function greaterThanTen(arr) {
  let newArr = [];
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] > 10) {
      newArr.push(arr[i]);
    }
  }
  return newArr;
}

greaterThanTen([2, 12, 8, 14, 80, 0, 1]);
// returns [12, 14, 80]

Usando un bucle for, esta función itera y accede a cada elemento de la matriz, y lo somete a una prueba simple que hemos creado. De esta manera, hemos determinado fácil y programática qué elementos de datos son mayores que 10, y hemos devuelto una nueva matriz que contiene esos elementos.

Hemos definido una función, filterArray, que toma arr, una matriz anidada y elem como argumentos, y devuelve una nueva matriz. elem representa un elemento que puede o no estar presente en una o más de las matrices anidadas dentro de arr. Modifique la función, utilizando un bucle for, para devolver una versión filtrada de la matriz aprobada de modo que se haya eliminado cualquier matriz anidada dentro de un arr que contenga elem.

El código con la solución se encuentra aquí:Download

Create complex multi-dimensional arrays

Increible, acabas de aprender un motón sobre matrices. Esta ha sido una descripción general de alto nivel, y hay muchos más que aprender sobre cómo trabajar con matrices, gran parte de lo cual verá en secciones posteriores. Pero antes de pasar a mirar Objetos, echemos un vistazo más y veamos cómo las matrices pueden volverse un poco más complejas de lo que hemos visto en desafíos anteriores.

Una de las características más poderosas cuando se piensa en las matrices como estructuras de datos , es que las matrices pueden contener, o incluso estar completamente formadas por otras matrices. Hemos visto matrices que contienen matrices en desafíos anteriores, pero bastante simples. Sin embargo, las matrices pueden contener una profundidad infinita de matrices que pueden contener otras matrices, cada una con sus propios niveles arbitrarios de profundidad, y así sucesivamente. De esta manera, una matriz puede convertirse rápidamente en una estructura de datos muy compleja, conocida como una matriz multidimensional o anidada. Considere el siguiente ejemplo:

let nestedArray = [ // top, or first level - the outer most array
  ['deep'], // an array within an array, 2 levels of depth
  [
    ['deeper'], ['deeper'] // 2 arrays nested 3 levels deep
  ],
  [
    [
      ['deepest'], ['deepest'] // 2 arrays nested 4 levels deep
    ],
    [
      [
        ['deepest-est?'] // an array nested 5 levels deep
      ]
    ]
  ]
];

Si bien este ejemplo puede parecer complicado, este nivel de complejidad no es desconocido, ni siquiera inusual, cuando se trata de grande cantidades de datos. Sin embargo, todavía podemos acceder fácilmente a los niveles más profundos de una matriz de este complejo con notación de corchetes:

console.log(nestedArray[2][1][0][0][0]);
// logs: deepest-est?

Y ahora que sabemos dónde está ese dato, podemos restablecerlo si necesitamos:

nestedArray[2][1][0][0][0] = 'deeper still';

console.log(nestedArray[2][1][0][0][0]);
// now logs: deeper still

Hemos definido una variable, myNestedArray, establecida igual a una matriz. Modifique myNestedArray, usando cualquier combinación de cadenas, números y booleanos para elementos de datos, de modo que tenga exactamente cinco niveles de profundidad (recuerde, la matriz más externa es el nivel 1). En algún lugar del tercer nivel incluya la cadena 'deep', en el cuarto nivel incluya la cadena "deeper", y en el quinto nivel incluya la cadena "deepest".

El código con la solución se encuentra aquí:Download

Add Key-Value Pairs to JavaScript Objects

En su forma más básica, los objetos son solo colecciones de pares clave-valor, o en otras palabras, datos asignados a identificadores únicos que llamamos propiedades o claves. Echemos un vistazo a un ejemplo muy simple:

let FCC_User = {
  username: 'awesome_coder',
  followers: 572,
  points: 1741,
  completedProjects: 15
};

El código anterior defina un objeto llamado FCC_User que tiene cuatro propiedades, cada una de las cuales se asigna a un valor específico. Si quisiéramos saber la cantidad de seguidores que tiene FCC_User, podemos acceder a esa propiedad escribiendo:

let userData = FCC_User.followers;
// userData equals 572

Esto se llama notación de putos. Alternativamente, también podemos acceder a la propiedad entre paréntesis, así:

let userData = FCC_User['followers'];
// userData equals 572

Tenga en cuenta que con la notación de corchetes, incluimos seguidores entre comillas. Esto se debe a que los corchetes realmente no permiten pasar una variables para ser evaluada como un nombre de propiedad (pista: tenga esto en cuenta para más adelante). Si hubiéramos pasado followers sin las comillas, el motor de JavaScript habría intentado evaluarlo como una variable, y se habría lanzado un ReferenceError: followers is not defined.

Usando la misma sintaxis, también podemos agregar nuevos pares de clave-valor a los objetos. Hemos creado un objeto de foods con tres entradas. Agregue tres entradas más bananas con un valor de 13, grapes con un valor de 35 y strawberries con un valor de 27.

El código con la solución se encuentra aquí:Download

Modify an Object Nested Within an Object

Ahora echemos un vistazo a un objeto un poco más complejo. Las propiedades de los objetos se pueden anidar a una profundidad arbitraria, y sus valores pueden ser cualquier tipo de datos admitidos por JavaScript, incluidas las matrices e incluso otros objetos. Considera lo siguiente:

let nestedObject = {
  id: 28802695164,
  date: 'December 31, 2016',
  data: {
    totalUsers: 99,
    online: 80,
    onlineStatus: {
      active: 67,
      away: 13
    }
  }
};

nestedObject tiene tres claves únicas: id cuyo valor es un número, date cuyo valor es un objeto que tiene otro objeto anidado dentro de él. Si bien las estructuras pueden volverse complejas rápidamente, aún podemos usar las mismas anotaciones para acceder a la información que necesitamos.

Aquí hemos definido un objeto, userActivity, que incluye otro objeto anidado dentro de él. Puede modificar las propieades de este objeto anidado de la misma manera que modificó las propiedades en el último desafío. Establezca el valor de la clave online a 45.

El código con la solución se encuentra aquí:Download

Access Property Names with Bracket Notation

En el primer desafío de objeto, mencionamos el uso de la notación de corchetes como una forma de acceder a los valores de propiedad mediante la evaluación de una variable. Por ejemplo, imagine que nuestro objeto de foods se esta utilizando en un programa para la caja registradora de un supermercado. Tenemos alguna función que establece el selectFood y queremos verificar la presencia de ese alimento en nuestros objetos de alimentos. Esto podría verse así:

let selectedFood = getCurrentFood(scannedItem);
let inventory = foods[selectedFood];

Este código evaluará el valor almacenado en la variable food en selectFood y devolverá el valor de esa clave en el objeto de food, o undefined si no está presente. La notación de corchetes es muy útil porque a veces las propiedades de los objetos no se conocen antes del tiempo de ejecución o necesitamos acceder a ellas de una manera más dinámica.

Hemos definido una función, checkInventory, que recibe un elemento escaneado como argumento. Devuelve el valor actual de la clave scannedItem en el objeyo foods. Puede suponer que solo se proporcionarán claves válidas como argumento para checkInvetory.

El código con la solución se encuentra aquí:Download

Use the delete Keyword to Remove Object Properties

Ahora ya sabe qué son los objetos y sus características y ventajas básicas. En resumen, son almacenes de valores clave que proporcionan una forma flexible e intuitiva de estructurar datos, proporcionan un tiempo de búsqueda muy rápido. En el resto de estos desafíos, describiremos varias operaciones comunes que puede realizar en objetos para que puede sentirse cómodo aplicando estas estructuras de datos útiles en sus programas.

En desafíos anteriores, hemos agregado y modificado los pares clave-valor de un objeto. Aquí veremos cómo podemos eliminar un par clave-valor de un objeto.

Volvamos a ver nuestro ejemplo de objeto de foods por última vez. Si quisiéramos eliminar la clave de las apples, podemos eliminarla usando la palabra clave delete como esta:

delete foods.apples;

Use la palabra clave delete para eliminar las claves de orange, plums y strawberries del objeto foods.

El código con la solución se encuentra aquí:Download

Check if an Object has a Property

Ahora podemos agregar, modificar y eliminar claves de los objetos. Pero, ¿y si solo quisiéramos saber si un objeto tiene una propiedad específica? JavaScript nos proporciona dos formas diferentes de hacer esto. Uno usa el método hasOwnProperty() y el otro usa la palabra clave in. Si tenemos un objeto user con una propiedad de Alan, podríamos verificar su presencia de cualquiera de las siguientes maneras:

users.hasOwnProperty('Alan');
'Alan' in users;
// both return true

Hemos creado un objeto, users, con algunos usarios y una función isEveryoneHere a la que pasamos el objeto de los usuarios como argumento. Termine de escribir esta función para que devuelva true solo si el objeto de usuario contiene los cuatro nombres, Alan, Jeff, Sarah y Ryan y false en caso contrario.

El código con la solución se encuentra aquí:Download

Iterate Through the Keys of an Object with a for...in Statement

A veces puede que necesita recorrer todas las claves dentro de un objeto. Esto requiere una sintaxis específica en JavaScript llamada for... en la declaración. Para nuestro objeto de usuario, esto podría verse así:

for (let user in users) {
  console.log(user);
}

// logs:
Alan
Jeff
Sarah
Ryan

En esta declaración, definimos una variable de usuario, y como puede ver, esta variable se restableció durante cada iteración a cada una de las key del objeto a medida que la declaración recorría el objeto, dando como resultado que el nombre de cada usuario se imprimiera en la consola. Nota: los objetos no mantienen un orden para las claves almacenadas como lo hacen las matrices; por lo tanto, la posición de una clave en un objeto, o el orden relativo en el que aparece, es irrelevante al hacer referencia o acceder a esa clave.

Hemos definido una función countOnline que acepta un argumento (un objeto de usuario). Use una declaración for...in dentro de esta función para recorrer el objeto de usuario pasado a la función y devolver el número de usuarios cuya propiedad en online se establece en true. A continuación se muestra un ejemplo de un objeto de usuario que podría pasarse a countOnline. Cada usuario tendrá una propiedad en online con un valor true o false.

{
  Alan: {
    online: false
  },
  Jeff: {
    online: true
  },
  Sarah: {
    online: false
  }
}

El código con la solución se encuentra aquí: Download

Generate an Array of All Object Keys with Object.keys()

También podemos generar una matriz que contenga todas las claves almacenadas en un objeto utilizando el método Object.keys() y pasando un objeto como argumento. Esto devolverá una matriz con cadenas que representan cada propiedad en el objeto. Nuevamente, no habrá un orden específico para las entradas en la matriz.

Termine de escribir la función getArrayOfUsers para que devuelva una matriz que contenga todas las propiedades del objeto que recibe como argumento.

El código con la solución se encuentra aquí:Download

Modify an Array Stored in an Object

Ahora ha visto todas las operaciones básicas para objetos JavaScript. Puede agregar, modificar y eliminar pares clave-valor, verificar si existen claves e iterar sobre todas las claves de un objeto. A medida que continué aprendiendo JavaScript, verá aplicaciones de objetos aún más versátiles. Además, las lecciones de estructuras de datos ubicadas en la sección de preparación de la entrevista de codificación del plan de estudios también cubren los objetos ES6 Map y Set, los cuales son similares a los objetos ordinarios pero proporcionan algunas características adicionales. Ahora que ha aprendido los conceptos básicos de las matrices y los objetos, está completamente preparado para comenzar a abordar problemas más complejos con JavaScript.

Eche un vistazo al objeto que proporcionamos en el editor de código. El objeto user contiene tres claves. La clave data contiene cinco claves, una de las cuales contiene un array con una serie de friends. A partir de esto, puede ver cuán flexibles son los objetos como estructuras de datos. Comenzaremos a escribir una función addFriend. Termine de escribirlo para que tome un objeto de user y agregue el nombre del argumento de friend a la matriz almacenada en user.data.friends y devuelva esa matriz.

El código con la solución se encuentra aquí:Download