06-1 반복기 이해하기

반복기와 반복기 제공자

1. next 라는 이름의 메서드를 제공한다.

2. next 메서드는 value, done 이라는 두 개의 속성을 가진 객체를 반환한다.

 

createRangeIterable 함수는 next 메서드를 return 해서 반복기 역할을 제공하고, 이를 '반복기 제공자(iterable)' 라고 한다.

사용자가 타입스크립트로 for...of 구문을 작성하면 TSC 컴파일러는 반복기 제공자와 반복기를 사용하는 코드로 바꿔준다.

export const createRangeIterable = (from: number, to: number) => {
  let currentValue = from

  return {
    next() {
      const value = currentValue < to ? currentValue++ : undefined
      const done = value == undefined

      return {value, done}
    }
  }
}

const iterator = createRangeIterable(1, 4) // 1부터 4까지 반복기, 함수 호출일 뿐 반복기는 동작하지 않음

while(true) {
  const {value, done} = iterator.next() // next 메서드를 호출하면서 반복기가 동작한다.
  if(done) break

  console.log(value) // 1 2 3
}

 

반복기는 왜 필요한가?

반복기 제공자는 어떤 범위의 값을 한 번에 생성해서 배열에 담지 않고 값이 필요할 때만 생성한다.

따라서 시스템 메모리의 효율성이라는 관점에서 보았을 때 메모리를 훨씬 적게 소모한다.

 

for...of 구문과 [Symbol.iterator] 메서드

위의 코드에서 createRangeIterable 함수를 for...of 구문으로 작성하면 아래 오류가 발생하고, 이 오류를 해결하기 위해서는 클래스로 구현해야 한다.

'Type '{ next(): { value: number; done: boolean; }; }' is not an array type or a string type or does not have a '[Symbol.iterator]()' method that returns an iterator.'

 

클래스 메서드느 자바스크립트의 function 키워드가 생략되었을 뿐 사실상 function 키워드로 만들어진 함수이다.

function 키워드로 만들어진 함수는 내부에서 this 키워드를 사용할 수 있고, next 함수 또한 function 키워드가 생략된 메서드이므로 컴파일러가 next의 this로 해석하지 않게 하는 자바스크립트의 유명한 코드 트릭이다.

export class RangeIterable {
  constructor(public from: number, public to: number) {}

  [Symbol.iterator]() {
    const that = this
    let currentValue = that.from

    return {
      next() {
        const value = currentValue < that.to ? currentValue++ : undefined
        const done = value == undefined

        return {value, done}
      }
    }
  }
}

const iterator = new RangeIterable(1, 4)

for(let value of iterator) {
  console.log(value) // 1 2 3
}

 

Iterable<T>와 Iterator<T> 인터페이스

타입스크립트는 반복기 제공자에 Iterable<T>와 Iterator<T> 제네릭 인터페이스를 사용할 수 있다.

 


06-2 생성기 이해하기

생성기는 function* 키워드로 만든 함수를 의미한다.

yield는 반드시 function* 키워드를 사용한 함수에서만 호출할 수 있고, yield는 return 키워드처럼 값을 반환한다.

export function* generator() {
  console.log('generator started.')

  let value = 1

  while(value < 4)
    yield value++

  console.log('generator fininsed.')
}

for(let value of generator())
  console.log(value)
  
// generator started.
// 1
// 2
// 3
// generator fininsed.

 

setInterval 함수와 생성기의 유사성

생성기가 동작하는 방식을 '세미코루틴' 이라고 한다. 

세미코루틴은 타입스크립트처럼 단일 스레드로 동작하는 프로그래밍 언어가 다중 스레드로 동작하는 것처럼 보이게 한다.

프로그램의 출력 내용만 보면 생성기 방식과 동일하지만, setInterval 함수가 동작하는 구조는 멀티 스레드가 동작하는 방식과 유사하다.

따라서 생성기는 일반적인 타입스크립트 코드가 다른 방식으로 동작하는 것을 기억해야 한다.

 

단일 스레드(싱글 스레드) vs 다중 스레드(멀티 스레드)

스레드란, 프로세스가 할당받은 자원을 시용하는 실행의 단위이다.

단일 스레드는 메인 스레드 하나만 가지고 작업을 처리하고, 작업을 순서대로 처리한다. (하나의 레지스터와 스택)

다중 스레드는 메인 스레드 외에 추가적인 스레드를 이용하여 병렬적으로 작업을 처리한다. context switching이 빠르게 일어나는 것이기 때문에 사용자 입장에서 프로그램들이 동시에 수행되는 것처럼 보인다.

 

let count = 0

console.log('program started.')

const id = setInterval(() => {
  if(count >= 3) {
    clearInterval(id)
    console.log('program finished.')
  } else {
    console.log(count++)
  }
}, 1000)

// program started.
// 0
// 1
// 2
// program finished.

 

function* 키워드

  1. function* 키워드로 함수를 선언한다.
  2. 함수 몸통 안에 yield문이 있다.

 

yield 키워드

  1. 반복기를 자동으로 만들어 준다.
  2. 반복기 제공자 역할도 수행한다.

 

function* 키워드로 선언된 함수만 생성기이고, 화살표 함수로는 생성기를 만들 수 없다.

function* getPage(pageSize: number = 1, list: number[]) {
  let output = []
  let index = 0

  while (index < list.length) {
    output = []

    for (let i = index; i < index + pageSize; i++) {
      if (list[i]) {
        output.push(list[i])
      }
    }

    yield output
    index += pageSize
  }
}

let page = getPage(3, [1, 2, 3, 4, 5, 6, 7, 8])

console.log(page.next()) // { value: [ 1, 2, 3 ], done: false }            
console.log(page.next()) // { value: [ 4, 5, 6 ], done: false }
console.log(page.next()) // { value: [ 7, 8 ], done: false }
console.log(page.next()) // { value: undefined, done: true }

 

 

yield* 키워드

yield는 단순히 값을 대상으로 동작하지만, yield*는 다른 생성기나 배열을 대상으로 동작한다.

function* gen12() {
  yield 1
  yield 2
}

function* gen12345() {
  yield* gen12()
  yield* [3, 4]
  yield 5
}

for(let value of gen12345()){
  console.log(value) // 1 2 3 4 5
}

 

yield 반환값

yield 연산자의 반환값은 반복기의 next 메서드 호출 때 매개변수에 전달하는 값이다.

function* gen(){
  let count = 3
  let select = 0

  while(count--){
    select = yield `select ${select}`
  }
}

const random = (max, min = 0) => Math.trunc(Math.random() * (max - min))

const iter = gen()

while(true){
  const {value, done} = iter.next(random(10, 1))

  if(done) {
    break
  } else {
    console.log(value)
  }
}

// select 0
// select 2
// select 5

 

 

 

참고자료

Do it! 타입스크립트 프로그래밍

05-1 배열 이해하기

자바스크립트와 타입스크립트에서 배열은 다른 언어와 다르게 객체이다.

 

  • new Array 배열 선언하기

new Arrar 키워드를 통해 배열을 만들 수 있고, 배열에 담긴 값을 아이템(item) 또는 원소(element) 라고 한다.

let arr: number[] = new Array

arr.push(1)
arr.push(2)
arr.push(3)

console.log(arr) // [1, 2, 3]

 

  • [] 단축 구문 배열 선언하기

[] 단축 구문을 사용해서 배열을 만들 수 있다.

// [] 단축 구문
const numArr: number[] = [1, 2, 3]
const strArr: string[] = ['hello', 'world']

console.log(num) // [1, 2, 3]
console.log(str) // ['hello', 'world']

 

문자열과 배열 간 변환

타입스크립트에서는 문자 타입이 없고, 문자열의 내용 또한 변경할 수 없다.

따라서 문자열을 변경하기 위해서는 문자열을 배열로 변환해야 한다.

 

let str: string = 'hello'
let strArr: string[] = str.split('')

console.log(strArr.join('-')) // h-e-l-l-o

 

인덱스 연산자

인덱스 연산자, [인덱스]는 배열의 특정 위치에 있는 값을 알 수 있다.

