JavaScript - λ°°μ—΄

Kim-DaHamΒ·2023λ…„ 2μ›” 27일
0

JavaScript

λͺ©λ‘ 보기
4/18
post-thumbnail

πŸ”₯ ν•™μŠ΅λͺ©ν‘œ

  • μžλ°”μŠ€ν¬λ¦½νŠΈ λ°°μ—΄κ³Ό κ·Έ νŠΉμ„±μ— λŒ€ν•΄ μ„€λͺ…ν•  수 μžˆλ‹€.
  • 배열에 μ‚¬μš© λ˜λŠ” λŒ€ν‘œμ μΈ ν•¨μˆ˜λ₯Ό ν™œμš©ν•  수 μžˆλ‹€.
  • μ½”ν”Œλ¦Ώμ„ ν’€λ©΄μ„œ 자꾸 ν—·κ°ˆλ¦° slice, splice ν•¨μˆ˜ 인자λ₯Ό μ •ν™•νžˆ μ΄ν•΄ν•œλ‹€.



🟩 λ°°μ—΄μ΄λž€?

  • μ—¬λŸ¬ 개의 값을 순차적으둜 λ‚˜μ—΄ν•œ 자료ꡬ쑰.

  • 배열이 가지고 μžˆλŠ” 값을 μš”μ†Œ(element)라고 λΆ€λ₯Έλ‹€.

  • μžλ°”μŠ€ν¬λ¦½νŠΈμ˜ λͺ¨λ“  값은 λ°°μ—΄μ˜ μš”μ†Œκ°€ 될 수 μžˆλ‹€.

    • μ›μ‹œκ°’, 객체, ν•¨μˆ˜, λ°°μ—΄ λ“± μžλ°”μŠ€ν¬λ¦½νŠΈμ—μ„œ μΈμ •ν•˜λŠ” λͺ¨λ“  것은 λ°°μ—΄μ˜ μš”μ†Œκ°€ 될 수 μžˆλ‹€.
  • 배열은 μš”μ†Œμ˜ 개수, λ°°μ—΄μ˜ 길이λ₯Ό λ‚˜νƒ€λ‚΄λŠ” length ν”„λ‘œνΌν‹°λ₯Ό κ°–λŠ”λ‹€. 이λ₯Ό μ‚¬μš©ν•˜μ—¬ for문을 톡해 순차적으둜 μš”μ†Œμ— μ ‘κ·Όν•  수 μžˆλ‹€.

  • λ°°μ—΄μ˜ νƒ€μž…μ€ Object 객체이닀.

typeof arr // Object
  • κ°μ²΄μ™€μ˜ 차이점: κ°μ²΄λŠ” κ°’μ˜ μˆœμ„œ(인덱슀)와 length ν”„λ‘œνΌν‹°λ₯Ό 갖지 μ•ŠλŠ”λ‹€.

⬜ ν¬μ†Œ λ°°μ—΄

μžλ°”μŠ€ν¬λ¦½νŠΈμ—μ„œ λ§ν•˜λŠ” 배열은 ν”νžˆ μžλ£Œκ΅¬μ‘°μ—μ„œ λ§ν•˜λŠ” λ°°μ—΄κ³Ό λ‹€λ₯΄λ‹€.


μžλ£Œκ΅¬μ‘°μ—μ„œ λ§ν•˜λŠ” 배열은...

λ™μΌν•œ 크기의 λ©”λͺ¨λ¦¬ 곡간이 λΉˆν‹ˆμ—†μ΄ μ—°μ†μ μœΌλ‘œ λ‚˜μ—΄λœ 자료ꡬ쑰λ₯Ό λ§ν•œλ‹€.
μš”μ†ŒλŠ” ν•˜λ‚˜μ˜ 데이터 νƒ€μž…μœΌλ‘œ ν†΅μΌλ˜μ–΄ 있으며 μ„œλ‘œ μ—°μ†μ μœΌλ‘œ 인접해 μžˆλ‹€.

이λ₯Ό 밀집 λ°°μ—΄(dense array)라고 ν•œλ‹€.

πŸ”΅ 일반적인 배열은 인덱슀둜 μš”μ†Œμ— λΉ λ₯΄κ²Œ μ ‘κ·Όν•  수 μžˆλ‹€.
πŸ”΄ ν•˜μ§€λ§Œ νŠΉμ • μš”μ†Œλ₯Ό κ²€μƒ‰ν•˜κ±°λ‚˜ μ‚½μž…/μ‚­μ œν•  λ•ŒλŠ” νš¨μœ¨μ μ΄μ§€ μ•Šλ‹€.


μžλ°”μŠ€ν¬λ¦½νŠΈμ—μ„œ λ§ν•˜λŠ” 배열은...

μžλ°”μŠ€ν¬λ¦½νŠΈμ˜ 배열은 일반적인 λ°°μ—΄μ˜ λ™μž‘μ„ 흉내 λ‚Έ νŠΉμˆ˜ν•œ 객체닀.

각각의 λ©”λͺ¨λ¦¬ 곡간은 λ™μΌν•œ 크기λ₯Ό 갖지 μ•Šμ•„λ„ 되며 μ—°μ†μ μœΌλ‘œ 이어져 μžˆμ§€ μ•Šμ„ μˆ˜λ„ μžˆλ‹€. 일뢀가 λΉ„μ–΄ μžˆμ„ μˆ˜λ„ μžˆλ‹€.

이λ₯Ό ν¬μ†Œ 배열이라고 ν•œλ‹€.

