es6에서는 class가 등장하였습니다.

class는 syntatic sugar로서 이를 babel로 변환하면 prototype으로 변환되는 것을 볼 수 있습니다.

syntatic sugar란 alias와 같은 개념으로 이해하시면 좋습니다. 복잡한 기능을 간단하게 사용할 수 있도록 도와줍니다.

React의 jsx도 대표적인 Syntatic sugar입니다.

 

Typescript에서 class를 사용하는 경우 어떠한 것들을 적용해야 하는지 알아보려 합니다.

 

js class

class Person {
  constructor(name){
    this.name = name
  }
  
  sayName() {
    console.log(this.name)
  }
}

 

 

ts class

typescript에서는 변수를 미리 선언해주어야 합니다.

또한 constructor에서 입력받는 인자에 type을 지정해주어야합니다.

class Person {
  // typescript에서의 클래스는 미리 변수를 선언해주어야 합니다.
  name: string
  
  constructor(name: string){
    this.name = name
  }
  
  sayName() {
    console.log(this.name)
  }
}

 


접근 제한자

앞서 ts의 class에서는 미리 변수를 선언해주어야 한다고 했습니다.

이때 접근 제한자를 사용할 수 있습니다

사용할 수 있는 접근 제한자에는 public, protected, private가 있습니다.

 

public은 모든 영역에서

protected는 자식 클래스와 자신의 내부에서만

private는 자신의 내부 에서만 접근이 가능합니다.

 

class Person {
  public name: string
  protected phone: string
  private money: number
  
  constructor(name: string, phone: string, money: number) {
    this.name = name;
    this.phone = phone;
    this.money = money;
  }
}

const logan = new Person('logan', '010', '10000')

logan.name // 🟢
logan.phone // 🔴
logan.money // 🔴

class Student extends Person {
  constructor(name: string, phone: string, money: number) {
    super(name, phone, money)
    
    console.log(this.name)  // 🟢
    console.log(this.phone) // 🟢
    console.log(this.money) // 🔴
  }
}

 


readonly 키워드

readonly 속성을 사용하여 재할당이 불가능하게 할 수 있습니다.

속성이 변하면 안되는 인스턴스에 readonly 키워드를 사용하여 불변을 보장해야할 수 도 있습니다.

class Person {
  private readonly MAX_HOUSE: number = 2

  constructor(name){
    this.name = name
  }
  
  sayName() {
    console.log(this.name)
  }
  
  sayHouse() {
    this.MAX_HOUSE = 20 // 🔴
    console.log(this.MAX_HOUSE)
  }
}

 

 


static 키워드

static 메서드를 선언하면 클래스의 이름으로 호출하여야 합니다.

생성된 인스턴스에서는 호출이 불가능 합니다.

class Person {
  constructor(name){
    this.name = name
  }
  
  static sayHi() {
    return 'hihi'
  }
  
  sayName() {
    console.log(this.name)
  }
}

console.log(Person.sayHi()) // hihi

const logan = new Person('logan')
console.log(logan.sayHi) // 🔴

 


추상 클래스

추상 클래스에는 아직 정의되지 않은 메서드와 정의되어진 메서드가 혼합될 수 있습니다.

다른 클래스에서 추상 클래스를 상속받았다면 추상 메서드는 무조건 정의되어야 합니다

abstract class Person {
  constructor(name){
    this.name = name
  }
  
  sayName() {
    console.log(this.name)
  }
  
  abstract sayHi(): void;
}


class Student extend Person {
  constructor(name: string) {
    super(name)
  }
  
  sayHi() {
    console.log('hihi')
  }
}

const logan = new Student('logan');
logan.sayName()
logan.sayHi()

 

아래와 같은 방식으로 추상클래스를 관리하면

상속받는 모든 클래스에서 필수로 추상 메서드가 정의되어야 하므로 관리하기가 쉬워졌던 경험이 있습니다.

 

export abstract class AbstractCommand {
  constructor() {}
  
  public abstract load(program: Command): void;
}





