코딩테스트를 위한 JavaScript 문법 정리

나는 평소 C++을 이용해 알고리즘 문제를 풀고있다. 근데 코딩테스트에서 사용할 수 있는 언어에 C++이 없어서 자바스크립트로 코딩테스트를 봐야한다. 평소 자바스크립트를 하고 있기에 큰 문제가 되지는 않았다. 알고리즘을 위한 자바스크립트 문법을 정리했다. 

배열순회

Array.prototype.forEach

const arr = [1, 2, 3, 4, 5];
arr.forEach((e, i)=>{
	console.log(`${i}번째 요소 ${e}`);
})

---

문자열 분해

String.prototype.split

문자열을 구분자를 기준으로 여러개의 문자열로 나누어 배열로 만들어주는 함수

const str = "1,2,3,4,5";
const ret  = string.split(",");
console.log(ret) // ["1", "2", "3", "4", "5"]

Array.prototype.join

배열의 모든 요소를 구분자로 연결해 문자열로 만들어주는 함수

const arr = [1, 2, 3, 4, 5];
const ret1 = arr.join();
const ret2 = arr.join("");
const ret3 = arr.join("-");
console.log(ret1) // "1,2,3,4,5"
console.log(ret2) // "12345"
console.log(ret3) // "1-2-3-4-5"

Array.prototype.concat과의 차이점은???
Array 인스턴스의 concat() 메서드는 두 개 이상의 배열을 병합하는 데 사용
Array 인스턴스의 Join() 메서드는 배열의 모든 요소를 쉼표나 지정된 구분 문자열로 구분하여 연결한 새 문자열을 만드는데 사용

---

정렬

Array.prototype.sort

배열의 요소를 어떠한(compare 함수) 기준으로 정렬하는 함수 이 함수는 stable한 정렬이 아닐 수 있다.

이 메서드는 원본 배열을 직접 변경(파괴적)하며, 정렬된 배열을 반환한다.

기본적으로는 문자열로 배열의 요소를 변환한 후 유니코드 순서에 따라 정렬한다.

const array = [1, 30, 4, 21, 100000];
array.sort();
console.log(array);
// 문자열로 배열의 요소를 변환후 유니코드 순서에 따라 정렬: [1, 100000, 21, 30, 4]

const fruits = ["banana", "apple", "cherry"];
fruits.sort();
console.log(fruits); // ["apple", "banana", "cherry"]

compare 함수

배열의 요소를 비교하는 데 사용하는 함수다. 이 함수는 두 개의 요소를 인자로 받아 다음 중 하나를 반환해야 한다.

• 0보다 작은 값: 첫 번째 인자가 두 번째 인자보다 작음.
• 0: 두 인자가 동일함.
• 0보다 큰 값: 첫 번째 인자가 두 번째 인자보다 큼.

const array = [1, 30, 4, 21, 100000];
array.sort((a, b) => a - b);
/*
	a - b가 음수이면 a가 b보다 앞에 오고,
	a - b가 양수이면 b가 a보다 앞에 온다.
*/
console.log(array);
// compare함수에 의해 정렬: [1, 4, 21, 30, 100000]

/* 객체 배열 정렬 */
let items = [
  { name: "Edward", value: 21 },
  { name: "Sharpe", value: 37 },
  { name: "And", value: 45 },
  { name: "The", value: -12 },
  { name: "Zeros", value: 37 }
];

items.sort((a, b) => a.value - b.value);
console.log(items);
// value를 기준으로 오름차순 정렬

---

배열 필터링

Array.prorotype.filter

배열의 각 요소를 지정한 조건에 따라 걸러내어 새로운 배열을 생성하는 데 사용된다. 이 메서드는 원본 배열을 변경하지 않으며, 얕은 복사를 해 조건을 만족하는 요소들로만 이루어진 새로운 배열을 반환합니다.

const numbers = [1, 2, 3, 4, 5, 6];
const evenNumbers = numbers.filter(number => number % 2 === 0);
console.log(evenNumbers); // 출력: [2, 4, 6]

/* 문자열 배열에서 특정 문자열 포함 여부로 필터링 */
const fruits = ["apple", "banana", "cherry", "apricot", "grape"];
const filteredFruits = fruits.filter(fruit => fruit.includes("apple"));
console.log(filteredFruits); // 출력: ["apple"]

