TypeScript Course
Search

TypeScript ๊ธฐ์ด
TypeScript Tutorials
[TypeScript] 0. TypeScript ๋ค์ด๊ฐ๊ธฐ

0. IDE
ํตํฉ ๊ฐ๋ฐ ํ๊ฒฝ(IDE)์ด๋?
โข
IDE(Integrated Development Environment)๋ ํ๋ก๊ทธ๋๋จธ๊ฐ ์ํํธ์จ์ด๋ฅผ ๊ฐ๋ฐ ํ ๋ ์ฌ์ฉํ๋ ์ํํธ์จ์ด ์ ํ๋ฆฌ์ผ์ด์
โข
์ฝ๋ฉ, ๋๋ฒ๊ทธ, ์ปดํ์ผ, ๋ฐฐํฌ ๋ฑ ํ๋ก๊ทธ๋จ ๊ฐ๋ฐ์ ๊ด๋ จ๋ ๋ชจ๋ ์์
์ ํ๋์ ํ๋ก๊ทธ๋จ ์์์ ์ฒ๋ฆฌํ๋ ํ๊ฒฝ
์ด๋ค IDE๋ฅผ ์ฌ์ฉํด์ผ ํ๋๊ฐ?

โข
2024 IDE ์ฌ์ฉ๋ฅ ํต๊ณ๋ก ์ดํด๋ณด๋ ํํฉ
โข
๊ฐ๋ฐ ์ธ์ด์ ๋ฐ๋ผ ํนํ๋ ํด์ด ์๊ธฐ๋ ํ๋ฉฐ, ์ต๊ทผ์๋ ์ ๋ฐ์ ์ผ๋ก ๊ธฐ๋ฅ์ ์ ๊ณตํ๊ธฐ ์ํ ํ๋ฌ๊ทธ์ธ๋ ๊ฐ๋ฐ๋๋ฉฐ ์ ์ ๊ฐ์ฑ์ผ๋ก ๋ณํ๊ณ ์์
โข
๊ทธ ๊ฒฝ๊ณ๊ฐ ํ๋ฆฟํ ๋งํผ ์ ๋ฃ์ธ ๊ฒ๊ณผ ๋ฌด๋ฃ์ธ ๊ฒ์์ ์ฌ์ฉ๋ฅ ์ ํฐ ์ฐจ์ด๊ฐ ์์ ์ ์์
[TypeScript] 1. ๊ฐ๋ฐ ํ๊ฒฝ ๊ตฌ์ถ๊ณผ VCS

1. TypeScript๋?

TypeScript?
โข
TypeScript๋ ํ์
๊ตฌ๋ฌธ์ด ์๋ JavaScript์ด๋ค.
โฆ
TypeScript๋ JavaScript ๊ธฐ๋ฐ์ ๊ฐ๋ ฅํ ํ์
ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ก ์ด๋ค ๊ท๋ชจ์์๋ ๋ ๋์ ๋๊ตฌ๋ฅผ ์ ๊ณตํ๋ค.
์ ์ VS ๋์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด(ํ ๊ธ)
โข
TypeScript๋ JavaScript์ ์์ ์งํฉ์ด๋ค.

ES(ECMAScript)6 ์ดํ, ๋ชจ๋ ์๋ฐ์คํฌ๋ฆฝํธ๋ผ๊ณ ๋ถ๋ฆ
โฆ
TypeScript๋ ์ถ๊ฐ์ ์ธ ๊ตฌ๋ฌธ์ JavaScript์ ์๋ํฐ์ ๊ธด๋ฐํ ์ฐ๊ฒฐ ๋๋ ๊ธฐ๋ฅ์ย ์ ๊ณต ํจ. ์๋ํฐ์์ ์ผ์ฐ ์ค๋ฅ๋ฅผ ์ก์ ์ ์์
โช
๊ฐ๋ฐ์๋ ๊ฐ๋ฐ ๋จ๊ณ์์ ์ฝ๋ ์์ฑ ์ค ์ค์๊ฐ์ผ๋ก ์ค๋ฅ๋ฅผ ๋ฐ๊ฒฌํ ์ ์์
โฆ
TypeScript ์ฝ๋๋ JavaScript๋ก ๋ณํ๋๋ฉฐ,ย JavaScript๊ฐ ์คํ๋๋ ๋ชจ๋ ๊ณณย (๋ธ๋ผ์ฐ์ , Node.js, Deno, Bun ๋ฐ ์ฑ)์์ ์คํ ๋จ
โช
TypeScript๋ ์ปดํ์ผ ๊ณผ์ ์์ ์๋ ์ฝ๋์ ์๋ฏธ๋ฅผ ๋ณด์กดํ๋ฉด์, ํ์
์ ๋ณด๋ ์ ๊ฑฐํ๊ณ ์์ํ JavaScript ์ฝ๋๋ก ๋ณํ ๋จ
โช
๊ธฐ์กด JavaScript ํ๋ก์ ํธ์ ์ฝ๊ฒ ํตํฉํ ์ ์๋ ์ฅ์
โฆ
TypeScript๋ JavaScript๋ฅผ ์ดํดํ๊ณ ย ํ์
์ถ๋ก ์ ์ฌ์ฉํ์ฌ ์ถ๊ฐ ์ฝ๋ ์์ด ํ๋ฅญํ ๋๊ตฌ๋ฅผ ์ ๊ณต
โช
TypeScript๋ JavaScript์ ๋ฌธ๋ฒ๊ณผ ๋์ ๋ฐฉ์์ ์์ ํ ์ดํดํ๊ณ ์์
โช
JavaScript๋ก ์์ฑ๋ ์ฝ๋๊ฐ TypeScript์์๋ ์ ํจํ๋ค๋ ๊ฒ
โข
TypeScript๋ JavaScript์ ์ ์ฐ์ฑ, ํ์ฅ์ฑ์ ์ ์งํ๋ฉด์๋ ์ ์ ํ์
์์คํ
์ ์ด์ ์ ์ ๊ณตํ์ฌ, ๋์ +์ ์ ํ์
์ธ์ด์ ํน์ฑ์ ๋ชจ๋ ์ดํดํ๋ ๋ ๋์ ๊ฐ๋ฐ ๊ฒฝํ์ ์ ๊ณต
[TypeScript] 2. TypeScript ์๊ฐ