export class GenearateCommmand implements AbstractCommand {
  public load(program: Command): void {
    console.log('this is generate')
  }
}

export class SpecialCommmand implements AbstractCommand {
  public load(program: Command): void {
      console.log('this is special')
  }
}

 

 


 

출처: https://poiemaweb.com/typescript-class

 

TypeScript - Class | PoiemaWeb

ES6에서 새롭게 도입된 클래스는 기존 프로토타입 기반 객체지향 언어보다 클래스 기반 언어에 익숙한 개발자가 보다 빠르게 학습할 수 있는 단순명료한 새로운 문법을 제시하고 있다. 하지만

poiemaweb.com

 

728x90

typescript를 처음 사용할 때는 주위에서 대세라고 하니까 한번 써봐야 겠다 라는 생각이 있었습니다.

하지만 지금은 typescript를 필수로 사용하려 합니다.

js -> ts -> js -> ts 식으로 개발을 진행했었었는데

두번째 js로 개발을 할때는 많은 불편함을 느꼈었던것 같습니다.

 

typescript를 왜 사용해야 할까요??

 

타입 스크립트 장점

 

정적 타입 지원

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


sum(1, 2) // 3
sum("1", "2") // "12"

위의 코드를 작성한 의도는 숫자 두개를 입력받아 더해준 값을 return 하기 위해 작성하지 않았을까 싶습니다.

하지만 string 값을 넣으면 "12" 값이 출력되게 됩니다.

이는 Javascript가 동적 type 언어이기 때문입니다.

동적 Type 언어란것은 어떤 것일까요?

변수나 반환값의 type을 사전에 지정하지 않는 특성을 말합니다.

런타임에서 동적으로 Type이 정해진다고 이해하면 될것 같습니다.

 

이런 언어의 특성상 javascript는 런타임에서 에러를 발생시킬 가능성을 내포하고 있습니다(저는 실제 서비스에 에러를 발생시킨적이 있습니다....)

typescript를 이용하면 위의 경우를 방지할 수 있습니다.

위의 이미지는 아까 확인한 sum 함수를 typescript를 이용하여 작성한 것입니다.

number 타입 이외의 값이 들어오면 컴파일 단계에서 에러를 발생시킵니다.

타입을 정적으로 선언해두었기 때문에 함수를 의도한대로 사용할 수 있게끔 해줍니다.

 

이러한 컴파일 과정으로 에러를 미리 사전에 방지할 수 있습니다.

 

장점이 매우 크지만 코드량이 많아 진다는 단점도 존재합니다.

하지만 저는 장점을 더욱 중요시 여겨 ts를 선호하고 있습니다.

 

또한 typescript는 optional하게 작성할 수도 있습니다.

필요한 곳에만 작성할 수 있다는 뜻입니다.

저는 a에만 number type을 받도록 작성하였습니다.

ide 내에서 b의 type도 작성하라고 추천하고 있지만 하지 않아도 실행하는 데 문제는 없습니다!

 

 

ide에서의 높은 호환성

typescript를 이용하면 IDE에서 다음과 같은 특징들을 제공해줄 수 있습니다.

  • code navigation (alt 와 함수 혹은 라이브러리를 클릭하면 해당 함수의 정보와 type을 확인할 수 있습니다.)
  • autocompletion (자동완성 기능)
  • quick fix (실수에 대한 수정을 알려줍니다.)
  • 타이핑중에 에러가 있다면 바로 에러를 출력해 줍니다.

 

객체지향 지원

인터페이스, 제네릭, 상속 과 같은 객체지향 프로그래밍 지원을 가능케 함으로써 크고 복잡한 프로젝트의 코드 기반을 구성하기 쉽게 도와줍니다. 또한 기존의 객체지향 언어에 익숙한 개발자들에게 낮은 허들을 제공해줍니다.

 

 

typescript는 javascript 슈퍼셋 입니다.

자바스크립트의 기본 문법에 type을 추가한 언어라는 뜻입니다. 따라서 js 파일은 ts로 변경하고 컴파일하여 사용할 수 있습니다.

 

 

