[๐ŸŠSTART WITH UDEMY] JS ์•Œ๊ณ ๋ฆฌ์ฆ˜ & ์ž๋ฃŒ๊ตฌ์กฐ ๋งˆ์Šคํ„ฐํด๋ž˜์Šค ๋ฝ€๊ฐœ๊ธฐ - Recursion

Yeeun_Anยท2022๋…„ 5์›” 9์ผ
3

Recursion ์žฌ๊ท€

๐Ÿ‘‰[JavaScipt ์•Œ๊ณ ๋ฆฌ์ฆ˜ & ์ž๋ฃŒ๊ตฌ์กฐ ๋งˆ์Šคํ„ฐํด๋ž˜์Šค ์ˆ˜์—…] ์„ ์ œ๊ณต ๋ฐ›์•„ ์•Œ๊ณ ๋ฆฌ์ฆ˜ ๊ณต๋ถ€๋ฅผ ํ•˜๊ณ  ์žˆ๋Š”๋ฐ์š”!
์œ ๋ฐ๋ฏธ์˜ ๊ฐ•์ ์ธ ์งฑ์งฑํ•œ ํ”„๋กœ๋ชจ์…˜ ๊ธฐ๊ฐ„์ด ์žˆ์œผ๋‹ˆ! ๊ผญ ์ฐฉํ•œ ๊ฐ€๊ฒฉ์— ์•Œ์ฐฌ ๊ฐ•์˜ ์Ÿ๊ฒจ๊ฐ€์‹œ๊ธธ ๋ฐ”๋ผ์š”

์žฌ๊ท€ ํ•จ์ˆ˜๋ž€?

a propcess (a function in out cas) that calls itself

์ž๊ธฐ ์ž์‹ ์„ ํ˜ธ์ถœํ•˜๋Š” ํ•จ์ˆ˜

์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ์—์„œ ์žฌ๊ท€ ํ•จ์ˆ˜๋ฅผ ํ˜ธ์ถœํ•  ๋•Œ ์–ด๋–ค ์ผ์ด ์ผ์–ด๋‚ ๊นŒ?

์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ์™€ ๊ฐ™์€ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด์—๋Š” ํ•จ์ˆ˜ ํ˜ธ์ถœ์„ ์ •๋ฆฌํ•˜๊ณ  ๋‹ด๋‹นํ•˜๋Š” ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ(data structure)๊ฐ€ ์žˆ๋‹ค. ์ด๊ฒƒ์„ call stack ์ด๋ผ๊ณ  ํ•œ๋‹ค.

ํ˜ธ์ถœ ์Šคํƒ์€ ์ž๋ฐ”์Šคํฌ๋ฆฝ์˜ ๋ณด์ด์ง€ ์•Š์€ ๊ณณ์—์„œ ์ž‘๋™ํ•˜๋Š” ์ •์  ๋ฐ์ดํ„ฐ ๊ตฌ์กฐ(static data structure)์ด๋‹ค.

stack ๋งจ ์œ„์˜ ํ•จ์ˆ˜๋ฅผ ์‹คํ–‰ํ•˜๊ณ , ๋ฆฌํ„ด์„ ํ™•์ธํ•œ ๋’ค, ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ ์Šคํƒ์˜ ์ œ์ผ ์œ„์— ์žˆ๋Š” ํ•จ์ˆ˜๋ฅผ ์ œ๊ฑฐํ•œ๋‹ค.

์žฌ๊ท€ ํ•จ์ˆ˜๋Š” ์–ด๋–ป๊ฒŒ ๋™์ž‘ํ• ๊นŒ?