πŸ”΅ JS 배열은 ν•΄μ‹œ ν…Œμ΄λΈ”λ‘œ κ΅¬ν˜„λœ κ°μ²΄μ΄λ―€λ‘œ νŠΉμ • μš”μ†Œλ₯Ό κ²€μƒ‰ν•˜κ±°λ‚˜ μš”μ†Œλ₯Ό μ‚½μž…/μ‚­μ œ ν•˜λŠ” κ²½μš°μ—λŠ” μΌλ°˜λ•μΈ 배열보닀 λΉ λ₯΄λ‹€.
πŸ”΄ ν•˜μ§€λ§Œ 인덱슀둜 μš”μ†Œμ— μ ‘κ·Όν•˜λŠ” 경우 일반적인 배열보닀 μ„±λŠ₯적인 λ©΄μ—μ„œ λŠλ¦¬λ‹€.


⬜ length ν”„λ‘œνΌν‹°

λ°°μ—΄μ˜ 길이λ₯Ό λ‚˜νƒ€λ‚΄λŠ” 0μ΄μƒμ˜ μ •μˆ˜λ₯Ό κ°’μœΌλ‘œ κ°–λŠ”λ‹€.

  • 빈 배열일 경우 0을 κ°–λŠ”λ‹€.

  • ν˜„μž¬ length ν”„λ‘œνΌν‹° 값보닀 μž‘μ€ 숫자λ₯Ό ν• λ‹Ήν•˜λ©΄ λ°°μ—΄μ˜ 길이가 쀄어든닀.

const arr = [1,2,3,4,5];
arr.length = 3;
console.log(arr); // [1,2,3]

  • length ν”„λ‘œνΌν‹° 값보닀 큰 숫자λ₯Ό ν• λ‹Ήν•˜λ©΄ length ν”„λ‘œνΌν‹° 값은 λ³€κ²½λ˜μ§€λ§Œ μ‹€μ œλ‘œ λ°°μ—΄μ˜ 길이가 λŠ˜μ–΄λ‚˜μ§„ μ•ŠλŠ”λ‹€.
    (κ°’ μ—†μ΄λŠ” λΉ„μ–΄μžˆλŠ” μš”μ†Œλ₯Ό μœ„ν•΄ λ©”λͺ¨λ¦¬ 곡간을 ν™•λ³΄ν•˜μ§€ μ•ŠμœΌλ©° 빈 μš”μ†Œλ₯Ό μƒμ„±ν•˜μ§€λ„ μ•ŠλŠ”λ‹€.)

μ• μ΄ˆμ— 빈 μš”μ†Œλ₯Ό λ§Œλ“€λ©΄ μ•„λž˜μ™€ κ°™λ‹€.

const sparse = [, 2, ,4];
console.log(sparse.length); //4
console.log(sparse); // [empty, 2, empty, 4]

πŸ”΄ 빈 곡간을 κ°€μ§ˆ 수 μžˆλŠ” ν¬μ†Œ λ°°μ—΄μ˜ νŠΉμ„± 상 ν¬μ†Œ λ°°μ—΄μ˜ lengthλŠ” ν¬μ†Œ λ°°μ—΄μ˜ μ‹€μ œ μš”μ†Œ κ°œμˆ˜λ³΄λ‹€ μ–Έμ œλ‚˜ 크닀. ν•˜μ§€λ§Œ ν¬μ†Œ 배열은 μ‚¬μš©ν•˜μ§€ μ•ŠλŠ” 것이 μ’‹λ‹€.

μ΅œμ ν™”κ°€ 잘 λ˜μ–΄μžˆλŠ” λͺ¨λ˜ μžλ°”μŠ€ν¬λ¦½νŠΈ 엔진은 μš”μ†Œμ˜ νƒ€μž…μ΄ μΌμΉ˜ν•˜μ§€ μ•ŠλŠ” 배열을 생성할 λ•Œ 일반적인 의미의 λ°°μ—΄μ²˜λŸΌ μ—°μ†λœ λ©”λͺ¨λ¦¬ 곡간을 ν™•λ³΄ν•œλ‹€.

λ°°μ—΄μ—λŠ” 같은 νƒ€μž…μ˜ μš”μ†Œλ₯Ό μ—°μ†μ μœΌλ‘œ μœ„μΉ˜μ‹œν‚€λŠ” 것이 μ΅œμ„ μ΄λ‹€.



🟣 λ°°μ—΄ 생성

⬜ λ°°μ—΄ λ¦¬ν„°λŸ΄

const arr = [1,2,3]; // μš”μ†Œ ν• λ‹Ή
const arr =[]; // 빈 λ°°μ—΄
const arr = [1, ,3]; // ν¬μ†Œ λ°°μ—΄(빈 곡간은 undefined)

⬜ Array μƒμ„±μž ν•¨μˆ˜

Array μƒμ„±μž ν•¨μˆ˜λ₯Ό 톡해 배열을 생성할 μˆ˜λ„ μžˆλ‹€. 전달 된 인수의 κ°œμˆ˜μ— 따라 λ‹€λ₯΄κ²Œ λ™μž‘ν•˜λ―€λ‘œ μ£Όμ˜κ°€ ν•„μš”ν•˜λ‹€.

const arr = new Array(); // [] 빈 λ°°μ—΄
const arr = new Array(10); // [empty Γ— 10] ν¬μ†Œ λ°°μ—΄
const arr = new Array(1,2,3); // [1,2,3]
const arr = new Array({}); // [{}] 전달 된 μΈμˆ˜κ°€ 1κ°œμ§€λ§Œ μˆ«μžκ°€ μ•„λ‹ˆλ©΄ 인수λ₯Ό μš”μ†Œλ‘œ κ°–λŠ” 배열을 μƒμ„±ν•œλ‹€.

⬜ Array.of