출처 : https://www.samsungsds.com/kr/insights/TypeScript.html

 

활용도가 높아지는 웹 프론트엔드 언어, 타입스크립트[TypeScript]

활용도가 높아지는 웹 프론트엔드 언어, 타입스크립트[TypeScript]

www.samsungsds.com

https://www.altexsoft.com/blog/typescript-pros-and-cons/

 

The Good and the Bad of TypeScript

“TypeScript is like JavaScript but with no surprises.” This is how developers often describe the open-source programming language introduced in 2012 by

www.altexsoft.com

https://poiemaweb.com/typescript-introduction

 

TypeScript - Intro & Install | PoiemaWeb

TypeScript 또한 AltJS의 하나로써 자바스크립트(ES5)의 Superset(상위확장)이다. C#의 창시자인 덴마크 출신 소프트웨어 엔지니어 Anders Hejlsberg(아네르스 하일스베르)가 개발을 주도한 TypeScript는 Microsoft

poiemaweb.com

 

728x90

Typescript에는 enum 타입이 있습니다.

enum 타입은 열거형 타입으로 의미가 명확한 코드와 코드의 가독성을 제공하기 위해 존재합니다.

enum에는 숫자형 타입과 문자형 타입이 존재합니다.

 

숫자형 타입

enum DirectionNumber {
  UP,
  DONW,
  RIGHT,
  LEFT,
}

enum DirectionNumberWithNumber {
  UP = 0,
  DONW = 1,
  RIGHT = 2,
  LEFT = 3,
}

숫자형 타입에서는 value의 할당을 생략할 수 도 있습니다.

할당을 생략하게 되면 값은 0 부터 차례대로 할당됩니다.

(ex. UP = 0, DOWN = 1, RIGHT = 2, LEFT = 3)

 

문자형 타입

enum DirectionString {
  UP = "up",
  DONW = "down",
  RIGHT = "right",
  LEFT = "left",
}

문자형 타입에서는 값의 할당을 해주어야 합니다.

만약에 빼먹으면 숫자형 타입으로 인식이 됩니다.

빼먹었을때 경우에 따라 error를 발생하는데 아래에서 살펴보겠습니다.

 


잠깐 딴길로 새면 

enum에서는 키 값들이 상수로 취급됩니다. 

따라서 값은 enum내에서는 같은 키값을 사용할 수가 없습니다.

enum test {
  a: string,
  a: string, // error
}

 

또한 enum은 선언적 할당을 이용해 확장할 수 있습니다. 

enum DirectionNumber {
  UP,
  DONW,
  RIGHT,
  LEFT,
}

enum DirectionNumber {
  CENTER = 5,
}

console.log(DirectionNumber)

/*
{
  '0': 'UP',
  '1': 'DONW',
  '2': 'RIGHT',
  '3': 'LEFT',
  '5': 'CENTER',
  UP: 0,
  DONW: 1,
  RIGHT: 2,
  LEFT: 3,
  CENTER: 5
}
*/

 

하지만 선언이후에 값을 변경할수는 없습니다.

 

아래와 같이 기존의 키 값에 존재하지 않는 키값을 추가해줄순 있지만

원래 enum의 역할은 할수가 없습니다.

 


모호한 타입

enum DirectionString {
  MIDDLE = 0,
  UP = "up",
  DONW = "down",
  RIGHT = "right",
  CENTER = 1,
  LEFT = "left",
}

숫자형과 문자형을 섞으면 위와 같은 복잡한 enum이 생성되게 됩니다.

공식문서에서는 위의 타입을 추천하지 않고 있습니다.

 

만약 위의 모호한 타입에서 숫자형 타입의 값을 할당하지 않으면 어떻게 될까요??

enum DirectionString {
  MIDDLE,  // 0으로 할당
  UP = "up",
  DONW = "down",
  RIGHT = "right",
  CENTER, // error
  LEFT = "left",
  CENTER, // error
}

비할당된 타입이 첫번째 위치에 올때는 0부터 인식이 됩니다.

