배열의 매서드

Array.isArray(obj)

객체가 Array라면 true, 아니라면 false

    모두 true 반환
    
    Array.isArray([]);
    Array.isArray([1]);
    Array.isArray(new Array());
    Array.isArray(new Array('a', 'b', 'c', 'd'));
    Array.isArray(new Array(3));
    Array.isArray(Array.prototype);  =>Array.prototype은 스스로도 배열입니다

unshift(), push(), shift(), pop()

배열 자체를 수정하며,

배열의 처음이나 끝에서 요소 하나를 추가하거나 제거하는 메서드들이다.

추가하는 메서드들은 "배열의 길이"를, 제거하는 메서드들은 "제거된 요소"를 반환한다.

push : 배열의 맨 뒤에 요소를 하나 추가한다.

pop : 배열의 맨 뒤에 요소를 하나 제거한다.

unshift : 배열의 맨 앞에 요소를 하나 추가한다.

shift : 배열의 맨 앞에 요소를 하나 제거한다.

array.splice(시작인덱스,삭제할요소갯수,특정요소추가)

배열의 기존 요소를 삭제 또는 교체하거나 새 요소를 추가하여 배열의 내용을 변경,이 메소드는 원본 배열 자체를 수정,아무 값도 제거하지 않았으면 빈 배열을 반환한다.

시작할인덱스

음수로 지정한 경우: 배열의 끝에서부터 요소를 센다

배열의 길이보다 큰 수를 지정한 경우: 실제 시작 인덱스는 배열의 길이로 설정

절대값이 배열의 길이보다 큰 경우: 0으로 세팅

const months = ['Jan', 'March', 'April', 'June'];
months.splice(1, 0, 'Feb');
// inserts at index 1
console.log(months);
// expected output: Array ["Jan", "Feb", "March", "April", "June"]

months.splice(4, 1, 'May');
// replaces 1 element at index 4
console.log(months);
// expected output: Array ["Jan", "Feb", "March", "April", "May"]

array.slice(시작 인덱스,끝 인덱스)

복사본을 새로운 배열 객체로 반환한다. 즉, 원본 배열은 수정되지 않는다

시작점에 인덱스

undefined인 경우: 0부터 

음수를 지정한 경우: 배열의 끝에서부터의 길이를 나타낸다. slice(-2)를 하면 배열의 마지막 2개의 요소를 추출한다.

배열의 길이와 같거나 큰 수를 지정한 경우: 빈 배열을 반환한다.

 

끝 인덱스(end를 제외하고 그 전까지의 요소만 추출한다.)

지정하지 않을 경우: 배열의 끝까지 

음수를 지정한 경우: 배열의 끝에서부터의 길이를 나타낸다

배열의 길이와 같거나 큰 수를 지정한 경우: 배열의 끝까지 추출.

 

array.concat()

메서드는 인자로 주어진 배열이나 값들을 기존 배열에 합쳐서 새 배열을 반환합니다.

const array1 = ['a', 'b', 'c'];
const array2 = ['d', 'e', 'f'];
const array3 = array1.concat(array2);

console.log(array3);
// expected output: Array ["a", "b", "c", "d", "e", "f"]

 

array.forEach(func(value, index, array))

배열을 순회하면서 인자로 전달한 함수를 호출하는 반복문

value : 현재 순회 중인 요소

index : 현재 순회 중인 요소의 index

array : 배열 객체

배열명.forEach(요소명 => { 실행문(요소명) });

const arr = ['apple', 'kiwi', 'grape', 'orange'];

arr.forEach((item, index, arr) => {
  console.log("index: " + index + ", item: " + item
      + ", arr[" + index + "]: " + arr[index]);
});

=>
index: 0, item: apple, arr[0]: apple
index: 1, item: kiwi, arr[1]: kiwi
index: 2, item: grape, arr[2]: grape
index: 3, item: orange, arr[3]: orange

array.indexOf(),lastIndexOf()

배열에서 지정된 요소를 찾을 수 있는 첫 번째 인덱스를 반환 ,indexOf 함수와 반대 방향인 배열 뒤에서부터 원소의 위치를 탐색

존재하지 않으면 -1을 반환

indexOf

let arr1 = ['tiger', 'lion', 'cat', 'dog', 'cat'];
console.log(arr1.indexOf('cat')); // 찾은 경우 인덱스 반환: 2
console.log(arr1.indexOf('rabbit')); // 못 찾은 경우 -1


last indexOf

let arr2 = ['tiger', 'lion', 'cat', 'dog', 'cat'];
console.log(arr2.lastIndexOf('cat')); // 4
console.log(arr2.lastIndexOf('rabbit')); // 못 찾은 경우 -1

array.includes()

메서드는 배열이 특정 요소를 포함하고 있는지 판별

const array1 = [1, 2, 3];

console.log(array1.includes(2));
// expected output: true

const pets = ['cat', 'dog', 'bat'];

console.log(pets.includes('cat'));
// expected output: true

console.log(pets.includes('at'));
// expected output: false

array.find()

find() 메소드는 주어진 테스트 함수의 조건을 만족하는 첫 번째 요소 값을 반환