/* 객체 배열에서 특정 속성 값으로 필터링 */
const people = [
  { name: "Alice", age: 17 },
  { name: "Bob", age: 22 },
  { name: "Charlie", age: 16 },
  { name: "David", age: 19 }
];
const adults = people.filter(person => person.age >= 18);
console.log(adults);
// 출력:
// [
//   { name: "Bob", age: 22 },
//   { name: "David", age: 19 }
// ]

/* 중복 제거 */
const numbers = [1, 2, 2, 3, 4, 4, 5];
const uniqueNumbers = numbers.filter((number, index, arr) => arr.indexOf(number) === index);
console.log(uniqueNumbers); // 출력: [1, 2, 3, 4, 5]

Array.prototype.indexOf가 뭐죠?
Array 인스턴스의 indexOf() 메서드는 배열에서 주어진 요소를 찾을 수 있는 첫 번째 인덱스를 반환하고, 찾을 수 없는 경우 -1을 반환한다.

Array.prototype.map

배열의 각 요소에 대해 지정된 함수를 호출하고, 그 결과로 새로운 배열을 생성하는 데 사용됩니다.

원본 배열은 변경되지 않으며, 각 요소를 변환하는 데 매우 유용하다

const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(number => number * 2);
console.log(doubled); // 출력: [2, 4, 6, 8, 10]

const fruits = ["apple", "banana", "cherry"];
const indexedFruits = fruits.map((fruit, index) => `${index + 1}: ${fruit}`);
console.log(indexedFruits);
// 출력: ["1: apple", "2: banana", "3: cherry"]

const users = [
  { firstName: "John", lastName: "Doe" },
  { firstName: "Jane", lastName: "Smith" },
  { firstName: "Emily", lastName: "Jones" }
];
// 각 사용자의 전체 이름을 생성
const fullNames = users.map(user => `${user.firstName} ${user.lastName}`);
console.log(fullNames);
// 출력: ["John Doe", "Jane Smith", "Emily Jones"]

const matrix = [
  [1, 2],
  [3, 4],
  [5, 6]
];
// 각 내부 배열의 합을 계산
const sums = matrix.map(row => row.reduce((acc, num) => acc + num, 0));
console.log(sums); // 출력: [3, 7, 11]

Array.prototype.reduce

배열의 각 요소를 순회하면서 누적된 값을 계산하거나, 배열을 단일 값으로 축소(reduce)하는 데 사용되는 메서드다.

이 메서드는 복잡한 연산을 간결하게 처리할 수 있게 해주며, 합계 계산, 최대값 찾기, 객체 생성 등 다양한 용도로 활용할 수 있다.

동작 방식

reduce 메서드는 배열의 각 요소를 순회하며 callback 함수를 호출한다. 이때 accumulator는 이전 callback 호출의 반환 값을 유지하며, currentValue는 현재 요소의 값을 가리킨다. 이를 통해 배열을 하나의 값으로 축소할 수 있다.

/* 배열의 합계 구하기 */
const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduce((acc, curr) => acc + curr, 0);
console.log(sum); // 출력: 15

/* 배열의 평균 구하기 */
const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduce((acc, curr) => acc + curr, 0);
const average = sum / numbers.length;
console.log(average); // 출력: 3

/* 배열에서 최댓값 찾기 */
const numbers = [10, 5, 20, 8, 15];
const max = numbers.reduce((acc, curr) => (curr > acc ? curr : acc), numbers[0]);
console.log(max); // 출력: 20

/* 배열의 속성 합계 계산 */
const items = [
  { name: "Apple", price: 100 },
  { name: "Banana", price: 200 },
  { name: "Cherry", price: 150 }
];
const totalPrice = items.reduce((acc, item) => acc + item.price, 0);
console.log(totalPrice); // 출력: 450

/* 배열을 객체로 변환 */
const fruits = ["apple", "banana", "cherry", "apple", "banana"];
const fruitCount = fruits.reduce((acc, fruit) => {
  acc[fruit] = (acc[fruit] || 0) + 1;
  return acc;
}, {});
console.log(fruitCount);
// 출력: { apple: 2, banana: 2, cherry: 1 }

/* 중첩된 배열 평탄화 */
const nestedArray = [[1, 2], [3, 4], [5, 6]];
const flatArray = nestedArray.reduce((acc, curr) => acc.concat(curr), []);
console.log(flatArray); // 출력: [1, 2, 3, 4, 5, 6]