1. TypeScript ์์ํ๊ธฐ
์๋ก์ด ํ๋ก์ ํธ (metaverse/greeter)
โข
node ํ๋ก์ ํธ ์์ฑ
npm init -y
Shell
๋ณต์ฌ
โข
ํ๋ก์ ํธ์ ํ์
์คํฌ๋ฆฝํธ ๋ชจ๋ ์ค์น
npm i typescript
Shell
๋ณต์ฌ
โข
src ํด๋ ์์ฑ ๋ฐ greeter.ts ํ์ผ ์์ฑ

function greeter(person: string) {
return "Hello, " + person;
}
let user = "Fred User";
document.body.textContent = greeter(user);
TypeScript
๋ณต์ฌ
โข
.ts TypeScript ํ์ผ๋ง ๊ฐ์ง๊ณ ๋ ํ๋ก๊ทธ๋จ์ ์คํ์ํฌ ์ ์๋ค.
node greeter.ts
Shell
๋ณต์ฌ

[TypeScript] 3. TypeScript ์ดํด๋ณด๊ธฐ

1. TypeScript์ ๊ธฐ๋ณธ ์ฌํญ
์๋ก์ด ํด๋ (metaverse/greeter/src/basic)
โข
basic.ts ์์ฑ
const message = "Hello!"
// Accessing the property 'toLowerCase'
// on 'message' and then calling it
message.toLowerCase();
// Calling 'message'
message();
TypeScript
๋ณต์ฌ
โข
message๋ string ํ์
์ ๋ณ์์ด๋ค.
โข
.toLowerCase(); ๋ฅผ ํตํด ์๋ฌธ์๋ก ๋ณํ ๋ ๊ฒ์ด๋ค.
โข
message(); ๋ฅผ ํตํด ๋ณ์๋ฅผ ํธ์ถ ํ ์ ์๋๊ฐ?

โข
์ปดํ์ผํ์ฌ .js ํ์ผ์ ์์ฑ ํ ์คํ
npx tsc basic.ts
Shell
๋ณต์ฌ
node basic.js
Shell
๋ณต์ฌ


โข
message๋ ํจ์๊ฐ ์๋๊ธฐ ๋๋ฌธ์ ์ ๋ฐ ๋ฐฉ์์ผ๋ก ํธ์ถ ํ ์ ์๋ค.
โฆ
์ด๋ฐ ์ค์๋ฅผ ๋ฏธ๋ฆฌ ๋ฐฉ์งํ๋ ๊ฒ์ด ์ค์ํ๋ค.
โข
TypeError๊ฐ ์๋ฏธํ๋ ๊ฒ
โฆ
basic.js์ ์ค๋ฅ๊ฐ ์๋ ๋ชจ์ต, ๊ฒฐ๊ตญ ์คํํด์ผ ์ค๋ฅ๊ฐ ๋ํ๋๋ ๋ชจ์ต์
โช
JavaScript ๋ฐํ์์ ์ฝ๋๊ฐ ์คํ ๋ ๋ ์์ ์ด ๋ฌด์์ ํด์ผ ํ ์ง ๊ฒฐ์ ํ๊ธฐ ์ํด ๊ฐ์ ํ์
๋ฟ๋ง ์๋๋ผ ์ด๋ค ๋์, ๋ฅ๋ ฅ, ํ๋๋ฅผ ๊ฐ์ง๊ณ ์๋์ง ํ์ธํจ
โฆ
basic.ts์ฒ๋ผ ํ์
์คํฌ๋ฆฝํธ์์ ์ด๋ฏธ ์ค๋ฅ ์ํ๋ฅผ ํ์
ํ ์ ์์

