NodeBird.propTypes = {
    Component: PropTypes.elementType.isRequired,
}

👩🏻 리액트 코딩할 때 'prop-types' 라이브러리를 설치하지 않아도돼고 위 코드처럼 propTypes를 선언해주지 않아도 돼서 편하다.  propTypes는 전달받은 데이터의 유효성을 검증하기 위해 다양한 유효성 검사기를 내보내는데, 만일 prop에 유효하지 않은 값이 전달 되었을 때, 경고문이 자바스크립트 콘솔을 통해 보인다. 반면에 타입스크립트는 에러가 나는 즉시 바로 에러를 체크 해주는 점도 베스트였다. 에러난 구문에 마우스 커서를 올리면 에러가 날 때 어떻게 고쳐나가야 될 지도 친절하게 알려준다. 이처럼 타입스크립트는 일반적인 오류를 최대한 많이 검출하면서 올바른 프로그램을 만들 수 있게 설계되었다 ! 이러니 요즘 많이 쓰는 추세인 듯 하다 👏🏻 하지만, 타입스크립트를 생성할 때마다 일일이 js파일로 컴파일 해줘야한다는 점이 번거롭기 때문에 다음에는 웹팩과 eslint 등등 웹 개발 환경 세팅하는 방법에 대해서 공부하기!

 

{
  "compilerOptions": {
    "noImplicitAny": false,
    "noEmitOnError": true,
    "removeComments": false,
    "sourceMap": true,
    "target": "es5",
    "outDir": "dist"
  },
  "include": [
    "scripts/**/*"
  ]
}
  • 포함은 TypeScript(*.ts) 파일을 찾을 수 있는 위치를 컴파일러에 알려줍니다.
  • outDir 옵션은 TypeScript 컴파일러에 의해 트랜스파일된 일반 JavaScript 파일의 출력 폴더를 지정합니다.
  • sourceMap 옵션은 컴파일러에서 sourceMap 파일을 생성할지 여부를 나타냅니다.

 

🎈 컴파일러 옵션

# tsconfig.json에 대한 fs를 역방향으로 검토하여 컴파일 실행
tsc

# 컴파일러 기본값으로 index.ts만 트랜스파일
tsc index.ts