하지만 중간이나 마지막에 위치하게 되면 원하는대로 동작하지 않습니다. 

 

숫자형 타입과 문자형타입의 차이는 타입의 종류 뿐만 아니라 transpile(ts -> js) 후에도 나타납니다.

숫자형, 문자형 타입을 두개를 선언하고 결과값을 살펴보겠습니다.

enum DirectionNumber {
  UP,
  DONW,
  RIGHT,
  LEFT,
}

enum DirectionString {
  UP = "up",
  DONW = "down",
  RIGHT = "right",
  LEFT = "left",
}

console.log(DirectionNumber);
/*
{
  '0': 'UP',
  '1': 'DONW',
  '2': 'RIGHT',
  '3': 'LEFT',
  UP: 0,
  DONW: 1,
  RIGHT: 2,
  LEFT: 3
}
*/

console.log(DirectionString);
// { UP: 'up', DONW: 'down', RIGHT: 'right', LEFT: 'left' }

숫자형 타입에는 값으로도 접근을 할수 있게끔 mapping이 되고 있는것을 확인할 수 있습니다.

console.log(DirectionNumber["0"]);
console.log(DirectionString["up"])

// UP
// undefined

 

이렇게 숫자형 타입에서 값으로도 접근할 수 있게 해주는 것을 reverse mapping이라고 합니다.

reverse mapping이 생성되는 이유는 transpile된 코드를 살펴보면 확인할 수 있습니다.

// reverse mapping 중
// DirectionNumber["UP"] = 0은 0을 반환함

var DirectionNumber;
(function (DirectionNumber) {
    DirectionNumber[DirectionNumber["UP"] = 0] = "UP";
    DirectionNumber[DirectionNumber["DONW"] = 1] = "DONW";
    DirectionNumber[DirectionNumber["RIGHT"] = 2] = "RIGHT";
    DirectionNumber[DirectionNumber["LEFT"] = 3] = "LEFT";
})(DirectionNumber || (DirectionNumber = {}));



var DirectionString;
(function (DirectionString) {
    DirectionString["UP"] = "up";
    DirectionString["DONW"] = "down";
    DirectionString["RIGHT"] = "right";
    DirectionString["LEFT"] = "left";
})(DirectionString || (DirectionString = {}));

잠깐 딴길로 새서 typescript에서 let과 const의 차이를 알아보겠습니다.

원시값의 타입과 참조값의 타입의 경우를 살펴보겠습니다.

 

원시 타입

let 변수의 경우 value의 타입이 나타나는 것을 볼 수 있습니다.

여기에 as const를 붙이면 어떻게 될까요?

타입이 "say hello"로 const에서의 경우와 같게끔 나오는 것을 확인할 수 있습니다.



원래 let 변수에는 재할당이 가능합니다. 

하지만 as const를 사용함으로써 재할당이 불가능하게 되었습니다.

 

 

참조 타입

객체를 const로 선언한 후에 타입을 살펴 보겠습니다.

const로 선언하였지만 value의 타입들이 mapping된 것을 확인할 수 있습니다.

이렇게 되면 추후에 값을 변경할 수가 있게 됩니다.

const로 선언한 객체에도 값을 변환할 수 없게 할 수 있습니다.

as const를 붙여주어 readonly가 추가된 것을 확인할 수 있습니다. 

이렇게 되면 test 변수의 값을 변경할 수가 없게 됩니다.

 

이 as const를 이용하여 enum을 대신할 수 있습니다.


const enum, enum, as const

자 이제 거의 다왔습니다.

enum DirectionNumber {
  UP,
  DONW,
  RIGHT,
  LEFT,
}

const DirectionObject = {
  UP: 0,
  DOWN: 1,
  RIGHT: 2,
  LEFT: 3
} as const

console.log(DirectionNumber.UP);  // 0
console.log(DirectionObject["UP"]); // 0

위의 경우 두개의 출력값은 같고 DirectionObject는 readonly 속성을 가지게 됩니다.

