πŸ“š What is TIL?

λ°°μ—΄

λ™μΌν•œ 데이터 μœ ν˜•μ˜ μ—¬λŸ¬ λ³€μˆ˜λ₯Ό μ €μž₯ν•˜λŠ” 데 μ‚¬μš©λœλ‹€
배열은 인덱슀λ₯Ό μ‚¬μš©ν•˜μ—¬ μš”μ†Œλ₯Ό μ ‘κ·Όν•˜λ―€λ‘œ μš”μ†Œλ₯Ό κ²€μƒ‰ν•˜λŠ”λ° νš¨μœ¨μ μ΄λ‹€
μš”μ†Œμ˜ μˆœμ„œλ₯Ό μœ μ§€ν•˜κ³  μΆ”κ°€ν•˜κ±°λ‚˜ μ œκ±°ν• λ•Œ λ‹€λ₯Έ μš”μ†Œμ˜ μœ„μΉ˜λ₯Ό λ³€κ²½ν•˜μ§€ μ•Šμ•„λ„ λœλ‹€

πŸ”Ž λ°°μ—΄μ˜ μ›μ†ŒλŠ” 객체가 될 μˆ˜λ„ 있고, 또 λ‹€λ₯Έ 배열이 될 μˆ˜λ„ μžˆλ‹€
πŸ”Ž λ°°μ—΄μ˜ μˆœμ„œλ₯Ό index, μˆœμ„œλ‘œ ν˜ΈμΆœν•˜λŠ” 것을 indexing λ°°μ—΄μ•ˆμ— 값을 μ›μ†Œ(elements) 라고 ν•œλ‹€


λ°°μ—΄μ—μ„œμ˜ ν”„λ‘œνΌν‹° μΆ”κ°€λž€?

const arr = [1, 2, 3];
arr.foo = 'bar';
[1, 2, 3, foo: "bar"]
console.log(arr.length) // ?

πŸ’‘ arrayμ—μ„œ ν”„λ‘œνΌν‹°λ₯Ό μΆ”κ°€ν•΄μ£ΌλŠ” 것은 μ™œ array.length에 ν¬ν•¨λ˜μ§€ μ•Šμ„κΉŒ?

πŸ”Ž λ°°μ—΄μ˜ length ν”„λ‘œνΌν‹°λŠ” 배열에 μ €μž₯된 κ°’ 쀑 μΈλ±μŠ€μ™€ 같은 κ°’λ§Œμ„ ν¬ν•¨ν•˜κΈ° λ•Œλ¬Έμ΄λ‹€


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


더보기
push
 λ°°μ—΄μ˜ λ’€μ—μ„œ 값을 μΆ”κ°€ν•œλ‹€

pop
 λ°°μ—΄μ˜ λ’€μ—μ„œ 값을 κΊΌλ‚΄κ³  λ°˜ν™˜ν•  수 μžˆλ‹€

unshift
 λ°°μ—΄μ˜ μ•žμ—μ„œ 값을 μΆ”κ°€ν•œλ‹€

shift
 λ°°μ—΄μ˜ μ•žμ—μ„œ 값을 κΊΌλ‚΄κ³  λ°˜ν™˜ν•  수 μžˆλ‹€

Array.prototype.flat(depth)
 λͺ¨λ“  ν•˜μœ„ λ°°μ—΄ μš”μ†Œλ₯Ό μ§€μ •ν•œ κΉŠμ΄κΉŒμ§€ ν‰νƒ„ν™”ν•œλ‹€

Array.prototype.splice(start, deleteCount, items)
 λ°°μ—΄μ˜ κΈ°μ‘΄ μš”μ†Œλ₯Ό μ‚­μ œ || ꡐ체 || μΆ”κ°€ν•˜μ—¬ λ°°μ—΄μ˜ λ‚΄μš©μ„ λ³€κ²½ν•œλ‹€

Array|string.prototype.slice(start, end)
 λ°°μ—΄μ˜ startλΆ€ν„° end의 직전 indexκΉŒμ§€ μƒˆλ‘œμš΄ λ°°μ—΄ 객체둜 λ°˜ν™˜ν•œλ‹€

Array.prototype.forEach(currentvalue, index, array)
 μ£Όμ–΄μ§„ ν•¨μˆ˜λ₯Ό λ°°μ—΄ μš”μ†Œ 각각에 λŒ€ν•΄ μ‹€ν–‰ν•œλ‹€

Array.prototype.map(currentValue, index, array)
 λͺ¨λ“  μš”μ†Œ 각각에 λŒ€ν•˜μ—¬ 주어진 ν•¨μˆ˜λ₯Ό ν˜ΈμΆœν•œ κ²°κ³Όλ₯Ό λͺ¨μ•„ μƒˆλ‘œμš΄ 배열을 λ°˜ν™˜