ES6μ—μ„œ λ„μž… 된 Array.of λ©”μ„œλ“œλŠ” 전달 된 인수λ₯Ό μš”μ†Œλ‘œ κ°–λŠ” 배열을 μƒμ„±ν•œλ‹€. Array μƒμ„±μž ν•¨μˆ˜μ™€ λ‹€λ₯΄κ²Œ μ „λ‹¬λœ μΈμˆ˜κ°€ 1개이고 μˆ«μžμ΄λ”λΌλ„ 인수λ₯Ό κ°–λŠ” 배열을 μƒμ„±ν•œλ‹€.

Array.of(1); // [1]
Array.of(1,2,3); // [1, 2, 3]
Array.of('string'); // ['string']

⬜ Array.from

ES6μ—μ„œ λ„μž… 된 Array.from λ©”μ„œλ“œλŠ” μœ μ‚¬ λ°°μ—΄ 객체 λ˜λŠ” μ΄ν„°λŸ¬λΈ” 객체λ₯Ό 인수둜 전달 λ°›μ•„ λ°°μ—΄λ‘œ λ³€ν™˜ν•˜μ—¬ λ°˜ν™˜ν•œλ‹€.

  • μœ μ‚¬ λ°°μ—΄ 객체 : λ°°μ—΄μ²˜λŸΌ 인덱슀둜 ν”„λ‘œνΌν‹° 값에 μ ‘κ·Ό κ°€λŠ₯ν•˜κ³  length ν”„λ‘œνΌν‹°λ₯Ό κ°–λŠ” 객체.
  • μ΄ν„°λŸ¬λΈ” 객체: Symbol.iterator λ©”μ„œλ“œλ₯Ό κ΅¬ν˜„ν•˜μ—¬ for...of 문으둜 순회 κ°€λŠ₯ν•˜κ³  μŠ€ν”„λ ˆλ“œ 문법과 ꡬ쑰 λΆ„ν•΄ ν• λ‹Ήμ˜ λŒ€μƒμœΌλ‘œ μ‚¬μš©ν•  수 μžˆλŠ” 객체λ₯Ό λ§ν•œλ‹€. Array, String, Map, Set, DOM μ»¬λ ‰μ…˜ 등이 μžˆλ‹€.

ꡬ쑰 λΆ„ν•΄ ν• λ‹Ή μ΄λž€?

let x, y, z;
[x, y, z] = [1, 2, 3];
let [x, y, z] = [1, 2, 3];
const arr = [1, 2, 3];
const [one, two, three] = arr;
console.log(one, two, three); // 1 2 3



// μœ μ‚¬ λ°°μ—΄ 객체λ₯Ό λ³€ν™˜ν•˜μ—¬ λ°°μ—΄ 생성
Array.from({length:2, 0: 'a', 1: 'b'}); // ['a', 'b']
// μ΄ν„°λŸ¬λΈ”μ„ λ³€ν™˜ν•˜μ—¬ λ°°μ—΄ 생성
Array.from('Hello'); // ['H', 'e', 'l', 'l', 'o']

두 번째 인수둜 콜백 ν•¨μˆ˜λ₯Ό 전달해 값을 λ§Œλ“€λ©΄μ„œ μš”μ†Œλ₯Ό μ±„μšΈ μˆ˜λ„ μžˆλ‹€.

첫 번째 μΈμˆ˜μ— μ˜ν•΄ 생성 된 λ°°μ—΄μ˜ μš”μ†Œκ°’κ³Ό 인덱슀λ₯Ό 순차적으둜 μ „λ‹¬ν•˜λ©΄μ„œ 콜백 ν•¨μˆ˜λ₯Ό ν˜ΈμΆœν•˜κ³ , κ·Έ λ°˜ν™˜κ°’μœΌλ‘œ κ΅¬μ„±λœ 배열을 λ°˜ν™˜ν•œλ‹€.

Array.from({ length: 3 }, (_, i)=> i); // [0,1,2] 



🟩 λ°°μ—΄ λ©”μ„œλ“œ

🟣 기타

Array.isArray(arr)

전달 된 μΈμˆ˜κ°€ 배열이면 true, μ•„λ‹ˆλ©΄ false


Array.prototype.indexOf(value)

인수둜 전달 된 μš”μ†Œλ₯Ό κ²€μƒ‰ν•˜μ—¬ 인덱슀λ₯Ό λ°˜ν™˜ν•œλ‹€.

  • μš”μ†Œκ°€ μ‘΄μž¬ν•˜μ§€ μ•ŠμœΌλ©΄ -1.
  • 쀑볡이 μžˆλ‹€λ©΄ 첫 번째 검색 된 μš”μ†Œμ˜ 인덱슀 λ°˜ν™˜.

πŸ”΄ λ°˜ν™˜κ°’μ΄ -1인지 ν™•μΈν•΄μ•Όν•˜κ³ , 배열에 NaN이 ν¬ν•¨λ˜μ–΄ μžˆλŠ”μ§€ 확인할 수 μ—†λ‹€λŠ” 단점이 μžˆλ‹€.


Array.prototype.includes(value)

λ°°μ—΄ 내에 νŠΉμ • μš”μ†Œκ°€ ν¬ν•¨λ˜μ–΄ μžˆλŠ”μ§€ ν™•μΈν•˜μ—¬ true/falseλ₯Ό λ°˜ν™˜ν•œλ‹€.

  • 첫 번째 인수둜 검색할 λŒ€μƒμ„ μ§€μ •ν•œλ‹€.

  • 두 번째 인수둜 검색을 μ‹œμž‘ν•  인덱슀λ₯Ό 전달할 수 μžˆλ‹€. μƒλž΅ κ°€λŠ₯ν•˜λ©° 기본값은 0이닀.

  • 음수 전달 μ‹œ length ν”„λ‘œνΌν‹° κ°’κ³Ό 음수 인덱슀λ₯Ό ν•©μ‚°ν•˜μ—¬ 검색 μ‹œμž‘ 인덱슀λ₯Ό μ„€μ •ν•œλ‹€.

  • indexOf 보닀 가독성이 μ’‹λ‹€.

  • [NaN].includes(NaN); // true κ°€λŠ₯