โข
๊ฒฐ๋ก ์ ์ผ๋ก, TypeScript๋ ๋ณ์์ ํ์
๋ฟ๋ง ์๋๋ผ, ํด๋น ๋ณ์์ ๋ฉ์๋์ ์์ฑ์ ๋ํ ์ ๋ณด๋ ํ์
ํ์ฌ, ์ฝ๋ ์์ฑ ์์ ์ ์ค๋ฅ๋ฅผ ๋ฏธ๋ฆฌ ๊ฐ์ง
โฆ
์ด๋ ๊ฐ๋ฐ์๊ฐ ๋ ์์ ํ๊ณ ์ค๋ฅ ์๋ ์ฝ๋๋ฅผ ์์ฑํ๋ ๋ฐ ๋์์ ์ค
2. TypeScript ๋ค์ํ ์ํฌํธ
[TypeScript] 4. TypeScript ์ ๊ธฐ๋ณธ ๊ธฐ๋ฅ

1. ์์ ํ์
์๋ก์ด ํด๋ (metaverse/greeter/src/types)
โข
types.ts ์์ฑ
//The primitives
const str = "Hello"; // string
const num = 10; // number
const bool = true; // boolean
console.log(str.length); // 5
console.log(str.toUpperCase()); // HELLO
TypeScript
๋ณต์ฌ
โฆ
string : ๋ฌธ์์ด / โ โ ๋ฐ์ดํ๋ก ๊ฐ์ธ์ ํํ
โฆ
number : ์ซ์ / ์ซ์๋ฅผ ํํ, Java์ ๋ฌ๋ฆฌ ๋ค์ํ ์ซ์ ํ์
(์: int, float, double)์ด ์์
โฆ
boolean : ๋
ผ๋ฆฌ / true or false ํํ
โข
์๋ฌธ์์์ ๊ธฐ์ตํ๋๋ก ํ๋ค. Java ๋ฑ์์๋ ๋๋ฌธ์๋ก ํ๊ธฐํ์ง๋ง JavaScript์์์ ๋๋ฌธ์ String, Number, Boolean์ wrapper ๊ฐ์ฒด๋ก ๋ณํํ๋ ๊ธฐ๋ฅ์ด ์๋๋ฐ ์ฌ์ฉ์ด ๊ถ์ฅ๋์ง ์์ผ๋ฉฐ ๋ง์ด ์ฌ์ฉ๋์ง ์์ผ๋ฏ๋ก ์ฃผ์ํ๋ค.
// ETC : Wrapper object
const wrapperStr = new String(num);
console.log(wrapperStr.length); // 2
console.log(wrapperStr.toUpperCase()); // HELLO
const wrapperNum = new Number("hello");
console.log(wrapperNum.toFixed(2));
const boolNum = 1;
const wrapperBool = new Boolean(boolNum);
console.log(wrapperBool)
TypeScript
๋ณต์ฌ
[TypeScript] 5. TypeScript์ ํ์
- 1ํธ

1. Union
์ ๋์จ ํ์
(metaverse/greeter/src/types)
โข
types.ts
// Union
function printId(id: number | string) {
console.log(id.toUpperCase());
// if (typeof id === "string") {
// // In this branch, id is of type 'string'
// console.log(id.toUpperCase());
// } else {
// // Here, id is of type 'number'
// console.log(id);
// }
}
TypeScript
๋ณต์ฌ
โฆ
id๋ผ๋ ๋ณ์๋ number ๋๋(or โ |) string ํ์
์ ๊ฐ์ง ์ ์์์ ๋ช
์
โฆ
ํด๋น ํจ์์ ์ ๋ฌ๋๋ ํ๋ผ๋ฏธํฐ id๋ ์ซ์๋ ๋ฌธ์์ด ํ์
์ผ ์ ์๋ค๋ ์๋ฏธ
โฆ
โ ํ์ง๋ง ํจ์ ์คํ๋ถ์์ ๊ฐ ํ์
์ผ ๋์ ๋ํ ํ์ ์ฒ๋ฆฌ๋ ํ์ํ๋ค๋ ์๋ฏธ