Array.prototype.sort(compareFunction)
 λ°°μ—΄μ˜ μš”μ†Œλ₯Ό μ •λ ¬ν•©λ‹ˆλ‹€


splice


const arr = [10,20,30,40,50]
const x = [1,2,3]
arr.splice(1,0,...x)
arr.splice(6,1,...x)
const arr = [1,2,3,4,5]
// [10, 1, 2, 3, 20, 30, 40, 1, 2, 3, 50]
// -------------
arr.splice() // []
const arr = [1,2,3,4,5]
arr.splice(1) // [2, 3, 4, 5]
const arr = [1,2,3,4,5]
arr.splice(2) // [3, 4, 5]
arr.splice().splice() // error

⚠️ arr.splice().splice() 와 같이 λ©”μ„œλ“œ 체이닝이 μ•ˆλ˜λŠ” μ΄μœ λŠ”
 spliceλŠ” arrκ°€ μ•„λ‹ˆλΌ μ‚­μ œλœ 값을 λ°˜ν™˜ν•˜κΈ° λ•Œλ¬Έμ— 리턴값이 빈 array이기 λ•Œλ¬Έμ΄λ‹€

⚠️ μ›λž˜ 배열을 직접 μˆ˜μ •ν•˜λ©΄ λ©”μ„œλ“œ 호좜이 μˆ˜μ •λœ 배열을 λ‚˜νƒ€λ‚΄λŠ” 값이 μ•„λ‹Œ,
β€ƒμ›λž˜ λ°°μ—΄μ—μ„œ μ œκ±°λ˜κ±°λ‚˜ μΆ”κ°€λœ μš”μ†Œλ₯Ό λ°˜ν™˜ν•œλ‹€

⚠️ λ”°λΌμ„œ λ©”μ„œλ“œ 체이닝이 이루어지기 μœ„ν•΄μ„  μˆ˜μ •λœ 배열을 λ‚˜νƒ€λ‚΄λŠ” 값을 λ°˜ν™˜ν•΄μ•Όν•œλ‹€
 즉, μ›λž˜ 배열을 μˆ˜μ •ν•˜μ§€μ•Šκ³  체인의 λ‹€μŒ λ©”μ„œλ“œλ‘œ 전달 ν•  수 μžˆλŠ” μˆ˜μ •λœ μƒˆ 배열을 λ°˜ν™˜ν•΄μ•Ό ν•œλ‹€


flat 0차원 이상 λ°°μ—΄(맀트릭슀)의 평탄화


λ‹€μ°¨μ›μ˜ 배열을 Tensor라고 ν•  수 μžˆλŠ”λ°, 닀차원 배열을 λ‹€λ£¨λŠ” λΌμ΄λΈŒλŸ¬λ¦¬μ΄λ‹€
인곡지λŠ₯μ—μ„œλŠ” ν…μ„œλ₯Ό μ΄μš©ν•΄μ„œ 데이터λ₯Ό ν‘œν˜„ν•˜κ³  μ—°μ‚°ν•œλ‹€ (μ•Œμ•„λ‘μž)

const tip = [
  [1,2,3],
  [4,5,6],
  [7,8,9]
]
tip.flat()
tip.flat(1) // ν•œλ²ˆ 평탄화 
tip.flat(2) // λ‘λ²ˆ 평탄화
tip.flat(Infinity) // λ‹€ νŽΌμ³μ§€λ©΄ μŠ€ν†±

πŸ”Ž Math.max(…tip.flat()) 둜 평탄화 ν›„ κ°€μž₯ 큰 값을 ꡬ할 μˆ˜λ„ μžˆλ‹€


forEach


μ›λž˜ 배열을 μˆ˜μ •ν•˜μ§€ μ•ŠλŠ”λ‹€
λ°°μ—΄μ˜ 각 μš”μ†Œμ— λŒ€ν•΄ μ½œλ°±ν•¨μˆ˜λ₯Ό μ‹€ν–‰ν•œλ‹€

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

myArray.forEach((element) => {
  console.log(element * 2);
  return element * 2;
});

console.log("End of script");

βœ”οΈ 콜백 ν•¨μˆ˜μ˜ return 값이 λ¬΄μ‹œλ˜λŠ” 것을 μ•Œ 수 μžˆλ‹€
βœ”οΈ λ°°μ—΄μ˜ μš”μ†Œλ₯Ό λ°˜λ³΅ν•˜κ³  각 μš”μ†Œμ— λŒ€ν•΄ λ³€μˆ˜λ₯Ό μ—…λ°μ΄νŠΈν•˜λŠ” μž‘μ—…μ„ μˆ˜ν–‰ν•˜κΈ° μœ„ν•œ λͺ©μ μœΌλ‘œ 쓰인닀

