01. at()

배열.at(위치값)

  • 지정한 숫자(index)를 받아, 배열에서 해당되는 인덱스의 요소를 반환합니다.
{
    ["a", "b", "c"].at(0)    // "a"
    ["a", "b", "c"].at(2)    // "c"
}

02. concat()

배열.concat(다른 배열)

  • 둘 이상의 배열을 결합하여, 새로운 배열을 반환합니다.
{
    ["a", "b"].concat(["c", "d"])    // ["a", "b", "c", "d"]
}

03. copyWithin()

배열.copyWithin(대상 인덱스, 복사 시작 인덱스[, 복사 끝 인덱스])

  • 배열의 일부를 얕게 복사한 뒤, 동일한 배열의 다른 위치에 덮어쓰고 그 배열을 반환합니다.
{
    ["a", "b", "c", "d", "e"].copyWithin(0, 3)    // ["d", "e", "c", "d", "e"]
}

04. entries()

배열.entries()

  • 배열의 각 인덱스에 대한 [인덱스, 요소값] 쌍을 반환합니다.
{
    [...["a", "b", "c"].entries()]    // [[0, "a"], [1, "b"], [2, "c"]]
}

05. keys()

배열.keys()

  • 배열의 각 인덱스에 대한 키 값을 반환합니다.
{
    [...["a", "b", "c"].keys()]    // [0, 1, 2]
}

06. fill()

배열.fill(값[, 시작 인덱스[, 끝 인덱스]])

  • 배열의 시작 인덱스부터 끝 인덱스까지 하나의 값으로 반환합니다.
{
    ["a", "b", "c"].fill("x", 1, 2)    // ["a", "x", "c"]
}

07. find()💛💛

배열.find(판별 함수)

  • 주어진 판별 함수를 만족하는 첫 번째 요소의 값을 반환합니다.
{
    [5, 12, 8, 130, 44].find(x => x > 10)    // 12
}

08. findIndex()

배열.findIndex(판별 함수)

  • 주어진 판별 함수를 만족하는 첫 번째 요소의 값을 인덱스로 반환합니다.
{
    [5, 12, 8, 130, 44].findIndex(x => x > 10)    // 1
}

09. findLast()

배열.findLast(판별 함수)

  • 주어진 판별 함수를 만족하는 첫 번째 요소의 값을 역순으로 반환합니다.
{
    [5, 12, 8, 130, 44].findLast(x => x > 10)    // 130
}

10. findLastIndex()

배열.findLastIndex(판별 함수)

  • 주어진 판별 함수를 만족하는 첫 번째 요소의 값을 역순 인덱스로 반환합니다.
{
    [5, 12, 8, 130, 44].findLastIndex(x => x > 10)    // 3
}

11. flat()

배열.flat([깊이])

  • 중첩된 배열을 하나의 배열로 반환합니다.
{
    [1, 2, [3, 4]].flat()    // [1, 2, 3, 4]
}

12. flatMap()

배열.flatMap(매핑 함수)

  • 먼저 매핑 함수를 사용해 각 엘리먼트에 대해 map 수행 후, 결과를 새로운 배열로 평탄화합니다.
{
    [1, 2, 3].flatMap(x => [x * 2])    // [2, 4, 6]
}

13. forEach()💛💛💛

배열.forEach(함수)

  • 주어진 함수 조건을 배열 요소 각각에 대해 실행하고, 그 결과를 반환합니다.
{
    [1, 2, 3].forEach(x => console.log(x))    // 1, 2, 3
}

14. filter()

배열.filter(함수)

  • 주어진 함수 조건에 맞는 모든 요소를 새로운 배열로 반환합니다.
{
    [1, 2, 3, 4].filter(x => x % 2 === 0)    // [2, 4]
}

15. every()

배열.every(함수)

  • 주어진 함수를 모두 통과하는지 확인하고, 불린(true, false)로 반환합니다.
{
    [2, 4, 6].every(x => x % 2 === 0)    // true
}

16. map()💛💛💛

배열.map(함수)

  • 주어진 함수를 호출하고, 그 결과를 모아서 만든 새로운 배열을 반환합니다.
{
    [1, 2, 3].map(x => x * 2)    // [2, 4, 6]
}

17. some()