โช
๊ฐ ํ์
์ผ ๊ฒฝ์ฐ์ ๋ํด์ ์คํ๋ถ๋ฅผ ์ขํ๋ ๊ฒ์ Narrowing ์ด๋ผ ํ๋ฉฐ ์ฃผ์ ๋ถ๋ถ๊ณผ ๊ฐ์ด ์ํฉ๋ณ ๋์ฒ๋ฅผ ์กฐ๊ฑด๋ฌธ์ผ๋ก ์ฒ๋ฆฌํด์ฃผ๋ ๋ฑ์ด ํ์
โข
ํ์ง๋ง, ์ด๋ฐ ๊ธฐ๋ฅ์ด ์๋๋ผ๋ ์ด๋ฐ ์ฝ๋๊ฐ ์ข์ ์ฝ๋์ธ์ง ์๊ฐํด๋ณผ ํ์๊ฐ ์์
โฆ
ํจ์(๋ฉ์๋)๋ ์ญํ ์ ๋ง๋ ํ๊ฐ์ง์ ์ผ๋ง ํ๋๋ก ๊ตฌ์ฑํด์ผ ํ๋ค. by CleanCode
โช
๋ชจ๋์ ๋ณต์ก๋, ๊ฒฐํฉ๋๋ฅผ ๋ฎ์ถฐ์ผ ํ๋ฉฐ, ์์ง๋๋ฅผ ๋์ฌ์ผ ํ๋ค.
โช
โ ์ฌ์ฌ์ฉ์ฑ์ ์ฆ๊ฐ ์ํค๋ฉฐ ์ด๋ ๊ณง ์ ์ง๋ณด์์ฑ์ ์ฆ๊ฐ ์ํจ๋ค.
โฆ
์คํ๋ถ์์ ๋ถ๊ธฐํ๋ ๊ฒ ๋ณด๋ค, ๊ฑฐ์ ๋์ผํ ์ฝ๋๊ฐ ์ค๋ณต๋๋๋ผ๋ ์ ํํ ๋ฉ์๋๋ฅผ ๋ถ๋ฆฌํ๋ ๊ฒ์ด ์ณ์ ํ๋จ ์ผ ์ ์๋ค.
โช
๊ฐ๋ฐ์๋ ์ด๋ฐ ๋ฌธ์ ๋ฅผ ๋ฐ๊ฒฌํ๊ณ ์ด๋ฐ ๋ถ๋ถ์์ ํ๋จ์ ๋๋ ค๋๊ฐ๋ ๋ฅ๋ ฅ์ ๊ฐ์ถ์ด์ผ ํ๋ค.
โช
GPT์ ์ฌ์ฉ? โ ๊ด๋ฆฌ, ๊ฐ์ฐฐ ํ ์ ์๋ ๋์ ๊ธธ๋ฌ์ผ ํจ
[TypeScript] 6. TypeScript์ ํ์
- 2ํธ

1. Object
โข
ํด๋์ค(Class)๋ฅผ ๋ค๋ฃจ๊ธฐ ์ํด์ ๊ฐ์ฒด(Object)์์๋ถํฐ ์ฐ๊ด์ฑ์ ์ด์ด๋๊ฐ๋๋ก ์ค๋ช
ํ๊ณ ์ ํจ
์๋ก์ด ํด๋(metaverse/greeter/src/class)
โข
object.ts
โข
ํ์
๊ด๋ จ ์ฐ์ต์ ํตํด์๋ ๋ช๋ฒ ๊ฐ์ฒด์ ๋ํด์ ๋ํ๋๊ธฐ๋ํ๊ณ Java๋ฑ ๋ค๋ฅธ ์ธ์ด๋ก๋ถํฐ ์ต์ ํ ์ ์์ง๋ง ๋ค์ ํ๋ฒ ๋ณต์ตํ๋ ์๊ฐ์ผ๋ก ์ง์
// Vanilia JS(PURE) : Object only -> Prototype-based programming
// object
let robot = { // Members
// Property(์์ฑ)
name: "R2-D2",
model: "AstroMech",
status: "Active",
// Method(ํ๋)
performTask: function (task: string) {
console.log(`${this.name} is performing ${task}.`);
},
}
// usage with "."" dot operator
console.log(robot.name); // Accessing property
robot.performTask("Getting ready to move") // Calling method
TypeScript
๋ณต์ฌ
โฆ
์์ JavaScript์์๋ Object๋ง ์์ผ๋ฉฐ ์ด๊ฒ์ ํ๋กํ ํ์
๋ฒ ์ด์ค ํ๋ก๊ทธ๋๋ฐ์ด๋ผ ํจ
โช
๊ฐ์ฒด๋ ์์ฑ๊ณผ ๋ฉ์๋๋ผ๋ ๋ฉค๋ฒ๋ฅผ ๊ฐ์ง๊ณ ์์
โข
์์ฑ : ๊ฐ์ฒด์ ์์ฑ์ผ๋ก ๊ฐ์ฒด์ ํน์ง
โข
๋ฉ์๋ : ๊ฐ์ฒด์ ํ๋ ๋๋ ์ญํ , ๊ฐ์ฒด์ ํจ์๋ ๋ฉ์๋๋ก ๋ถ๋ฆฌ์
โช
๊ฐ์ฒด์ ๋ฉค๋ฒ์ ์ ๊ทผ(์ฌ์ฉ)ํ๊ธฐ ์ํด์๋ . ๋ํธ ์ฐ์ฐ์๋ฅผ ํตํด ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ๊ฒ ๋จ
[TypeScript] 7. TypeScript์ Object/Class

