[ํ๋ก๊ทธ๋๋ฐ ํจ๋ฌ๋ค์] OOP์ FP
OOP๋?
OOP๋ Object Oriented Programming์ ์ฝ์๋ก ๊ฐ์ฒด ์งํฅ ํ๋ก๊ทธ๋๋ฐ์ ๋ปํฉ๋๋ค.
class์ object์ ๊ธฐ๋ฐํ ํ๋ก๊ทธ๋๋ฐ ํจ๋ฌ๋ค์(๋์์ธ ํจํด)์ผ๋ก, ๊ด๋ จ๋ ๋ฐ์ดํฐ๋ผ๋ฆฌ ๋ฌถ์ด์ class๋ฅผ ํ์ฑํ๊ณ ๊ทธ ์์์ object instance๋ฅผ ๋ง๋ค์ด ํ๋ก๊ทธ๋จ์ ๋์์ธ ํฉ๋๋ค. ๋ํ์ ์ผ๋ก ์๋ฐ๊ฐ ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ๋๋ค.
- ๊ฐ์ฒด๋ค์ ์งํฉ์ผ๋ก ํ๋ก๊ทธ๋จ์ ์ํธ ์์ฉ์ ํํ
- ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฒด๋ก ์ทจ๊ธํ์ฌ ๊ฐ์ฒด ๋ด๋ถ์ ์ ์ธ๋ ๋ฉ์๋๋ฅผ ํ์ฉํ๋ ๋ฐฉ์
OOP์ ์ฅ์
- ์ฝ๋์ ์ฌ์ฌ์ฉ๋ฅ ์ ๋์ด๊ณ ์ฝ๋๋ฅผ ๊ฐ๊ฒฐํ๊ฒ ํจ์ผ๋ก์จ ์ ์ง๋ณด์๊ฐ ์ฌ์
- ๋ฐ์ดํฐ๋ฅผ ์์ ํ๊ฒ ๋ณด์กด์ํฌ ์ ์์(์บก์ํ)
OOP์ ํน์ง 4๊ฐ์ง
์บก์ํ(Encapsulation)
์บก์ํ๋ ๊ฐ์ฒด์ ๋ด๋ถ ๋ก์ง์ ๊ฐ์ถ๊ณ ์ธ๋ถ์๋ ์๋์ ์ผ๋ก ์์ ์ ์ธ ๋ถ๋ถ๋ง ๊ณต๊ฐํจ์ผ๋ก์จ ๋ฐ์ดํฐ๋ฅผ ์์ ํ๊ฒ ๋ณด์กดํ๋ ๊ธฐ๋ฒ์ ๋๋ค. ์ธ๋ถ์ ์ํฅ์ ์ฃผ์ง ์๊ณ ๊ฐ์ฒด ๋ด๋ถ์ ๊ตฌํ์ ๋ณ๊ฒฝํ ์ ์๊ธฐ ๋๋ฌธ์ ๋ด๋ถ ๋ก์ง์ ๋ํ ์ ์ฐํจ์ ์ ๊ณตํฉ๋๋ค.
- ๊ฐ์ฒด์ ์์ฑ๊ณผ ๋ฉ์๋๋ฅผ ํ๋๋ก ๋ฌถ๊ณ ์ผ๋ถ๋ฅผ ์ธ๋ถ์ ๊ฐ์ถ์ด ์๋
- Implementation : ์จ๊ธธ ๋ถ๋ถ
- Interface : ๊ณต๊ฐํ ๋ถ๋ถ
- ์บก์ํ๋ ๊ฐ์ฒด์ ๋์ ๊ตฌํ์ ์ค์ ์ ๋
์ถ์ํ(Abstraction)
์ถ์ํ๋ ๊ณตํต์ ์ ์ฐพ์ Class๋ก ํ๋ฒ์ ๋ฌถ๊ณ ๋ณต์กํ ๋ํ ์ผ์ ์จ๊ธฐ๊ณ ํต์ฌ๋ง ์ถ์ถํด๋๊ฐ๋ ํํ์ ๋๋ค.
๊ตฌํ ์ธ๋ถ์ฌํญ ๋์ ํฐ ๋ฒ์์ ๊ณตํต๋ ๊ธฐ๋ฅ ์ธก๋ฉด์์ ํด๋์ค๋ฅผ ๊ฐ๋ฐํ๋ ๊ฒ์ ๋๋ค.
- ๋ณต์กํ ์์คํ ์ผ๋ก๋ถํฐ ํต์ฌ์ ์ธ ๊ฐ๋ ๋๋ ๊ธฐ๋ฅ์ ๊ฐ์ถ๋ ค๋ด๋ ๊ฒ
- ์ถ์ํ๋ ๊ฐ์ฒด์ ๋์, ๊ธฐ๋ฅ ์์ฒด์๋ง ์ค์ ์ ๋
- ์บก์ํ์ ์ถ์ํ๋ ์ํธ ๋ณด์์
์์์ฑ(Inheritence)
์์์ ํ๋กํ ํ์ ์ ๊ธฐ๋ฐ์ผ๋ก ๋ถ๋ชจ ํด๋์ค๋ถํฐ ํ์ ํด๋์ค๋ ์์์ ๋ฐ์ ์ ์์ต๋๋ค.
์์ ํด๋์ค์ ๋ชจ๋ ๊ฒ์ ํ์ ํด๋์ค๊ฐ ๋ชจ๋ ์ด์ด๋ฐ์ ๋ถ๋ชจํด๋์ค์ ํน์ง์ ์์ํด๋์ค์๊ฒ ๋ชจ๋ ๋ฌผ๋ ค์ฃผ๋ ํ์์ ๋๋ค.
- ์์ ํด๋์ค์ ํน์ฑ์ ํ์ ํด๋์ค๊ฐ ์ด์ด๋ฐ์์ ์ฌ์ฌ์ฉ, ์ถ๊ฐ, ํ์ฅ
- ์ฝ๋์ ์ฌ์ฌ์ฉ ์ธก๋ฉด, ๊ณ์ธต์ ์ธ ๊ด๊ณ ์์ฑ, ์ ์ง ๋ณด์์ฑ ์ธก๋ฉด์์ ์ค์
๋คํ์ฑ(Polymorphism)
๊ฐ์ ์ด๋ฆ์ ๊ฐ์ง ๋ฉ์๋๋ผ๋ ๊ฐ ํ์ ํด๋์ค์ ์ํฉ์ ๋ง๊ฒ ๋ค๋ฅด๊ฒ ๊ตฌํ๋ ์ ์๊ฒ ํ๋ ๊ฒ์ ๋๋ค.
์ฆ, ํ๋์ ๋ณ์๋ช , ํจ์๋ช ๋ฑ์ด ์ํฉ์ ๋ฐ๋ผ ๋ค๋ฅธ ์๋ฏธ๋ก ํด์๋ ์ ์์ต๋๋ค.
์ค๋ฒ๋ก๋ฉ๊ณผ ์ค๋ฒ๋ผ์ด๋ฉ์ด ๋คํ์ฑ์์ ์ค์ํ ๊ฐ๋ ์ ๋๋ค.
- ์ค๋ฒ๋ผ์ด๋ฉ
- ์์ ํด๋์ค์ ๋ฉ์๋์ ๊ฐ์ ์ด๋ฆ, ๋งค๊ฐ๋ณ์๋ฅผ ์ฌ์ ์ ํจ
- Runtime์ ์ด๋ฃจ์ด์ง๋ ๋์ ๋คํ์ฑ
- ์ค๋ฒ๋ก๋ฉ
- ๊ฐ์ ์ด๋ฆ์ ํจ์๋ฅผ ์ฌ๋ฌ๊ฐ ์ ์ํ๊ณ , ํ๋ผ๋ฏธํฐ์ ํ์ ๊ณผ ๊ฐ์๋ฅผ ๋ค๋ฅด๊ฒ ํ์ฌ ํ๋ผ๋ฏธํฐ์ ๋ฐ๋ผ ๋ค๋ฅด๊ฒ ํธ์ถ๋จ
- Compile time์ ์ด๋ฃจ์ด์ง๋ ์ ์ ๋คํ์ฑ
FP๋?
FP๋ Functional Programming์ ์ฝ์๋ก ํจ์ํ ํ๋ก๊ทธ๋๋ฐ์ ๋ปํฉ๋๋ค.
Side effect(๋ถ์์ฉ)์ด ์๋ Pure function(์์ ํจ์)๋ฅผ ๊ตฌํํจ์ผ๋ก์จ ํ๋ก๊ทธ๋จ์ ๋์์ธํฉ๋๋ค.
์ฌ๋ฌ๊ฐ์ ์์ function์ ์ฎ์ด ํ๋์ ํฐ function์ ๊ตฌํํ๊ณ ๋ถ๋ณ์ฑ์ ์งํค๊ฒ ๋ฉ๋๋ค.
๋ํ์ ์ผ๋ก ์ต๊ทผ ํ๋ก ํธ ๊ฐ๋ฐ์์ ์ฃผ๋ก ์ฌ์ฉ๋๋ ๋ฉํฐ ํจ๋ฌ๋ค์์ธ Javascript์ธ์ด์ ๊ฒฝ์ฐ OOP๋ก ์์๋์์ง๋ง, ๋ฆฌ์กํธ์ hooks๊ฐ ๋์ ๋๊ณ ๋ํ FP๋ก ์ฃผ๋ก ๊ฐ๋ฐ์ ์งํํฉ๋๋ค.
FP์ ์ฅ์
- ๋์ ์์ค์ ์ถ์ํ๋ฅผ ์ ๊ณต
- ํจ์ ๋จ์์ ์ฝ๋ ์ฌ์ฌ์ฉ์ฑ ์ฆ๊ฐ
- ๋๋ฒ๊น ์ด ์ฌ์
- ๋ถ๋ณ์ฑ์ ์งํฅํ๊ธฐ ๋๋ฌธ์ ํ๋ก๊ทธ๋จ์ ๋์์ ์์ธกํ๊ธฐ ์ฌ์
FP์ ํน์ง
1๊ธ ๊ฐ์ฒด(Fist Object, 1๊ธ ์๋ฏผ)
์ปดํจํฐ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์ ์ผ๋ฐ์ ์ผ๋ก ๋ค๋ฅธ ๊ฐ์ฒด๋ค์ ์ ์ฉ ๊ฐ๋ฅํ ์ฐ์ฐ์ ๋ชจ๋ ์ง์ํ๋ ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฅดํต๋๋ค.
- ๋ณ์๋ ๋ฐ์ดํฐ ๊ตฌ์กฐ์์ ๋ด์ ์ ์์
- ํ๋ผ๋ฏธํฐ๋ก ์ ๋ฌ ํ ์ ์์
- ๋ฐํ๊ฐ์ผ๋ก ์ฌ์ฉํ ์ ์์
- ํ ๋น์ ์ฌ์ฉ๋ ์ด๋ฆ๊ณผ ๊ด๊ณ์์ด ๊ณ ์ ํ ๊ตฌ๋ณ์ด ๊ฐ๋ฅํจ
- ๋์ ์ผ๋ก ํ๋กํฐ๋ ํ ๋น์ด ๊ฐ๋ฅํจ
๊ณ ์ฐจ ํจ์(Higher Order Function)
ํจ์ํ ํ๋ก๊ทธ๋๋ฐ์์๋ ์ฌ๋ฌ ์์ ์์ ํจ์๋ค์ ์ฐ์์ ํน์ ๋ณ๋ ฌ์ ์ผ๋ก ํธ์ถํด ๋ ํฐ ํจ์๋ฅผ ๋ง๋ค์ด๊ฐ๋๋ค.
์ด๋ ๊ฒ ํจ์๋ฅผ ์ฎ๊ธฐ ์ํด HOC(๊ณ ์ฐจ ์ปดํฌ๋ํธ)๋ฅผ ํ์ฉํ๊ฒ ๋ฉ๋๋ค.
- ํจ์์ ํ๋ผ๋ฏธํฐ๋ก ํจ์๋ฅผ ์ ๋ฌํ ์ ์์
- ํจ์์ ๋ฐํ๊ฐ์ผ๋ก ํจ์๋ฅผ ์ฌ์ฉํ ์ ์์
์ฝ๊ฒ ๋งํด, ํจ์๋ฅผ ๋ค๋ฃจ๋ ํจ์๋ก Javascript์์๋ map, filter, reduce์ ๊ฐ์ ๊ณ ์ฐจ ํจ์๋ฅผ ์ด์ฉํด ๋น๋ฒํ for๊ณผ while์ ์ฌ์ฉ์ ์ค์ผ ์ ์์ต๋๋ค.
// map
const arr = [1, 2, 3, 4, 5];
const result = arr.map((n) => n * 2);
console.log(result); // [ 2, 4, 6, 8, 10 ]
//filter - ์กฐ๊ฑด์ ๋ง๋ ๊ฐ์ returnํ๋ค.
const arr = [1, 2, 3, 4, 5];
const result = arr.filter((n) => n > 2);
console.log(result); // [ 3, 4, 5 ]
//reduce - ๊ฐ๋จํ๊ฒ ๋ฐฐ์ด์ ์๋ ๋ชจ๋ ๊ฐ์ ๋ ํ ์ ์๋ค.
const arr = [1, 2, 3, 4, 5];
const result = arr.reduce((prev, curr) => (prev += curr), 0);
console.log(result); // 15
๋ถ๋ณ์ฑ(Immutablility)
๊ฐ์ด ๋ณ๊ฒฝ๋์ง ์๋๋ค๋ ์๋ฏธ์ ๋๋ค.
๋ฐ์ดํฐ ๋ณ๊ฒฝ์ด ํ์ํ ๊ฒฝ์ฐ, ์๋ณธ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ๋ณ๊ฒฝํ์ง ์๊ณ ๋ ๊ทธ ๋ฐ์ดํฐ๋ฅผ ๋ณต์ฌ๋ณธ์ ๋ง๋ค์ด ๊ทธ ์ผ๋ถ๋ง ๋ณ๊ฒฝํ๊ณ , ๋ณ๊ฒฝํ ๋ณต์ฌ๋ณธ์ ์ฌ์ฉํด ์์ ์ ์งํํฉ๋๋ค.
์์ ํจ์(Pure function)
- ์์ํจ์๋ ๊ฐ์ ์ ๋ ฅ์ ๋ํด ํญ์ ๊ฐ์ ๊ฐ์ ์ถ๋ ฅํจ
- ์์ํจ์๋ ๋ถ์ ํจ๊ณผ(Side-effect)๊ฐ ์์
- ํจ์ ์ธ๋ถ์ ์ํฅ์ ๋ฐ์ง ์์
https://limkydev.tistory.com/30
https://velog.io/@suyeonme/JavascriptOOP
https://koras02.tistory.com/172
https://www.learningman.co/oopfp/