let numbers: number[] = [1, 2, 3]

for(let i = 0; i < numbers.length; i++) {
    console.log(numbers[i])
}

// 1 2 3

 

배열의 비구조화 할당

객체뿐만 아니라 배열에도 비구조화 할당을 적용할 수 있다.

비구조화 할당이란, 배열이나 객체 속성을 해체하여 그 값을 변수에 담을 수 있게 하는 표현식이다.

let arr: number[] = [1, 2, 3, 4, 5]
let [first, second, third, ...rest] = arr

console.log(first, second, third, rest) // 1 2 3 [ 4, 5 ]

 

for ...in 문

배열의 인덱스 값을 순회한다.

let names: string[] = ['다연', '하영', '희재']

for(let index in names) {
    console.log(`[${index}]: ${names[index]}`)
}

// [0]: 다연 [1]: 하영 [2]: 희재

 

for ...of 문

배열의 아이템 값을 대상으로 순회한다. (인덱스값을 알 수 없다.)

let names: string[] = ['다연', '하영', '희재']

for(let index of names) {
    console.log(index)
}

// 다연 하영 희재

 

제네릭 방식 타입

배열을 다루는 함수를 작성할 때는 고정된 타입을 함수를 만들기보다는 T[] 형태(제네릭 타입)로 배열의 아이템 타입을 한꺼번에 표현하는 것이 편리하다.

타입스크립트는 타입 변수가 생략된 제네릭 함수를 만나면 타입 추론을 통해서 생략된 타입을 찾아낸다.

 

제네릭 사용 이유
  1. 한 가지 타입보다 여러 가지 타입에서 동작하는 컴포넌트를 생성할 수 있다.
  2. 재사용성이 높은 함수와 클래스를 생성할 수 있다.
  3. any 타입을 사용하는 대신에 사용하기 때문에 오류를 쉽게 검출할 수 있다.

 

function sort<T>(item: T[]): void {
    console.log(item.sort())
}
 
const nums: number[] = [3, 2, 5, 4, 1];
const chars: string[] = ['d', 'a', 'e', 'c', 'b'];
 
sort<number>(nums) // [ 1, 2, 3, 4, 5 ]
sort<string>(chars) // [ 'a', 'b', 'c', 'd', 'e' ]

 

전개 연산자

배열에서도 전개 연산자를 사용할 수 있다.

const arr1: number[] = [1, 2, 3]
const arr2: string[] = ['a', 'b', 'c']
const arr3: (number | string)[] = [...arr1, ...arr2]

console.log(arr3) // [ 1, 2, 3, 'a', 'b', 'c' ]

 

range 함수 구현

range 함수는 재귀 함수 스타일로 동작하고, 배열을 생성해 준다.

const range = (from: number, to: number): number[] => {
    return from < to ? [from, ...range(from + 1, to)] : []
}

let numbers: number[] = range(1, 5)

console.log(numbers) // [ 1, 2, 3, 4 ]

 


05-2 선언형 프로그래밍과 배열

명령형 프로그래밍

ex) for 문

  • 입력 데이터 얻기
  • 입력 데이터 가공해 출력 데이터 생성
  • 출력 데이터 출력

 

선언형 프로그래밍

ex) for 문을 사용하지 않고 모든 데이터를 배열에 담는 형식

  • 문제를 푸는 데 필요한 모든 데이터 배열에 저장
  • 입력 데이터 배열을 가공해 출력 데이터 배열 생성
  • 출력 데이터 배열에 담긴 아이템 출력

 

1부터 100까지 더하기 

  • 명령형 프로그래밍
let sum = 0

for(let i = 1; i <= 100; i++) {
    sum = sum + i
}

console.log(sum) // 5050

 

  • 선언형 프로그래밍
const range = (from: number, to: number): number[] => {
    return from < to ? [from, ...range(from + 1, to)] : []
}

const numbers: number[] = range(1, 101)

console.log(numbers.reduce((acc, cur) => acc + cur)) // 5050

 


05-3 배열의 map, reduce, filter 메서드

filter 메서드

깊은 복사의 형태로 동작한다. (= 원본 배열을 변경하지 않는다.)