# 기본 설정으로 src 폴더 안에 모든 .ts 파일을 트랜스파일
tsc src/*.ts

# tsconfig.json의 컴파일러 설정으로 src 폴더 안에 모든 .ts 파일을 트랜스파일
tsc --project tsconfig.json src/*.ts

 

typescript-kr.github.io/

 

TypeScript 한글 문서

TypeScript 한글 번역 문서입니다

typescript-kr.github.io

 

🎈 타입스크립트 모듈화란?

타입스크립트에서 가르키는 모듈이라는 개념은 ES6의 모듈과 개념이 유사하다. 모듈은 전역 변수와 구분되는 자체 유효 범위를 가지며 export. import와 같은 키워드를 사용하지 않으면 다른 파일에서 접근할 수 없게 된다.

 

🎈 Import & Export

임포트와 익스포트는 자바스크립트의 코드를 모듈화 할 수 있는 기능이다. 여기서 모듈화란 쉽게 말해 다른 파일에 있는 자바스크립트의 기능을 특정 파일에서 사용할 수 있는 것을 의미한다.

 

🎈 모듈화의 필요성

기본적으로 자바스크립트의 유효 범위는 전역으로 시작한다.

 

🎈 기본 문법

export 변수, 함수

다른 파일에서 가져다 쓸 변수나 함수의 앞에 export라는 키워드를 붙혀 사용한다.

import {불러올 변수 또는 함수 이름} from '파일 경로';

 익스포트된 파일음 import로 불러와 사용할 수 있다.

 

🎈 타입스크립트 모듈화 예시

[types.ts]

export interface Todo {
  title: string,
  checked: boolean,
}

 

[app.ts]

import { Todo } from './types';

var item: Todo = {
  title: '할 일1',
  checked: false,
}

types.ts 라는 파일에 인터페이스를 다른 파일에 사용할 수 있도록 export[내보내기] 해주고, app.ts라는 파일에서 types를 import 시켜서 item 변수에 인터페이스 타입들을 불러왔다.

🎈 타입호환 이란?

타입스크립트 코드에서 특정 타입이 다른 타입에 잘 맞는지를 의미한다. 타입스크립트가 코드를 해석해 나가는 과정에서 두 개의 타입이 서로 호환이 되는지를 점검하는 것을 타입 호환성이라고 한다. 

interface Developer {
  name: string;
  skill: string;
}
interface Person {
  name: string;
}
var developer: Developer;
var person : Person;

person = developer;

이렇게 Developer와 Person의 인터페이스를 생성하고 중복되는 속성은 name뿐이다. Developer는 name과 skill이라는 속성이 총 2개나 있고, Person은 name이라는 속성 1개뿐. 만약 위에는 인터페이스를 선언하고 아래는 클래스를 선언해도 실제로 이 두 개의 타입은 같다고 한다. 타입에 정의되어 있는 타입을 가지고 실제로 호환 되는지를 점검하는데 이런 것을 공식문서에서는 구조적 타이핑이라고 한다.

 

이렇게 됐을 때,

person = developer;

이처럼 오른쪽에는 더 많은 속성을 가지고 있거나 더 큰 관계를 갖고 있을 때에 왼쪽과 호환이 된다.  더 객체가 많은 속성을 가진, 구조적으로 더 큰 관계를 갖고 있기 때문이다.

 

🎇 다른 예시 01

var add = function(a: number) {
  console.log(a);
}

var sum = function(a: number, b: number) {
  return a + b;
}

여기서 add와 sum의 차이점은 sum함수가 파라미터 한 개가 더 들어있다. 그래서 sum이라는 함수 자체가 add라는 함수보다 더 크다고 볼 수 있다. 크다라는 의미는 추가적으로 옵션들을 더 제공한다.

 

🎇 다른 예시 02

interface Empty<T> {

}
var empty1: Empty<string>;
var empty2: Empty<number>;
empty1 = empty2;
empty2 = empty1;

맨 위에 인터페이스는 안에 값이 비어있어서 어떤 값이 들어와도 동일한 타입이라고 간주한다. 

 

🎇 다른 예시 03 : 제네릭

interface NotEmpty<T> {
  data:T;
}
var notEmpty1: NotEmpty<string>;
var notEmpty2: NotEmpty<number>;
notEmpty1 = notEmpty2;
notEmpty2 = notEmpty1;

이렇게 제네릭으로 인터페이스 호출해주면 타입이 바뀐걸로 간주되어 서로 타입 호환이 되지 않아 에러가 난다.

🎈 타입 단언 알아보기

var a;

이렇게만 선언한 a에 대한 타입은 any가 되고

a = 20;

이렇게 숫자로 대입한 a는 숫자로 추론이 된다.

a = 'a';

얘는 문자열로 추론이 된다.

var b = a;

얘는 원래같으면 맨 처음에 선언된 any가 b에 할당된다.

var b = a as string;

이렇게 as 키워드를 사용하여 후에 타입을 선언하면 선언 한 타입(string)으로 지정된다. 이처럼 타입 단언은 타입스크립트보다 개발자가 타입을 더 잘 알고있다라는 의미로 타입스크립트 너는 신경쓰지 말고 내가 정한 타입에 간주하라... 요런 너낌으로 받아들이면 된다.

 

🎈 DOM API 조작

<div id="app">hi</div>

var div = document.querySelector('div');

if (div) {
  div.innerText
}

웹페이지에 태그를 조작해줄 때 가장 많이 사용하는 API는 querySelector이다. 그리고 위 코드처럼 DIV라는 변수에 담아 태그에 접근하면 알아서 HTMLElement라고 추론해준다. 그리고 if문으로 div가 있는지 확인을 하고 그 다음에 조작을 해주는게 일반적인 타입단언의 패턴이다. div라는 값이 null일 수도 있기 때문에 밑에 호출된 div가 어떤 걸 데려오는지 div가 있는지를 if문을 통해 확인해보는 것이다.

 

그래서 이때,

var div = document.querySelector('div') as HTMLDivElement;
div.innerText;

이렇게 as라는 키워드를 사용하여 미리 HTMLElement로 타입을 단언해주는 것이다. as를 쓰는 시점에는 코드가 돌아갈 때 querySelector가 HTMLElement라고 단언해준다. 

 

🎈 타입 가드 알아보기

interface Developer {
  name: string;
  skill: string;
}

interface Person {
  name: string;
  age: number;
}

function introduce(): Developer | Person {
  return { name: 'Tony', age: 33, skill: 'Iron Making'}
}

var Tony = introduce();
console.log(Tony.name);

if ((Tony as Developer).skill) {
  var skill = ((Tony as Developer).skill);
  console.log(skill);
} else if ((Tony as Person).age) {
  var age = (Tony as Person).age;
  console.log(age);
}

인터페이스 선언해주고, introduce라는 함수에 유니온 타입으로 작성하여 Tony를 호출해줬다. 그리고 if문을 사용하여 타입 단언 방식으로 as를 써가며 타입이 있나 없나 확인하는 과정이다. 첫 줄에는 Tony as Developer를 사용하여 디벨로퍼에  skill이 있나 없나 확인을 한 후에 있으면 또 skill이라는 것을 호출해주도록 변수에 담는 이 과정을 반복해서 만들었다. 이렇게 하면 가독성도 떨어지고 여러번 선언해야 된다는 불편한 점이 있어 이것을 보완한 것이 타입 가드이다.

 

🎈 타입 가드 정의

function isDeveloper(target: Developer | Person): target is Developer {
  return (target as Developer).skill !== undefined;
}
if (isDeveloper(Tony)) {
  console.log(Tony.skill) 
} else {
  console.log(Tony.age) 

타입가드 함수는 is라는 패턴과 target이라는 키워드를 사용한다. 그리고 skill이라는 값이 있을 때 !== undefined 함수를 사용했다. if문은 토니가 Developer이면 스킬을 제공해준다. 그렇지 않으면 토니는 Person으로 인식하여 age를 제공해준다. if문 첫 줄에는 developer가 토니이고, 밑에줄은 Person으로서의 토니이기 때문에 각각의 필요한 속성을 접근할 수 있다.

 

🎈 타입추론 특징

let x = 3;

위와 같이 x 변수가 따로 타입을 지정하지 않더라도 일단 x는 3이라는 수식어가 들어있기에 number 타입으로 간주된다. 이렇게 변수를 선언하거나 초기화 할 때 타입이 추론된다. 이외에도 변수, 속성, 인자의 기본값, 함수의 반환값 등을 설정할 때 타입 추론이 일어난다.

var a = 'abc';

function getB(b = 10) {
  var c = 'hi';
  return b + c;
}

변수 C의 속성은 'hi' 라는 문자열이 들어있어 타입이 알아서 string 문자열로 자동 추론된다.

그리고 반환값은 b + c 인 경우

b: number, c:string

으로 간주되어 출력되는 값은 //10hi 로 출력된다. 그리고 getB 파라미터에 타입을 정의되지 않은 채 b만 정의가 될 경우 알아서 any라는 타입으로 정의해준다.

 

🎈 타입추론 기본 예제 02

interface Dropdown<T> {
  value: T;
  title: string;
}

var shoppingItem: Dropdown<string> = {
  value: 'abc',
  title: 'hello',
}

인터페이스와 제너릭을 이용한 타입 추론 방식이다. T에 따라서 value값이 변경 될 수도 있다. title이란 속성값은 string으로 고정시켜 놓았으니 그 타입 고대로 Fix 된 것. 그리고 다른 함수를 선언하면서 변수를 초기화 하면 타입도 초기화 된다. 위 코드처럼 value값에 'abc'를 넣으면 자동으로 문자열로 변동되고 숫자를 넣으면 자동으로 number 타입으로 변동된다.

 

🎈 타입추론 기본 예제 03 : 복잡한 구조에서의 타입 추론 방식

interface Dropdown<T> {
  value: T;
  title: string;
}

interface DetailedDropdown<K> extends Dropdown<K> {
  description: string;
  tag: K;
}

var DetailedItem: DetailedDropdown<string> = {
  title: 'hello',
  description: 'ab',
  value: 'a',
  tag: 'a'
}

처음에는 인터페이스로 제너릭을 선언해주고 value값도 T 제너릭 형태로 타입정의. 그리고 또 다른 인터페이스를 선언할 때는 Dopdown 인터페이스를 extends(확장) 키워드를 써서 데려오면 굳이 선언하지 않아도 암묵적으로 Dropdown에 있는 속성들이 들어와있다. (value, title) 그리고 새로운 DetailedItem 함수를 생성할 때 DetailedDropdown을 가져옴과 동시에 즉시 타입을 지정해주면 위에 있는 인터페이스들 value값들이 자동으로 string으로 변동된다. 그리고 DetailedItem 변수에 담긴 속성들은 문자열로 나열해주어야 에러를 방지할 수 있다.

 

🎈 가장 적절한 타입

타입은 보통 몇 개의 표현식을 바탕으로 타입을 추론한다. 그리고 그 표현식을 이용하여 가장 근접한 타입을 추론하게 되는데 이 가장 근접한 타입을 Best Common Type이라고 한다.

  • 예제
let arr = [0, 1, null];

배열에 들어가는 값들이 한 타입으로 통일되지 않았다. 2개는 숫자형, 1개는 논리형으로 들어가있는데 위 코드처럼 선언 후 arr 변수 위에 마우스 커서를 올려 놓으면 number | boolean 값으로 알아서 유니온 방식으로 추론해준다.

🎈 유니온 타입 :  var seho : string | number | boolean; 

var seho : string | number | boolean; 

여기서 | 는 OR을 뜻한다.

interface Developer {
  name: string;
  skill: string;
}

interface Person {
  name: string;
  age: number;
}

function askSomeone(someone: Developer | Person ) {
  someone.name;
}
askSomeone({ name: '디벨로퍼', skill: '웹 개발'});
askSomeone({ name: '캡틴', age: 100});

한 가지 이상의 타입을 사용하고 싶을 때 | (파이프)를 사용하면 된다. 유니온 타입은 Developer와 Person의 인터페이스를 생성했을 때 둘 다 공통으로 들어간 name값만 뽑아내준다. 그 이유는  someone에 age나 skill이 타입 검증도 없이 바로 써버리게 되면 안전하지 않아 이 코드상 에러가 날 수 있다고 한다. 쉽게 말해 인터페이스 구조체에 공통된 속성만 제공한다고 보면된다.

function askSomeone(someone: Developer | Person ) {
  // someone.name;
  // someone.skill;
  // someone.age;
}
askSomeone({ name: '디벨로퍼', skill: '웹 개발'});
askSomeone({ name: '캡틴', age: 100});

다른 타입들의 속성을 불러오고 싶다면 이렇게 askSomeone을 두 번 호출해서 각각 지정해주는 타입의 속성들만 골라 호출해줄 수 있다. (skill, age) 

 

🎈 인터섹션 타입 : var capt : string & number & boolean;

var capt : string & number & boolean; 

&는 AND를 뜻한다.

interface Developer {
  name: string;
  skill: string;
}

interface Person {
  name: string;
  age: number;
}

function askSomeone1(someone: Developer & Person ) {
  // 인터섹션 : Developer 과 Person이 합친 하나의 타입
  someone.name;
  someone.skill;
  someone.age;
}
askSomeone1({ name: '디벨로퍼', skill: '웹 개발', age: 34});

인터섹션은  Developer 과 Person이 합친 하나의 타입으로 ! 공통인 name 뿐만 아니라 skill과 age 속성도 같이 제공해준다. 그래서 호출할 땐 반드시 name, skill, age라는 속성 값들을 한 번에 한 줄로 출력해주어야 빨간 에러가 발생하지 않는다.

 

유니온 타입처럼

askSomeone1({ name: '디벨로퍼', skill: '웹 개발'});
askSomeone1({ name: '캡틴', age: 100});

이런식으로 호출해주면 빨간줄 에러가 생긴다. 

 


 

🎈 정리

유니온타입같은 경우에는 공통된 타입만 제공이 가능했던 반면에 인터섹션 코드 같은 경우에는 Developer와 Person이 가지고 있는 모든 속성과 타입을 다 포함한 하나의 타입이라고 정의했기 때문에 에러가 안나고 전부 제공해준다. 하지만 두 가지 중에서 유니온 타입이 훨씬 더 자주 쓰인다는 점을 유의하자.

👩🏻 타입별칭과 인터페이스를 통해 함수에 타입들을 작성하지 않고도 따로 정의하여 중복 코드들을 리팩토링 할 수 있다는점. 코드 리팩토링 굉장히 중요ㅠ.ㅠ 나중에는 천천히 코드 디자인패턴에 대해서 연구해보자...

 

🎈 타입별칭

type MyName = string;
const name: MyName = 'capt';

타입 별칭은 특정 타입이나 인터페이스를 참조할 수 있는 타입 변수를 의미한다. 예를 들면 위에 처럼 타입별칭은 새로운 타입 값을 하나 생성하는 것이 아니라 정의한 타입에 대해 나중에 쉽게 참고할 수 있게 이름을 부여하는 것과 같다. 타입별칭 쓰는 법은 type으로 시작해서 위 코드처럼 속성들의 타입들을 담아주면 된다. 

 

🎈 인터페이스

interface User {
  age: number;
  name: string;
  }

var seho: User = {
  age: 33,
  name: '세호'
}

function getUser(user : ✔️User) {
console.log(user);
}

인터페이스는 타입스크립트에서 하이라이트라고 할 수 있다. 그만큼 중요하다. 인터페이스를 이용한 위의 코드를 보면 User라는 interface 만들어 속성들을 넣어주고, 변수에 인터페이스를 활용한 다음 새로운 함수를 만들 때 User를 넣어주면 긴 코드의 명시적 타입들을 안넣어도 된다.

🎈 타입별칭과 인터페이스 차이점

타입 별칭과 인터페이스의 가장 큰 차이점은 타입의 확장 가능, 불가능 여부이다. 인터페이스는 확장이 가능한데 반해 타입 별칭은 확장이 불가능하다. 따라서, 가능한한 type보다는 interface로 선언해서 사용하는 것을 추천한다.

 

 


 

 

🎈함수의 스펙(구조)에 인터페이스 활용

interface SumFunction {
  (a: number, b: number) : number;
}

let sum : SumFunction;
sum = function(a: number, b: number) : number {
  return a+b;
}

sum 이라는 함수의 규칙을 정의함

 

🎈인덱싱

interface StringArray {
  [index: number] : string;
  //index는 숫자를 받고, 반환되는 값은 문자열로
}

var arr : StringArray = ['a','b','c','d'];

index는 숫자를 받기 때문에 number로 지정하고, 반환되는 값은 문자열(string)로. 그리고 arr라는 변수를 만들 때 이미 만들어진 StringArray 인터페이스 속성 규칙대로 배열 값들은 문자열로 입력해준다.

 

 

🎈 인터페이스 딕셔너리 패턴

interface StringRegexDictionary {
  [key:string] : RegExp;
}

var obj : StringRegexDictionary = {
  cssFile : /\.css$/,
  jsFile : /\.js$/
}

Object.keys(obj).forEach(function(value) {})

StringRegexDictionary 인터페이스에 왼쪽에 있는 key값은 string으로 오른쪽은 RegExp라는 정규표현식으로 지정했다. obj라는 변수에 StringRegexDictionary를 불러왔으니 새로운 변수를 만들 때 상호관계 일치하게 왼쪽에는 string 방식으로 오른쪽에는 정규표현식을 사용해줘야한다. 그리고 마지막에 Object로 시작하는 문장의 코드는 keys에 obj라는 key들만 배열로 만든 다음에 반복문 forEach 돌려준다는 것이고 function 함수 파라미터 안에 들어있는 value는 string를 의미한다.

 

🎈 인터페이스의 확장

interface Person {
  name: string;
  age: number;
}

interface Developer extends Person {
  language: string;
}

Person이라는 인터페이스 안에 속성들을 정의해두고 이걸 확장해서 코드 수를 줄이는 방법이다. 먼저 Person 인터페이스를 정의 했으니 Developer라는 인터페이스에 extends를 사용해서 Person을 확장 시켜줬기 때문에, name과 age란 속성은 알아서 암묵적으로 가지고 가게 된다. 그리고 Developer라는 인터페이스에는 필요로 하는 속성들은 그때 그때마다 새롭게 추가시켜서 선언해주면 된다. (위 코드 보면 language만 추가시켜주었다)

 

 

🎈 TODO-LIST 프로젝트 코드리뷰

interface Todo {
  id: number;
  title: string;
  done: boolean;
}

let todoItems: Todo[];


🎈api
function fetchTodoItems():Todo[] {
  //{ id: number; title: string; done: boolean; }
  const todos = [
    { id: 1, title: '안녕', done: false }, //이것들이 다 object다
    { id: 2, title: '타입', done: false },
    { id: 3, title: '스크립트', done: false },
  ];
  return todos;
}

🎈crud methods
function fetchTodos(): object[] {
  const todos = fetchTodoItems();
  return todos;
} 

=> 리턴했을 때  object[] 를 반환한다.

🎈할 일 추가하기
function addTodo(todo: Todo): void {
  todoItems.push(todo);
}

=> 함수의 반환값(return)이 없을 때 void를 해줘야한다.

🎈 할 일 지우기
function deleteTodo(index : number):void {
  todoItems.splice(index, 1);
}

=> index는 배열의 index이기 때문에 타입은 number로 지정해주는 것이 좋다.

🎈 할 일 완료하기
function completeTodo(
  index:number,
  todo: Todo
):void {
  todo.done = true;
  todoItems.splice(index, 1, todo);
}

=> void로 값 반환

🎈 business logic
function logFirstTodo(): object{
  return todoItems[0];
} 

function showCompleted() : object[] {
  return todoItems.filter(item => item.done);
} 

function addTwoTodoItems() : void {
  const item1 = {
    id: 4,
    title: '아이템 4',
    done: false,
  }

  addTodo(item1);
  addTodo({
    id: 5,
    title: '아이템 5',
    done: false,
  });
} 

function log() : void {
  console.log(todoItems);
}

todoItems = fetchTodoItems();
addTwoTodoItems();
log();

앞서 📃 타입스크립트 입문 03 : 자주 쓰는 기본 타입 정의, 문자열 선언 방식 에서 알아본 타입정의들을 투두리스트 프로젝트에 다 녹여내었다. 타입스크립트의 가장 핵심인 인터페이스를 사용해 Todo의 타입들을 선언해주었고, 할 일 목록은 여러개이니 배열로 반환해주었다. ex) Todo[].

그리고 인터페이스를 사용하지 않았더라면

function fetchTodoItems(id: number; title: string; done: boolean;) {
  const todos = [
    { id: 1, title: '안녕', done: false },
    { id: 2, title: '타입', done: false },
    { id: 3, title: '스크립트', done: false },
  ];
  return todos;
} 

위처럼 엄청나게 긴 코드를 선보였을텐데 인터페이스를 사용해서 한번에 Todo[ ] 이런식으로 나타내어 코드를 최소화 시켰다. 그리고 할 일 추가 할 때는 push를 사용하였고, 반환값은 할 일을 그때그때마다 추가하는거라 없으니 void를 해주었다. 그리고 할 일 지울 때도 마찬가지. 대신 할 일 지울 때는 splice 를 사용하였다. splice 메서드는 배열의 기존 요소를 삭제 또는 교체하거나 새 요소를 추가하여 배열의 내용을 변경한다는 뜻이다. 할 일이 완료되면 체크란에 체크가 토글방식으로 on/off기능을 true, false로 나타내주었다. 그리고 특정 함수만 걸러내는 것을 filter라고 한다. filter를 사용할 때는 오브젝트들이 배열로 되어있어 그 중에서 걸러주는 것이니 [ ] 배열 표시를 해줘야한다. 

 

 

🎈 함수의 옵셔널 파라미터

function log(a: string, b?:string) {

}
log('hello world');
log('hello ts', 'abc');

 

함수의 옵셔널 파라미터란 해당 값에 ? 물음표를 넣어주면 파라미터에 속한 인자값과 출력되는 값이 비례하지 않아도 된다. 위 코드처럼 log를 두 줄 넣었을 때 첫번째 log는 출력되는 값이 1개 일 때 function log(a:string, b?:string) 여기 b에 물음표가 없으면 첫번째 log에 빨간 에러 표시가 생긴다. 이걸 바로 함수의 옵셔널 파라미터(선택적 파라미터)라고 부른다.

👩🏻 이 쯤되면 눈치 챘을텐데 타입스크립트의 포인트는 코드를 작성할 때 원래 사용하던 자바스크립트의 타입을 좀 더 정확하게 명시적으로 나타내주는 것이다. 그래서 타이핑이 필요하다. 타이핑이란 타입이 정의되지 않은 코드에 타입을 입혀주는 행위이다.

 

🎈 TS를 편리하게 코딩할 수 있도록 JSON파일 생성

[tsconfig.json]

{
  "compilerOptions": {
    "allowJs": true,
    "checkJs": true,
    "noImplicitAny": true
  },
  "include": ["./src/**/*"]
}