πŸ’‘ 그럼 μ½œλ°±ν•¨μˆ˜λž€??

πŸ”Ž νŒŒλΌλ―Έν„°λ‘œ ν•¨μˆ˜λ₯Ό 전달 λ°›μ•„, ν•¨μˆ˜μ˜ λ‚΄λΆ€μ—μ„œ μ‹€ν–‰ν•˜λŠ” ν•¨μˆ˜λ₯Ό λ§ν•œλ‹€


map


μ›λž˜ λ°°μ—΄μ˜ 각 μš”μ†Œμ— 콜백 ν•¨μˆ˜λ₯Ό μ μš©ν•œ κ²°κ³Όλ₯Ό ν¬ν•¨ν•˜λŠ” μƒˆ 배열을 λ°˜ν™˜ν•œλ‹€
λ³€ν™˜λœ 값을 ν¬ν•¨ν•˜λŠ” μƒˆ 배열을 λ§Œλ“€κΈ° μœ„ν•΄ 쓰인닀


sort μ •λ ¬


JavaScript sort() λ©”μ„œλ“œλŠ” μš”μ†Œκ°€ 숫자 값인 κ²½μš°μ—λ„ λ¬Έμžμ—΄λ‘œ μ •λ ¬ν•œλ‹€
이둜 인해 두 μžλ¦Ώμˆ˜κ°€κ°€ λ„˜μ–΄κ°€λŠ” μ‹œμ λΆ€ν„° β€˜10’이 β€˜2’보닀 λ¨Όμ € μ •λ ¬λ˜λŠ” λ¬Έμ œκ°€ μžˆλ‹€
λ”°λΌμ„œ 숫자 κ°’μœΌλ‘œ λΉ„κ΅ν•˜κΈ° μœ„ν•΄μ„  sort() λ©”μ„œλ“œμ— 손을 λ΄μ„œ μ¨μ•Όν•œλ‹€

// μ˜€λ¦„μ°¨μˆœ
const nums2 = [3,1,11,8,6]
console.log(nums2.sort((a,b)=>a-b)); 

// λ‚΄λ¦Όμ°¨μˆœ
const nums2 = [3,1,11,8,6]
console.log(nums2.sort((a,b)=>b-a)); 

// μ‹€λ¬΄μ‚¬μš©μ½”λ“œ
function sort(key){
  if (click){
      click = false
      var sortedData = jsonData.sort((a, b) => (a[key] < b[key] ? -1 : (a[key] > b[key] ? 1 : 0)))
  }
  else{
      click = true
      var sortedData = jsonData.sort((a, b) => (a[key] > b[key] ? -1 : (a[key] < b[key] ? 1 : 0)))
  }
}


객체

key 와 value λ₯Ό μ €μž₯ν•˜λŠ”λ° μ‚¬μš©λ˜κ³  속성 이름을 μ‚¬μš©ν•˜μ—¬ 속성에 μ ‘κ·Όν•˜λ―€λ‘œ 속성을 κ²€μƒ‰ν•˜λŠ”λ° νš¨μœ¨μ μ΄λ‹€
κ°μ²΄λŠ” μˆœμ„œκ°€ μ—†μœΌλ―€λ‘œ μš”μ†Œμ˜ μˆœμ„œλ₯Ό μœ μ§€ν•  ν•„μš”κ°€ μ—†λ‹€

const aespa = {
  members: ['μΉ΄λ¦¬λ‚˜', 'μœˆν„°', '지저', '닝닝'],
  from: 'κ΄‘μ•Ό',
  sing: function(){
      return "hello world"
  }
};
console.log(aespa.hasOwnProperty('itzy')); // false
console.log(aespa.hasOwnProperty('sing')); // true
// aespa.keys()
console.log(Object.keys(aespa))
console.log(Object.keys(aespa)) 


μœ μ‚¬λ°°μ—΄ 객체와 λ°°μ—΄


const arr = {
  0: 10,
  1: 20,
  length: 3
};

μœ μ‚¬λ°°μ—΄μ€ λ°°μ—΄κ³Ό λΉ„μŠ·ν•œ ν˜•νƒœλ₯Ό 가진 객체둜 λ°°μ—΄μ˜ ꡬ쑰와 λ™μž‘μ—μ„œ λΉ„μŠ·ν•œμ μ΄ μžˆλ‹€
ν•˜μ§€λ§Œ 배열에 λΉ„ν•΄ νš¨μœ¨μ μ΄μ§€ μ•Šμ•„μ„œ μ‹€λ¬΄μ—μ„œλŠ” μ‚¬μš©λ˜μ§€ μ•ŠλŠ”λ‹€