/* 문자열에 포함된 문자 갯수 세기*/
const str = "hello world";
const charCount = str.split('').reduce((acc, char) => {
  if (char !== ' ') { // 공백 제외
    acc[char] = (acc[char] || 0) + 1;
  }
  return acc;
}, {});
console.log(charCount);
// 출력: { h: 1, e: 1, l: 3, o: 2, w: 1, r: 1, d: 1 }

---

요소 찾기

Array.prototype.find

배열의 요소를 순회하며 주어진 조건을 만족하는 첫 번째 요소를 반환하는 메서드다.

이 메서드는 특정 조건을 만족하는 요소를 찾을 때 유용하며, 조건을 만족하는 요소가 없으면 undefined를 반환한다. find()는 원본 배열을 변경하지 않으며, 새로운 배열을 생성하지 않는다.

const array1 = [5, 12, 8, 130, 44];
const found = array1.find((element) => element > 10);
console.log(found); // 12

/* 객체 배열 속성 중 하나로 요소 찾기 */
const inventory = [
  { name: "apples", quantity: 2 },
  { name: "bananas", quantity: 0 },
  { name: "cherries", quantity: 5 },
];
const result = inventory.find(({ name }) => name === "cherries");
console.log(result); // { name: 'cherries', quantity: 5 }

/* 배열에서 소수 찾기 */
function isPrime(element, index, array) {
  let start = 2;
  while (start <= Math.sqrt(element)) {
    if (element % start++ < 1) {
      return false;
    }
  }
  return element > 1;
}
console.log([4, 6, 8, 12].find(isPrime)); // undefined, 소수 없음
console.log([4, 5, 8, 12].find(isPrime)); // 5

Array.prototype.indexOf

배열 내에 특정 요소가 처음으로 나타나는 인덱스를 반환하는 메서드다.

이 메서드는 배열을 순회하면서 지정된 요소를 찾고, 해당 요소가 발견된 첫 번째 위치의 인덱스를 반환한다. 만약 배열 내에 요소가 존재하지 않으면 -1을 반환한다.

const fruits = ["apple", "banana", "cherry", "banana"];
const index1 = fruits.indexOf("banana");
console.log(index1); // 출력: 1
const index2 = fruits.indexOf("cherry");
console.log(index2); // 출력: 2
const index3 = fruits.indexOf("grape");
console.log(index3); // 출력: -1

/* 검색을 특정 인덱스부터 시작*/
const fruits = ["apple", "banana", "cherry", "banana"];
// 인덱스 2부터 검색 시작
const index = fruits.indexOf("banana", 2);
console.log(index); // 출력: 3
// 배열의 끝에서부터 검색 시작 (fromIndex = -2)
const index = fruits.indexOf("banana", -2);
console.log(index); // 출력: 3

/* 배열의 마지막 인덱스를 찾는 방법 */
const fruits = ["apple", "banana", "cherry", "banana"];
const lastIndex = fruits.lastIndexOf("banana");
console.log(lastIndex); // 출력: 3

객체 배열에서 특정 객체를 찾는 경우, indexOf()는 참조를 비교하기 때문에 원하는 결과를 얻지 못할 수 있다. 이때는 findIndex()를 사용하는 것이 적합하다.

/* 객체 배열에 사용 */
const users = [
  { id: 1, name: "Alice" },
  { id: 2, name: "Bob" },
  { id: 3, name: "Charlie" }
];
const user = { id: 2, name: "Bob" };
const index = users.indexOf(user);
console.log(index); // 출력: -1 (참조가 다르기 때문)

Array.prototype.findIndex

배열의 요소를 순회하며 주어진 조건을 만족하는 첫 번째 요소의 인덱스를 반환하는 메서드다.

이 메서드는 특정 조건을 만족하는 요소를 찾고자 할 때 유용하며, 조건을 만족하는 요소가 없으면 -1을 반환한다. findIndex()는 원본 배열을 변경하지 않으며, 새로운 배열을 생성하지 않는다.

/* 위 Array.prototype.indexOf를 이용한 객체 배열 조회가 안되는 문제 해결 */
const index = users.findIndex(u => u.id === 2);
console.log(index); // 출력: 1

/* 기본 사용법 */
const numbers = [1, 3, 5, 4, 2];
const firstEvenIndex = numbers.findIndex(number => number % 2 === 0);
console.log(firstEvenIndex); // 출력: 3

---

배열 생성

Array.prototype.fill