여기서 "noImplicitAny": true 이것은 함수 타입을 any라도 지정해주어라 라는 뜻이다.

🎈 자주 사용하는 변수 & 함수의 타입 정의

Boolean : 논리형

Number : 숫자형

String : 문자형

Object : 객체

Array : 배열

Tuple : 튜플

Enum : 이넘

Any : 모든 타입 가능

Void : 반환타입

Null : 0

Undefined : 정의 x

Never

 

예시

💛TS문자열
let str: string = 'hello';

💛TS숫자
let num: number = 10;

💛TS배열
let arr: Array<number> = [1,2,3];
//Array는 다른 타입과 다르게 첫 글자가 대문자여야 된다.
//<>괄호에는 어떤 타입만 들어올 수 있는지 선언해주기

let heroes: Array<string> = ['Capt', 'Thor', 'Hulk', 10];
//만약 이렇게 문자열 타입으로 선언했는데 숫자 10이 들어오면 빨간 줄로 에러표시가 생긴다.

let items: number[] = [1,2,3];
// [] 이거는 배열 리터럴이란 뜻이다. []괄호 앞에 number라는 타입을 지정해주기

💛TS 튜플
let address01: [string, number] = ['gangnam', 100];
// 배열의 각각 인덱스에 타입이 정의되어 있다.

