OOP, ์ ์ฐจ์งํฅ, ํจ์ํ ํ๋ก๊ทธ๋๋ฐ .. ๋ง์ด ์ฌ์ฉํ์ง๋ง ์ ํํ ๊ธฐ๋ณธ ๊ฐ๋ ์ ์๊ณ ์์ง ์๋ค๋ ์๊ฐ์ด ๋ค์ด, ๊ด๋ จ ๋ด์ฉ์ ๋ด์ ์ ๋ฆฌํ ๊ธ์ ์จ ๋ณธ๋ค.
๐ Introdction
์ ์ฐจ์งํฅํ ํ๋ก๊ทธ๋๋ฐ, ๊ฐ์ฒด์งํฅํ ํ๋ก๊ทธ๋๋ฐ, ํจ์ํ ํ๋ก๊ทธ๋๋ฐ ๋ฑ์ ์ฉ์ด๋ฅผ ์์ธ๋ฌ 'ํ๋ก๊ทธ๋๋ฐ ํจ๋ฌ๋ค์'์ด๋ผ ์นญํ๋ค. ์ผ์ข ์ ํ๋ก๊ทธ๋๋ฐ ์ธ๊ณ๊ด์ด๋ผ๊ณ ํ ์ ์๋๋ฐ, ํน์ ๊ธฐ๋ฒ์ด๋ ์ด๋ก ์ ๋ชจ์ ํ๋์ ์ฒด๊ณ๋ก ๋ง๋ค์๋ค๊ณ ๋ณผ ์ ์๋ค.
ํ๋ก๊ทธ๋๋ฐ ํจ๋ฌ๋ค์์ ์ ํ์ ๋ฐ๋ผ ๋ช ๋ นํ/์ ์ธํ์ผ๋ก ๋ถ๋ฅํ ์ ์๋ค.
๐ก ๋ช ๋ นํ ํ๋ก๊ทธ๋๋ฐ: ์ด๋ป๊ฒ(How) ํ ๊ฑด์ง๋ฅผ ์ค๋ช ํ๋ ๋ฐฉ์
- ์ ์ฐจ์งํฅ ํ๋ก๊ทธ๋๋ฐ
- ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ
๐ก ์ ์ธํ ํ๋ก๊ทธ๋๋ฐ: ๋ฌด์(What)์ ํ ๊ฑด์ง๋ฅผ ์ค๋ช ํ๋ ๋ฐฉ์
- ํจ์ํ ํ๋ก๊ทธ๋๋ฐ
โจ ์ ์ฐจ์งํฅ ํ๋ก๊ทธ๋๋ฐ
์ต๊ทผ๊น์ง๋ ํ๋ก๊ทธ๋๋ฐ ํจ๋ฌ๋ค์ ์ค ๊ฐ์ฅ ํฐ ์ง๋ถ์ ์ฐจ์งํ๊ณ ์๋ OOP (๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ) ๊ฐ ๋์ค๊ธฐ ์ ์ ๊ฐ์ฅ ๋ง์ด ํ์ฉ๋์์ผ๋ฉฐ, ํ์ฌ๋ ์ฒ์ ํ๋ก๊ทธ๋๋ฐ์ ์ ํ ๋๋ ์์ฐ์ค๋ ์ ํ๋ ๊ฒ์ด ๋ฐ๋ก ์ ์ฐจ์งํฅ ํ๋ก๊ทธ๋๋ฐ์ด๋ค.
์ ์ฐจ์งํฅ ํ๋ก๊ทธ๋๋ฐ์ ๋ง ๊ทธ๋๋ก ์์ฑํ ๋ชจ๋ ์ฝ๋๋ฅผ ์์ฐจ์ ์ผ๋ก ์คํํ๋ค๊ณ ์๊ฐํ๋ฉฐ ์ฝ๋๋ฅผ ์์ฑํ๋ ๋ฐฉ์์ ๊ณ ์ํ๋ค. ์์์ ์๋๋ก ๋ฌธ์๋ฅผ ์ฝ์ด๊ฐ๋ ์ฌ๋์ ์ฌ๊ณ ์ ๊ฐ๊น๊ธฐ ๋๋ฌธ์ ๋น ๋ฅด๊ฒ ์ต์ํด์ง๊ณ ํ์ฉํ๊ธฐ ์ฝ๋ค๋ ์ฅ์ ์ด ์๋ค.
๐ ์ ์ฐจ์งํฅ ํน์ง
- ๋ณ์์ ํจ์๊ฐ ๋ถ๋ฆฌ๋์ด ์์ฑ๋๋ค.
- ํจ์์ ํจ์, ๋ณ์์ ํจ์ ๋ฑ ์๋ก์ ๋ํ ์์กด์ฑ์ด ๋๋ค.
์๋๋ ์ ์ฐจ์งํฅ ํ๋ก๊ทธ๋๋ฐ์ ์์ด๋ค.
const year = 2021
const month = September
const day = 14
function today() {
return `Today is ${month} ${day}, ${year}`;
}
function tomorrow() {
return `Tomorrow is ${month} ${day + 1}, ${year}`;
}
โจ ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ
OOP(Object-oriented Programming)์ผ๋ก๋ ๋๋ฆฌ ์๋ ค์ง ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ ์ญ์ ์ง๊ด์ ์ด๋ฉฐ, ์ฌ๋์ด ์ฌ๊ณ ํ๋ ๋ฐฉ์๊ณผ ๊ฐ๊น๋ค๋ ์ฅ์ ์ด ์๋ค. ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ์ ๊ฐ๋ ์ ๋ ผํ๊ธฐ ์ํด์๋ ์ฃผ์ ํน์ง 4๊ฐ์ง์ธ ์บก์ํ, ์ถ์ํ, ์์, ๋คํ์ฑ์ ๊ตฌ์ฒด์ ์ผ๋ก ์์๋ณด์์ผ ํ๋ค.
๐ Encapsulation (์บก์ํ)
๊ฐ์ฒด์งํฅ์ ๊ฐ์ฅ ํฐ ํน์ง ์ค ํ๋๋ ์๋ก ๊ด๋ จ๋์ด ์๋ ๋ณ์์ ํจ์๋ฅผ ํ๋์ ๋จ์๋ก ๋ฌถ๋๋ค๋ ๊ฒ์ด๋ค. (๊ฐ์ ๋ชฉ์ ์ ๊ฐ๋ ๊ธฐ๋ฅ๊ณผ ๋ฐ์ดํฐ๋ฅผ ํ๋๋ก ๋ฌถ๋ ๊ฒ๊ณผ๋ ๊ฐ๋ค) ์ฐ๊ด์ฑ ๋์ ๊ฒ๋ค๋ผ๋ฆฌ ํ๋์ ๋จ์, ์ฆ ์บก์ ์์ ๋ด๋๋ค๊ณ ํ์ฌ '์บก์ํ' ๋ผ๊ณ ๋ถ๋ฅด๋ฉฐ, ์ฌ๊ธฐ์ ๋งํ๋ ๋จ์๋ ์บก์์ด ๊ณง ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์ ์ฌ์ฉ๋๋ ๊ฐ์ฒด์ด๋ค.
โ ๋ง์ ์ฌ๋๋ค์ด ์คํดํ๋ ๊ฒ ์ค ํ๋๊ฐ, JavaScript (๋๋ ๋ค๋ฅธ ์ธ์ด์) Class ๊ฐ ๊ณง OOP ์ ๊ฐ์ฒด์ผ ๊ฒ์ด๋ผ๋ ์ ์ด๋ค. ์ด๋ ๋ถ์ ํํ ํํ์ด๋ฉฐ, 'OOP๋ฅผ ๊ตฌํํ๊ธฐ ์ํด ํด๋์ค์ ์ธ์คํด์ค๋ฅผ ์ฌ์ฉํ๋ค' ๊ณ ํํํ๋ ๊ฒ์ด ๋ ์ ํํ๋ค. ์ฆ JS ๊ฐ ์ง์ํ๋ ํด๋์ค๋ฅผ ํตํด OOP ๋ฅผ ๊ตฌํํ ์ ์๊ฒ ๋๋ ๊ฒ์ด๋ค.
ํ๋์ ์บก์ ์์๋ ๋ฐ์ดํฐ์ ์ด ๋ฐ์ดํฐ์ ๋ํ ํน์ ์์ ์ ์คํํ ์ ์๋ ๊ธฐ๋ฅ์ด ํจ๊ป ๋ด๊ธด๋ค. ์ค๋ช ์ด ์กฐ๊ธ ์ถ์์ ์ธ๋ฐ, ํด๋์ค์ ํ๋กํผํฐ์ ๋ฉ์๋์ ๊ฐ๋ ์ ๋ ์ฌ๋ฆฌ๋ฉด ์กฐ๊ธ ์ดํด๊ฐ ์ฌ์ธ ๊ฒ์ด๋ค. ํ๋กํผํฐ๋ ํด๋์ค์ ์์ฑ์ด๋ฉฐ, ๋ฉ์๋๋ ์ด๋ค ๋ช ๋ น์ ํตํด ํด๋์ค์ ๊ฐ์ ์ ๊ทผํ์ฌ ํน์ ์์ ์ ํ ์ ์๋ค.
์บก์ํ๋ฅผ ํตํด ์ธ๋ถ๋ก๋ถํฐ ๋ด๋ถ๋ฅผ ๊ฐ์ธ ์จ๊ธธ ์ ์๋ค๋ ํน์ง์ด ์๋ค. ์ฆ, ์ธ๋ถ์์๋ ๊ฐ์ฒด ๋ด๋ถ์ ๋ณ์์ ์ง์ ์ ๊ทผํ๊ฑฐ๋ ๋ณ๊ฒฝํ ์ ์๋ค. ์ด๋ ๋ฐ์ดํฐ๊ฐ ์๋์น ์๊ฒ ๋ณํ๋ ์๊ธฐ์น ๋ชปํ ์ํฉ์ ์๋ฐฉํด์ค๋ค. ๋ํ, ํ๋์ ๊ฐ์ฒด๊ฐ ๋ค๋ฅธ ๊ฐ์ฒด๋ก๋ถํฐ ๋ ๋ฆฝ์ ์ด์ด์ ์ฝ๋ ์ ์ฒด์ ๋ณต์ก๋๊ฐ ๋ฎ์์ง๋ค. ์ด๊ฒ์ด ์ฅ์ ์ด ๋๋ ์ด์ ๋, ๋ณต์ก์ฑ์ด ์ค๋ฉด ์ฝ๋์ ์ฌ์ฌ์ฉ์ฑ์ ๋์ผ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค.
๋ค์ ์ฝ๋๋ฅผ ๋ณด๋ฉด, ์์์ ์ธ๊ธํ ํน์ง์ด ๋ค ๋ด๊ฒจ ์๋ค.
class Grade {
constructor (score) {
this.score = score;
this.curve = 10
}
getTotal() {
return this.score * this.curve
}
}
const myGrade = new Grade(9);
myGrade.getTotal() // 90
- ์ฐ๊ด์ฑ์ด ๋์ ๊ฐ (score, curve) ๊ณผ ๊ธฐ๋ฅ (getTotal) ๋ผ๋ฆฌ ํ๋์ ์บก์ (Grade) ์์ ๋ด๊ฒจ ์๋ค.
- ์ธ๋ถ์์๋ ๋ด๋ถ์ ๊ฐ์ ์ง์ ์ ๊ทผํ ์ ์๋ค. Grade ์ธ์คํด์ค๋ฅผ ์์ฑํ๊ณ ๋ฉ์๋๋ฅผ ํธ์ถํจ์ผ๋ก์จ ๊ฐ๋ฅํ๋ค.
- ํ๋์ ๊ฐ์ฒด๊ฐ ๋ค๋ฅธ ๊ฒ์ผ๋ก๋ถํฐ ๋ ๋ฆฝ์ ์ด๋ค. Grade ํด๋์ค๋ ๋ค๋ฅธ ํด๋์ค์ ์ ํ ๋ค๋ฅธ ๊ฐ๊ณผ ๋ฉ์๋๋ฅผ ๊ฐ์ง๊ณ ์์ผ๋ฉฐ, ๋ค๋ฅธ ์ธ๋ถ ๊ฐ์ ์์กดํ์ง ์๋๋ค.
๐ Abstraction (์ถ์ํ)
์ถ์ํ๋, ๋ณต์กํ ๊ธฐ๋ฅ์ ๋จ์ํํ์ฌ ํํํ๋ ๊ฒ์ด๋ค. ์ฆ, ๊ฐ์ฒด ์์ ๊ณตํต์ ์ธ ํน์ง์ ์ถ์ถํ์ฌ ํ๋์ ๊ฐ๋ ๋๋ ๊ธฐ๋ฅ์ผ๋ก ์ ์ํจ์ผ๋ก์จ ์ธํฐํ์ด์ค ์ ๊ตฌํ์ ๋ถ๋ฆฌํ๋ ํน์ง์ด๋ค. ์ด๋ฅผ ํตํด ์ธ๋ถ์์๋ ๋ด๋ถ ์ฝ๋์ ์๋ ๋ฐฉ์์ ์ดํดํ์ง ์๊ณ ๋, ๋จ์ํ๊ฒ ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
๊ฐ๋ น, ์์ ์ฝ๋์์ score, curve, getTotal ์ ๋ชจ๋ '์ฑ์ '์ ๊ตฌํ๊ธฐ ์ํด ํ์ํ ๊ฐ๊ณผ ๊ธฐ๋ฅ๋ค์ด๋ค. ๋ฐ๋ผ์ ์ด ๋ชจ๋ ๊ฐ์ด ๋ด๊ธด ๊ฐ์ฒด์ ์ด๋ฆ์ 'Grade' ๋ก ์ ์๋์๋ค. ๋ํ, ์ธ๋ถ์์๋ Grade ๋ด์ getTotal() ๋ฉ์๋๊ฐ ์ด๋ค ๋ฐฉ์์ ํตํด ์ฑ์ ์ ์ฐ์ถํ๋์ง ์ ํ ์์ง ๋ชปํด๋ ์ด๋ฅผ ํธ์ถํ์ฌ ์ฑ์ ์ ๊ตฌํ ์ ์๋ค.
์ถ์ํ์ ์ฅ์ ์ ๊ฐ์ฒด ๋ด๋ถ์ ๋ณํ๊ฐ ์ธ๋ถ์ ๋ฏธ์น๋ ์ํฅ๋ ฅ์ ์ค์ผ ์ ์๋ค๋ ๊ฒ์ด๋ค. ์ธ๋ถ์ ๊ตฌํ๋ ์ธํฐํ์ด์ค๋ ๊ทธ๋๋ก ์ ์ง๋๋ค๋ฉด, ๋ด๋ถ์ ๋ก์ง์ด๋ ๊ฐ์ด ์ด๋ป๊ฒ ๋ฐ๋๋ ์ด๋ฅผ ํ์ฉํ์ฌ ์ฐ๋ ์ฌ์ฉ์ (ํ๋ก๊ทธ๋๋จธ) ๋ ๊ธฐ์กด ๋ช ์นญ์ ๊ทธ๋๋ก ํ์ฉํ์ฌ ๊ฐ์ ์ฐ์ถํ ์ ์๋ค.
๐ Inheritance (์์)
์์์ ์ด๋ฏธ ๋ง๋ค์ด๋์ ๊ฐ์ฒด์ ํน์ง์ ์๋ก์ด ๊ฐ์ฒด๊ฐ ์ด์ด๋ฐ์ ์ฌ์ฉํ ์ ์๋๋ก ํ๋ ๊ฒ์ด๋ค. ์์ ๊ฐ์ฒด๋ฅผ ์์๋ฐ์ ํ์๊ฐ์ฒด๋ ์์ ๊ฐ์ฒด์ ํน์ง์ ๊ทธ๋๋ก ์ฌ์ฉํ๋ฉด์๋, ๋ณธ์ธ๋ง์ ์๋ก์ด ๊ธฐ๋ฅ์ ์ถ๊ฐํ์ฌ ์์ ๋กญ๊ฒ ์ฌ์ฉํ ์ ์๋ค.
์์ Grade ๋ฅผ ์์๋ฐ์ ์์ ๋ง์ ๊ธฐ๋ฅ์ ์ถ๊ฐํ letterGrade ํด๋์ค ์์ ๋ฅผ ๋ณด๋ฉด ์ด๋ฅผ ํ์ธํ ์ ์๋ค.
class letterGrade extends Grade {
getLetter () {
return (this.score >= 60 ? 'P' : 'F')
}
}
const hisGrade = new letterGrade(5);
console.log(hisGrade); // {score: 5, curve:10}
hisGrade.getLetter(); // 'F'
์์์ ๊ฐ์ฅ ํฐ ์ฅ์ ์ ์ค๋ณต๋๋ ์ฝ๋๋ฅผ ์ค์ด๊ฒ ํด ์ค๋ค๋ ๊ฒ์ด๋ค. ์ฝ๊ฐ์ ์ฐจ์ด๋ง ์กด์ฌํ๋ ๋ ๊ฐ์ ๊ธฐ๋ฅ์ ๋ง๋ค๊ธฐ ์ํด ์ค๋ณต ๋ด์ฉ์ ์ผ์ผ์ด ์ด๊ฑฐํ ํ์ ์์ด, ํ๋์ ๊ฐ์ฒด๋ฅผ ๋ง๋ ๋ค ๋ค๋ฅธ ๊ฐ์ฒด์ ์์ํ๋ฉด ๋๊ธฐ ๋๋ฌธ์ด๋ค.
๐ Polymorphism (๋คํ์ฑ)
๋คํ์ฑ์ ์ฌ๋ฌ ๊ฐ์ ๊ฐ์ฒด๊ฐ ๊ฐ์ ์ฑ์ง์ ์์๋ฐ์๋, ๊ฒฐ๊ณผ๋ ๋ค์ํ๊ฒ ํํ๋๋ ๊ฒ์ ์๋ฏธํ๋ค. ์์ ์ดํ ๊ธฐ์กด์ ๊ธฐ๋ฅ๋ช ์ ํ์ฉํ ์๋ก์ด ๋ก์ง์ ์ง๊ฑฐ๋, ์๋ก์ด ๊ฐ์ ๋ถ์ฌํจ์ผ๋ก์จ ๋ฌ์ฑํ ์ ์๋ ํน์ง์ด๋ค.
โจ ํจ์ํ ํ๋ก๊ทธ๋๋ฐ
ํจ์๋ ์ฃผ์ด์ง ๋ฐ์ดํฐ๋ฅผ ๋ฐ์ ๊ฒฐ๊ณผ๋ฌผ์ ๋์ค๋๋ก ํ๋ ์ผ์ข ์ ํ์ดํ๋ผ์ธ์ด๋ค. ๋๋ถ๋ถ์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ค์ ํจ์๋ฅผ ์ง์ํ๋๋ฐ, ๋จ์ํ ๋ชจ๋ ์ฝ๋๋ฅผ ํจ์๋ก ์์ฑํ๋ค๊ณ ํ์ฌ "ํจ์ํ ํ๋ก๊ทธ๋๋ฐ"์ ๊ตฌํํ ๊ฒ์ ์๋๋ค. ํจ์ํ ํ๋ก๊ทธ๋๋ฐ์๋ ์ฌ๋ฌ ๋ณต์กํ ๊ท์น๊ณผ ๊ฐ๋ ์ด ํฌํจ๋๋๋ฐ, ์ด ๊ธ์์๋ ๊ธฐ๋ณธ์ ์ธ ํน์ง๋ง ๋ค๋ฃฌ๋ค.
๐ ์์ํจ์ ์ฌ์ฉ
์์ํจ์๋ ํจ์์์ ์ธ๋ถ ์ํ๊ฐ์ ์ฐธ์กฐํ๊ฑฐ๋ ์ธ๋ถ ์ํ๋ฅผ ๋ณ๊ฒฝํ์ง ์๋ ํจ์์ด๋ค. ๋ํ, ๋์ผํ ์ธ์๋ฅผ ๋ฃ์ ๋ ๋์ผํ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ ํจ์์ด๋ค. ์์ํจ์๋ ์ธ๋ถ์ ์ ํ ์ํฅ์ ๋ฐ์ง ์์ผ๋ฉฐ, ์ค์ง ์ฃผ์ด์ง๋ ์ธ์๋ง์ผ๋ก ์์ ํ๋ค.
// NOT pure function
let a = 1;
function add (num) {
return num + a;
}
// pure function
function add (num1, num2) {
return num1 + num2;
}
๐ ๋น์ํ์ฑ, ๋ถ๋ณ์ฑ
ํจ์ํ ํ๋ก๊ทธ๋๋ฐ์์์ ํจ์๋ ์์ํจ์์ด๊ธฐ ๋๋ฌธ์, ์ธ์๋ก ์ ๋ฌ๋ ๋ฐ์ดํฐ๋ฅผ ๋ณ๊ฒฝํ์ง ์์์ผ๋ก์จ, side effect ๋ฅผ ๋ฐฉ์งํ๋ค. ์ธ์๋ฅผ ์ง์ ์กฐ์ํ๊ธฐ๋ณด๋ค ์๋ก์ด ๊ฐ์ฒด๋ฅผ ๋ง๋ค๊ฑฐ๋ ์๋ก์ด ๋ณ์๋ฅผ ๋ง๋ค์ด ๋ฐํํ๋ค.
Side effect ๋ ํจ์ ํธ์ถ์์ ๋ฐ์ํ๋ ์๊ธฐ์น ๋ชปํ ๋ณ์ ๊ฐ์ ๋ณ๊ฒฝ, ๊ฐ์ฒด๋ ์๋ฃ ์์กฐ์ ๊ฐ ์์ , ์ค๋ฅ ๋ฐ์, I/O ์์ ๋ฑ์ ๋ชจ๋ ํฌํจํ๋ค.
// NOT functional programming
function (obj) {
obj.Name = 'Function'
return obj
}
// functional programming
function (obj) {
return { ...obj, Name: 'Function'}
}
๐ ์ผ๊ธ๊ฐ์ฒด, ๊ณ ์ฐจํจ์ ์ฌ์ฉ
์ผ๊ธ๊ฐ์ฒด๋ ๋ค์์ ํน์ฑ์ ์ง๋ ๊ฐ์ฒด์ด๋ค.
- ๋ณ์๋ ๋ฐ์ดํฐ ๊ตฌ์กฐ ์์ ๋ด์ ์ ์์
- Parameter ๋ก ์ ๋ฌ ๊ฐ๋ฅ
- ๋ฐํ๊ฐ (return) ์ผ๋ก ์ฌ์ฉ ๊ฐ๋ฅ
JS ์ ํจ์๋ ์์ ํน์ง์ ๋ชจ๋ ๊ฐ์ง๊ณ ์๊ธฐ ๋๋ฌธ์, ์ผ๊ธ ๊ฐ์ฒด์ด๋ค. ๋ฐ๋ผ์ ํจ์๋ฅผ ํ๋ผ๋ฏธํฐ๋ก ๋๊ธฐ๊ฑฐ๋ ๋ฐํํ๋ ๊ณ ์ฐจํจ์๋ฅผ ์์ฃผ ํ์ฉํ๊ฒ ๋๋ค.
const calc = (num1, num2, op) => op(num1, num2);
const add = (num1, num2) => num1 + num2;
const multiply = (num1, num2) => num1 * num2;
const power = (num1, num2) => Math.pow(num2, num1);
calc(2, 3, add) // 5
calc(2, 3, multiply) // 6
calc(2, 3, power) // 9
โจ ๋ฐฐ์ด ์
- ๋์ธ๊ฐ OOP ์์ ํจ์ํ ํ๋ก๊ทธ๋๋ฐ์ผ๋ก ์ด๋ํ๊ณ ์๋ค๊ณ ํ๋๋ฐ ์์ง ์ ์ฐจ์งํฅ๊ณผ OOP ์ ์ต์ํ ๋๋ก์จ๋ ํจ์ํ์ ๊ตฌ์ฒด์ ์ธ ๊ฐ๋ ๋ค์ด ์์ง ์๋ฟ์ง ์๋๋ค. (ํนํ ๋ชจ๋๋..) ๊ณ ์ฐจํจ์์ ์ผ๊ธ๊ฐ์ฒด์ ๋ํ ๊ธฐ๋ณธ๊ธฐ๋ฅผ ์กฐ๊ธ ๋ ๋ค์ง ๋ค์, ํจ์ํ ํ๋ก๊ทธ๋๋ฐ ๊ด๋ จ ๊ตฌ์ฒด์ ์ธ ํน์ง๋ค์ ์์ฉํด๋ณด์์ผ ํ๊ฒ ๋ค๋ ์๊ฐ์ด ๋ ๋ค.
โจ์ฐธ๊ณ ์๋ฃ
'๐ป DEV > Computer Science' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
How is code allocated in memory? (1) | 2023.06.05 |
---|---|
[CS] REST API ๊ฐ์ (0) | 2021.11.04 |
[CS] ํ๋ก์ธ์ค(Process)์ ์ค๋ ๋(Thread) (0) | 2021.05.27 |
[CS] ์ปดํ์ผ๋ฌ(Compiler)์ ์ธํฐํ๋ฆฌํฐ(Interpreter) (0) | 2021.05.27 |
[CS] ๋ผ์ด๋ธ๋ฌ๋ฆฌ & ํ๋ ์์ํฌ (0) | 2021.05.13 |
๋๊ธ