배열의 모든 요소를 지정된 값으로 채우는 데 사용되는 메서드다. 이 메서드는 배열을 초기화하거나 특정 값으로 배열을 재설정할 때 유용하게 활용된다. fill()은 원본 배열을 변경하며, 메서드 체이닝이 가능하다.

/* 배열의 모든 요소를 0으로 초기화 */
const arr = new Array(5).fill(0);
console.log(arr); // 출력: [0, 0, 0, 0, 0]

/*
	객체나 배열을 값으로 채울 경우, 모든 요소가 동일한 참조를 가리키게 된다.
	따라서 하나의 요소를 변경하면 모든 요소에 영향을 미친다.
*/
const arr = new Array(3).fill({ a: 1 });
arr[0].a = 2;
console.log(arr); // 출력: [{ a: 2 }, { a: 2 }, { a: 2 }]
/* 위 참조 문제를 해결하는 방법 */
const arr = new Array(3).fill(null).map(() => ({ a: 1 }));
arr[0].a = 2;
console.log(arr); // 출력: [{ a: 2 }, { a: 1 }, { a: 1 }]

/* 인덱스를 기반으로 값 채우기 */
const arr = new Array(5).fill().map((_, index) => index + 1);
console.log(arr); // 출력: [1, 2, 3, 4, 5]

fill() vs map() vs forEach()

메서드	반환값	주요용도
fill()	원본 배열	배열의 모든 요소를 동일한 값으로 채우기
map()	새로운 배열	배열의 각 요소를 변환하여 새로운 배열 생성
forEach()	undefined	배열의 각 요소에 대해 부수 효과 발생

---

문자열 수정

String.prototype.subString

문자열의 일부를 추출하여 새로운 문자열을 반환하는 데 사용된다. 이 메서드는 지정한 시작 인덱스부터 종료 인덱스 이전까지의 문자를 반환하며, 원본 문자열은 변경되지 않는다.

const str = "Hello, World!";
/* 7번째 인덱스부터 11인덱스 까지 추출 */
const result1 = str.substring(7, 12);
console.log(result1); // 출력: "World"
/* 7번째 인덱스부터 끝까지 추출 */
const result2 = str.substring(7);
console.log(result2); // 출력: "World!"

/* url 추출 */
const url = "<https://www.example.com/path/page.html>";
const start = url.indexOf("//") + 2;
const end = url.indexOf("/", start);
const domain = url.substring(start, end);
console.log(domain); // 출력: "www.example.com"

String.prototype.slice

문자열의 일부를 추출하여 새로운 문자열을 반환하는 메서드. 이 메서드는 지정된 시작 인덱스부터 종료 인덱스 이전까지의 문자를 추출, 원본 문자열은 변경되지 않는다. slice()는 음수 인덱스를 지원하여 문자열의 끝에서부터 문자를 추출할 수도 있다.

const str = "Hello, World!";

/* subString이랑 똑같다 */
const result1 = str.slice(7, 12);
console.log(result1); // 출력: "World"
const result2 = str.slice(7);
console.log(result2); // 출력: "World!"

/* 음수 인덱스 활용 */
// 뒤에서 6번째 부터 뒤에서 첫번째까지 추출
const result3 = str.slice(-6, -1);
console.log(result3); // 출력: "World"

//시작 인덱스가 종료 인덱스보다 크면 빈 문자열을 반환
const result4 = str.slice(12, 7);
console.log(result4); // 출력: ""

slice vs substring vs substr

메서드 파라미터 음수 인덱스 처리 인덱스 교환 반환 방식

slice	slice(start, end)	지원	순서에 따라 처리	시작 인덱스부터 종료 인덱스 전까지
substring	substring(start, end)	0으로 간주	교환하여 처리	시작 인덱스부터 종료 인덱스 전까지
substr	substr(start, length)	지원	해당 없음	시작 인덱스부터 길이만큼

---

객체 정보

Object.keys

주어진 객체의 속성 이름들을 일반적인 반복문과 동일한 순서로 순회되는 열거할 수 있는 배열로 반환하는 메서드다.

const person = {
  name: "Alice",
  age: 25,
  city: "Seoul"
};
const keys = Object.keys(person);
console.log(keys); // 출력: ["name", "age", "city"]

Object.values

객체가 가지는 (열거 가능한) 속성의 값들로 이루어진 배열을 리턴한다. 이 배열은 for...in 구문과 동일한 순서를 가진다.