💛Object
let obj : object = {};
let person01: object = {
  name: 'capt',
  age: 100
}
//객체 속성은 어떤 타입이 들어오던 크게 신경 쓰지 않는다.

let person: { name: string, age: number } = {
  name: 'thor',
  age: 1000
}
// 각 인자마다 타입을 지정해주면, 이렇게 객체 함수를 나타낼 수도 있다.

💛boolean 진위값
let show: boolean = true;

 

🎈 문자열 선언방식 + 함수에 타입을 정의하는 방식

👉🏻일반 JS 문자열 선언방식
var str = 'hello';

👉🏻TS 문자열 선언방식
let str: string = 'hello';

// -------------------------------
// 함수에 타입을 정의하는 방식

💛JS
function sum(a, b) {
  return a + b;
}

sum(10, 20, 30, 40, 50);

💛TS
function sum3(a: number, b: number): number {
  return a + b;
}

sum(10, 20, 30, 40, 50);

JS의 경우 파라미터 값이 2개여도 30,40,50은 자동으로 유연하게 무시해준다. 하지만 TS의 경우 30, 40, 50에 에러밑줄이 생기는데, 이유는 TS가 JS에 비해 파라미터를 엄격하게 체크해주기 때문이다. 만약 인자 갯수보다 sum 파라미터 인자 갯수가 적을 경우에도 에러가 난다. 무조건 파라미터 인자 갯수와 리턴되는 인자 갯수가 비례해야 된다.