๊ธฐ๋ณธ์ ์ธ ๊ฐœ๋…์€ ๋™์ผํ•œ ํ•จ์ˆ˜๋ฅผ ๋ฐ˜๋ณต์ ์œผ๋กœ ํ˜ธ์ถœํ•˜๋Š” ๊ฒƒ์ด๋‹ค. ํ•˜์ง€๋งŒ ์˜์›ํžˆ ๋ฐ˜๋ณตํ•œ๋‹ค๋ฉด ๊ณผ๋ถ€ํ•˜๊ฐ€ ์ผ์–ด๋‚˜๊ณ  ํ•˜๋“œ์›จ์–ด์— ํฐ ์•…์˜ํ–ฅ์„ ๋ผ์น  ๊ฒƒ์ด๋‹ค. ๊ทธ๋ž˜์„œ ์žฌ๊ท€ํ•จ์ˆ˜๋Š” base case์ฆ‰, ์ข…๋ฃŒ ์กฐ๊ฑด์ด ์žˆ์–ด์•ผ ํ•œ๋‹ค.

  1. Base case (=stopping point) ์ข…๋ฃŒ ์กฐ๊ฑด์€ ์žฌ๊ท€๋ฅผ ๋ฉˆ์ถ”๊ธฐ ์œ„ํ•ด ๋งŒ์กฑํ•ด์•ผ ํ•˜๋Š” ์กฐ๊ฑด์ด๋‹ค.
  2. Different Input
    ์—ฌ๋Ÿฌ๊ฐ€์ง€ ๋‹ค๋ฅธ ๋ฐ์ดํ„ฐ๋ฅผ ๊ฐ€์ง€๊ณ  ํ•จ์ˆ˜๋ฅผ ์‹คํ–‰ํ•  ์ˆ˜ ์žˆ์–ด์•ผ ํ•œ๋‹ค.

์˜ˆ์‹œ๋กœ ๋ณด๊ธฐ

//์žฌ๊ท€๋ฅผ ์‚ฌ์šฉํ•œ ๊ฒฝ์šฐ
function sayHello(num){
	if(num <= 0){ //end point
		console.log('Hello');
		return; // returnํ•˜๋Š” ๊ฒƒ์ด ์—†๋”๋ผ๋„ ๊ผญ return์„ ํ•ด์ค˜์•ผ ํ•จ
	}
	console.log(num)
	num--;
	sayHello(num);
}

//๋ฐ˜๋ณต๋ฌธ์„ ์‚ฌ์šฉํ•œ ๊ฒฝ์šฐ
function sayHello(num){
	for(let i = num; i > 0; i--){
		console.log(i);
	}
	console.log('Hello')
}

sayHello(3)

์œ„์˜ ์˜ˆ์‹œ์—์„œ ์žฌ๊ท€ ํ•จ์ˆ˜์˜ ๊ฒฝ์šฐ,
sayHello(0) ๊ฐ€ ๋˜๋ฉด num <= 0 ์ด ๋˜์–ด console.log('Hello') ๊ฐ€ ์ž‘๋™ํ•œ๋‹ค. ์ด๊ฒƒ์ด ๋ฐ”๋กœ ์ข…๋ฃŒ ์กฐ๊ฑด์ด๋‹ค.

return ํ•ด์ฃผ๋Š” ๊ฒƒ์ด ์—†๋”๋ผ ํ•˜๋”๋ผ๋„ ์žฌ๊ท€ ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•  ๋•Œ, ์ข…๋ฃŒ ์กฐ๊ฑด ์•ˆ์—๋Š” ๊ผญ! return์„ ํฌํ•จํ•ด์ฃผ์–ด์•ผ ํ•œ๋‹ค. ๋งŒ์•ฝ ๋ฆฌํ„ด๋ฌธ์ด ์—†๋‹ค๋ฉด ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ ํ•จ์ˆ˜๋ฅผ ์ œ๊ฑฐํ•˜์ง€ ์•Š๊ณ  ๊ณ„์† ์ง„ํ–‰๋  ๊ฒƒ์ด๋‹ค.

์˜ˆ์‹œ๋กœ ๋ณด๊ธฐ2 (base case)

function mul(num){
	if (num === 1) return 1; // num === 1 ์€ base case
	return num * mul(num-1);
}

์œ„์˜ ์ฝ”๋“œ๋ฅผ ์‚ดํŽด๋ณด์ž

mul(5)๋ฅผ ์‹คํ–‰ํ•œ๋‹ค๋ฉด