🟣 원본 배열을 직접 λ³€κ²½ν•˜λŠ” λ©”μ„œλ“œ

Array.prototype.push

인수둜 전달받은 λͺ¨λ“  값을 원본 λ°°μ—΄μ˜ λ§ˆμ§€λ§‰ μš”μ†Œλ‘œ μΆ”κ°€ν•˜κ³  λ³€κ²½λœ length ν”„λ‘œνΌν‹° 값을 λ°˜ν™˜ν•œλ‹€.

  • push λ©”μ„œλ“œλŠ” μ„±λŠ₯ λ©΄μ—μ„œ 쒋지 μ•Šλ‹€.
  • λ§ˆμ§€λ§‰μœΌλ‘œ μΆ”κ°€ ν•  μš”μ†Œκ°€ ν•˜λ‚˜ 뿐이라면 length ν”„λ‘œνΌν‹°λ₯Ό μ‚¬μš©ν•˜μ—¬ λ°°μ—΄μ˜ λ§ˆμ§€λ§‰ μš”μ†Œμ— 직접 μΆ”κ°€ν•˜λŠ” 게 λΉ λ₯΄λ‹€.

Array.prototype.pop

원본 λ°°μ—΄μ—μ„œ λ§ˆμ§€λ§‰ μš”μ†Œλ₯Ό μ œκ±°ν•˜κ³  μ œκ±°ν•œ μš”μ†Œλ₯Ό λ°˜ν™˜ν•œλ‹€.


Array.prototype.unshift

원본 λ°°μ—΄μ˜ 선두에 μš”μ†Œλ₯Ό μΆ”κ°€ν•˜κ³  λ³€κ²½λœ length ν”„λ‘œνΌν‹° 값을 λ°˜ν™˜ν•œλ‹€.

ES6 μŠ€ν”„λ ˆλ“œ 문법을 λŒ€μ‹  μ‚¬μš©ν•˜λ©΄ 원본 배열을 λ³€κ²½ν•˜μ§€ μ•Šκ³  μš”μ†Œλ₯Ό μΆ”κ°€ν•  수 μžˆλ‹€.


Array.prototype.shift

원본 λ°°μ—΄μ˜ 첫 번째 μš”μ†Œλ₯Ό μ œκ±°ν•˜κ³  μ œκ±°ν•œ μš”μ†Œλ₯Ό λ°˜ν™˜ν•œλ‹€.


Array.prototype.splice

원본 λ°°μ—΄μ˜ 쀑간에 μš”μ†Œλ₯Ό μΆ”κ°€ν•˜κ±°λ‚˜ 쀑간에 μžˆλŠ” μš”μ†Œλ₯Ό μ œκ±°ν•˜λŠ” 경우 μ‚¬μš©ν•œλ‹€.

arr.splice(start, deleteCount, items);

  • start : μš”μ†Œλ₯Ό μ œκ±°ν•˜κΈ° μ‹œμž‘ν•  인덱슀. 음수인 경우 λ°°μ—΄μ˜ λμ—μ„œμ˜ 인덱슀.
  • deleteCount : startλΆ€ν„° μ œκ±°ν•  μš”μ†Œμ˜ 개수.
  • itmes : μ œκ±°ν•œ μœ„μΉ˜μ— μ‚½μž…ν•  μš”μ†Œλ“€ λͺ©λ‘. μƒλž΅ μ‹œ μ§€μ •λœ μš”μ†Œ 제거만.

πŸ”΄ start만 μ§€μ •ν•˜λ©΄ 원본 λ°°μ—΄μ˜ startλΆ€ν„° λͺ¨λ“  μš”μ†Œλ“€μ„ μ œκ±°ν•œλ‹€.
πŸ”΄ deleteCountλ₯Ό 0으둜 μ§€μ •ν•˜λ©΄ μ•„λ¬΄λŸ° μš”μ†Œλ„ μ œκ±°ν•˜μ§€ μ•Šκ³  μƒˆλ‘œμš΄ μš”μ†Œλ₯Ό μ‚½μž…ν•œλ‹€.
πŸ”΄ deleteCountλ₯Ό μƒλž΅ν•˜λ©΄ start λΆ€ν„° λͺ¨λ“  μš”μ†Œλ₯Ό μ œκ±°ν•œλ‹€.

λ°°μ—΄μ—μ„œ νŠΉμ • μš”μ†Œλ₯Ό μ œκ±°ν•˜λ €λ©΄ indexOf λ©”μ„œλ“œλ₯Ό 톡해 νŠΉμ • μš”μ†Œμ˜ 인덱슀λ₯Ό μ·¨λ“ν•œ λ‹€μŒ splice λ©”μ„œλ“œλ₯Ό μ‚¬μš©ν•œλ‹€.

const index = array.indexOf(item);
if(index !== -1) array.splice(index, 1);

filter λ©”μ„œλ“œλ₯Ό μ‚¬μš©ν•˜λ©΄ νŠΉμ • μš”μ†Œκ°€ 쀑볡 된 경우 λͺ¨λ‘ μ œκ±°λœλ‹€.

array.filter(v=> v!==item);

Array.prototype.reverse

