2024-03-04.md
๐กDIL: ๋ชจ๋ ๋ฆฌ์กํธ ๋ฅ ๋ค์ด๋ธ, 1์ฃผ์ฐจ-1
์คํฐ๋: ์๊ฐ CS, https://github.com/monthly-cs/2024-03-modern-react-deep-dive
์ค๋ ์งํ: ๊ฐ์ธ๊ณต๋ถ
DIL-week1-1_2024-03-04
| DIL ์ฃผ์ฐจ | ๋ฒ์ | ๋ด์ฉ | ์ค๋์ฐจ ์ง๋ | | -------- | ------ | ------------------------------ | ----------- | | 1์ฃผ์ฐจ | 1, 2์ฅ | ๋ฆฌ์กํธ ํต์ฌ์์์ ์๋ฐ์คํฌ๋ฆฝํธ | 26p์ค~59p |
์ค๋ ์ฝ์ ๋ด์ฉ์ markdown์ผ๋ก ๊ฐ๋จํ ๋ฉ๋ชจ
์ฝ์ ์๊ฐ: 9์๋ฐ~12์ ๋น ๋ฅด๊ฒ ์ฝ๊ธฐ~!
๊ฐ์ฒด
- ๊ฐ์ฒด๋? ์ฐธ์กฐ ํ์ ์ด๋ค~ reference type์ด๋ค~
- ๊ฐ์ฒด๋? ๋ณ๊ฒฝ ๊ฐ๋ฅํ๋ค~ writable์ด๋ค~
- ๊ฐ์ฒด๋? ๋ณต์ฌํ ๋ ์ฐธ์กฐ๋ฅผ ์ ๋ฌํ๋ค~ !==~
Object.is
- [ES6(ES2015)] ์๋ ๊ฐ์ฒด ๋น๊ต๋ !==
Object.is({},{}) // false
๋ฆฌ์กํธ์ ๋๋ฑ ๋น๊ต๋ Object.is๋ค?!?
- objectIs: ES6 ํด๋ฆฌํ
function is(x: any, y: any) {
return (
(x === y && (x !== 0 || 1 / x === 1 / y)) || (x !== x && y !== y) // eslint-disable-line no-self-compare
);
}
const objectIs: (x: any, y: any) => boolean =
typeof Object.is === "function" ? Object.is : is;
export default objectIs;
- shallowEqual: ๊ฐ์ฒด ๊ฐ ๋น๊ต(Object.is + ๋ฐฐ์ด ๊ธธ์ด + ํค ๋น๊ต + ๊ฐ ๋น๊ต)
- Object.is์ ๋ฌ๋ฆฌ => React์ shallowEqual์ ์ฐธ์กฐ๊ฐ ๋ค๋ฅธ ๊ฐ์ฒด๋ 1 depth๊น์ง๋ ๋น๊ต๊ฐ ๊ฐ๋ฅํ๋ค~
export default function shallowEqual(objA: mixed, objB: mixed): boolean {
if (is(objA, objB)) return true;
if (
typeof objA !== "object" ||
objA === null ||
typeof objB !== "object" ||
objB === null
)
return false;
const keysA = Object.keys(objA); // ํค
const keysB = Object.keys(objB);
if (keysA.length !== keysB.length) return false; // ๋ฐฐ์ด ๊ธธ์ด ๋น๊ต
for (let i = 0; i < keysA.length; i++) {
const currentKey = keyA[i];
if (
!hasOwnProperty.call(objB, currentKey) ||
!is(objA[currentKey], objB[currentKey])
)
return false;
}
return true;
}
- JSX props๋ ๊ฐ์ฒด๋ค~ ์์ ๋น๊ต๋ฅผ ํ๋ค~
- ์ฆ, props์ ๋ ๋ค๋ฅธ ๊ฐ์ฒด๋ฅผ ๋๊ฒจ์ค๋ค๋ฉด~? ์์์น ๋ชปํ๊ฒ ์๋ํ ์ ์๋ค~~
- ์๋ฐ์คํฌ๋ฆฝํธ์ ํน์ง => ๊ฐ์ฒด ๋น๊ต์ ๋ถ์์ ์ฑ, ์์ ๋น๊ต๋ง ์ฌ์ฉํด์ ํ์ํ ๊ธฐ๋ฅ์ ๊ตฌํํ๊ณ ์๋ค.
ํจ์
- ํจ์๋?
- ์์ ์ ์ํํ๊ฑฐ๋, ๊ฐ์ ๊ณ์ฐํ๋ ๋ฑ์ ๊ณผ์ ์ => ํ๋์ ๋ธ๋ก์ผ๋ก ๊ฐ์ธ์ ์คํ ๋จ์๋ก ๋ง๋ ๊ฒ
- ํจ์ ์ ์ธ๋ฌธ์? ๋ฌธ statement์ด๋ค~ ๊ทธ๋ฐ๋ฐ?? ์ฝ๋ ๋ฌธ๋งฅ์ ๋ฐ๋ผ ํํ์์ผ๋ก๋ ์ฌ์ฉ๋ ์ ์๋ค~ (JS ์์ง์ ๋ชป ๋ง๋ ค~)
const sum = function sum(a, b) {
return a + b;
};
sum(10, 24); // 34
- ํจ์ ํํ์์? ๋ณ์์ ํ ๋น, ํจ์๋ช ์ ์ฃผ๋ก ์๋ต
- ์ผ๊ธ ๊ฐ์ฒด: ๋งค๊ฐ๋ณ์, ๋ฐํ๊ฐ, ํ ๋น ๋ค ๊ฐ๋ฅ
- Function ์์ฑ์๋? ํจ์ ๋ชธํต์ด ๋ฌธ์์ด, ํด๋ก์ ์์ฑ๋์ง ์์
- ํ์ดํ ํจ์๋? ์์ฑ์ ํจ์๋ก x, arguments ์์
- this๋? ์์ ์ด ์ํ ๊ฐ์ฒด๋, ์์ ์ด ์์ฑํ ์ธ์คํด์ค๋ฅผ ๊ฐ๋ฆฌํค๋ ๊ฐ
- ํ์ดํ ํจ์์ this๋? ์์ ์ค์ฝํ this~ => ๋ณ๋์ ์์ ์์ด ์์ this์ ์ ๊ทผ
IIFE, Immediately Invoked Function Expression
- ๊ธ๋ก๋ฒ ์ค์ฝํ๋ฅผ ์ค์ผ์ํค์ง ์๋ ๋ ๋ฆฝ์ ์ธ ํจ์ ์ค์ฝํ๋ฅผ ์ด์ฉ
- ์บก์~
Higher Order Function / Higher Order Component
- ๊ณ ์ฐจ ํจ์~ ์ผ๊ธ ๊ฐ์ฒด~ ๊ณ ์ฐจ ์ปดํฌ๋ํธ~
์์ ํจ์ Pure Component
- ๋ถ์ ํจ๊ณผ side-effect ๊ฐ ์๋ ํจ์
- useEffect๋ฅผ ์ค์ด์ ์ง์ง๋ก
ํจ์๋ฅผ ์๊ฒ ๋ง๋ค์ด๋ผ
- max-lines-per-function, 50์ค~
- Malcolm Douglas McIlroy => Do One Thing and Do It Well. ํจ์๋ ํ๋์ ์ผ์, ๊ทธ ํ๋๋ง ์ ํ๋ฉด ๋๋ค.
ํด๋์ค
- React 16.8 ์ด์ ์๋? ํด๋์ค ์ปดํฌ๋ํธ
- [ES2019] #์ผ๋ก private
- Typescript: private, protected, public
- ์ธ์คํด์ค ๋ฉ์๋ == ํ๋กํ ํ์ ๋ฉ์๋
const myCar = new Car("์ฐจ์ฐจ์ฐจ");
Object.getPrototypeOf(myCar) === Car.prototype; // true
myCar.__proto__ === Car.prototype; // true
- ๐
__proto__
๋ฅผ ์ฐ๋ฉด ์๋๋ค => ์๋?typeof null === 'object'
์ฒ๋ผ, ์๋๋ ํ์ค์ ์๋์ง๋ง ๊ณผ๊ฑฐ ๋ธ๋ผ์ฐ์ ์ ํธํ์ฑ์ ์งํค๊ธฐ ์ํด์๋ง ์กด์ฌํ๋ ๊ธฐ๋ฅ์ด๊ธฐ ๋๋ฌธ์ - =>
Object.getPrototypeOf
๋ฅผ ์ฐ์ - prototype chaining ์์ =>
Object
์toString()
ํด๋์ค์ ํจ์
- ES6 ์ด์ ์๋ ํ๋กํ ํ์ ์ผ๋ก ํด๋์ค ์๋ ๋ฐฉ์์ ๊ตฌํํ์
- ๋ฐ๋ฒจ ํธ๋์คํ์ผ๋ง: _createClass ๋ผ๋ ํฌํผ ํจ์๋ฅผ ๋ง๋ค์ด => ํด๋์ค์ ๋์ผํ ๋ฐฉ์์ผ๋ก ๋์ํ๋๋ก ํจ
- prototype ๊ธฐ๋ฐ, ์์ฑ์ ํจ์๋ก ์ ์ฌํ๊ฒ ์ฌํ / ํด๋์ค๋ syntactic sugar
์์ด
Strict Equality Operator, ๋๋ฑ ์ฐ์ฐ์ / Equality Operator, ์ผ์น ์ฐ์ฐ์