조건에 맞는 요소를 찾을 수 없다면 undefined를 반환

find()는 호출되는 배열을 변경하지 않는다. 

const array1 = [5, 12, 8, 130, 44];

const found = array1.find(element => element > 10);

console.log(found);
// expected output: 12

array.findIndex() 

메서드는 주어진 판별 함수를 만족하는 배열의 첫 번째 요소에 대한 인덱스를 반환

 만족하는 요소가 없으면 -1을 반환

const array1 = [5, 12, 8, 130, 44];

const isLargeNumber = (element) => element > 13;

console.log(array1.findIndex(isLargeNumber));
// expected output: 3

array.filter()

테스트를 통과하는 모든 요소를 모아 새로운 배열로 반환

let animals = [
  { species: 'mammalia', name: "cat" },
  { species: 'reptiles', name: "lizard" },
  { species: 'amphibia', name: "flog" },
  { species: 'mammalia', name: "dog" },
  { species: 'amphibia', name: "salamander" }
];

  let result = animals.filter((value) => value.species == 'mammalia')
  

console.log(result);
=>

[{ species: "mammalia", name: "cat" }, { species: "mammalia", name: "dog" }]

array.join()

배열의 모든 요소를 연결해 하나의 문자열로 만든다

 

const elements = ['Fire', 'Air', 'Water'];

console.log(elements.join());
=> expected output: "Fire,Air,Water"

console.log(elements.join(''));
=>expected output: "FireAirWater"

console.log(elements.join('-'));
=> expected output: "Fire-Air-Water"

 

array.map()

배열의 모든 값들을 순환 후 새로운 배열을 반환하기 위해 사용

const arr1 = [1, 2, 3, 4];

const arr2 = arr1.map(function add(currValue) {
  currValue = currValue + 1;
})

document.writeln(arr1 + '<br>'); // [1, 2, 3, 4]
document.writeln(arr2[0] + '<br>'); // undefined
=>callback 함수에서 값을 리턴하지 않으면, 
map() 함수에 의해 생성되는 새로운 배열(arr2)의 element는 undefined 값을 가지게 되고,
arr1의 값도 변경되지 않눈다

★forEach() 기존의 Ararry를 변경하는 반면, map()은 새로운 Ararry를 반환

array.reduce()

배열의 왼쪽부터 콜백 함수를 실행 후 누산함

배열.reduce( function(acc, cur, index, arr) {} [, initialValue] )

누산기accumulator (acc),현재 값 (cur)현재 인덱스 (idx),원본 배열 ,초기값(initialValue)

array.sort()

배열의 요소를 적절한 위치에 정렬한 후 그 배열을 반환 기본 정렬 순서는 문자열의 유니코드 코드 포인트를 따른다

const months = ['March', 'Jan', 'Feb', 'Dec'];
months.sort();
console.log(months);
// expected output: Array ["Dec", "Feb", "Jan", "March"]

const array1 = [1, 30, 4, 21, 100000];
array1.sort();
console.log(array1);
// expected output: Array [1, 100000, 21, 30, 4]

문자열 대신 숫자를 비교하기 위해 compare 함수는 a에서 b를 뺄 수 있습니다. 다음 함수는 배열을 오름차순으로 정렬합니다 (Infinity 및 NaN이 포함되어 있지 않은 경우).

var numbers = [4, 2, 5, 1, 3];
numbers.sort(function(a, b) {
  return a - b;
});
console.log(numbers);

// [1, 2, 3, 4, 5]

 

mutable(원본을 수정하는) method

arr.push() 
=>배열의 맨 뒤에 요소 추가 <-> immutable한 concat과 비교된다

arr.pop() 
=>배열의 맨 뒤의 요소 삭제

arr.shift() 
=>배열의 맨 앞의 요소 삭제

arr.unshift() 
=>배열의 맨 앞에 요소 추가

arr.fill(value, startIndex, endIndex) 
=> 배열의 startIndex부터 endIndex까지 value로 채워넣음. 채우고 난 후의 값을 return한다

arr.reverse() 
=>배열의 순서 반전시켜return한다

arr.sort() 
=>배열의 정렬하여 배열을 return한다

arr.splice(startIndex, deleteCount, item1, item2) 
=> startIndex부터 시작해서 deleteCount만큼의 요소를 제거한 뒤 item들을 해당 인덱스에 추가, 
변화된 뒤의 배열을 return한다

 

Immutable(원본을 수정하지 않는) method

arr.slice(start, end) 
=> 배열의 stsart지점부터 end인덱스 전까지를 추출함. 추출한 부분을 return한다. 
=>arr.slice() 로 원본과 독립적인 배열을 복사할 수 있다


arr.includes(element,start) 
=>start index부터 요소가 있는지 판별해서 있으면 true를 return한다.


arr.indexof(element,start) 
=> start index부터 찾기 시작해서 요소의 index를 return한다. 찾을 수 없으면 -1 


arr.join() 
=> 배열의 각 배열을 문자열로 반환

newarr = arr1.concat(arr2) 
=> push와 비슷하지만 원본을 변화시키지 않고 새로운 배열을 return한다