원본 λ°°μ—΄μ˜ μˆœμ„œλ₯Ό λ°˜λŒ€λ‘œ λ’€μ§‘λŠ”λ‹€.


Array.prototype.fill

인수둜 전달받은 값을 λ°°μ—΄μ˜ μ²˜μŒλΆ€ν„° λκΉŒμ§€ μš”μ†Œλ‘œ μ±„μš΄λ‹€.

arr.fill(element, start, end)

const arr =  [1,2,3];
arr.fill(0);
console.log(arr); // [0,0,0]
arr.fill(0,1); // 인수둜 전달받은 κ°’ 0을 인덱슀 1λΆ€ν„° λκΉŒμ§€ μš”μ†Œλ‘œ μ±„μš΄λ‹€.
arr.fill(0,1,4); // 1λΆ€ν„° 인덱슀 3κΉŒμ§€ μš”μ†Œλ‘œ μ±„μš΄λ‹€.

λͺ¨λ“  μš”μ†Œλ₯Ό ν•˜λ‚˜μ˜ κ°’λ§ŒμœΌλ‘œ μ±„μšΈ μˆ˜λ°–μ— μ—†λ‹€λŠ” 단점이 μžˆλ‹€.

Array.from λ©”μ„œλ“œλ₯Ό μ‚¬μš©ν•˜λ©΄ 콜백 ν•¨μˆ˜λ₯Ό 톡해 μš”μ†Œκ°’μ„ λ§Œλ“€λ©΄μ„œ 배열을 μ±„μšΈ 수 μžˆλ‹€.


Array.prototype.flat

인수둜 μ „λ‹¬ν•œ 깊이만큼 μž¬κ·€μ μœΌλ‘œ 배열을 평탄화 ν•œλ‹€.

[1,[2,[3,[4]]]].flat(1); // [1,2,[3,[4]]]



🟣 μƒˆλ‘œμš΄ 배열을 λ°˜ν™˜ν•˜λŠ” λ©”μ„œλ“œ

Array.prototype.concat

인수둜 μ „λ‹¬λœ 값듀을 원본 λ°°μ—΄μ˜ λ§ˆμ§€λ§‰ μš”μ†Œλ‘œ μΆ”κ°€ν•œ μƒˆλ‘œμš΄ 배열을 λ°˜ν™˜ν•œλ‹€.

  • λ°˜ν™˜κ°’μ„ λ°˜λ“œμ‹œ λ³€μˆ˜μ— ν• λ‹Ήλ°›μ•„μ•Ό ν•œλ‹€.

  • 전달 값이 배열인 경우 배열을 ν•΄μ²΄ν•˜μ—¬ μƒˆλ‘œμš΄ λ°°μ—΄μ˜ μš”μ†Œλ‘œ μΆ”κ°€ν•œλ‹€.

  • push와 unshiftλ₯Ό λŒ€μ‹ ν•  수 μžˆλ‹€.

// arr1.unshift(1,2)
let result = [1,2].concat(arr1);
// arr1.push(5,6)
result = result.concat(5,6);

concat λ©”μ„œλ“œλŠ” μŠ€ν”„λ ˆλ“œ λ¬Έλ²•μœΌλ‘œ λŒ€μ²΄ν•  수 μžˆλ‹€.

let result = [1,2].concat([3,4]);
result = [...[1,2], ...[3,4])

πŸ”΄ 결둠적으둜 push/unshift λ˜λŠ” concat λ³΄λ‹€λŠ” μŠ€ν”„λ ˆλ“œ 문법을 일관성 있게 μ‚¬μš©ν•˜λŠ” 것이 μ’‹λ‹€.


🟧 Array.prototype.slice

인수둜 전달 된 λ²”μœ„μ˜ μš”μ†Œλ“€μ„ λ³΅μ‚¬ν•˜μ—¬ μƒˆλ‘œμš΄ λ°°μ—΄λ‘œ λ°˜ν™˜.

arr.slice(start, end);

  • start: 볡사λ₯Ό μ‹œμž‘ν•  인덱슀. 음수인 경우 λ°°μ—΄μ˜ λμ—μ„œμ˜ 인덱슀.
  • end: 볡사λ₯Ό μ’…λ£Œν•  인덱슀. μΈλ±μŠ€μ— ν•΄λ‹€ν•˜λŠ” μš”μ†ŒλŠ” λ³΅μ‚¬λ˜μ§€ μ•ŠλŠ”λ‹€. μƒλž΅ κ°€λŠ₯ν•˜λ©° 기본값은 length ν”„λ‘œνΌν‹° 값이닀.

πŸ”΄ endλ₯Ό μƒλž΅ν•˜λ©΄ start둜 전달받은 μΈλ±μŠ€λΆ€ν„° λͺ¨λ“  μš”μ†Œλ₯Ό λ³΅μ‚¬ν•˜μ—¬ λ°°μ—΄λ‘œ λ°˜ν™˜ν•œλ‹€.
πŸ”΄ 인수λ₯Ό λͺ¨λ‘ μƒλž΅ν•˜λ©΄ 원본 λ°°μ—΄μ˜ 볡사본을 μƒμ„±ν•˜μ—¬ λ°˜ν™˜ν•œλ‹€. μ΄λ•Œ 얕은 볡사가 μΌμ–΄λ‚œλ‹€.


Array.prototype.join

원본 λ°°μ—΄μ˜ λͺ¨λ“  μš”μ†Œλ₯Ό λ¬Έμžμ—΄λ‘œ λ³€ν™˜ν•œ ν›„, κ΅¬λΆ„μžλ‘œ μ—°κ²°ν•œ λ¬Έμžμ—΄μ„ λ°˜ν™˜ν•œλ‹€.