mul(5) = 5*mul(4)
mul(4) = 4*mul(3)
mul(3) = 3*mul(2)
mul(2) = 2*mul(1)
mul(1) = 1

๋”ฐ๋ผ์„œ ์œ„์˜ ํ•จ์ˆ˜๋Š” num๋งŒํผ์˜ ์ˆซ์ž๋ฅผ ๋ชจ๋‘ ๊ณฑํ•œ ๊ฐ’์„ ๋ฆฌํ„ดํ•œ๋‹ค.

์˜ˆ์‹œ๋กœ ๋ณด๊ธฐ (ํŒฉํ† ๋ฆฌ์–ผ)

//๋ฐ˜๋ณต ํ•จ์ˆ˜๋กœ ๊ตฌํ˜„
function factorial(n){
	const result = 1;
	for( let i = n; i > 1; i-- ){
		result *= i
	}
return result;
}

์œ„์˜ ํŒฉํ† ๋ฆฌ์–ผ์„ ๋ฐ˜๋ณต๋ฌธ์œผ๋กœ ๊ตฌํ˜„ํ•œ ํ•จ์ˆ˜๋ฅผ ์žฌ๊ท€๋กœ ๊ตฌํ˜„ํ•ด๋ณด๋„๋ก ํ•˜์ž.

//์žฌ๊ท€๋กœ ๊ตฌํ˜„ - **๋ฌดํ•œ๋ฐ˜๋ณต ์—๋Ÿฌ**
function factorial(n){
	return n * factorial(n-1)
}

์œ„์˜ ์ฝ”๋“œ๋Š” ์—”๋“œํฌ์ธํŠธ, ์ข…๋ฃŒ์ง€์ ์ด ์—†๋‹ค. ๋ฌดํ•œ ๋ฐ˜๋ณต์ด ๋  ์ˆ˜ ๋ฐ–์— ์—†๋‹ค.
์Šคํƒ์— ๋ฌดํ•œ์œผ๋กœ ํ•จ์ˆ˜๊ฐ€ ์Œ“์ด๋Š” ๊ฒƒ์ด๋‹ค. ๊ทธ๋Ÿฌ๋ฉด ์ตœ๋Œ€ ํ˜ธ์ถœ ์Šคํƒ์„ ์ดˆ๊ณผํ–ˆ๋‹ค๋Š” ์—๋Ÿฌ๊ฐ€ ๋‚  ์ˆ˜ ์žˆ๊ณ  ์ด๋ฅผ stack overflow ๋ผ๊ณ  ํ•œ๋‹ค.

//์žฌ๊ท€๋กœ ๊ตฌํ˜„
function factorial(n){
	if(n===1) return 1;
	return n * factorial(n-1)
}

์ด๋ ‡๊ฒŒ ์—”๋“œ ํฌ์ธํŠธ๋ฅผ ๊ฑธ์–ด์ฃผ๋ฉด ๋ฌดํ•œ ๋ฐ˜๋ณตํ•˜์ง€ ์•Š๋Š” ์ฝ”๋“œ๋ฅผ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ๋‹ค.

์ง€๊ธˆ๊นŒ์ง€ ๊ตฌํ˜„ํ•œ ์žฌ๊ท€ ํ•จ์ˆ˜๋Š” ๋‹จ์ผ ๋‹จ๋… ํ•จ์ˆ˜(single standalone function) ์ด๋‹ค. ์™ธ๋ถ€์—์„œ ํŒฉํ† ๋ฆฌ์–ผ ํ•จ์ˆ˜๋ฅผ ํ˜ธ์ถœํ•˜๋ฉด ํŒฉํ† ๋ฆฌ์–ผ ํ•จ์ˆ˜๋Š” ์ง์ ‘ ์ž์ฒด ์ฝ”๋“œ ๋‚ด์˜ ํŒฉํ† ๋ฆฌ์–ผ ํ•จ์ˆ˜๋ฅผ ํ˜ธ์ถœํ•œ๋‹ค. ํ•˜์ง€๋งŒ helper method ์žฌ๊ท€๋Š” ๋‹จ๋… ํ•จ์ˆ˜์™€ ์กฐ๊ธˆ ๋‹ค๋ฅด๋‹ค.