const arr: number[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

const odd: number[] = arr.filter((item, index) => item % 2 !== 0)
const even: number[] = arr.filter((item, index) => item % 2 === 0)

console.log(odd) // [ 1, 3, 5, 7, 9 ]
console.log(even) // [ 2, 4, 6, 8, 10 ]

 

map 메서드

깊은 복사의 형태로 동작한다. (= 원본 배열을 변경하지 않는다.)

const arr: number[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

const double = arr.map((item, index) => item * 2)

console.log(double) // [2,  4,  6,  8, 10, 12, 14, 16, 18, 20]

 

reduce 메서드

const arr: number[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

const total = arr.reduce((acc, cur) => acc + cur)

console.log(total) // 55

 


05-4 순수 함수와 배열

함수형 프로그래밍에서 함수는 '순수 함수'라는 조건을 만족해야 한다.

그러나 타입스크립트의 배열에는 순수 함수 조건에 부합하지 않는 메서드들이 많다.

 

순수 함수란?

'순수 함수'는 부수 효과(side-effect)가 없는 함수를 의미한다. (부수 효과가 있으면 '불순 함수' 라고 한다.)

 

  • 함수 몸통에 입출력에 관련된 코드가 없어야 한다.
  • 함수 몸통에서 매개변숫값을 변경시키지 않는다. (즉, 매개변수는 const나 readonly 형태로만 사용한다.)
  • 함수는 몸통에서 만들어진 결과를 즉시 반환한다.
  • 함수 내부에 전역 변수나 정적 변수를 사용하지 않는다.
  • 함수가 예외를 발생시키지 않는다.
  • 함수가 콜백 함수로 구현되었거나 함수 몸통에 콜백 함수를 사용하는 코드가 없다.
  • 함수 몸통에 Promise와 같은 비동기 방식으로 작동하는 코드가 없다.

 

  • 순수 함수
function pure(a: number, b: number): number {
    return a + b
}

console.log(pure(1, 2)) // 3

 

  • 불순 함수

매개변수 arr이 변경된다.

function impure(arr: number[]): void {
    console.log(arr) // []
    
    arr.push(100)
    
    console.log(arr) // [100]
}

impure([])

 

타입 수정자 readonly

타입스크립트는 순수 함수 구현을 쉽게 하도록 readonly 키워드를 제공한다.

또는 인터페이스, 클래스, 함수의 매개변수는 let, const 키워드 없이 선언하기 때문에 심벌에 const와 같은 효과를 주기 위해서 readonly 타입 수정자가 필요하다.

function impure(arr: readonly number[]): void {
    // Property 'push' does not exist on type 'readonly number[]'.
    arr.push(100)
}

 

불변과 가변

  • 불변 변수

const 또는 readonly 키워드로 선언된 변수이다.

초기값을 항상 유지한다.

 

  • 가변 변수

var 또는 let 키워드로 선언된 변수이다.

언제든 변수의 값을 변경할 수 있다.

 

깊은 복사와 얕은 복사

순수 함수를 구현할 때는 매개변수가 불변성을 유지해야 한다. 매개변수를 가공하려고 할 때 깊은 복사를 실행해 매개변숫값이 변경되지 않게 해야 한다.

그러나 새로운 변수에 기존 변수를 할당하는 방식으로 복사를 시도하면 객체와 배열은 얕은 복사 방식으로 동작하기 때문에 주의해야 한다.

 

  • 깊은 복사

원본 변수의 값이 변경되지 않는다.

let original = 1
let copy = original

copy = copy + 2

console.log(original) // 1
console.log(copy) // 3

 

  • 얕은 복사

원본 배열의 값이 변경된다.

let original = [1, 2, 3]
let copy = original

cop.push(4)

console.log(original) // [1, 2, 3, 4]
console.log(copy) // [1, 2, 3, 4]

 

전개 연산자와 깊은 복사

전개 연산자를 사용해 객체와 배열을 깊은 복사할 수 있다.

let originArr = [1, 2, 3]
let copyArr = [...originArr]

copyArr.push(4)

console.log(originArr) // [ 1, 2, 3 ]
console.log(copyArr) // [ 1, 2, 3, 4 ]

 

배열의 sort 메서드를 순수 함수로 구현하기

sort 메서드는 원본 배열의 내용을 변경한다. 

따라서 원본 배열을 유지한채 sort 메서드를 사용하고 싶다면 전개 연산자의 깊은 복사 기능을 먼저 사용하면 된다.

 

  • sort 얕은 복사

원본 배열의 값이 변경된다.

let arr: number[] = [3, 5, 2, 1, 4]
let sortArr: number[] = arr.sort()

console.log(arr) // [ 1, 2, 3, 4, 5 ]
console.log(sortArr) // [ 1, 2, 3, 4, 5 ]

 

  • sort 깊은 복사

원본 배열의 값이 변경되지 않는다.

let arr: number[] = [3, 5, 2, 1, 4]
let sortArr: number[] = [...arr].sort()

console.log(arr) // [ 3, 5, 2, 1, 4 ]
console.log(sortArr) // [ 1, 2, 3, 4, 5 ]

 

배열의 filter 메서드와 순수한 삭제

보통 배열에서 특정 아이템을 삭제할 때 splice 메서드를 많이 사용하는데 splice 메서드는 원본 배열을 변경하므로 순수 함수에서는 사용할 수 없다.

filter 메서드는 깊은 복사 형태로 동작하기 때문에 원본 배열을 유지한 채 특정 아이템을 삭제할 수 있다.

interface Data {
  id: number
  title: string
}

const data: Data[] = [
  { id: 1, title: '제목1' },
  { id: 2, title: '제목2' },
  { id: 3, title: '제목3' }
]

let filterData = data.filter((item, index) => item.id !== 1)

console.log(data) // [ { id: 1, title: '제목1' }, { id: 2, title: '제목2' }, { id: 3, title: '제목3' } ]
console.log(filterData) // [ { id: 2, title: '제목2' }, { id: 3, title: '제목3' } ]

 

가변 인수 함수와 순수 함수

가변 인수(variadic arguments)는 함수를 호출할 때 전달하는 인수의 개수를 제한하지 않는다.

 

  1. 가변 인수로 호출할 때 타입에 상관없이 동작하게 하기 위해서 제네릭 타입으로 구현한다.
  2. 전개 연산자를 사용해 가변 인수를 표현한다.
  3. 가변 인수로 전달하는 값이 배열이기 때문에 타입을 배열의 배열로 선언하고, 매개변수는 변경되면 안되기 때문에 readonly로 선언한다.

 

const mergeArr = <T>(...arr: readonly T[][]): T[] => {
  let result: T[] = []

  for(let i = 0; i < arr.length; i++) {
    const array: T[] = arr[i]
    result = [...result, ...array]
  }

  return result
}

console.log(mergeArr([1, 2, 3])) // [1, 2, 3]
console.log(mergeArr(['hello', 'world'])) // [ 'hello', 'world' ]
console.log(mergeArr([{name: '희재', age: 27}])) // [ { name: '희재', age: 27 } ]

 

순수 함수를 고려하면 사실상 자바스크립트 배열이 제공하는 많은 메서드를 사용할 수 없지만,
전개 연산자 등의 메커니즘을 사용하면 순수 함수 형태로 간단하게 표현될 수 있음을 알아야 한다.

 


05-5 튜플 이해하기

튜플이란, 길이와 타입이 고정된 배열이다. 배열에 담긴 데이터를 만들 때 순서를 무시하고 만들게 되는 오류를 방지할 수 있다.

또한 튜플은 물리적으로 배열이기 때문에 배열처럼 인덱스 연산자나 비구조화 할당문을 적용할 수 있다.

// 타입 별칭으로 튜플의 의미를 정확하게 한다.
type tupleType = [number, string]

const tuple1: tupleType = [1, 'title1']
const tuple2: tupleType = ['title2', 2] // Type 'string' is not assignable to type 'number'.

console.log(tuple1[0], tuple1[1]) // 1, title1 (인덱스 연산자 사용)

// 비구조화 할당
let [id, title] = tuple1 
console.log(id, title) // 1, title1

 

그러나 튜플의 의미와 맞지 않게 push 메서드를 사용해 배열의 길이를 늘릴 수 있어 주의해야 한다. 

type tupleType = [number, string]

const tuple: tupleType = [1, 'title']

tuple.push('content')
tuple.push(true) // Argument of type 'boolean' is not assignable to parameter of type 'string | number'.

console.log(tuple) // [ 1, 'title', 'content' ]

 

 

 

참고자료

Do it! 타입스크립트 프로그래밍

결과 화면

 


1. styled-components, @types/styled-components 설치하기

styled-components 패키지와 @types/styled-components 패키지를 설치한다.

 

자바스크립트일 경우, styled-components 패키지만 설치해도 되지만,

타입스크립트에서 사용하기 위해서는 @types/styled-components 패키지도 설치해야 한다.

yarn add styled-components
또는
npm install styled-components
yarn add @types/styled-components
또는
npm install @types/styled-components

 

2. Button 컴포넌트 만들기

2-1. StyledButton 만들기

  • src/components/Button.tsx

styled-components를 import 한다.

StyledButton 컴포넌트를 만든 후, `` 안에 css를 작성한다.

StyledButton 컴포넌트를 적용할 Button 컴포넌트를 만든다. 

import styled from 'styled-components'

const StyledButton = styled.button`
  // 필요한 css를 작성한다.
  
  width: 100%;
  height: 50px;
  ...
`

const Button = () => {
  return (
    <StyledButton>버튼</StyledButton>
  )
}

export default Button

 

2-2. StyledButton에 props 적용하기

props로 값을 받기 위해서는 ${(props) => props.~} 형태로 받아야 한다.

 

backgroundColor 변수를 만들고, 필요한 값을 작성한다. (background-color가 필요했을 뿐, 다른 값들도 가능하다.)

props로 넘길 값(backgroundColor)의 타입을 정의하기 위해 interface를 만든다.

StyledButton 컴포넌트에 타입(ButtonProps)과 props로 넘길 값을 정의한다.

Button 컴포넌트의 파라미터에 variant 값을 넘긴다.

import styled from 'styled-components'

const backgroundColor = {
  primary: '#677987',
  secondary: '#B4B6AC'
}

interface ButtonProps {
  readonly variant: 'primary' | 'secondary'
}

const StyledButton = styled.button<ButtonProps>`
  width: 100%;
  height: 50px;
  background-color: ${(props) => backgroundColor[props.variant]};
  text-align: center;
`

const Button = ( { variant }: ButtonProps) => {
  return (
    <StyledButton variant={variant}>버튼</StyledButton>
  )
}

export default Button

 

2-3. 부모 컴포넌트에 값 전달하기

Button 컴포넌트의 텍스트도 props로 전달하기 위해서 children을 사용한다.

 

interface에 children의 타입을 정의한다.

Button 컴포넌트의 파라미터에 childred 값을 넘긴다.

import styled from 'styled-components'

const backgroundColor = {
  primary: '#677987',
  secondary: '#B4B6AC'
}

interface ButtonProps {
  children: string
  readonly variant: 'primary' | 'secondary'
}

const StyledButton = styled.button<ButtonProps>`
  width: 100%;
  height: 50px;
  background-color: ${(props) => backgroundColor[props.variant]};
  text-align: center;
`

const Button = ({ children, variant }: ButtonProps) => {
  return (
    <StyledButton variant={variant}>{children}</StyledButton>
  )
}

export default Button

 


최종 코드

  • src/components/Button.tsx
import styled from 'styled-components'

const backgroundColor = {
  primary: '#677987',
  secondary: '#B4B6AC'
}

const textColor = {
  primary: '#FCFCFC',
  secondary: '#FCFCFC'
}

interface ButtonProps {
  children: string
  readonly variant: 'primary' | 'secondary'
}

const StyledButton = styled.button<ButtonProps>`
  width: 100%;
  height: 50px;
  border-radius: 5px;
  background-color: ${(props) => backgroundColor[props.variant]};
  color: ${(props) => textColor[props.variant]};
  font-size: 16px;
  text-align: center;
  transition: all 0.3s;
  
  &:hover {
    opacity: 0.8;
  }
`

const Button = ({ children, variant }: ButtonProps) => {
  return (
    <StyledButton variant={variant}>{children}</StyledButton>
  )
}

export default Button

 

  • src/App.tsx

Button 컴포넌트를 import 한다.

props로 넘길 값들(children, variant)을 작성한다.

 

Title 컴포넌트도 같은 방식으로 작성됐다.

import Title from '../../components/base/Title'
import Button from '../../components/form/Button'
import './index.scss'

const App = () => {
  return (
    <>
      <div className="board-create">
        <Title children="Write content"/>
        
        <Button children="Confirm" variant="primary"/>
        <Button children="Cancel" variant="secondary"/>
      </div>
    </>
  )
}

export default App

결과화면

 


1. react-router-dom 설치하기

react-router-dom 패키지를 설치한다.

설치가 완료되면 packae.json 파일에서 확인할 수 있다.

yarn add react-router-dom
또는
npm install react-router-dom

 

2. BrowerRouter 컴포넌트를 최상위 태그에 감싸기

  • src/index.tsx

App 컴포넌트 위에 BrowerRouter 컴포넌트를 감싼다.

import React from 'react'
import ReactDOM from 'react-dom/client'
import { BrowserRouter } from 'react-router-dom'
import App from './App'

const root = ReactDOM.createRoot (
  document.getElementById('root') as HTMLElement
)

root.render(
  <React.StrictMode>
    <BrowserRouter>
      <App/>
    </BrowserRouter>
  </React.StrictMode>
)

 

3. path를 설정하기

  • src/App.tsx

path와 그에 해당하는 element 컴포넌트를 작성한다.

import React from 'react'
import { Routes, Route } from 'react-router-dom'
import Layout from './components/layouts/Layout'
import MainPage from './pages/main'
import BoardPage from './pages/board'
import './assets/scss/common.scss'

const App = () => {
  return (
    <>
      {
        <Layout>
          <Routes>
            <Route path="/" element={<MainPage/>}/>
            <Route path="/board" element={<BoardPage/>}/>
          </Routes>
        </Layout>
      }
    </>
  )
}

export default App

결과 화면

 


1. node-sass 설치하기

node-sass 패키지를 설치한다.

설치가 완료되면 packae.json 파일에서 확인할 수 있다.

yarn add node-sass
또는
npm install node-sass

 

2. SCSS 작성하기

  • src/assets/scss/components/header.scss
header {
  width: 100%;

  .inner {
    display: flex;
    justify-content: space-between;
    align-items: center;
    height: 80px;

    h1 {
      a {
        font-family: 'Cherry Bomb One', cursive;
      }
    }

    nav {
      ul {
        display: flex;
        justify-content: space-between;
        align-items: center;

        li {
          padding-left: 20px;
        }
      }
    }
  }
}

 

  • src/components/layouts/Heaser.tsx

작성한 scss 파일을 상단에 import 시킨다.

import '../../assets/scss/components/header.scss'

const Header = () => {
  return (
    <>
      <header>
        <div className="inner">
          <h1><a href="/">BOB</a></h1>

          <nav>
            <ul>
              <li><a href="/">menu01</a></li>
              <li><a href="/">menu02</a></li>
              <li><a href="/">menu03</a></li>
            </ul>
          </nav>
        </div>
      </header>
    </>
  )
}

export default Header

 

  • src/assets/scss/common.scss

reset.scss, font.scss 등 공통적으로 필요한 scss 파일을 페이지마다 import 하면 번거롭고, 코드도 길어지기 때문에 common.scss를 만들어 한 개의 scss 파일에 작성되도록 한다.

// base
@import './base/reset';
@import './base/font';

// layout
@import './layout/layout';

 

  • src/App.tsx

최종적으로 common.scss를 App 컴포넌트에 import 한다.

import React from 'react'
import Layout from './components/layouts/Layout'
import './assets/scss/common.scss'

const App = () => {
  return (
    <Layout>
      <h1>내용을 작성해 주세요.</h1>
    </Layout>
  )
}

export default App

결과 화면

 


1. 레이아웃 컴포넌트 만들기

  • src/components/layouts/Header.tsx
const Header = () => {
  return (
    <>
      <header>헤더 컴포넌트입니다.</header>
    </>
  )
}

export default Header

 

  • src/components/layouts/Footer.tsx
const Footer = () => {
  return (
    <>
      <footer>푸터 컴포넌트입니다.</footer>
    </>
  )
}

export default Footer

 

  • src/components/layouts/Layout.tsx

헤더와 푸터는 페이지마다 공통으로 보여지는 영역이기 때문에 import 해서 사용하면 되지만,

메인의 컨텐츠 영역은 페이지마다 내용이 바뀌기 때문에 props로 사용한다.

import Header from './Header'
import Footer from './Footer'

const Layout = (props: {children: React.ReactNode}) => {
  return (
    <>
      <Header/>

      <main>{props.children}</main>

      <Footer/>
    </>
  )
}

export default Layout

 

2. index.tsx, App.tsx 수정하기

  • src/index.tsx

불필요한 소스를 삭제한다.

import React from 'react'
import ReactDOM from 'react-dom/client'
import App from './App'
import './index.css'

const root = ReactDOM.createRoot(
  document.getElementById('root') as HTMLElement
)

root.render(
  <React.StrictMode>
    <App/>
  </React.StrictMode>
)

 

  • src/App.tsx

레이아웃 컴포넌트를 import 한다.

<h1>의 내용이 <Layout> 컴포넌트의 <main> 태그 안에 들어가게 된다.

<Layout> 컴포넌트로 감싸 여러 페이지들을 만들면 된다.

import React from 'react'
import Layout from './components/layouts/Layout'
import './App.css'

const App = () => {
  return (
    <Layout>
      <h1>내용을 작성해 주세요.</h1>
    </Layout>
  )
}

export default App

1. Node.js 설치하기

https://nodejs.org/ko

Node.js는 Chrome V8 JavaScript 엔진으로 빌드된 JavaScript 런타임이다.

 

위의 정의는 노드를 통해서 자바스크립트 애플리케이션을 실행할 수 있다는 의미이다.

타입스크립트는 자바스크립트에 타입을 추가한 언어이기 때문에 타입스크립트를 사용하기 위해서는 Node.js를 먼저 설치해야 한다.

 

1-1. Node.js 버전 확인하기

node --version
또는
node -v

 

 

2. typescript, ts-node 글로벌 설치하기

typescript와 ts-node를 글로벌로 설치하면 리액트 프로젝트가 아니더라도 타입스크립트를 사용할 수 있기 때문에 따로 설치하는 것이 좋다.

또한 글로벌이기 때문에 1번만 설치하면 추가 설치 없이 바로 사용할 수 있다.

yarn add -g typescript ts-node
또는
npm install -g typescript ts-node

 

2-1. typescript, ts-node 버전 확인하기

tsc --version 또는 tsc -v

ts-node --version 또는 ts-node -v

 

 

3. 프로젝트 만들기

yarn create react-app 폴더명 --template typescript
또는
npx create-react-app 폴더명 --template typescript

 

tsx 파일이 생성됐는지 확인한다.

 

 

4. 불필요한 파일 삭제하기

src 폴더에서 App.css, App.tsx, index.css, index.tsx 파일만 남기고 전부 삭제한다.

 

5. 로컬호스트 연결 확인하기

http://localhost:3000/

터미널에서 yarn start 명령어를 실행해 로컬호스트에 접속이 잘 되는지 확인한다.

아래와 같은 화면이 나온다면 정상적으로 세팅이 완료된 것이다.

 

04-1 함수 선언문

자바스크립트에서 함수는 function 키워드로 만든 함수=> 기호로 만든 화살표 함수 2가지가 있다.

 

타입스크립트 함수 선언문은 매개변수와 함수 반환값(return)에 타입 주석을 붙이는 형태이다.

함수 선언문에서도 매개변수와 반환값에 타입 주석을 생략할 수 있지만, 타입이 생략되어 있으면 함수의 구현 의도를 알기 어렵기 때문에 바람직하지 않다.

 

function addNumber(~~)의 괄호 안의 값을 parameter, 매개변수 라고 하고,

콘솔의 addNumber(~~)의 괄호 안의 값을 argument, 인수, 인자 라고 한다.

 

  • function 키워드로 만든 함수
function addNumber(num1: number, num2: number): number {
  return num1 + num2
}

console.log(addNumber(1, 2)) // 3

 

  • => 기호로 만든 화살표 함수
const addString = (str1: string, str2: string): string => str1 + str2

console.log(addString('가나다', '라마바')) // 가나다라마바

 

void 타입

void 타입은 값을 반환하지 않는 함수이다.

function printMe(name: string, age: number): void {
  console.log(`name: ${name}, age: ${age}`)
}

printMe('HeeJae', 29) // name: HeeJae, age: 29

 

type 키워드로 타입 별칭 만들기

타입 별칭(type alias)의 type 키워드는 기존에 존재하는 타입을 단순히 이름만 바꿔서 사용할 수 있게 해 준다.

함수를 선언할 때, 타입 별칭을 사용하면 매개변수의 개수, 타입, 반환 타입이 다른 함수를 선언하는 것을 미리 방지할 수 있다.

type stringNumberFunc = (arg1: string, arg2: number) => void

let f: stringNumberFunc = function(a: string, b: number): void {
  console.log(a, b)
}

f('Heejae', 29) // { name: 'Heejae', age: 29 }
f('Heejae') // Expected 2 arguments, but got 1.
f() // Expected 2 arguments, but got 0.

 

type vs interface

타입 별칭과 인터페이스의 가장 큰 차이점은 확장 가능, 불가능의 여부이다.

인터페이스는 확장이 가능하지만, 타입별칭은 확장이 불가능하기 때문에 타입 별칭보다는 인터페이스를 사용하는 것을 추천한다.

 

undefined 관련 주의 사항

타입스크립트에서 undefined은 타입이면서 값이기 때문에 값을 변경할 수가 없다.

초기화를 안 했거나 값이 없을 경우, undefined으로 나오는데 오류를 방지하기 위해서 매개변수 값이 undefined인지 판별하는 코드를 작성해야 한다.

 

필수 속성은 값이 있어야 하기 때문에 undefined를 할당하면 오류가 발생하고,

선택속 성은 값이 없어도 되기 때문에 undefined를 판별하는 코드가 있으면 오류가 발생하지 않는다.

 

FIXME: getName(undefined!)에서 !가 없으면 오류, Argument of type 'undefined' is not assignable to parameter of type 'INameable'.

// 필수속성 undefined
interface INameable {
  name: string
}

function getName(userName: INameable) {
  return userName !== undefined ? userName.name : 'unknown name'
}

console.log(getName(undefined!)) // unknown name
console.log(getName({name: 'Heejae'})) // Heejae
// 선택속성 undefined
interface IAgeable {
  age?: number
}

function getAge(userAge: IAgeable) {
  return userAge !== undefined && userAge.age ? userAge.age : 'unknow age'
}

console.log(getAge(undefined!)) // unknow age
console.log(getAge({age: 29})) // 29

 

선택적 매개변수

인터페이스의 선택 속성처럼 함수의 매개변수에도 물음표(?)를 붙여 선택적 매개변수를 만들 수 있다.

function userList(name: string, age?: number) {
  console.log(`name: ${name}, age: ${age}`)
}

userList('Heejae', 29) // name: Heejae, age: 29
userList('Heejae') // name: Heejae, age: undefined

 


04-2 함수 표현식

타입스크립트와 자바스크립트는 객체지향 언어와 함수형 언어의 특징을 모두 가지고 있다.

 

함수 표현식을 선언할 때는 let보다는 const 키워드로 선언하는 것이 바람직하다.

let 변수는 값이 변할 수 있고, const 변수는 값이 절대로 변하지 않기 때문이다. 

 

  • 변수 선언문 형태의 함수
const add = new Function('a', 'b', 'return a + b')

console.log(add(1, 2)) // 3

 

  • 함수 표현식 형태의 함수
const add = function(a: number, b: number) { return a + b }

console.log(add(1, 2)) // 3

 

표현식: 리터럴, 연산자, 변수, 함수 등 복합적으로 구성된 코드 형태

함수 표현식(=익명함수): 함수 이름을 제외한 함수 코드

함수 호출: 함수 표현식의 몸통 부분을 실행

 

일등 함수

일등 함수란, 변수와 함수를 구분하지 않는다는 의미이다.

위의 코드를 보면 add 라는 변수에 함수를 할당했기 때문에 add가 변수인지 함수인지 사실상 구분할 수 없다.

 


04-3 화살표 함수와 표현식 문

C언어는 모든 문장이 반드시 세미콜론 ;으로 끝나야 하고, C언어 구문을 참조해 만든 ES5 자바스크립트 또한 모든 문장 끝에 세미콜론이 있어야 한다. 반면에 ESNext 자바스크립트와 타입스크립트에서는 세미콜론을 생략할 수 있다.

 

  • 실행문 지향 언어

실생문은 CPU에서 실행되는 코드를 의미한다. 

실행문은 CPU에서 실행만 될 뿐 결과는 알려주지 않기 때문에 return 키워드를 사용해서 실행된 결과를 알려줘야 한다.

 

ex) C언어, ES5, ESNext, 타입스크립트

const add = (a: number, b: number): number => {return a + b}

console.log(add(1, 2)) // 3

 

  • 표현식 지향 언어

표현식은 CPU에서 실행된 결과를 return 키워드를 사용하지 않아도 알려준다.

 

ex) 스칼라, ESNext, 타입스크립트

const add = (a: number, b: number): number => a + b

console.log(add(1, 2)) // 3

 

실행문과 표현식을 동시에 지원하는 언어 = 다중 패러다임 언어= ESNext, 타입스크립트

 

복합 실행문과 return

복합 실행문은 중괄호{}를 사용해서 작성하고, 컴파일러는 여러 줄의 실행문을 한 줄의 실행문으로 인식한다.

실행문에서 return을 작성하지 않으면 'void 함수 반환 값이 사용되었습니다' 라는 오류가 발생한다.

return 키워드는 반드시 함수의 몸통에서만 사용할 수 있다.

 

복합 실행문의 유효범위는 local scope(지역 범위)이다.

function f() {
  let x = 1
  return x
}

function g() {
  let x = 2
  return x
}

console.log(f()) // 1
console.log(g()) // 2

 


04-4 일등 함수 살펴보기

콜백 함수

콜백 함수는 매개변수 형태로 동작하는 함수이다.

콜백 함수는 프레임워크의 API 구현에 매우 유용하다.

export const init = (callback: () => void): void => {
  console.log('first message')
  callback()
  console.log('second message')
}

init(() => console.log('function message'))

// first message
// function message
// second message

 

중첩 함수

함수형 언어에서 함수는 함수 표현식 안에 또 다른 함수를 작성할 수 있다.

const calc = (num1: number, num2: (result: number) => void): void => {
  let add = (a: number, b: number) => a + b

  function multiply(a: number, b: number) {return a * b}
  let result = multiply(add(1, 2), num1)

  num2(result)
}

calc(30, (result: number) => console.log(`result is ${result}`)) // result is 90

 

고차 함수와 클로저, 그리고 부분 함수

고차 함수는 또 다른 함수를 반환하는 함수이다. 함수형 언어에서 함수 표현식 또한 값이기 때문에 다른 함수를 반환할 수 있다.

고차 함수는 함수 안에 또 다른 함수가 있기 때문에 변수의 스코프가 중요한데, 함수를 return 하고, return 하는 함수가 클로서를 형성한다.

const add = (a: number): (b: number) => number => (b: number): number => a + b
const result = add(10)(20)

console.log(result) // 30

 


04-5 함수 구현 기법

매개변수 기본값 지정하기

선택적 매개변수는 항상 그 값이 undefined로 고정된다. 만약 함수 호출 시, 인수를 전달하지 않더라도 매개변수에 어떤 값을 설정하고 싶다면 기본값을 지정할 수 있고, 이를 디폴트 매개변수라고 한다.

export type Person = {name: string, age: number}

export const makePerson = (name: string, age: number = 10): Person => {
    // 단축 구문(shorthand)
    const person = {name, age}
    return person
}

console.log(makePerson('Jack')) // { name: 'Jack', age: 10 }
console.log(makePerson('Jack', 33)) // { name: 'Jack', age: 33 }

 

객체를 반환하는 화살표 함수 만들기

화살표 함수에서 객체를 반환할 때, 아래처럼 중괄호로 구현한다면 객체가 아닌 복합 실행문으로 해석하여 오류가 발생한다.

export type Person = {name: string, age: number}

// Left side of comma operator is unused and has no side effects.
export const makePerson = (name: string, age: number = 10): Person => {name, age}

소괄호로 감싸주어 객체임을 알려준다.

export type Person = {name: string, age: number}

export const makePerson = (name: string, age: number = 10): Person => ({name, age})

console.log(makePerson('Jack')) // { name: 'Jack', age: 10 }
console.log(makePerson('Jack', 33)) // { name: 'Jack', age: 33 }

 

매개변수에 비구조화 할당문 사용하기

비구조화: 구조화된 데이터의 일부만 사용하는 것

객체뿐만 아니라 함수의 매개변수도 비구조화 할당문을 적용할 수 있다.

export type Person = {name: string, age: number}

export const makePerson = ({name, age}: Person): void => {
    console.log(`My name is ${name}. My age is ${age}.`)
}

console.log(makePerson({name: 'Jack', age: 10})) // My name is Jack. My age is 10.

 

색인 키와 값으로 객체 만들기

색인 가능 타입(indexable type)은 {[key]: value} 형태를 의미하고, key와 value의 타입을 명시한다.

객체의 속성 이름을 변수로 만들 때 사용한다. (키 값을 변경할 수 있다.)

export type KeyValeuType = {
    [key: string]: string
}

const makeObject  = (key: string, value: string): KeyValeuType => (
    {[key]: value}
)

console.log(makeObject('key', 'value')) // { key: 'value' }
console.log(makeObject('NAME', 'Jack')) // { NAME: 'Jack' }

 


04-6 클래스 메서드

function 함수와 this 키워드

function 키워드로 만든 함수는 this를 사용할 수 있지만,

화살표 함수는 this를 사용할 수 없다.

 

클래스 메서드 구문

타입스크립트에서 메서드는 function으로 만든 함수 표현식을 담고 있는 속성이다.

생성자를 통해 전달된 값이 value에 설정되고, method가 호출돼서 값이 출력된다.

export class B {
    constructor(public value: number = 1) {}
    method(): void {
        console.log(`value: ${this.value}`)
    }
}

let a: B = new B()
a.method() // value: 1

let b: B = new B(2)
b.method() // value: 2

 

정적 메서드

메서드 이름 앞에 static을 붙여 정적 메서드를 만들 수 있다.

export class C {
    static whoAreYou(): string {
        return 'I am class C'
    }
}

export class D {
    static whoAreYou(): string {
        return 'I am class D'
    }
}

console.log(C.whoAreYou()) // I am class C
console.log(D.whoAreYou()) // I am class D

 

메서드 체인

메서드 체인(method chain)은 객체의 메서드를 이어서 계속 호출하는 방식의 코드를 의미하고, 타입스크립트로 메서드 체인을 구현하려면 메서드가 항상 this를 반환해야 한다.

export class Caculator {
    constructor(public value: number = 0) {}

    add(value: number) {
        this.value += value
        return this
    }

    multiply(value: number) {
        this.value *= value
        return this
    }
}

let calc = new Caculator
let result = calc.add(1).add(2).multiply(3).multiply(4).value

console.log(result) // (((0 + 1 + 2) * 3) * 4) = 36

 

 

 

참고자료

Do it! 타입스크립트 프로그래밍

03-1 타입스크립트 변수 선언문

타입스크립트 타입

let name:string = '이희재'

let age:number = 29

let isAdult:boolean = true

let a:null = null

let b:undefined = undefined // undefined은 타입이면서 값이고, undefined 값만 가질 수 있다.

// 배열
let arr1:number[] = [1, 2, 3]
let arr2:Array<number> = [1, 2, 3]

let arr3:string[] = ['hello', 'world']
let arr4:Array<string> = ['hello', 'world']

// 튜플
let tuple:[string, number]

tuple = ['hello', 100]
tuple = [10, 100] // Type 'number' is not assignable to type 'string'.

tuple[0].toLowerCase()
tuple[1].toLowerCase() // Property 'toLowerCase' does not exist on type 'number'.

// void: 함수에서 아무것도 반환하지 않을 때 사용
function sayHello():void {
  console.log('hello')
}

// never: error를 반환하거나 영원히 끝나지 않는 함수일 때 사용
function infLoop():never {
  throw new Error()

  while(true) {
	
  }
}

// enum: 자바스크립트에는 없는 타입, 아무것도 정의하지 않으면 0부터 1씩 증가하면서 할당
enum Os1 {
  Window, // 0
  Ios,    // 1
  Android // 2
}

enum Os2 {
  Window = 5,
  Ios,    // 6
  Android // 7
}

// 숫자가 아닐 때는 단방향 맵핑만 된다.
enum Os3 {
  Window = 'win',
  Ios = 'ios',
  Android = 'and'
}

console.log(Os1) // Window: 0, Ios: 1, Android: 2
console.log(Os2[5]) // Window
console.log(Os3.Window) // win

 

any 타입

any 타입은 변수의 값이 타입과 무관하게 어떤 종류의 값도 저장할 수 있다.

let random:any = '랜덤'

random = 100
random = true
random = null
random = undefined
random = [1, 2, 3]

 

undefined 타입

undefined 타입은 타입이면서 값이고, 오직 undefined 값만 가질 수 있다.

변수를 선언하고, 초기화를 하지 않으면 undefined 값을 가지는 것이 아니라 에러가 발생하기 때문에 주의해야 한다.

초기값이 없을 경우, undefined으로 선언하고 null safe(?)를 사용하는 방식으로 해결할 수도 있지만, 변수 초기화를 해주는 것이 좋다.

let num:number
console.log(num) // Variable 'num' is used before being assigned.

let num:undefined
console.log(num) // undefined

 

let과 const 키워드

  • var

var 변수는 재선언(중복 선언)되고, 재할당(업데이트) 된다.

var 변수로 선언할 경우, 유지보수의 어려움이 있어 ESNext에서 var 키워드는 사용하지 말라고 권고한다.

 

  • let

let 변수는 재할당은 가능하지만, 재선언은 불가능하다.

let으로 선언한 변수는 코드에서 그 값이 수시로 변경될 수 있음을 암시한다.

 

  • const

const 변수는 재선언, 재할당 모두 불가능하다.

const로 변수를 선언할 때는 반드시 초깃값을 명시해야 하고, 변숫값이 절대로 바뀌지 않는다.

 

타입 주석

타입 주석(type annotation)은 자바스크립트 변수 선언문을 확장해 타입을 명시하는 것을 의미한다.

let으로 선언한 변수는 값을 변경할 수 있지만, 선언된 타입과 다른 타입의 값으로 바꾸려고 하면 오류가 발생한다.

let 변수 이름: 타입
const 변수 이름: 타입 = 초깃값

let name:string = '이희재'
let age:number = 29
let isAudult:boolean

age =  30
age = '삼십' // Type 'string' is not assignable to type 'number'.

 

타입 추론

타입스크립트는 자바스크립트와 호환성을 위해 타입 주석 부분을 생략할 수 있다.

타입 추론(type inference)은 대입 연산자(=)가 오른쪽 값에 따라 변수의 타입을 지정하는 것을 의미한다.

let name = '이희재' // name을 string로 판단
let age = 29 // age를 number로 판단

 

템플릿 문자열

템플릿 문자열은 변수에 담긴 값을 조합해 문자열을 만들 수 있게 한다.

`${변수 이름}`

let count = 10
let message = 'Your count'
let result = `${message} is ${count}`

console.log(result) // Your count is 10

 


03-2 객체와 인터페이스

object 타입은 인터페이스와 클래스의 상위 타입이다.

object 타입으로 선언된 변수는 속성 이름이 다른 객체를 자유롭게 담을 수 있다.

 

아래 코드는 오류가 나지 않는 정상 코드이다.

속성값이 달라져도 오류가 발생하지 않기 때문에 오류 검출 및 유지보수를 위해서 타입 스크립트의 인터페이스 구문이 생겨났다.

let obj:object = { name: '이희재', age: 29 }
obj = { first: 1, second: 2 }

 

인터페이스 선언문

interface 키워드는 객체의 타입을 정의할 수 있다.

인터페이스를 설계할 때 필수 속성과 선택 속성이 있고, 속성 이름 뒤에 물음표 기호를 붙이면 선택 속성이 된다.

// 속성들이 여러 개일 경우, 쉼표, 세미콜론 또는 줄바꿈을 구분자로 사용한다.
interface IPerson {
  name: string
  age: number
  isAdult?: boolean // 선택 속성
  readonly birthYear: number // 읽기만 가능하고, 값을 변경할 수 없다.
}


let person1:IPerson = {
  name: '이희재',
  age: 29,
  isAdult: true,
  birtyYear: 1995
}
person1.birthYear = 2000 // Cannot assign to 'birthYear' because it is a read-only property.


Type '{ name: string; }' is missing the following properties from type 'IPerson': age, birthYear
let person2:IPerson = {
  name: '이희재'
}


// 'number' does not exist in type 'IPerson'.
let person3:IPerson = {
  name: '이희재',
  age: 29,
  number: '010-1111-1111'
}

 

익명 인터페이스

익명 인터페이스는 interface 키워드도 사용하지 않고, 인터페이스 이름도 없는 인터페이스를 의미한다.

let ai: {
  name: string
  age: number
  etc?: boolean
} = { name: 'Tom', age: 20 }

console.log(ai) // { name: 'Tom', age: 20 }

 


03-3 객체와 클래스

클래스 선언문

타입스크립트는 C++나 자바 같은 객체지향 언어에서 흔히 볼 수 있는 class, private, public, protected, implements, extend와 같은 키워드를 제공한다.

 

타입스크립트에서 생성자 변수의 타입을 선언하지 않으면 에러가 발생한다.

class Person {
  name: string
  age?: number

  // 생성자: 클래스의 속성(name, age)를 선언할 수 있다.
  constructor(name: string, age?: number) {
    this.name = name
    this.age = age
  }
}

let jack:Person = new Person()
jack.name = 'Jack'
jack.age = 32

console.log(jack) // Person { name: 'Jack', age: 32 }

 

접근 제한자

  • public

클래스 내부, 자식 클래스, 클래스 인스턴스 모두 접근이 가능하다. 아무것도 작성하지 않으면 public으로 간주한다.

 

  • protected

클래스 내부, 자식 클래스에서 접근이 가능하다.

 

  • private

클래스 내부에서만 접근이 가능하다.  캡슐화

외부에서 필요하지 않은 메서드(ex. 비밀번호 암호화 로직) 또는 임의로 변경하면 안 되는 데이터(ex. 계산기에서의 값은 계산을 통해서만 변경, 직접 값을 변경 X)를 만들 때 주로 private로 선언한다.

 

 접근 가능성  public  protected  private
 클래스 내부  O  O   O
 자식 클래스 내부  O  O  X
 클래스 인스턴스  O  X  X

 

class Car {
  public color: string // Car { color: 'black' }
  protected color: string // Property 'color' is protected and only accessible within class 'Car' and its subclasses.
  private color: string // Property 'color' is private and only accessible within class 'Car'.
  
  constructor(color: string) {
    this.color = color
  }
}

let bmw:Car = new Car()
bmw.color = 'black'

console.log(bmw)

 

인터페이스 구현

implements 키워드는 클래스가 인터페이스를 구현할 때 사용한다.

클래스에는 반드시 인터페이스가 정의하고 있는 속성을 멤버 속성으로 포함해야 한다.

 

인터페이스가 정의하고 있는 속성을 모두 포함하고 있지 않으면(name 또는 age가 하나라도 없으면) 해당 에러가 발생한다.

Class 'User' incorrectly implements interface 'IUser'.   Property 'age' is missing in type 'User' but required in type 'IUser'.

interface IUser {
  name: string
  age: number
}

class User implements IUser {
  name: string
  age: number

  constructor(name: string, age: number) {
    this.name = name
    this.age = age
  }
}

let tom:IUser = new User('Tom')

console.log(tom) // User { name: 'Tom', age: undefined }

 

추상 클래스

abstract 키워드는 추상 클래스를 정의할 때 사용하고, 직접 인스턴스를 생성할 수 없고, 상속만을 위해 사용된다.

즉, 프로퍼티나 메서드의 이름만 선언해 주고(몸체가 구현되지 않았다.), 구체적인 기능은 상속받은 쪽에서 작성할 때 사용한다.

 

클래스의 상속

extends 키워드를 사용해서 상속 클래스를 만든다.

super 키워드는 부모 클래스의 생성자를 호출할 수 있다.

abstract class Car {
  color: string
  wheel: number

  constructor(color: string, wheel: number) {
    this.color = color
    this.wheel = wheel
  }

  abstract changeColor(color: string): string
  abstract wheelCount(wheel: number): number
}

class kia extends Car {
  constructor(color: string, wheel: number) {
    super(color, wheel)
  }

  changeColor(): string {
    return 'change color'
  }

  wheelCount(): number {
    return 4
  }
}

const k5: kia = new kia('white', 4)

console.log(k5) // kia { color: 'white', wheel: 4 }
console.log(k5.changeColor()) // change color
console.log(k5.wheelCount()) // 4

 

static 속성

static 키워드는 다른 객체지향 언어처럼 클래스 정적 메서드를 정의한다. (정적인 속성을 가질 수 있다.)

정적 메서드는 인스턴스가 아닌 클래스 이름으로 호출하고, 클래스의 인터페이스를 생성하지 않아도 호출할 수 있다.

정적 메소드는 this를 사용할 수 없다.

class A {
  static first: number = 1
  second: number = 2
}

let first = A.first
let second = A.second // Property 'second' does not exist on type 'typeof A'.

console.log(first) // 1

 


03-4 객체의 비구조화 할당문

구조화

구조화(structuring)는 인터페이스나 클래스를 사용해 관련된 정보를 묶어 새로운 타입으로 표현하는 것을 의미한다..

// 구조화
export interface IPerson {
  name: string
  age: number
}

export interface ICompany {
  name: string
  age: number
}

let jack:IPerson = {
  name: 'Jack',
  age: 29
}

let naver:ICompany = {
  name: 'Naver',
  age: 10
}

console.log(jack) // { name: 'Jack', age: 29 }
console.log(naver) // { name: 'Naver', age: 10 }

 

비구조화

구조화된 데이터는 어떤 시점에서 일부만 사용해야 할 때가 있다.

이때 구조화된 데이터를 분해하는 것을 비구조화(destructuring) 라고 한다.

// 비구조화
let jack_name = jack.name
let jack_age = jack.age

console.log(jack_name, jack_age) // Jack 29

// 비구조화 할당: 중괄호로 묶어 각각의 초깃값으로 할당받는다.
let {name, age} = naver

console.log(name, age) // Naver 10

 

잔여 연산자

... 잔여 연산자를 사용하면 country와 city를 제외한 나머지 속성들이 담긴다.

let address:any = {
  country: 'Korea',
  city: 'Seoul',
  address1: '양천구',
  address2: '목동서로',
  address3: '221'
}

const {country, city, ...detail} = address

console.log(country) // 대한민국
console.log(city) // 서울
console.log(detail) // { address1: '양천구', address2: '목동서로', address3: '221' }

 

전개 연산자

... 전개 연산자를 사용하면 객체의 속성을 모두 전개해 새로운 객체로 만들어 준다.

let name = {name: 'Jack'}
let age = {age: 30}

const userInfo = {...name, ...age}

console.log(userInfo) // { name: 'Jack', age: 30 }

 


03-5 객체의 타입 변환

타입 변환(type conversion)은 특정 타입의 변숫값을 다른 타입의 값으로 변환할 수 있는 기능이다.

let person: object = {name: 'Jack', age: 32};

person.name // Property 'name' does not exist on type 'object'.

(<{name: string}>person).name // Jack

 

타입 단언

타입 단언(type assertion)은 컴파일러에게 타입을 확실히 알려주기 위해 사용하고,

강제로 타입을 지정하는 것이기 때문에 타입을 만족하지 않더라도 오류를 무시한다.

 

타입을 변경하기 위해서 as 타입 단언을 사용하지 않는 것은 좋지 않지만, 원시 타입에서 원시 타입으로 변경하거나 response(then, catch)에서 받은 값의 데이터 타입을 모를 때, as 타입 단언을 통해 데이터 타입을 주입시키는 용도로도 사용할 수 있다.

 

콜론(:)을 사용해서 타입을 지정하는 것은 타입 선언이고, 타입 선언을 이용하면 할당되는 값이 선언된 타입을 만족하는지 검사한다.

주의: react의 JSX에서 <> 꺽쇠 괄호를 사용하기 때문에 리액트에서는 as를 사용한다.

(<타입>객체)
(객체 as 타입)

export default interface INameable {
  name: string
}

let obj:object = {name: 'Jack'}

let name1 = (<INameable>obj).name
let name2 = (obj as INameable).name

console.log(typeof obj, obj) // object { name: 'Jack' }
console.log(typeof name1, name1) // string Jack
console.log(typeof name2, name2) // string Jack

 

 

참고자료

Do it! 타입스크립트 프로그래밍

02-1 타입스크립트 프로젝트 만들기

타입스크립트 개발은 nodejs 프로젝트를 만든 다음, 개발 언어를 타입스크립트로 설정하는 방식으로 진행한다.

 

프로젝트 생성자 관점에서 패키지 설치하기

1. 폴더 만들기

2. 만든 폴더로 이동 후, 터미널에서 npm init (package.json 파일이 생긴다.)

3. npm install -D typescript ts-node (node_modules 디렉터리가 생기고, 각 패키지의 디렉터리들을 확인할 수 있다.)

 

프로젝트 이용자 관점에서 패키지 설치하기

프로젝트를 구현할 때 여러 패키지를 설치하게 되므로 node_modules 디렉터리의 크기가 매우 커진다. 그래서 다른 사람들에게 프로젝트를 전달할 때 node_modules 폴더를 모두 지운다. package.json 파일이 있는 디렉터리의 터미널에서 npm install 또는 npm i 명령어를 실행하면 package.json에 등록된 패키지들이 node_modules 디렉터리에 자동으로 설치된다.

// package.json
{
  "name": "ch02-1",
  "version": "1.0.0",
  "description": "",
  "main": "src/index.js",
  "scripts": {
    "dev": "ts-node src",
    "build": "tsc && node dist"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "@types/chance": "^1.1.3",
    "@types/node": "^20.1.0",
    "@types/ramda": "^0.29.1",
    "ts-node": "^10.9.1",
    "typescript": "^5.0.4"
  },
  "dependencies": {
    "chance": "^1.1.11",
    "ramda": "^0.29.0"
  }
}

 

tsconfig.json 파일 만들기

tsc --init 명령어를 실행하면 타입스크립트 컴파일러의 설정파일인 tsconfig.json 파일이 만들어진다.

// tsconfig.json
{
  "compilerOptions": {
    "module": "commonjs",
    "moduleResolution": "node",
    "target": "es5",
    "baseUrl": ".",
    "outDir": "dist",
    "paths": {
      "*": [
        "node_modules/*"
      ]
    },
    "esModuleInterop": true,
    "sourceMap": true,
    "downlevelIteration": true,
    "noImplicitAny": false,

  },
  "include": [
    "src/**/*"
  ]
}

 


02-2 모듈 이해하기

타입스크립트에서는 index.ts와 같은 소스 파일을 모듈(module)이라고 한다.

소스 파일을 하나로 구현해도 되지만, 코드 관리와 유지보수를 편리하기 하기 위해서 모듈마다 고유한 기능을 구현하는 방식으로 소스코드를 분할한다. 이러한 작업을 모듈화(modulization) 라고 한다.

 

export 키워드

작성한 소스코드를 다른 파일에서 동작하게 하려면 export 키워드로 심벌을 내보낸다.

export 키워드는 interface, class, type, let, const 키워드 앞에도 붙일 수 있다.

 

export default 키워드

export default 키워드는 한 모듈이 내보내는 기능 중 오직 1개에만 붙일 수 있다.

export default가 붙은 기능은 import 문으로 불러올 때 중괄호 없이 사용할 수 있다.

export default interface IPerson {
  name: string,
  age: number
}

 

import 키워드

export 키워드로 내보낸 심벌을 사용하기 위해서 import 키워드로 해당 심벌을 불러온다.

import { 심벌목록 } from '파일 상대 경로'
import * as 심벌 from '파일 상대 경로'

import IPerson from './IPerson'

 

외부 패키지를 사용할 때 import 문

chance는 가짜 데이터를 만들어 주는 패키지이다.

ramda는 함수형 유틸리티 패키지이다.

npm i -S chance ramda
npm i -D @types/chance @types/ramda

import Chance from 'chance'
import * as R from 'ramda'

 


02-3 tsconfig.json 파일 살펴보기

콜론(:)을 기준으로 "키:키값" 형태로 작성한다.

// tsconfig.json
{
  "compilerOptions": {
    "module": "commonjs",
    "moduleResolution": "node",
    "target": "es5",
    "baseUrl": ".",
    "outDir": "dist",
    "paths": {
      "*": [
        "node_modules/*"
      ]
    },
    "esModuleInterop": true,
    "sourceMap": true,
    "downlevelIteration": true,
    "noImplicitAny": false,

  },
  "include": [
    "src/**/*"
  ]
}

 

  • compilerOptions

tsc 명령 형식에서 옵션을 나타낸다.

 

  • include

compilerOptions의 대상 파일 목록이다.

 

  • module

타입스크립트 소스코드가 컴파일되어 만들어진 자바스크립트 소스코드는 웹 브라우저와 nodejs 모두 동작해야 한다. 그런데 웹 브라우저와 nodejs는 물리적으로 동작하는 방식이 달라서 자바스크립트 코드 또한 웹 브라우저랑 nodejs에서 다르게 동작한다. 따라서 tsconfig.js 파일에서 module 키는 동작 대상이 웹 브라우저인지 nodejs인지 구분해줘야 한다.

 

웹 브라우저에서 동작: amd

nodejs에서 동작: commonjs

 

  • moduleResolution

module의 키 값이 amd이면 moduleResolution 키 값은 classic

module의 키 값이 commonjs이면 moduleResolution 키 값은 node

 

  • target 키

트랜스파일할 대상 자바스크립트의 버전을 설정한다.

 

  • baseUrl

주로 현재 디렉터리를 의미하는 "."으로 키 값을 설정한다.

 

  • outUrl

baseUrl 설정값을 기준으로 했을 때 하위 디렉터리의 이름이다.

빌드된 결과가 해당 디렉터리에 만들어진다.

 

  • paths

import 문에서 from 부분을 해석할 때 찾아야 하는 디렉터리이다.

 

  • esModuleInterop

chance 패키지를 사용하려면 true로 설정한다.

 

  • sourceMap

sourceMap의 값이 true이면 트랜스파일 디렉터리에 js 파일뿐만 아니라. js.map 파일도 만들어진다.

 

  • downlevelIteration

생성기 구문을 사용하려면 true로 설정한다.

 

  • noImplicitAny

타입을 지정하지 않더라도 오류로 인식하지 않게 하려면 false로 설정한다.

 

 

참고자료

Do it! 타입스크립트 프로그래밍

+ Recent posts