const arr = [1,2,3,4];
arr.join(); // '1,2,3,4' κΈ°λ³Έκ°’ 콀마
arr.join(''); // '1234'
arr.join('!'); // '1!2!3!4'



🟣 λ°°μ—΄ κ³ μ°¨ ν•¨μˆ˜

ν•¨μˆ˜λ₯Ό 인수둜 μ „λ‹¬λ°›κ±°λ‚˜ ν•¨μˆ˜λ₯Ό λ°˜ν™˜ν•˜λŠ” ν•¨μˆ˜.

Array.prototype.sort

λ°°μ—΄μ˜ μš”μ†Œλ₯Ό μ •λ ¬ν•œλ‹€. 원본 배열을 직접 λ³€κ²½ν•˜λ©° μ •λ ¬λœ 배열을 λ°˜ν™˜ν•œλ‹€.

  • 기본적으둜 μ˜€λ¦„μ°¨μˆœμœΌλ‘œ μš”μ†Œλ₯Ό μ •λ ¬ν•œλ‹€.
  • μ •λ ¬ μˆœμ„œλŠ” μœ λ‹ˆμ½”λ“œ μ½”λ“œ 포인트의 μˆœμ„œλ₯Ό λ”°λ₯΄λ‹€.

κ·Έ 문제둜, λ¬Έμžμ—΄ '2'와 '10'을 μ •λ ¬ν•˜λ©΄ ['10', '2']와 같이 μ •λ ¬λœλ‹€.

λ˜ν•œ sort λ©”μ„œλ“œλŠ” λ°°μ—΄μ˜ μš”μ†Œλ₯Ό μΌμ‹œμ μœΌλ‘œ λ¬Έμžμ—΄λ‘œ λ³€ν™˜ν•œ ν›„ μ •λ ¬ν•˜λ―€λ‘œ 숫자 2, 10을 정렬해도 [10, 2] 와 같이 μ •λ ¬ λœλ‹€.

πŸ”΅ λ”°λΌμ„œ 숫자 μš”μ†Œλ₯Ό μ •λ ¬ν•  λ•ŒλŠ” μ •λ ¬ μˆœμ„œλ₯Ό λΉ„κ΅ν•˜λŠ” 비ꡐ ν•¨μˆ˜λ₯Ό 인수둜 전달해야 ν•œλ‹€.

  • λ°˜ν™˜κ°’μ΄ 0보닀 μž‘μœΌλ©΄ 첫 번재 인수 μš°μ„  μ •λ ¬.
  • 0이면 μ •λ ¬ν•˜μ§€ μ•ŠμœΌλ©°
  • 0보닀 크면 두 번째 인수 μš°μ„  μ •λ ¬.
const points = [40, 100, 1, 5, 2, 25, 10];
// μ˜€λ¦„μ°¨μˆœ μ •λ ¬. 
points.sort((a,b)=>a-b);
// λ‚΄λ¦Όμ°¨μˆœ μ •λ ¬
points.sort((a,b)=>b-a);

🟧 Array.prototype.forEach

μžμ‹ μ„ ν˜ΈμΆœν•œ 배열을 μˆœνšŒν•˜λ©΄μ„œ μˆ˜ν–‰ν•΄μ•Ό ν•  처리λ₯Ό 콜백 ν•¨μˆ˜λ‘œ 전달 λ°›μ•„ 반볡 ν˜ΈμΆœν•œλ‹€. 원본 배열은 λ³€κ²½ν•˜μ§€ μ•ŠμœΌλ©° μ–Έμ œλ‚˜ undefinedλ₯Ό λ°˜ν™˜ν•œλ‹€.

μ‘°κ±΄λ¬Έμ΄λ‚˜ λ°˜λ³΅λ¬Έμ€ 둜직의 흐름을 μ΄ν•΄ν•˜κΈ° μ–΄λ ΅κ²Œ ν•œλ‹€. μ΄λ•Œ for문을 λŒ€μ²΄ν•  수 μžˆλŠ” 게 forEach κ³ μ°¨ν•¨μˆ˜λ‹€.

  • ν•¨μˆ˜ν˜• ν”„λ‘œκ·Έλž˜λ°: 순수 ν•¨μˆ˜μ™€ 보쑰 ν•¨μˆ˜μ˜ 쑰합을 톡해 둜직 내에 μ‘΄μž¬ν•˜λŠ” 쑰건문과 λ°˜λ³΅λ¬Έμ„ μ œκ±°ν•˜μ—¬ λ³΅μž‘μ„±μ„ ν•΄κ²°ν•˜κ³  λ³€μˆ˜μ˜ μ‚¬μš©μ„ μ–΅μ œν•˜μ—¬ μƒνƒœ 변경을 ν”Όν•˜λ €λŠ” ν”„λ‘œκ·Έλž˜λ° νŒ¨λŸ¬λ‹€μž„.

const numbers = [1,2,3];
const pows=[];
numbers.forEach(item => pows.push(item**2));
console.log(pows) // [1, 4, 9]

πŸ”΅ forEach λ©”μ„œλ“œλŠ” 원본 배열을 λ³€κ²½ν•˜μ§€ μ•ŠμœΌλ‚˜ 콜백 ν•¨μˆ˜λ₯Ό 톡해 λ³€κ²½ν•  수 μžˆλ‹€.