Helper method resursion ํ—ฌํผ ๋ฉ”์†Œ๋“œ ์žฌ๊ท€

ํ—ฌํผ ๋ฉ”์†Œ๋“œ ์žฌ๊ท€์˜ ๊ธฐ๋ณธ ํ˜•ํƒœ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.
์™ธ๋ถ€ ํ•จ์ˆ˜ ๋‚ด์— ์žฌ๊ท€ ํ•จ์ˆ˜๊ฐ€ ๋“ค์–ด์žˆ๋‹ค.

//์™ธ๋ถ€ํ•จ์ˆ˜
function outer(input){
	let outerScopeVariable = []
	//์žฌ๊ท€ํ•จ์ˆ˜
	function helperRecursion(helperInput){
		helperRecursion(helperInput--)
	}
	helper(input)
	return outerScopedVariable;
}

๋ฐฐ์—ด์ด๋‚˜ ๋ฐ์ดํ„ฐ ๋ชฉ๋ก ๊ฐ™์€ ๊ฒƒ์„ ์ปดํŒŒ์ผ ํ•ด์•ผ ํ•  ๋•Œ ํ—ฌํ„ฐ ๋ฉ”์†Œ๋“œ ์žฌ๊ท€๋ฅผ ์‚ฌ์šฉํ•œ๋‹ค. recursive helper๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ๋นˆ ๋ฐฐ์—ด์— ์ˆ˜์ง‘ํ•ด์•ผ ํ•˜๋Š” ๋ฐ์ดํ„ฐ๋“ค์„ ์ €์žฅํ•˜๊ธฐ์— ์šฉ์ดํ•˜๋‹ค.

๋งŒ์•ฝ ์žฌ๊ท€ ํ•จ์ˆ˜ ์ž์ฒด์—์„œ ๋ฐฐ์—ด ๋ณ€์ˆ˜๋ฅผ ์„ ์–ธํ•˜๊ฒŒ ๋œ๋‹ค๋ฉด ํ•จ์ˆ˜๋ฅผ ํ˜ธ์ถœํ•  ๋•Œ๋งˆ๋‹ค ๋ฐฐ์—ด ๊ฐ’์ด ๋ฆฌ์…‹ ๋  ๊ฒƒ์ด๋‹ค.

function collectNums(arr){
	let result = []; //ํ˜ธ์ถœ ํ•  ๋•Œ ๋งˆ๋‹ค ์žฌ์ •์˜๋จ
	if(arr.length === 0){
			return;
		}
	...
}

์œ„์˜ ์ฝ”๋“œ๋ฅผ ํ—ฌํผ ์žฌ๊ท€๋กœ ์ˆ˜์ •ํ•ด๋ณด์ž.

function collectNums(arr){
	let result=[]

	//ํ—ฌํผ์žฌ๊ท€
	function helperEvens(helperInput){
		//end point ์ข…๋ฃŒ ์กฐ๊ฑด
		if(helperInput.length === 0){
			return;
		}
		if(helperInput[0] % 2 == 0){
			result.push(helperInput[0])
		}
		
		helperEvens(helperInput.slice(1))
	}
	
	helperEvens(arr)
	return result;
}