1. Generics
์๋ก์ด ํด๋(metaverse/greeter/src/generics)
โข
generics.ts
โข
identity() ๋ผ๋ ํจ์๊ฐ ๋ค์์ฒ๋ผ ๊ตฌ์ฑ๋์ด ์๋ค.
function identity(arg: number): number {
return arg;
}
TypeScript
๋ณต์ฌ
โฆ
์ซ์ ํ์
์ ํ๋ผ๋ฏธํฐ arg ๋ณ์๋ฅผ ์
๋ ฅ๋ฐ์, ์ซ์ ํ์
์ arg ๋ณ์๋ฅผ ๋ฐํ
โฆ
์ด๋ฐ ํจ์๋ ์์๋๊ฐ?
โช
CLI์์ echo command์์ ์์ฃผ ๋ณผ ์ ์์
โช
์
๋ ฅ๋ ๊ฐ์ ํ๋ฉด์ ์ถ๋ ฅํ๋๋ฐ ์ฌ์ฉ ๋จ
โข
์ฌ์ฉ์๊ฐ ์
๋ ฅํ ๋ฐ์ดํฐ๊ฐ ์์ํ ํ์์ธ์ง ํ์ธํ๋ ํ์
๊ฒ์ฆ์ ๋ชฉ์
โข
์
๋ ฅ๊ฐ์ ๋ค๋ฅธ ํจ์์ ์ ๋ฌํ๊ฑฐ๋, ์กฐ๊ฑด๋ฌธ์์ ์ฌ์ฉํ์ฌ ํ๋ก๊ทธ๋จ์ ํ๋ฆ์ ์ ์ดํ๋ ์ฐ์ฐ์ ๊ธฐ์ด๋ก ํ์ฉ
โข
์ฌ์ฉ์์๊ฒ ์
๋ ฅํ ๊ฐ์ ๋ค์ ๋ณด์ฌ์ค์ผ๋ก์จ, ์
๋ ฅ์ด ์ฌ๋ฐ๋ฅด๊ฒ ์ฒ๋ฆฌ๋์์์ ํ์ธํ๊ธฐ ์ํ ๊ธฐ์ด
โข
๋ง์ฝ, ๋ค๋ฅธ ํ์
๋ ๋ฐ์ ์ ์๋๋ก ํ๋ ค๋ฉด ์ด๋ป๊ฒ ๊ตฌ์ฑํด์ผ ํ๋๊ฐ?
function identity(arg: any): any {
return arg;
}
TypeScript
๋ณต์ฌ
โฆ
๋จ์ํ, ๋ฐฐ์ด ๊ฒ ์ฒ๋ผ any ํ์
์ ์ด์ฉ ํ ์๋ ์๋ค.
โฆ
ํ์ง๋ง ์ด๊ฒ์ ์ ํํ ํ์
๊ฒ์ฆ์ ๋ชฉ์ ์ ๋ฌ์ฑ ํ๊ธฐ ์ด๋ ค์ธ ์ ์์
โช
number ๋ฅผ ์
๋ ฅํ๋๋ฐ ์ด๋ ํ ์์ธ์ ์ํด์๋ผ๋ ๋ณ์ง๋๋ค๋ฉด string์ด ๋์๋ ํ์
์ด ๋ณํ๊ฒ์ ์ค๋ฅ๋ก ์ ์ ์์
โข
๊ทธ๋ผ ๋ชจ๋ ํ์
๋ง๋ค ์ด๊ฒ์ ์์ฑํด์ผ ํ๋๊ฐ?
โฆ
์ด๊ฒ ๋ํ ํจ์์ ์ด๋ฆ์ด ์ค๋ณต๋์ด ํ์ฉ๋์ง ์๋๋ค.