이제 object를 enum 대신 사용할수 있을것만 같습니다.

 

아래와 같이 속성을 추가할 수도 있습니다.

const DirectionObject = {
  UP: 0,
  DOWN: 1,
  RIGHT: 2,
  LEFT: 3
}

DirectionObject["CENTER"] = 4

Object.defineProperty(DirectionObject, "CENTER", { value: 4, writable: false, enumerable: true})
DirectionObject["CENTER"] = 5

예제 코드에서는 writable: false를 사용하여 값의 재할당이 불가능하게 하였습니다.

위의 예제에 as const를 사용하면 더 역할을 잘 수행할 수 있을것 같습니다.

 

하지만 객체가 enum의 역할을 수행하는 것은 코드를 접했을때 enum 보다는 확실한 메시지를 전달할 수 없습니다.

나는 열거형 타입이야 라고 외치고 있는 enum을 사용하는 것이 코드의 의미를 파악하기 더 쉽지 않을까요??!!

 

하지만 enum은 객체에 비해 transpile되는 코드량이 많고 reverse mapping의 경우 불필요한 코드의 생산을 초래할 수 있습니다.

숫자형 열거 타입에서 값으로 접근하는 경우는 특수한 경우와 용도가 아니라면 사용되지 않을것 같습니다.(Log에 error 찍는 경우???)

 

근데 왜 불필요한 코드가 적어야 할까요??
사용자의 디바이스에서 transpile된 코드를 실행하게 됩니다.
불필요한 코드가 줄어들면 파일의 크기가 줄어들고 실행이 간결해 집니다.
사용자는 로드를 더 빠르게 할 수 있고 화면에 렌더링이 더 빠르게 할 수 있다라는 뜻이 됩니다.

 

이런 문제를 해결할 수 있는 것이 enum앞에 const를 붙이는 것입니다.

위의 이미지는 enum을 const로 선언한 것과 하지 않은것의 transpile된 결과 입니다.

const enum을 transpile하는 코드는 존재하지 않고 값만 출력하고 있는 것을 볼 수 있습니다.

 

자 이제 어떤걸 사용해야 하는지 알수 있을것 같습니다.

enum을 사용하여 좀 더 의미있는 코드를 작성합니다. 

근데 이때 const를 곁들이면 transpile 된 코드의 양을 줄일수 있습니다!!

 

 

Object와 enum의 차이

  • object 는 코드내에서 새로운 속성을 자유롭게 추가할 수 있지만, enum 은 선언할때 이후에 변경할 수 없습니다.
  • object 의 속성값은 JS가 허용하는 모든 타입이 올 수 있지만, enum 의 속성값으로는 문자열 혹은 숫자만 허용됩니다.



출처:

https://www.typescriptlang.org/docs/handbook/enums.html#computed-and-constant-members

 

Handbook - Enums

How TypeScript enums work

www.typescriptlang.org

 https://sambalim.tistory.com/142

 

Typescript Enum이란?

Javascript와 다르게 Typescript에서는 Enum을 제공합니다. Enum이 무엇인지, Enum을 사용하면 어떤 이점이 있는지 알아봅시다. Enum? enum 은 enumerated type(열거형)을 의미합니다. Enum은 값들의 집합을 명명..

sambalim.tistory.com

https://velog.io/@logqwerty/Enum-vs-as-const

 

Enum vs as const

Typescript에서 가독성을 높이기 위한 일환으로 서로 연관된 상수들을 하나의 namespace에 묶어 관리할 때, 다음과 같이 enum키워드를 사용해 Enum type을 선언하거나객체 리터럴에 as const라는 type assertion

velog.io

 

728x90
  • 타입과 인터페이스의 차이를 아나요?
  • 프로젝트 진행 시에 어떤 상황에서 타입을 쓰고 어떤 상황에서 인터페이스를 썼나요?

type과 interface는 객체의 타입의 이름을 지정하는 것입니다.

둘의 기능은 거의 비슷하지만 몇 가지 차이점이 있습니다.

 

상속 받는 법