collectNums([1,2,3,4,5])
  1. collectNums([1,2,3,4,5]) ์€ collectNums ๋ฅผ ํ˜ธ์ถœํ•œ๋‹ค.
  2. collectNums ์•ˆ์— ์žˆ๋Š” helperEvens([1,2,3,4,5]) ๊ฐ€ ํ˜ธ์ถœ๋œ๋‹ค.
  3. [1,2,3,4,5] ์˜ ๊ธธ์ด๊ฐ€ 0์ด ์•„๋‹ˆ๊ธฐ ๋•Œ๋ฌธ์— ์ข…๋ฃŒ ์กฐ๊ฑด์€ ํŒจ์Šคํ•œ๋‹ค. if(helperInput[0] % 2 == 0) ๋ฅผ ๋ณด๋ฉด, helperInput[0] ์ธ arr์˜ ์ธ๋ฑ์Šค 0์ธ 1์€ 2๋กœ ๋‚˜๋ˆ ์ง€์ง€ ์•Š๊ธฐ ๋•Œ๋ฌธ์— ๋˜ ํŒจ์Šคํ•œ๋‹ค.
  4. helperInput.slice(1) = [2,3,4,5] ์ด๋ฏ€๋กœ helperEvens(helperInput.slice(1)) ์— ์˜ํ•ด helperEvens([2,3,4,5]) ๋ฅผ ์‹คํ–‰ํ•œ๋‹ค.
  5. ๋‘ ๋ฒˆ์งธ if๋ฌธ ์—์„œ helperInput ๋ฐฐ์—ด์˜ ์ธ๋ฑ์Šค 0์ธ 2๋Š” result ์— push๋œ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ๋˜ slice๋กœ ์ธ๋ฑ์Šค 0์„ ์ž˜๋ผ๋‚ด๊ณ  ๊ทธ ๋’ค์˜ ์›์†Œ๋“ค์„ ์žฌ๊ท€๋ฅผ ํ†ตํ•ด ์ง์ˆ˜ํŒ๋ณ„์„ ํ•œ๋‹ค.
  6. ๋งˆ์ง€๋ง‰์œผ๋กœ helperInput ์˜ ๊ธธ์ด๊ฐ€ 0์ด ๋˜๋ฉด ๋ฐฐ์—ด result ์—๋Š” ์ง์ˆ˜๋งŒ ๋‚จ๊ฒŒ ๋˜๊ณ  return ๋œ๋‹ค.
๐Ÿ’ก ํ—ฌํผ ๋ฉ”์†Œ๋“œ ์žฌ๊ท€๋Š” ์™ธ๋ถ€ ํ•จ์ˆ˜๊ฐ€ ์žฌ๊ท€์ ์ธ ๋‚ด๋ถ€ ํ•จ์ˆ˜๋ฅผ ํ˜ธ์ถœํ•˜๋Š” ๋ฐฉ์‹์ด๋‹ค. ํ•จ์ˆ˜๋ฅผ ๊ฑฐ์นœ ๊ฐ’๋“ค์„ ์ƒˆ๋กœ์šด ๋ฐฐ์—ด์— ์ €์žฅํ•˜๊ณ  ๋ฆฌํ„ดํ•˜๊ณ  ์‹ถ์„ ๋•Œ ์šฉ์ดํ•˜๋‹ค.

Pure recursion ์ˆœ์ˆ˜ ์žฌ๊ท€

์ˆœ์ˆ˜ ์žฌ๊ท€ ํ•จ์ˆ˜๋ž€ ํ•จ์ˆ˜์— ๋ชจ๋“  ์ฝ”๋“œ๋ฅผ ํฌํ•จํ•˜๊ณ  ์žฌ๊ท€์ ์œผ๋กœ ์ž‘๋™ํ•˜๋„๋ก ํ•˜๋Š” ๊ฒƒ์ด๋‹ค. ํ—ฌํผ ์žฌ๊ท€์™€ ๋‹ฌ๋ฆฌ ์™ธ๋ถ€ ํ•จ์ˆ˜, ๋‚ด๋ถ€ ํ•จ์ˆ˜๋ฅผ ๊ตฌ๋ถ„ ์ง€์–ด ์ค‘์ฒฉ ํ•จ์ˆ˜๋กœ ์ž‘์„ฑํ•˜๋Š” ๊ฒƒ์ด ์•„๋‹ˆ๋ผ ํ•˜๋‚˜์˜ ํ•จ์ˆ˜๋กœ ์ž‘์„ฑํ•˜๋Š” ๊ฒƒ์ด๋‹ค.

function collectEven(arr){
	let result = [];
	
	if(arr.length === 0){
		return result;
	}
	
	if(arr[0] % 2 === 0){
		result.push(arr[0]);
	}
	
	result = result.concat(collectEven(arr.slice(1)));
	return result;
}