πŸ”Ž λ°°μ—΄μ˜ 값은 indexλ₯Ό μ‚¬μš©ν•΄μ„œ λ°°μ—΄μ˜ μœ„μΉ˜λ‘œ 쉽고 λΉ λ₯΄κ²Œ μ ‘κ·Όν•  수 μžˆλŠ” λ°©μ‹μœΌλ‘œ μ €μž₯λœλ‹€
πŸ”Ž μœ μ‚¬ λ°°μ—΄ κ°μ²΄λŠ” λ°°μ—΄ 처럼 보이도둝 κ΅¬μ‘°ν™”λœ JavaScript 객체이닀
πŸ”Ž λ°°μ—΄μ—λŠ” μœ μ‚¬ λ°°μ—΄ 객체가 μ‚¬μš©ν•  수 μ—†λŠ” λ‚΄μž₯ λ©”μ„œλ“œκ°€ μ‘΄μž¬ν•œλ‹€
πŸ”Ž μ΄λŸ¬ν•œ μ €μž₯ 방식차이와 λ‚΄μž₯ λ©”μ„œλ“œμ˜ 유무둜 인해 배열은 μ ‘κ·Ό 및 λ°˜λ³΅μ— λŒ€ν•΄ 더 νš¨μœ¨μ μ΄λ‹€


λ©”μ„œλ“œλž€?


객체의 ν”„λ‘œνΌν‹°λŠ” 이름과 κ°’μœΌλ‘œ κ΅¬μ„±λœ λ³€μˆ˜λ“€μ˜ 집합이닀 ν”„λ‘œνΌν‹°μ˜ κ°’μœΌλ‘œ ν•¨μˆ˜κ°€ 올 μˆ˜λ„ μžˆλŠ”λ° μ΄λŸ¬ν•œ ν”„λ‘œνΌν‹°λ₯Ό λ©”μ„œλ“œλΌκ³  ν•œλ‹€

πŸ”Ž 즉, λ©”μ„œλ“œλŠ” 객체가 가지고 μžˆλŠ” μ–΄λ–€ λ™μž‘μ„ λ§ν•œλ‹€
πŸ”Ž ν”„λ‘œνΌν‹°μ™€ λ©”μ„œλ“œμ˜ 차이점은 κ°’μœΌλ‘œ ν•¨μˆ˜κ°€ 올 수 μžˆλŠ”μ§€μ˜ 여뢀이닀
πŸ”Ž μ‰½κ²Œ μƒκ°ν•΄μ„œ .을 찍어 μ ‘κ·Ό ν•  수 μžˆλŠ” ν•¨μˆ˜λŠ” λ©”μ„œλ“œμ΄λ‹€


ν•¨μˆ˜

νŠΉμ •ν•œ μž‘μ—…μ„ μˆ˜ν–‰ν•˜κΈ° μœ„ν•΄ ν˜ΈμΆœν•  수 μžˆλŠ” μ½”λ“œλΈ”λ‘μ„ λ§ν•œλ‹€

const three = function(a, b, c) { // 1
  let z = c(a,b) + c(a,b)
  return z ** 2 // 3
}
four(10, 20, one)

πŸ”Ž μž¬μ‚¬μš©μ„±μ΄ λ†’μ•„ν•˜λ‹€
πŸ”Ž μœ μ§€λ³΄μˆ˜κ°€ μš©μ΄ν•˜λ‹€
πŸ”Ž ꡬ쑰 νŒŒμ•…μ΄ μš©μ΄ν•˜λ‹€

function four(a, b, c) {
  let z = one(a,b) + one(a,b)
  return z * 2
}
four(7, 3, one)

⚠️ μœ„μ˜ 경우 ν•¨μˆ˜μ˜ μˆœμˆ˜μ„±, μˆœμˆ˜ν•¨μˆ˜μ˜ μž₯점을 살릴 수 μ—†λ‹€

const three = function(a, b, c) { // 1
  let z = c(a,b) + c(a,b)
  return z ** 2 // 3
}
four(7, 3, one)

βœ”οΈ μœ„ 의 경우처럼 μ™ΈλΆ€μ—μ„œ 직접 값을 κ°€μ Έμ˜€λŠ” 것을 μ§€μ–‘ν•˜μž


RORO 기법


Receive an Object, Return an Object