배열.some(함수)

  • 주어진 판별 함수를 통과하는지 테스트하여, 그 결과를 불린(true, false)로 반환합니다.
{
    [1, 2, 3, 4].some(x => x % 2 === 0)    // true
}

18. includes()💛

배열.includes(값[, 시작 인덱스])

  • 배열 포함 여부를 검색하여, 불린(true, false)을 반환합니다.
{
    [1, 2, 3].includes(2)    // true
}

19. indexOf()💛

배열.indexOf(값[, 시작 인덱스])

  • 배열을 검색하고, 위치값(숫자)을 반환합니다.
{
    [1, 2, 3].indexOf(2)    // 1
}

20. lastIndexOf()

배열.lastIndexOf(값[, 시작 인덱스])

  • 역순으로 배열을 검색하고, 위치값(숫자)을 반환합니다.
{
    [1, 2, 3, 1].lastIndexOf(1)    // 3
}

21. join()💛

배열.join([구분자])

  • 배열의 요소를 추가하여, 하나의 문자열로 반환합니다.
{
    ["a", "b", "c"].join("-")    // "a-b-c"
}

22. pop()

배열.pop()

  • 배열 마지막 요소를 제거하고, 제거한 요소를 반환합니다.
{
    ["a", "b", "c"].pop()    // "c"
}

23. push()💛💛

배열.push(요소)

  • 배열 끝에 요소를 추가하고, 배열의 새로운 길이값을 반환합니다.
{
    ["a", "b"].push("c")    // 3
}

24. reduce()

배열.reduce(함수[, 초기값])

  • 배열의 각 요소를 실행하고, 하나의 결과값을 반환합니다.
{
    [1, 2, 3, 4].reduce((acc, val) => acc + val, 0)    // 10
}

25. reduceRight()

배열.reduceRight(함수[, 초기값])

  • 배열의 각 요소를 마지막부터 실행하고, 하나의 결과값을 반환합니다.
{
    [1, 2, 3, 4].reduceRight((acc, val) => acc - val, 0)    // -2
}

26. reverse()

배열.reverse()

  • 배열 요소의 순서를 반대로 하고, 반대로 된 배열을 반환합니다.
{
    [1, 2, 3].reverse()    // [3, 2, 1]
}

27. shift()

배열.shift()

  • 배열 처음 요소를 제거하고, 제거한 요소를 반환합니다.
{
    ["a", "b", "c"].shift()    // "a"
}

28. unshift()

배열.unshift(요소)

  • 배열 앞에 요소를 추가하고, 배열의 새로운 길이 값을 반환합니다.
{
    ["a", "b"].unshift("c")    // 3
}

29. slice()💛

배열.slice([시작 인덱스[, 종료 인덱스]])

  • 배열 시작 위치에서 종료 위치 값을 추출하여, 새로운 배열을 반환합니다.
{
    ["a", "b", "c", "d", "e"].slice(2, 4)    // ["c", "d"]
}

30. splice()💛

배열.splice(시작 인덱스[, 삭제할 요소 개수[, 추가할 요소1, 추가할 요소2, ...]])

  • 배열의 기존 요소를 삭제 또는 교체하거나 새 요소를 추가하여 배열의 내용을 변경합니다.
{
    let arr = ["a", "b", "c", "d"];
    arr.splice(2, 1, "x", "y")    // ["c"]
    arr    // ["a", "b", "x", "y", "d"]
}

31. sort()💛

배열.sort([비교 함수])

  • 배열의 요소를 적절한 위치에 정렬한 후, 그 배열을 반환합니다.
{
    [4, 2, 5, 1, 3].sort((a, b) => a - b)    // [1, 2, 3, 4, 5]
}

32. toLocaleString()

배열.toLocaleString()

  • 배열의 요소를 문자열로 반환합니다.
{
    [1, 2, 3].toLocaleString()    // "1,2,3"
}

33. toString()

배열.toString()

  • 데이터를 배열로 변환하고, 새로운 배열을 반환합니다.
{
    [1, 2, 3].toString()    // "1,2,3"
}

34. values()

배열.values()

  • 배열 각 인덱스에 대한 값을 객체로 반환합니다.
{
    [...[1, 2, 3].values()]    // [1, 2, 3]
}