collectEven([1,2,3,4,5])
  1. collectEven([1,2,3,4,5]) ๋ฅผ ํ•˜๋ฉด, ์ฒซ ์กฐ๊ฑด๋ฌธ์—์„œ ๊ธธ์ด๊ฐ€ 0์ด ์•„๋‹ˆ๊ธฐ ๋•Œ๋ฌธ์— ์ด ์กฐ๊ฑด๋ฌธ์€ ํŒจ์Šคํ•œ๋‹ค. ๋‘ ๋ฒˆ์งธ ์กฐ๊ฑด๋ฌธ์—์„œ๋„ arr[0]์ด 2๋กœ ๋‚˜๋ˆ„์—ˆ์„ ๋•Œ ๋‚˜๋จธ์ง€๊ฐ€ 0์ด ์•„๋‹ˆ๊ธฐ ๋•Œ๋ฌธ์— ํŒจ์Šคํ•œ๋‹ค.
  2. arr1.concat(arr2) ์€ arr1๊ณผ arr2๋ฅผ ํ•ฉํ•˜์—ฌ ์ƒˆ๋กœ์šด ๋ฐฐ์—ด์„ ๋ฐ˜ํ™˜ํ•œ๋‹ค.
    result = result.concat(collectEven(arr.slice(1))); ์—์„œ arr.slice(1) ๋Š” [2,3,4,5] ์ด๋‹ค.
    ๊ทธ ๋‹ค์Œ, collectEven(arr.slice(1)) ์œผ๋กœ ํ•จ์ˆ˜๋ฅผ ์žฌ๊ท€์ ์œผ๋กœ ํ˜ธ์ถœํ–ˆ๊ธฐ์— ์ง„ํ–‰ํ•œ๋‹ค.
  3. collectEven([2,3,4,5]) ์—์„œ result์— 2๊ฐ€ ๋“ค์–ด๊ฐ„๋‹ค.
    [2].concat(collectEven([3,4,5]));์ด ๋˜๊ณ  ์ด๋ฅผ ์ž์„ธํžˆ ๋‚˜ํƒ€๋‚ด๋ณด์ž๋ฉด
    collectEven([1,2,3,4,5])
    	[].concat(collectEven([2,3,4,5])) 
    		[2].concat(collectEven([3,4,5])) 
    			[].concat(collectEven([4,5])) 
    				[4].concat(collectEven([5])) 
    					[].concat(collectEven([]))
    						[]
๊ฑฐ์Šฌ๋Ÿฌ ์˜ฌ๋ผ๊ฐ€ ๋ณด๋ฉด์„œ ํ˜ธ์ถœ๋˜๋Š” ๊ฐ’๋“ค์„ ํ™•์ธํ•˜์ž๋ฉด
   []
   	[].concat(collectEven([])) //collectEven([]) = [] => [].concat([])
   		[4].concat(collectEven([5])) //[4].concat([])
   			[].concat(collectEven([4,5])) //[].concat([4])
   				[2].concat(collectEven([3,4,5])) //[2].concat{[4])
   					[].concat(collectEven([2,3,4,5])) //[].concat([2,4])
   						collectEven([1,2,3,4,5])
๋ฆฌํ„ด๊ฐ’์€ `[2,4]` ๋กœ ์ง์ˆ˜๋งŒ ํ‘ธ์‰ฌ๋œ ๋ฐฐ์—ด์ด ๋งŒ๋“ค์–ด์ง„๋‹ค.