const person = {
  name: "Alice",
  age: 25,
  city: "Seoul"
};

const values = Object.values(person);
console.log(values); // 출력: ["Alice", 25, "Seoul"]

Object.entries

for...in와 같은 순서로 주어진 객체 자체의 enumerable 속성 [key, value] 쌍의 배열을 반환한다.

const person = {
  name: "Alice",
  age: 25,
  city: "Seoul"
};

const entries = Object.entries(person);
console.log(entries);
// 출력: [["name", "Alice"], ["age", 25], ["city", "Seoul"]]

Object.values() vs Object.keys() vs Object.entries()

메서드 반환값 설명

Object.keys()	열거 가능한 자체 속성 이름 배열	객체의 키(속성 이름)만을 배열로 반환합니다.
Object.values()	열거 가능한 자체 속성 값 배열	객체의 값만을 배열로 반환합니다.
Object.entries()	[키, 값] 쌍의 배열	객체의 키와 값을 쌍으로 배열에 반환합니다.

---

숫자 변환

Math.round

Math 객체에 속한 메서드로, 주어진 숫자를 가장 가까운 정수로 반올림(round)하는 데 사용된다. 이 메서드는 소수점을 포함한 숫자를 처리할 때 유용하며, 결과는 항상 정수 형태로 반환된다.

console.log(Math.round(4.5)); // 출력: 5
console.log(Math.round(4.4)); // 출력: 4
console.log(Math.round(-4.5)); // 출력: -4
console.log(Math.round(-4.6)); // 출력: -5

/* 소수점 이하 여러자리 숫자 */
function roundToDecimalPlaces(number, decimalPlaces) {
  const factor = Math.pow(10, decimalPlaces);
  return Math.round(number * factor) / factor;
}
console.log(roundToDecimalPlaces(3.14159, 2)); // 출력: 3.14
console.log(roundToDecimalPlaces(3.14159, 3)); // 출력: 3.142

Math.ceil

주어진 숫자를 올림(ceil)하여 가장 가까운 정수로 반환한다. 이 메서드는 소수점을 포함한 숫자를 처리할 때 유용하며, 결과는 항상 정수 형태로 반환한다.

console.log(Math.ceil(4.1)); // 출력: 5
console.log(Math.ceil(4.5)); // 출력: 5
console.log(Math.ceil(4.9)); // 출력: 5
console.log(Math.ceil(-4.1)); // 출력: -4
console.log(Math.ceil(-4.5)); // 출력: -4
console.log(Math.ceil(-4.9)); // 출력: -4
console.log(Math.ceil(3.14159)); // 출력: 4
console.log(Math.ceil(-3.14159)); // 출력: -3

Math.floor

주어진 숫자를 내림(Floor)하여 가장 가까운 정수로 반환한다. 이 메서드는 소수점을 포함한 숫자를 처리할 때 유용하며, 결과는 항상 정수 형태로 반환한다.

console.log(Math.floor(4.7));  // 출력: 4
console.log(Math.floor(4.2));  // 출력: 4
console.log(Math.floor(-4.7)); // 출력: -5
console.log(Math.floor(-4.2)); // 출력: -5
console.log(Math.floor(3.14159)); // 출력: 3
console.log(Math.floor(-3.14159)); // 출력: -4

Math.round() vs Math.floor() vs Math.ceil()

메서드	설명	예시
Math.round()	가장 가까운 정수로 반올림	Math.round(4.5) → 5
Math.floor()	내림하여 가장 큰 정수로	Math.floor(4.9) → 4
Math.ceil()	올림하여 가장 작은 정수로	Math.ceil(4.1) → 5

Math.abs

주어진 숫자의 절댓값(absolute value)을 반환한다.

console.log(Math.abs(5));      // 출력: 5
console.log(Math.abs(-5));     // 출력: 5
console.log(Math.abs(0));      // 출력: 0
console.log(Math.abs(-0));     // 출력: 0
console.log(Math.abs(3.14));   // 출력: 3.14
console.log(Math.abs(-3.14));  // 출력: 3.14
console.log(Math.abs(NaN));          // 출력: NaN
console.log(Math.abs(Infinity));     // 출력: Infinity
console.log(Math.abs(-Infinity));    // 출력: Infinity