โข
๊ทธ๋ผ ์ค๋ณต์ ํผํด์ ๋ง๋ค์๋ค๊ณ ๊ฐ์ ํ์.
function identityNum(arg: number): number {
return arg;
}
function identityStr(arg: string): string {
return arg;
}
function identityBool(arg: boolean): boolean {
return arg;
}
//...
function identityObj1(arg: obj1): obj1 {
return arg;
}
function identityObj2(arg: obj2): obj2 {
return arg;
}
interface obj1 {
//...
}
interface obj2 {
//...
}
//...
TypeScript
๋ณต์ฌ
โฆ
ํ์ง๋ง ํ์
์ ๊ธฐ๋ณธํ ํ์
๋ง ์์ง ์๋ค. ๊ฐ์ฒด๋ ํ์
์ด ๋ ์ ์๊ณ ๋ฐ๋ผ์ ์์์ด ๋ง์ ํจ์๋ฅผ ์์ฑํด์ผ ํ๊ฒ ๋ ๊ฒ์ด๋ค.
โข
์ด๋ฐ ๋นํจ์จ์ ์ธ ์ํฉ์ ๋์ฒํ๊ธฐ ์ํ ๊ฒ์ด Generics์ด๋ค.
โฆ
< > ์์ ์์ฑ๋ ํค์๋๊ฐ ํด๋น ํจ์์ ๋์ผํ ํํ๋ค์ ๋์ ์ผ๋ก ํต์ผ์ํจ๋ค๋ ๊ฒ์ ๋ํ๋
โฆ
ํต์ผ ๋ ์ต์ด ํ์
์ ํค์๋๊ฐ ์์ฑ๋ Parameter(๋งค๊ฐ๋ณ์)์ ํ์
์ด ๊ธฐ์ค์ด ๋๋ฉฐ ํด๋น ๋ธ๋ก์ ํค์๋๊ฐ ํฌํจ ๋ ํ์
๋ค์ ๋ชจ๋ ์ด๋ฅผ ๋ฐ๋ฅด๊ฒ ๋จ
// Use Generics
function identity<Type>(arg: Type): Type {
return arg;
}
TypeScript
๋ณต์ฌ
โฆ
Type์ด๋ ํค์๋ ๋์ T๋ผ๋ ํค์๋๋ก ๋์ฒดํ์ฌ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์
// Use Generics
function identity<T>(arg: T): T {
return arg;
}
TypeScript
๋ณต์ฌ
โฆ
์ฐธ๊ณ : ์ฌ๊ธฐ ํํ๋ Type ๋๋ T(or U or V โฆ) ๋ ์ค์ ์๋ ์๋ฃํ(ํ์
) ์ด ์๋๋ค. ์์ ๋กญ๊ฒ ์ง์ ํ ์ ์์ด ํ์
๋ณ์นญ(Type Alias)๊ณผ ํผ๋ ๋ ์ ์์ง๋ง ๋ค๋ฅธ ๊ธฐ๋ฅ
โช
๊ด๋ก์ ์ผ๋ก T๋ฅผ, ๋งค๊ฐ ๋ณ์๊ฐ 2๊ฐ ์ด์์ ์ ๋๋ฆญ์ผ๋ก ํํํด์ผ ํ๋ ๊ฒฝ์ฐ์ ์ดํ๋ก๋ U, V, W ๋ฑ์ ์์ฃผ ์ฌ์ฉํ๋ค.
function identity<T, U>(arg1: T, arg2: U): [T, U] {
return [arg1, arg2];
}
const result = identity(20, "Hello"); // result๋ [number, string] ํ์
TypeScript
๋ณต์ฌ
โฆ
์ ํํ ๊ตฌ๋ถ ๋๋์ง ํ
์คํธ
function isNumber(value: any) {
return typeof value === 'number' && !isNaN(value);
}
function isString(value: any) {
return typeof value === 'string';
}
// isArray๋ Array์ ๋ด์ฅ ํจ์ ์ฌ์ฉ
// ๊ฐ๋จ ํ
์คํธ
// given
const testValue1: number = 20;
const testValue2: string = "Hi";
const testValue3: number[] = [1, 20];
// when 1
const numberIdentity = identity(testValue1); // number ํ์
// then 1
console.log(`Input type is : ${typeof testValue1}`);
console.log(`Output type is : ${typeof numberIdentity}`);
console.log(`Is number: ${isNumber(numberIdentity)}`); // true
// when 2
const stringIdentity = identity(testValue2); // string ํ์
// then 2
console.log(`Input type is : ${typeof testValue2}`);
console.log(`Output type is : ${typeof stringIdentity}`);
console.log(`Is string: ${isString(stringIdentity)}`); // true
// when 3
const arrayIdentity = identity(testValue3); // number[] ํ์
// then 3
console.log(`Input type is : ${typeof testValue3}`);
console.log(`Output type is : ${typeof arrayIdentity}`);
console.log(`Is array: ${Array.isArray(arrayIdentity)}`) // true
TypeScript
๋ณต์ฌ
โฆ
Generics๋ฅผ ์ฌ์ฉํ identity() ํจ์๊ฐ ์์๋๋ก ์๋ํ๋์ง ํ์ธํด๋ณด์.
โช
ํ
์คํธ์ฝ๋ ์์ฑ์ Given-When-Then ํจํด
โช
์ค๋น-์คํ-๊ฒ์ฆ์ ๋จ๊ณ๋ก ํ
์คํธ์ ํ๋ฆ์ด ๋ช
ํํ๊ณ , ๊ฐ ๋จ๊ณ์์ ์ด๋ค ์์
์ด ์ด๋ฃจ์ด์ง๋์ง ์ฝ๊ฒ ์ดํดํ๊ธฐ ์ํ ํํ ๊ธฐ๋ฒ
โข
Given: ํ
์คํธ์ ํ์ํ ์ด๊ธฐ ๋ฐ์ดํฐ๋ฅผ ์ค์
โข
When: ํ
์คํธ๋ฅผ ์คํํ๋ ๋ถ๋ถ์ผ๋ก, identity ํจ์๋ฅผ ํธ์ถ
โข
Then: ๊ฐ ์
๋ ฅ๊ฐ์ ๋ํ ๊ฒฐ๊ณผ๋ฅผ ๊ฒ์ฆํ๊ณ ์ถ๋ ฅ
โข
์ ๋๋ฆญ์ ์ค์ ๋ก ๊ตฌํํ๊ณ , ์ฌ์ฉํ๊ธฐ ์ด๋ ค์ธ ์๋ ์์ง๋ง, ์๊ณ ์์ด์ผ ํ๋ ์ด์

โฆ
Array์ ๊ฐ์ ๋ด์ฅ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ดํด๋ณด์.
โฆ
์ฐ๋ฆฌ๊ฐ ์ฌ์ฉํ๋ ๋ง์ ํจ์, ๋ฉ์๋, ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๋ฑ์ ์ด์ฒ๋ผ ๊ตฌํ๋์ด ์๊ธฐ ๋๋ฌธ์ ์ด๋ ๋ค์ํ ๋ฐ์ดํฐ ํ์
์ ์ฝ๊ฒ ์ฌ์ฉ ํ ์ ์๋๋ก ๊ตฌํ๋์ด ์๋ค.
โฆ
ํ์์ ๋ฐ๋ฅธ ํ๋, ๊ฒํ ๋ฑ์ ์ํด ๋ด๋ถ ๊ตฌ์กฐ๋ฅผ ์ดํด๋ณด๊ฒ ๋ ๋ ์ดํด ํ ์ ์์ด์ผ ํ๋ค.
[TypeScript] 8. TypeScript์ Generics