์ˆœ์ˆ˜ ์žฌ๊ท€ Tips

  1. slice the spread operator concat ๊ฐ™์€ ๋ฉ”์†Œ๋“œ๋ฅผ ํ™œ์šฉํ•˜๋ฉด ์ƒˆ๋กœ์šด ๋ฐฐ์—ด์„ ๋งŒ๋“ค์–ด ๋ฐ˜ํ™˜ํ•˜๊ธฐ ๋•Œ๋ฌธ์— ๋ฐฐ์—ด ์ž์ฒด๋ฅผ ๋ณ€๊ฒฝํ•  ํ•„์š”๊ฐ€ ์—†๋‹ค.
  2. ๋ฌธ์ž์—ด์„ ๋‹ค๋ฃฐ ๋•Œ ๋ฌธ์ž์—ด์€ immutable ํ•˜๋‹ค. ๋ณ€๊ฒฝ, ์ˆ˜์ •์ด ๋ถˆ๊ฐ€ํ•˜๊ธฐ ๋•Œ๋ฌธ์— slice substr ๋“ฑ์„ ํ†ตํ•ด ๋ณต์‚ฌ๋ณธ์œผ๋กœ ํ™œ์šฉํ•˜๋Š” ๊ฒƒ์ด ์ข‹๋‹ค.
  3. ๊ฐ์ฒด๋ฅผ ๋‹ค๋ฃฐ ๋•Œ๋Š” Object.assign ์ด๋‚˜ the spread operator ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋”ฅํ•œ ๋ณต์‚ฌ๋ฅผ ํ•˜๋Š” ๊ฒƒ์ด ์›๋ณธ์„ ๋ฐฉํ•ดํ•˜์ง€ ์•Š๊ธฐ์— ์ข‹๋‹ค.

๋ฌธ์ œ๋ฅผ ํ’€์–ด๋ณด์ž ๐Ÿš€ํ€ด์ฆˆ ํƒ€์ž„

์ด ๊ฐ•์˜์˜ ์žฅ์ ์€ ์ด๋ ‡๊ฒŒ ๊ณผ์ œ๋ฅผ ์ œ๊ณตํ•œ๋‹ค๋Š” ์ ์ด์—์š”!

์„น์…˜ 8์€ ์žฌ๊ท€๋ฌธ์ œ ์ง‘ํ•ฉ์ด๊ณ  ๋” ์—ฐ์Šตํ•ด๋ณด๊ณ  ์‹ถ์€ ์‚ฌ๋žŒ๋“ค์„ ์œ„ํ•ด ์„น์…˜ 9 ๋ณด๋„ˆ์Šค ๋„์ „ ์žฌ๊ท€ ๋ฌธ์ œ ๊นŒ์ง€ ์žˆ๋‹ต๋‹ˆ๋‹ค!

์•„์‰ฝ๊ฒŒ๋„ ๋ฌธ์ œ ์ง‘ํ•ฉ ์„น์…˜์€ ์žฌ๊ท€๊นŒ์ง€๋งŒ ์žˆ์–ด์š”.
์•„๋ฌด๋ž˜๋„ ๊ธฐ์ดˆ๋ฅผ ๋‹ค์žก๊ณ ์ž ํ•˜๋Š” ๊ฒƒ์— ๋ชฉ์ ์ด ์žˆ๋Š” ๊ฐ•์˜์ด๋‹ค ๋ณด๋‹ˆ ๊ณผ์ œ๊ฐ€ ๋ชจ๋“  ๊ฐœ๋…๋“ค์— ์ œ๊ณต๋˜์ง„ ์•Š์Šต๋‹ˆ๋‹ค!

๊ทธ๋ž˜์„œ ์œ ๋ฐ๋ฏธ [JavaScript ์•Œ๊ณ ๋ฆฌ์ฆ˜ & ์ž๋ฃŒ๊ตฌ์กฐ ๋งˆ์Šคํ„ฐํด๋ž˜์Šค] ๋กœ ๊ฐœ๋…์„ ๋‹ค์žก๊ณ  ๋ฐฑ์ค€์œผ๋กœ ํ•ด๋‹น ๊ฐœ๋…์—ํ•œ ์ถ”๊ฐ€์ ์ธ ๋ฌธ์ œ๋ฅผ ํ’€์–ด๋ณด๋Š” ๊ฒƒ์ด ๊ฐ€์žฅ ๋ฒ ์ŠคํŠธ๋ผ๊ณ  ์ƒ๊ฐํ•ฉ๋‹ˆ๋‹ค!

profile
๋’น๊ตด ๋’น๊ตด ๊ฐœ๋ฐœ์ผ์ง€

0๊ฐœ์˜ ๋Œ“๊ธ€