function runPython(user, time, code, lv){
}
runPython({
  user: 'dongsup',
  time: 100,
  code: 'function...',
  lv: 3
})

πŸ”Ž 뜻 κ·ΈλŒ€λ‘œ 객체둜 λ°›κ³  객체둜 λ°˜ν™˜ν•˜λŠ” 것이닀
πŸ”Ž 식별 μ΄μŠˆκ°€ μžˆμ„ 경우 μ“°λŠ” μ½”λ“œμ˜ 가독성과 μœ μ§€λ³΄μˆ˜μ„±μ΄ 쒋아진닀


μ¦‰μ‹œ μ‹€ν–‰ ν•¨μˆ˜


(function() {
  console.log('이 ν•¨μˆ˜λŠ” λ§Œλ“€μ–΄μ§€μžλ§ˆμž λ°”λ‘œ μ‹€ν–‰λ©λ‹ˆλ‹€!');
})();

πŸ”Ž ν•¨μˆ˜λ₯Ό κ΄„ν˜Έλ‘œ 감싸면 ν•¨μˆ˜κ°€ λ§Œλ“€μ–΄μ§€λ§ˆμž μ‹€ν–‰λœλ‹€


Mutableκ³Ό Immutable

Mutable은 λ³€κ²½ κ°€λŠ₯ν•œ κ°’ 객체, λ°°μ—΄, ν•¨μˆ˜, 클래슀 등을 λ§ν•œλ‹€
Immutable은 λ³€κ²½λ˜μ§€ μ•ŠλŠ” μ›μ‹œνƒ€μž…μ„ λ§ν•œλ‹€



πŸ”— TIP

μ•Œμ•„λ‘˜ λ§Œν•œ 싀무 팁

let tip = [1,2,3,4,5]
console.log([...tip].pop())

πŸ”Ž 원본 μˆ˜μ •(손상) 없이 [1,2,3,4] κ°’κ³Ό [5]λΌλŠ” 값을 μ–»μ–΄λ‚΄κ³  싢을 λ•Œ



let tip = [1,2,3,4,5]
console.log(...tip, 1000, ...tip) 
// [1,2,3,4,5, 1000, 10,20,30,40,50]
console.log([tip.slice(0,2), 1000, tip.slice(2, 5)])
console.log([...tip.slice(0,2), 1000, ...tip.slice(2, 5)])
tip.splice(2, 0, 1000)



const tip = Array.from('hello world') // new없이도 μž‘λ™
const tip = new Array(10).fill(0) // new없이도 μž‘λ™
const tip = Array(100).fill(0).map((v,i) => i+1)
'.'.repeat(100).split('.') // κΆŒν•˜μ§„ μ•ŠμŒ



const human = {
  name: "dongsup",
  age: 53,
  from: "korea",
  askingHim: function () {
      console.log("hello world!");
  },
  0: '01050442903'
};
human.name = 'jun'
human.askingHim()
delete human.job;
console.log('age' in human)
// console.log(20 in [10,20,30,40]) error
// inμ—°μ‚°μžκ°€ ν‚€λ₯Ό μˆœνšŒν•΄μ„œ error



function ν•¨μˆ˜1(a,b,c) {
  return a + b + c
}
ν•¨μˆ˜1(10,20,30,40) //errorκ°€ λ°œμƒν•˜μ§€ μ•ŠλŠ”λ‹€
ν•¨μˆ˜1(10,20) // errorκ°€ λ°œμƒν•˜μ§€ μ•ŠλŠ”λ‹€ λ‹€λ₯Έμ–Έμ–΄μ˜ 경우 error

function ν•¨μˆ˜1(a=10, b=20, c=30){
  return a + b + c
}
ν•¨μˆ˜1(1, 1)

function ν•¨μˆ˜1(a=10, b=20, c=30){
  return a + b + c
}
// a와 c에 λ“€μ–΄κ°ˆ 것이라고 μƒκ°ν–ˆμ§€λ§Œ a와 b에 λ“€μ–΄κ°„λ‹€
ν•¨μˆ˜1(a=1, c=1)



function hello(para) {
  console.log(para)
  console.log('hello')
  return 100
}
console.log(hello(10)) // 10 hello 100
let x = console.log('hello') 
// console.log('hello') μžλ¦¬μ— return 값이 λ“€μ–΄κ°€κΈ° λ•Œλ¬Έμ— undefined
x // undefined 

πŸ”Ž returnκ³Ό console.logλ₯Ό ν˜Όλ™ν•˜μ§€μ•Šκ³  μ‚¬μš©ν•˜μž

λŒ“κΈ€λ‚¨κΈ°κΈ°