interface는 extends를 type에서는 &를 이용해 상속을 통한 확장을 진행합니다.

interface interface1 {
  a: string;
}

interface interface2 extends interface1 {
  b: string;
}

const interfaceConst: interface2 = {
  a: 'a',
  b: 'b'
}

type type1 = {
  a: string;
}

type type2 = type1 & {
  b: string;
};

const typeConst: type2 = {
  a: 'a',
  b: 'b',
}

 

선언적 확장 / 자동 확장

interface는 같은 이름의 객체를 다시한번 선언하면 자동으로 확장이 됩니다.

하지만 type은 불가능 합니다.

따라서 외부에 공개되어야 하는 library 같은 경우에는 타입객체의 확장성을 위해 interface를 사용하는 것을 추천한다고 합니다.

 

아래 사진은 interface에서는 문제가 없는 모습을 캡처한 이미지 입니다.

 

computed value 사용

아래와 같이 사용할 수 없습니다.

 

튜플이나 단순한 원시값의 타입 선언의 경우에는 type을 사용(interface는 객체의 타입 정의에 사용 가능)

아래의 예제에서 유의해야 하는 점은 

intersection type과 union type입니다.

intersectin type은 두개의 객체에 포함된 모든 속성을 만족해야 합니다.

union type은 두개의 객체중 하나의 속성만 만족하면 됩니다!

type stringA = string;
type arrayA = Array<string>;
type num = 1 | 2 | 3 | 4 | 5;
type intersection = {a: string, b: string} & { a: string, c: string }
type union = { a: string } | { b: string };

const testIntersection : intersection = {
  a: 'a',
  b: 'b',
  c: 'c'
}

const testUnion: union = {
  a: 'a'
}

 

IDE 에서 출력해주는 내용

vscode에서는 타입을 정의하는 type이나 interface에 커서를 가져다 대면 정보를 제공해 줍니다. 

하지만 이때 type과 interface에서 제공해주는 정보가 다릅니다.

type에서는 타입객체의 내부 정보까지 제공해줍니다,

interface에서는 내부 정보는 제공해주지 않습니다.

interface 출력 내용
type 출력 내용


결론 

공식문서에서는 뭘 사용할지 모를때는 interface를 사용하고 type의 특성이 필요할때만 type을 사용하라고 하고 있습니다.

 

튜플이나 단순한 원시값의 타입 선언의 경우에는 type을 사용하여야 합니다.

type의 특성중 하나는 Utility 타입이 될수 있을것 같습니다!

2022.03.02 - [Frontend/Typescript] - Typescript 유틸리티 타입 [Utility Types]

 

하지만 정답은 없고 팀의 컨벤션에 따라가는 것이 좋지 않을까 싶습니다.

 

 

 

출처 : https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#differences-between-type-aliases-and-interfaces

 

Documentation - Everyday Types

The language primitives.

www.typescriptlang.org

https://bny9164.tistory.com/m/48

728x90

타입스크립트에서는 여러가지 유틸리티 타입을 제공해 줍니다. 

잘 사용하게 되면 이미 선언한 타입들에서 입맛에 맞게 원하는 타입만 입력받을수 있게 해주어 유용할 때가 있었습니다.

전체 유틸리티 타입중 자주 사용하는 것들 위주로 정리를 해보려 합니다.

 


Partial<Type>

타입의 모든 타입들을 optional로 만들어 줍니다.

아래의 이미지와 코드에서는 type People에서 name, age, job은 필수 입력 요소입니다.

하지만 Partial로 인해 전부 optional property로 바뀐것을 확인할 수 있습니다.

백수여서 직업이 없는 코드

// Partial<Type>
type People = {
  name: string;
  age: number;
  job: string;
  house?: boolean;
}

type 백수 = Partial<People>

const me: 백수 = {
  name: 'me',
  age: 123
}

 

Required<Type>

위에서 type people중 house는 optional 이였습니다.

아래 이미지에서는 Required로 인해 house가 필수 요소로 바뀐것을 확인할 수 있습니다.