πŸ”΅ forEach λ©”μ„œλ“œμ˜ 두 번째 인수둜 forEach λ©”μ„œλ“œ 콜백 ν•¨μˆ˜ λ‚΄λΆ€μ—μ„œ this둜 μ‚¬μš©ν•  객체λ₯Ό 전달할 수 μžˆλ‹€. 클래슀 내뢀에 μžˆλŠ” 경우 클래슀 λ‚΄λΆ€μ˜ λͺ¨λ“  μ½”λ“œλŠ” μ•”λ¬΅μ μœΌλ‘œ strict modeκ°€ 적용되기 λ•Œλ¬Έμ—, thisκ°€ μ „μ—­ 객체가 μ•„λ‹Œ undefinedλ₯Ό 가리킨닀. λ”°λΌμ„œ 두 번째 인수둜 클래슀의 thisλ₯Ό 지정해주어야 ν•œλ‹€.

🌠 checkpoint# strict mode?

μƒˆλ‘œμš΄ κΈ°λŠ₯이 μΆ”κ°€ 된 ES5 이후 κΈ°μ‘΄ κΈ°λŠ₯ 쀑 일뢀가 λ³€κ²½λ˜μ–΄, ν•˜μœ„ ν˜Έν™˜μ„± λ¬Έμ œκ°€ 생기지 μ•Šλ„λ‘ ES5 κΈ°λ³Έλͺ¨λ“œμ—μ„  λ³€κ²½ 사항이 ν™œμ„±ν™” λ˜μ§€ μ•Šλ„λ‘ ν•˜λŠ” μ§€μ‹œμž.
🎁 엄격 λͺ¨λ“œλž€?


!!ν•˜μ§€λ§Œ!!


πŸ”΄ 더 λ‚˜μ€ 방법은 ν™”μ‚΄ν‘œ ν•¨μˆ˜λ₯Ό μ‚¬μš©ν•˜λŠ” 것이닀. ν™”μ‚΄ν‘œ ν•¨μˆ˜λŠ” ν•¨μˆ˜ 자체의 this 바인딩을 갖지 μ•ŠκΈ° λ•Œλ¬Έμ— ν™”μ‚΄ν‘œ ν•¨μˆ˜ λ‚΄λΆ€μ—μ„œ thisλ₯Ό μ°Έμ‘°ν•˜λ©΄ μƒμœ„ μŠ€μ½”ν”„μ˜ thisλ₯Ό κ·ΈλŒ€λ‘œ μ°Έμ‘°ν•œλ‹€.


class Numbers {
	numberArray = [];
	multiply(arr) {
    	arr.forEach((item) => {this.numberArray.push(item*item));
    }
}

πŸ”΅ forEach λ©”μ„œλ“œλŠ” break, continue 문을 μ‚¬μš©ν•  수 μ—†λ‹€.
πŸ”΅ ν¬μ†Œ λ°°μ—΄μ˜ 경우 μ‘΄μž¬ν•˜μ§€ μ•ŠλŠ” μš”μ†ŒλŠ” 순회 λŒ€μƒμ—μ„œ μ œμ™Έλœλ‹€. map, filter, reduce λ©”μ„œλ“œ λ“±μ—μ„œλ„ λ§ˆμ°¬κ°€μ§€λ‹€.

πŸ”΄ forEach λ©”μ„œλ“œλŠ” for문에 λΉ„ν•΄ μ„±λŠ₯이 μ’‹μ§€λŠ” μ•Šμ§€λ§Œ 가독성은 더 μ’‹λ‹€. 높은 μ„±λŠ₯이 ν•„μš”ν•œ κ²½μš°κ°€ μ•„λ‹ˆλΌλ©΄ forEachλ₯Ό ꢌμž₯ν•œλ‹€.


🟧 Array.prototype.map

μžμ‹ μ„ ν˜ΈμΆœν•œ λ°°μ—΄μ˜ λͺ¨λ“  μš”μ†Œλ₯Ό μˆœνšŒν•˜λ©΄μ„œ 인수둜 전달받은 콜백 ν•¨μˆ˜λ₯Ό 반볡 ν˜ΈμΆœν•œλ‹€.

그리고 콜백 ν•¨μˆ˜μ˜ λ°˜ν™˜κ°’λ“€λ‘œ κ΅¬μ„±λœ μƒˆλ‘œμš΄ 배열을 λ°˜ν™˜ν•œλ‹€.

μ΄λ•Œ 원본 배열은 λ³€κ²½λ˜μ§€ μ•ŠλŠ”λ‹€.