1. ํ๋ก๊ทธ๋๋ฐ ๋ฐฐ๊ฒฝ์์์ ๋ชจ๋
ํ๋ก๊ทธ๋๋ฐ ์ ๋ฐ ๊ด์ ์ ๋ชจ๋
โข
๋ชจ๋์ด๋ ํ๋ก๊ทธ๋จ์ ๊ตฌ์ฑํ๋ ์์คํ
์ ๊ธฐ๋ฅ ๋จ์๋ก ๋
๋ฆฝ์ ์ธ ๋ถ๋ถ์ผ๋ก ๋ถ๋ฆฌํ ๊ฒ
โข
๋จ์ํ ๊ท๋ชจ๊ฐ ํฐ ๊ฒ์ ์๊ฒ ์ฌ๋ฌ ๊ฐ๋ก ๋๋ ์กฐ๊ฐ์ด ์๋๋ผ, ํ๋ ์ด์์ ๋
ผ๋ฆฌ์ ์ธ ๊ธฐ๋ฅ์ ์ํํ๊ธฐ ์ํ ๋ช
๋ น์ด๋ค์ ์งํฉ
โข
๋ชจ๋์ ๋
๋ฆฝ์ ์ธ ํ๋ก๊ทธ๋จ ๊ทธ ์์ฒด์ผ ์๋ ์๊ณ ํจ์๋ ๋ฉ์๋์ผ ์๋ ์์
โข
๋ชจ๋์ด ๋๋ ค๋ฉด ๋ค๋ฅธ ๊ฒ๋ค๊ณผ ๊ตฌ๋ถ๋ ์ ์๋ ๋
๋ฆฝ์ ์ธ ๊ธฐ๋ฅ์ ๊ฐ์ ธ์ผ ํ๊ณ ์ ์ผํ ์ด๋ฆ์ ์ฌ์ฉํด์ผ ํ๋ค.
โข
๋ค๋ฅธ ํ๋ก๊ทธ๋จ์ด๋ ๋ ๋ค๋ฅธ ๋ชจ๋์์ ํธ์ถํ์ฌ ์ฌ์ฉํ ์๋ ์์ด์ผ ํ๋ค. ๋, ๋ชจ๋ ์์ฒด๋ก์ ์ฌ์ฌ์ฉ๋ ์ ์๊ณ ๋
๋ฆฝ์ ์ผ๋ก ์ปดํ์ผ์ด ๊ฐ๋ฅํด์ผ ํ๋ค๋ ์ค์ํ ํน์ง์ ํฌํจํด์ผ ํ๋ค.
โข
๋ชจ๋์ ๋ค์ํ ํํ๋ก ์กด์ฌํ ์ ์๋๋ฐ ์ฉ๋๊ฐ ๋น์ทํ ํจ์๋ ์ถ์ํ๋ ์๋ฃ, ๊ฐ์ฒด(Object), ๋ฉ์๋(Method)๋ฑ์ด ์ด์ ํด๋นํ๋ค.
โข
๋ฌด์ธ๊ฐ ๋
๋ฆฝ์ ์ธ, ์ฌ์ฌ์ฉ๊ฐ๋ฅํ, ๋ค๋ฅธ๋ถ๋ถ์๋ ์ฌ์ฉ๋๋ ์ผ์ข
์ ๋ถํ๊ณผ ๊ฐ์ ๊ฐ๋
์ผ๋ก ๊ธฐ์ต
โข
์ด๋ฐ ๊ธฐ๋ฅ์ ์ธ ๋ถ๋ฆฌ๋ฅผ ํตํด์ ๋ค๋ฅธ ํ๋ก๊ทธ๋จ์ ๊ฐ๋ฐํ ๋์๋ ์ ์ง๋ณด์์ ์ฝ๋ ์ฌ์ฌ์ฉ์ฑ์ ๋์ฌ ์ํํธ์จ์ด๋ฅผ ์ค๊ณํ๋ ๊ธฐ๋ฒ์ ๋ชจ๋ํ(Modularization)๋ผ๊ณ ํจ
๋
๋ฆฝ์ ์ธ ๋ชจ๋์ด ๊ฐ์ ธ์ผ ํ ํน์ฑ
โข
๋ชจ๋์ ์์ง๋๊ฐ ๋์์ผ ํ๋ฉฐ, ๊ฒฐํฉ๋์ ์์กด๋๋ ๋ฎ์์ผ ํ๋ค.
โฆ
์์ง๋ (Cohesion)
โช
์ ์: ๋ชจ๋ ๋ด์ ๊ตฌ์ฑ ์์๋ค์ด ์ผ๋ง๋ ๋ฐ์ ํ๊ฒ ๊ด๋ จ๋์ด ์๋์ง๋ฅผ ๋ํ๋ด๋ ์ฒ๋
โช
ํน์ง:
โข
๋์ ์์ง๋: ๋ชจ๋์ด ํ๋์ ํน์ ๊ธฐ๋ฅ์ ์ํํ๊ณ , ๊ทธ ๊ธฐ๋ฅ๊ณผ ๊ด๋ จ๋ ๋ชจ๋ ์์๊ฐ ๋ชจ๋ ๋ด์ ํฌํจ๋์ด ์์ ๋.
โฆ
์ฅ์ : ๋์ ์์ง๋๋ฅผ ๊ฐ์ง ๋ชจ๋์ ๊ฐ๋
์ฑ๊ณผ ์ ์ง๋ณด์์ฑ์ด ๋์์ง๋ฉฐ, ์ฝ๋์ ๊ฐ๋
์ฑ์ด ๋์์ง
โข
๋ฎ์ ์์ง๋: ์ฌ๋ฌ ๊ฐ์ง ๊ธฐ๋ฅ์ด ํผํฉ๋์ด ์๊ฑฐ๋, ์๋ก ๊ด๋ จ ์๋ ์์
๋ค์ด ํจ๊ป ํฌํจ๋ ๊ฒฝ์ฐ.
โฆ
2. ๊ฒฐํฉ๋ (Coupling)
โช
์ ์: ๋ชจ๋ ๊ฐ์ ์์กด์ฑ์ ๋ํ๋ด๋ ์ฒ๋์
๋๋ค. ํ ๋ชจ๋์ด ๋ค๋ฅธ ๋ชจ๋์ ์ผ๋ง๋ ์์กดํ๊ณ ์๋์ง๋ฅผ ๋ํ๋
โช
ํน์ง:
โข
๋ฎ์ ๊ฒฐํฉ๋: ๋ชจ๋์ด ์๋ก ๋
๋ฆฝ์ ์ผ๋ก ์๋ํ ์ ์๊ณ , ํ ๋ชจ๋์ ๋ณ๊ฒฝ์ด ๋ค๋ฅธ ๋ชจ๋์ ์ํฅ์ ๋ฏธ์น์ง ์์ ๋.
โฆ
์ฅ์ : ๋ฎ์ ๊ฒฐํฉ๋๋ฅผ ๊ฐ์ง ์์คํ
์ ์ ์ฐ์ฑ๊ณผ ์ฌ์ฌ์ฉ์ฑ์ด ๋์์ง๋ฉฐ, ์ ์ง๋ณด์์ ํ์ฅ์ฑ์ด ๋์์ง
โข
๋์ ๊ฒฐํฉ๋: ๋ชจ๋ ๊ฐ์ ์์กด์ฑ์ด ๊ฐํ ๊ฒฝ์ฐ, ํ ๋ชจ๋์ ๋ณ๊ฒฝ์ด ๋ค๋ฅธ ๋ชจ๋์ ์ํฅ์ ๋ฏธ์น๊ฒ ๋จ
โฆ
3. ์์กด๋ (Dependency)
โช
์ ์: ํ ๋ชจ๋์ด ๋ค๋ฅธ ๋ชจ๋์ด๋ ์ปดํฌ๋ํธ์ ์์กดํ๋ ์ ๋๋ฅผ ๋ํ๋ด๋ ์ฒ๋์
๋๋ค. ์์กด๋๋ ๋ชจ๋ ๊ฐ์ ๊ด๊ณ๋ฅผ ์ค๋ช
ํ๋ฉฐ, ํน์ ๋ชจ๋์ด ๋ค๋ฅธ ๋ชจ๋์ ๊ธฐ๋ฅ์ด๋ ๋ฐ์ดํฐ๋ฅผ ํ์๋ก ํ ๋ ๋ฐ์ํฉ๋๋ค.
โช
ํน์ง:
โข
๋์ ์์กด๋: ํ ๋ชจ๋์ด ๋ค๋ฅธ ๋ชจ๋์ ๊ฐํ๊ฒ ์์กดํ ๊ฒฝ์ฐ, ๋ณ๊ฒฝ ์ ์ํฅ์ ๋ฐ์ ๊ฐ๋ฅ์ฑ์ด ๋์
โข
๋ฎ์ ์์กด๋: ๋ชจ๋์ด ๋ค๋ฅธ ๋ชจ๋์ ๋ํ ์์กด์ฑ์ด ์ ๊ฑฐ๋ ์๋ ๊ฒฝ์ฐ, ๋ณ๊ฒฝ ์ ์ํฅ์ด ์ ์
โฆ
์ฅ์ : ๋ฎ์ ์์กด๋๋ฅผ ๊ฐ์ง ์์คํ
์ ๋ชจ๋ ๊ฐ์ ๋
๋ฆฝ์ฑ์ ๋์ฌ, ์ ์ง๋ณด์์ ํ
์คํธ๊ฐ ์ฉ์ดํด์ง
[TypeScript] 9. TypeScript์ Modules