[week2] Days 1 - JS data structure part 2
Published: 2022-02-01 12:05:45

After some time with a lot of problems , i am still in the way to improve my self . I dont reset because i only make 1 week in the 100 day of code .
So back to business , this is what i learned today 

###Copy an Array with the Spread Operator
You can copy easily the content of another array with this method:

```javascript
let thatArray = [...thisArray];
```

###Combine Arrays with the Spread Operator
You can put in a specific place your new data by using your spread operator in the middle of an array .

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

let thatArray = ['basil', 'cilantro', ...thisArray, 'coriander'];
```

###Check For The Presence of an Element With indexOf()

indexOf() takes an element as a parameter, and when called, it returns the position, or index, of that element, or -1 if the element does not exist on the array.

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

fruits.indexOf('dates');//-1
fruits.indexOf('pears');//2
```

###Iterate Through All an Array's Items Using For Loops

You can use iteration to move in a multidimensional array and use indexOf() like this 

```javascript
function filteredArray(arr, elem) {
  let newArr = [];
  // Only change code below this line
  for ( let i=0 ; i<arr.length; i++){
    if (arr[i].indexOf(elem) == -1) {
      newArr.push(arr[i]); 
}
  }
  // Only change code above this line
  return newArr;//[[10, 8, 3], [14, 6, 23]]
}

console.log(filteredArray([[10, 8, 3], [14, 6, 23], [3, 18, 6]], 18))
```

###Create complex multidimensional arrays

One of the most powerful features when thinking of arrays as data structures, is that arrays can contain, or even be completely made up of other arrays. We have seen arrays that contain arrays in previous challenges, but fairly simple ones. However, arrays can contain an infinite depth of arrays that can contain other arrays, each with their own arbitrary levels of depth, and so on. In this way, an array can very quickly become a very complex data structure, known as a multi-dimensional, or nested array. Consider the following example:

```javascript
let nestedArray = [
  ['deep'],
  [
    ['deeper'], ['deeper'] 
  ],
  [
    [
      ['deepest'], ['deepest']
    ],
    [
      [
        ['deepest-est?']
      ]
    ]
  ]
];
```

The deep array is nested 2 levels deep. The deeper arrays are 3 levels deep. The deepest arrays are 4 levels, and the deepest-est? is 5.

###Add Key-Value Pairs to JavaScript Objects

At their most basic, objects are just collections of key-value pairs. In other words, they are pieces of data (values) mapped to unique identifiers called properties (keys). Take a look at an example:

```javascript
const tekkenCharacter = {
  player: 'Hwoarang',
  fightingStyle: 'Tae Kwon Doe',
  human: true
};
```

add property 

```javascript
tekkenCharacter.origin = 'South Korea';
```

You can add this property with bracket notation by doing:

```javascript
tekkenCharacter['hair color'] = 'dyed orange';
```

Without quotes, it will be evaluated as a variable and the name of the property will be whatever value the variable is. Here's an example with a variable:

```javascript
const eyes = 'eye color';

tekkenCharacter[eyes] = 'brown';
```

at the end this is the final result 

```javascript
final result 
{
  player: 'Hwoarang',
  fightingStyle: 'Tae Kwon Doe',
  human: true,
  origin: 'South Korea',
  'hair color': 'dyed orange',
  'eye color': 'brown'
};
```

###Modify an Object Nested Within an Object
Inside a nested object, you can modify the data by specifying what you want to change 
```javascript
let nestedObject = {
  id: 28802695164,
  date: 'December 31, 2016',
  data: {
    totalUsers: 99,
    online: 80,
    onlineStatus: {
      active: 67,
      away: 13,
      busy: 8
    }
  }
};

nestedObject.data.onlineStatus.busy = 10; //modification
```

###Access Property Names with Bracket Notation
You can get the data inside an object like this 

```javascript
let inventory = foods[selectedFood];
```

###Use the delete Keyword to Remove Object Properties
You can delete the data inside an object like this 


```javascript
delete foods.apples;
```

###Check if an Object has a Property

One uses the hasOwnProperty() method and the other uses the in keyword. If we have an object users with a property of Alan, we could check for its presence in either of the following ways:

```javascript
users.hasOwnProperty('Alan');
'Alan' in users;
```

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

Sometimes you may need to iterate through all the keys within an object. This requires a specific syntax in JavaScript called a for...in statement. For our users object, this could look like:

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

##New training site 
I discover a website where I can test what I have learned so far, it's : https://exercism.org/ .
I will try to do some exercise a write about it
Today i have done : 
JavaScript - Lucian's Luscious Lasagna , it's about creating function and variable 

PS:

- if you see any spelling or grammar mistakes, can you notify me (I am still improving my English) ? thank you !
- if you have any tips for improving my post feel free to comment on the po