/* 배열의 모든 요소 절댓값 구하기 */
const numbers = [-1, -2, 3, -4, 5];
const absoluteValues = numbers.map(num => Math.abs(num));
console.log(absoluteValues); // 출력: [1, 2, 3, 4, 5]

---

Map

Map 객체는 키-값 쌍을 저장하는 컬렉션이다. 각 키는 고유(unique)하며, 모든 데이터 타입을 키로 사용할 수 있다. Map은 삽입된 순서를 기억하며, 이로 인해 반복 시 예측 가능한 순서를 제공한다.

const map1 = new Map();

map1.set('a', 1);
map1.set('b', 2);
map1.set('c', 3);

console.log(map1.get('a')); // 1

map1.set('a', 97);

console.log(map1.get('a')); // 97

console.log(map1.size); // 3

map1.delete('b');

console.log(map1.size); // 2

Map과 일반 객체(Object) 비교

Map과 일반 객체(Object)는 모두 키-값 쌍을 저장할 수 있는 데이터 구조이지만, 몇 가지 중요한 차이점이 있습니다.

특징 Map Object

키의 데이터 타입	모든 데이터 타입 가능 (객체, 함수, 심볼 등)	문자열과 심볼(Symbol)만 가능
키의 순서	삽입 순서 유지	순서는 보장되지 않음 (ES2015 이후 일부 순서 보장)
크기 관리	size 프로퍼티로 손쉽게 크기 확인 가능	별도의 크기 계산 필요 (Object.keys(obj).length)
프로토타입 체인	키에 프로토타입 체인 속성 영향 없음	프로토타입 체인에 상속된 속성이 포함될 수 있음
반복(iteration)	이터러블, for...of, forEach 등으로 쉽게 반복 가능	for...in, Object.keys(), Object.values() 등 사용
성능	대용량 데이터에 더 효율적일 수 있음	작은 객체에서는 성능 차이가 미미함
기능성	다양한 메서드 제공 (set, get, has 등)	제한된 메서드, 대부분은 Object 생성자 메서드 사용

---

Set

Set 객체는 값의 중복을 허용하지 않는 값들의 집합을 저장한다. 각 값은 유일하며, Set은 값의 삽입 순서를 기억한다. Set은 주로 중복된 데이터를 제거하거나, 고유한 값들의 컬렉션을 관리할 때 사용된다.

const mySet1 = new Set();

mySet1.add(1); // Set(1) { 1 }
mySet1.add(5); // Set(2) { 1, 5 }
mySet1.add(5); // Set(2) { 1, 5 }
mySet1.add("some text"); // Set(3) { 1, 5, 'some text' }
const o = { a: 1, b: 2 };
mySet1.add(o);

mySet1.add({ a: 1, b: 2 }); // o 는 다른 객체를 참조하고 있기 때문에 이는 괜찮습니다

mySet1.has(1); // true
mySet1.has(3); // false, 3 이 set에 추가되지 않았기 때문입니다.
mySet1.has(5); // true
mySet1.has(Math.sqrt(25)); // true
mySet1.has("Some Text".toLowerCase()); // true
mySet1.has(o); // true

mySet1.size; // 5

mySet1.delete(5); // set에서 5 제거
mySet1.has(5); // false, 5 는 제거되었습니다.

mySet1.size; // 4, 막 하나를 제거했기 때문에

mySet1.add(5); // Set(5) { 1, 'some text', {...}, {...}, 5 } - 이전에 삭제된 아이템이 새로운 아이템으로 추가되나, 삭제 전 원래 위치를 유지하진 못합니다.

console.log(mySet1); // Set(5) { 1, "some text", {…}, {…}, 5 }

Set과 배열(Array) 비교

Set과 배열(Array)은 모두 여러 값을 저장할 수 있는 컬렉션이지만, 몇 가지 중요한 차이점이 있습니다.

특징 Set Array

중복 허용	중복 불허	중복 허용
데이터 타입	모든 데이터 타입 허용	모든 데이터 타입 허용
순서 유지	삽입 순서 유지	삽입 순서 유지
크기 관리	size 프로퍼티로 크기 확인 가능	length 프로퍼티로 크기 확인 가능
메서드	add, delete, has, clear, forEach 등	push, pop, shift, unshift, map, filter 등
성능	중복 확인 및 빠른 검색에 유리	순차적 데이터 처리에 유리
반복(iteration)	for...of, forEach 등으로 간편하게 반복 가능	다양한 반복 메서드 제공 (for, for...of, forEach 등)