[Typescript] 타입스크립트로 블록체인 만들기 강의 학습 #4

class Player {
	// 타입스크립트는 생성자의 파라미터만 정해주면 생성자 함수를 만들어준다.
	constructor(
    	private firstName: string,
        private lastName: string,
        public nickName: string,
    ){}
    
    // in javascript
	// constructor(firstName, lastName){
    //	 this.firstName = firstName;
    //	 this.lastName = lastName;
    // }
}
const jh = new Player("jh", "c", "정훈");
// javascript에는 private가 없지만, typescript에서 에러 발생시킴
// jh.firstName 

상속

abstract class User {
	constructor(
    	private firstName: string,
        private lastName: string,
        public nickName: string,
    ){}
    getFullName(){
    	return `${this.firstName} ${this.lastName}`
    }
}
class Player extends User{
}
const jh = new Player("jh", "cha", "정훈");
jh.getFullName();

추상 클래스는 다른 클래스가 상속받을 수 있는 클래스
하지만, 직접 인스턴스를 만들지는 못함.

// 인스턴스 생성 불가능
const jhcha = new User("a", "b", "C");

자바스크립트는 private와 같이, abstract 키워드를 사용하지 않고, 일반 클래스로 동작시킨다.
추상 클래스 안에 추상 메소드 (abstract function)는 기능을 구현하면 안되고 call signature만 명시해야 한다.

abstract class User {
	constructor(
    	protected firstName: string,
        protected lastName: string,
        protected nickName: string,
    ){}
    abstract getNickName(): void
}
class Player extends User{
	getNickName(){
    	//private은 접근 불가능, protected라서 접근 가능
    	console.log(this.nickName);
    }
}
const jh = new Player("jh", "cha", "정훈");
jh.getFullName();

추상 메소드를 가진 추상 클래스를 상속하면 반드시 상속한 클래스 내부에 추상 메소드를 구현해야 한다.

접근 제어자

public: 외부에서 접근 가능, 접근에 제한이 없다.
private: 내부에서만 접근 가능
protected: 외부에서 접근 불가능, 상속한 클래스에서 접근 가능

해시맵

type Words = {
	[key: string]: string
}

class Dict {
  private words: Words
	constructor(){
    this.words = {}
  }
  add(word: Word){
    if(this.words[word.term] === undefined){
      this.words[word.term] = word.def;
    }
  }
  def(term: string){
    return this.words[term];
  }
  // TODO 단어를 삭제하고 수정하는 함수 작성
  del(term: string){
  	if(this.words[word.term] !== undefined){
    	delete this.words[term];
    }
  }
  mod(term: string, def: string){
  	if(this.words[word.term] !== undefined){
    	this.words[term] = def;
    }
  }
}

class Word {
  constructor(
    public term: string,
    public def: string
  ){}
  addDef(def: string){
    this.def = `${this.def} ${def}`;
  }
  modDef(def: string){
    this.def = def;
  }
  printWord(): void{
    console.log(`${this.term} ${this.def}`)
  }
}

const kimchi = new Word("kimchi", "한국의 음식");
const dict: Dict = new Dict();

delete

delete 키워드는 객체의 속성을 제거한다. delete를 사용하여 배열의 특정 원소를 삭제하면, 해당 배열의 크기는 그대로 유지되고 해당 원소만 초기화된다.

const arr: number[] = [1, 2, 3, 4];
delete arr[3];
// arr.length는 4, arr는 [1, 2, 3, empty] 상태로 변경된다.

delete는 원본 객체를 수정하므로 side effect가 발생할 수 있으니 주의해야 한다.

static

static 키워드는 자바스크립트에서 사용하는 것과 같다.

class Dict {
	static hello(): void{
    	console.log("hello");
    }
    add(){...}
}
// Dict.add() 함수 호출 불가능, static 함수 호출 가능
Dict.hello()  

type

type은 타입의 alias를 만들거나, 특정 값만 사용할 수 있도록 제한할 수 있다.
concrete의 특정 값

type Team = "read" | "blue" | "yellow"
type Health = 1 | 5 | 10

type Player = {
	nickname: string,
    team: Team,
    health: Health
}

const jh: Player = {
	nickname: "jh",
    team: "blue",
    health: 10

interface

interface는 오브젝트의 모양을 특정해주기 위한 키워드
interface는 type과 아래와 같은 문법적 차이가 있다.

type Player = { ... }
// object 모양과 같음
interface Player { ... }

type 키워드가 interface 키워드보다 더 많은 기능을 할 수 있다. interface는 단지 오브젝트 모양을 설명해주는 하나의 목적으로만 사용할 수 있다.

//interface는 alias 처럼 사용 불가능
interface Hello = string

//interface는 type처럼 값에 대한 제한도 불가능
interface Hello = "AAA" | "BBB"

type과 인터페이스의 차이는 단순히 문법적 차이 뿐만 아니라 기능할 수 있는 범위도 다르다.

// interface 상속 방법
interface User {
	name: string
}
interface Player extends User {

}

// type 상속 방법
type User = {
	name: string
}
type Player = User & { }

interface는 아래와 같이 동일한 이름의 인터페이스를 중복 선언이 가능하고, 해당 인터페이스를 사용할 때 타입스크립트가 자동으로 합쳐준다. type은 불가능

interface User {
	name: string
}
interface User {
	age: number
}
const jh: User = {
	name: "jh",
    age: 27
}