🎈 타입스크립트 시작하기

 

  1. 노드 버전을 설치해야한다 (버전 10이상)
  2. 타입스크립트 라이브러리를 설치해준다 $npm i typescript -g
  3. 타입스크립트의 파일을 js파일로 변환해준다. $tsc [변환할 ts 파일명]

이 과정까지 하고 나면 같은 폴더 경로 안에 index.ts가 index.js라는 파일로 변환되어 나타난다. 하지만 매번 tsc라는 명령어를 통해 귀찮게 파일을 컴파일 시켜줄 수 없으니 웹팩 또는 걸프같은 모듈 번들러를 사용해서 자동화 시켜주면 효율적이고 좋다. 추후에 웹팩 반드시 공부하기!

 

[index.ts] 파일 생성하여 아래와 같은 코드 입력하기

```
function sum(a: number, b: number) : number {
  return a + b;
}

sum(10, 20);
```

이런 코드가 index.ts 라는 확장자 파일에 담겨있을 때 브라우저로 인식할 수 있도록 컴파일 해주어야 한다. 여기서 말하는 컴파일이란 ( ts => js)로 변환해주는 과정을 뜻한다.

 

🎈 타입스크립트 환경세팅 속성 알아보기

https://www.typescriptlang.org/tools

이 사이트에 들어가서 TSConfig Reference 라는 페이지에 들어가면 tsconfig.json 파일에 환경 세팅 해줄 속성들이 많이 나오니, 필요한 속성들을 이 공식문서를 보고 찾아서 사용하면 된다.

 

🎈 타입스크립트 플레이 그라운드 소개

 

ts식 코드를 쳤는데 오른쪽에는 js로 컴파일 된 코드들을 확인 가능하다. 바벨도 자바스크립트의 최신 문법을 많은 브라우저에서 호환 될 수 있게 해주는 도구이다. 

+ Recent posts