결혼을 하려면 집이 필요한 모습

// Required<Type>
type 결혼 = Required<People>

const thirtyFiveMe: 결혼 = {
  name: 'me',
  age: 35,
  job: 'programmer'
} // Property 'house' is missing in type '{ name: string; age: number; job: string; }' but required in type 'Required<People>'.ts(2741)

 

 

Readonly<Type>

readonly를 이용하게 되면 모든 속성이 readonly로 바뀌게 됩니다.

해당 type을 가진 변수를 변경하려면 아래와 같이 변경할 수 없다고 보여주는 것을 확인할 수 있습니다.

이미 할당된 property를 고집으로 인해 변경할 수 없는 모습

// Readonly<Type>
type 고집 = Readonly<People>

const 꼰대: 고집 = {
  name: "who",
  age: 123,
  job: ""
}

꼰대.name = "whowho";  // Cannot assign to 'name' because it is a read-only property.ts(2540)

 

Pick<Type, Keys>

pick은 type 파라미터에서 keys로 입력받은 친구들만 선택해줍니다.

Pick<People, "name" | "age"> 를 통해 학생 type은 name, age만 가지게 되는것을 확인할 수 있습니다.

학생은 이름과 나이만 있는 모습

// Pick<Type>
type 학생 = Pick<People, "name" | "age">

const 대학생: 학생 = {
  name: 'me',
  age: 123
}

 

 

Omit<Type, Keys>

omit은 type 파라미터에서 keys로 입력받은 친구들만 삭제해줍니다.

Omit<People, "job" | "house"> 를 통해 학생 type은 name, age만 가지게 되는것을 확인할 수 있습니다.

고등학생은 집과 직업이 없는 모습

// Omit<Type>
type 고등학생 = Omit<People, "job" | "house">

const 고딩: 고등학생 = {
  name: 'me',
  age: 123,
}

 

 

 

 

 

 

 

 

https://www.typescriptlang.org/docs/handbook/utility-types.html

 

Documentation - Utility Types

Types which are globally included in TypeScript

www.typescriptlang.org

 

728x90

'Frontend > Typescript' 카테고리의 다른 글

Typescript class 🏛  (0) 2022.04.19
Typescript 사용 이유  (0) 2022.03.23
Typescript enum, enum vs object  (0) 2022.03.23
Typescript type vs interface  (0) 2022.03.23
Typescript '<variable>' is declared but its value is never read.  (0) 2022.03.02

에러 발생 1번 상황
에러 발생 2번 상황

 

제목과 이미지에 나와있는 error는 typescript를 사용하면서 발생할 수 있습니다.

위와 같은 에러 상황이 나올수 있는 경우는 두가지 입니다.

 

1. 선언후에 사용하지 않는 변수가 있으면 Typescript compiler가 에러를 뱉어내게 됩니다.

2. functional Component에서 인자로 받은 변수를 사용하지 않으면 에러를 뱉어내게 됩니다.

 


 

가장 좋은 방법은 지시하는 대로 따르는 것이라 생각해요.

사용하지 않는 변수는 지워주고 사용하지 않는 인자도 지워주는 것이 좋지 않을까 싶습니다.

 

이 에러가 발생하는 원인과 해결책은 tsconfig.json에 있습니다.

아래와 같이 변경해주면 compile 해주는데 문제는 발생하지 않습니다.

아래 두개의 property가 true이면 위의 사진과 같이 에러가 발생하게 됩니다.

{
  "compilerOptions": {
    // ....
    "noUnusedParameters": false, // 함수 인자
    "noUnusedLocals": false, // 사용하지 않는 변수
   // .....
  },
  // .....
}

 

728x90

'Frontend > Typescript' 카테고리의 다른 글

Typescript class 🏛  (0) 2022.04.19
Typescript 사용 이유  (0) 2022.03.23
Typescript enum, enum vs object  (0) 2022.03.23
Typescript type vs interface  (0) 2022.03.23
Typescript 유틸리티 타입 [Utility Types]  (0) 2022.03.02

+ Recent posts