  • forEach λ©”μ„œλ“œλŠ” λ‹¨μˆœνžˆ λ°˜λ³΅λ¬Έμ„ λŒ€μ²΄ν•˜κΈ° μœ„ν•œ κ³ μ°¨ ν•¨μˆ˜μ΄κ³ ,
  • map λ©”μ„œλ“œλŠ” μš”μ†Œκ°’μ„ λ‹€λ₯Έ κ°’μœΌλ‘œ λ§€ν•‘ν•œ μƒˆλ‘œμš΄ 배열을 μƒμ„±ν•˜κΈ° μœ„ν•œ κ³ μ°¨ ν•¨μˆ˜λ‹€.

map λ©”μ„œλ“œλŠ” 콜백 ν•¨μˆ˜λ₯Ό ν˜ΈμΆœν•˜λ©΄μ„œ (μš”μ†Œκ°’, 인덱슀, this)의 인수λ₯Ό μ „λ‹¬ν•œλ‹€.

arr.map((item, index, arr) => {
	Math.sqrt(item);
});

Array.prototype.filter

μžμ‹ μ„ ν˜ΈμΆœν•œ λ°°μ—΄μ˜ λͺ¨λ“  μš”μ†Œλ₯Ό μˆœνšŒν•˜λ©΄μ„œ 콜백 ν•¨μˆ˜μ˜ λ°˜ν™˜κ°’μ΄ true인 μš”μ†Œλ‘œλ§Œ κ΅¬μ„±λœ μƒˆλ‘œμš΄ 배열을 λ°˜ν™˜ν•œλ‹€.

filter(item, index, arr)

findById(id){
	obj.filter(item => item.id === id);
}

🟧 Array.prototype.reduce

λ°°μ—΄μ˜ λͺ¨λ“  μš”μ†Œλ₯Ό μˆœνšŒν•˜λ©° 콜백 ν•¨μˆ˜μ˜ λ°˜ν™˜κ°’μ„ λ‹€μŒ 순회 μ‹œμ— 콜백 ν•¨μˆ˜μ˜ 첫 번째 인수둜 μ „λ‹¬ν•œ λ’€,
결과적으둜 ν•˜λ‚˜μ˜ 결과값을 λ§Œλ“€μ–΄ λ°˜ν™˜ν•œλ‹€.

μ΄λ•Œ 원본 배열은 λ³€κ²½λ˜μ§€ μ•ŠλŠ”λ‹€.

arr.reduce(callback, initial)

callback(initial(or 이전값), item, index, arr)

πŸ”΄ reduce λ©”μ„œλ“œλ₯Ό ν˜ΈμΆœν•  λ•ŒλŠ” μ–Έμ œλ‚˜ μ΄ˆκΈ°κ°’μ„ μ „λ‹¬ν•˜λŠ” 것이 μ•ˆμ „ν•˜λ‹€.
πŸ”΄ 객체의 νŠΉμ • ν”„λ‘œνΌν‹° 값을 ν•©μ‚°ν•˜λŠ” κ²½μš°μ—λŠ” λ°˜λ“œμ‹œ μ΄ˆκΈ°κ°’μ„ 전달해야 ν•œλ‹€.


Array.prototype.some

μžμ‹ μ„ ν˜ΈμΆœν•œ λ°°μ—΄μ˜ μš”μ†Œλ₯Ό μˆœνšŒν•˜λ©΄μ„œ 콜백 ν•¨μˆ˜μ˜ λ°˜ν™˜κ°’μ΄ 단 ν•œ λ²ˆμ΄λΌλ„ 참이면 true, λͺ¨λ‘ 거짓이면 faleλ₯Ό λ°˜ν™˜ν•œλ‹€.

단 ν•˜λ‚˜λΌλ„ trueκ°€ λ°˜ν™˜λ˜λ©΄ λ°˜λ³΅μ„ μ€‘μ§€ν•œλ‹€.

arr.some(item => item>10);

λ©”μ„œλ“œλ₯Ό ν˜ΈμΆœν•œ 배열이 빈 배열인 경우 μ–Έμ œλ‚˜ falseλ₯Ό λ°˜ν™˜ν•œλ‹€.


Array.prototype.every

μžμ‹ μ„ ν˜ΈμΆœν•œ λ°°μ—΄μ˜ μš”μ†Œλ₯Ό μˆœνšŒν•˜λ©΄μ„œ 콜백 ν•¨μˆ˜μ˜ λ°˜ν™˜κ°’μ΄ λͺ¨λ‘ 참이면 true, 단 ν•œ λ²ˆμ΄λΌλ„ 거짓이면 falseλ₯Ό λ°˜ν™˜ν•œλ‹€.


Array.prototype.find

μžμ‹ μ„ ν˜ΈμΆœν•œ λ°°μ—΄μ˜ μš”μ†Œλ₯Ό μˆœνšŒν•˜λ©΄μ„œ 콜백 ν•¨μˆ˜μ˜ λ°˜ν™˜κ°’μ΄ true인 첫 번째 μš”μ†Œλ₯Ό λ°˜ν™˜ν•œλ‹€. μš”μ†Œκ°€ μ‘΄μž¬ν•˜μ§€ μ•ŠμœΌλ©΄ undefinedλ₯Ό λ°˜ν™˜ν•œλ‹€.


Array.prototype.findIndex

μžμ‹ μ„ ν˜ΈμΆœν•œ λ°°μ—΄μ˜ μš”μ†Œλ₯Ό μˆœνšŒν•˜λ©΄μ„œ 콜백 ν•¨μˆ˜μ˜ λ°˜ν™˜κ°’μ΄ true인 첫 번째 μš”μ†Œμ˜ 인덱슀λ₯Ό λ°˜ν™˜ν•œλ‹€. μ‘΄μž¬ν•˜μ§€ μ•ŠλŠ”λ‹€λ©΄ -1을 λ°˜ν™˜ν•œλ‹€.


Array.prototype.flatMap

map λ©”μ„œλ“œλ₯Ό 톡해 μƒμ„±λœ μƒˆλ‘œμš΄ 배열을 ν‰νƒ„ν™”ν•œλ‹€.

즉 map λ©”μ„œλ“œμ™€ flat λ©”μ„œλ“œλ₯Ό 순차적으둜 μ‹€ν–‰ν•˜λŠ” νš¨κ³Όκ°€ μžˆλ‹€.

const arr = ['hello', 'world'];
arr.map(x => x.split('')).flat();
arr.flatMap(x => split(''));



⬜ 뢀둝 - λ°°μ—΄/객체 for~in for~of 차이

  • λ°°μ—΄

    • for ~ in : 인덱슀λ₯Ό λ°˜ν™˜
    • for ~ of : μš”μ†Œλ₯Ό λ°˜ν™˜
  • 객체

    • for ~ in : ν‚€λ₯Ό λ°˜ν™˜
    • for ~ of : κ°μ²΄λŠ” μ΄ν„°λŸ¬λΈ”μ΄ μ•„λ‹ˆλΌ μ‚¬μš© λΆˆκ°€.



profile
λ‹€ ν•˜μž

0개의 λŒ“κΈ€