[TypeScript] Class/Hash Map

1. Class

접근 가능한 위치

구분	선언한 클래스 내	상속받은 클래스 내	인스턴스
public	o	o	o
protected	o	o	x
private	o	x	x

public: 모든 클래스에서 접근 가능

protected: 해당 클래스와 자식 클래스에서 접근 가능

private: 해당 클래스 내에서만 접근 가능하며, 자식 클래스에서도 접근 불가

 

class Player {
    constructor(
        private firstName:string,
        private lastName:string,
        public nickname:string 
    ){}
}

const mi = new Player("mi", "ma", "go")

mi.firstName // error private라
mi.nickname // "go"

class Player {
    constructor(firstName, lastName, nickname) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.nickname = nickname;
    }
}

constructor의 매개변수를 지정해주면 this.firstName = firstName 같은 자바스크립트 코드로 자동 변환해준다.

 

추상 클래스

abstract class User {
    constructor(
        private firstName: string,
        private lastName: string,
        public nickname: string
    ) { }
}

class Player extends User {
}

const mi = new Player("aa", "bb", "go")

다른 클래스가 상속받을 수 있는 클래스인데 직접 새로운 인스턴스를 만들 수 없다.

 

추상클래스 메소드

abstract class User {
    constructor(
        private firstName: string,
        private lastName: string,
        public nickname: string
    ) { }
    getFullName(){
        return `${this.firstName} ${this.lastName}`
    }
}

class Player extends User {
}

const mi = new Player("first", "last", "nic")

console.log(mi.getFullName()) // "first last"

 

abstract class User {
    constructor(
        private firstName: string,
        private lastName: string,
        public nickname: string
    ) { }
    private getFullName(){
        return `${this.firstName} ${this.lastName}`
    }
}

class Player extends User {
}

const mi = new Player("first", "last", "nic")

console.log(mi.getFullName()) // error

abstract class User {
    constructor(
        private firstName: string,
        private lastName: string,
        public nickname: string
    ) { }
    public getFullName(){ // private에서 public으로 변경
        return `${this.firstName} ${this.lastName}`
    }
}

class Player extends User {
}

const mi = new Player("first", "last", "nic")

console.log(mi.getFullName()) // "first last"

property를 private로 만들면 Player가 User를 상속받지만 난 거기에 접근하지 못한다.

private가 있다면 인스턴스 밖에서 접근할 수 없고, 다른 자식 클래스에서도 접근 불가능하다.

 

추상 메소드를 만드려면, 메소드를 클래스 안에서 구현하면 안되며, call signature만 작성한다.

추상 메소드란 추상 클래스를 상속받는 클래스들이 반드시 구현해야하는 메소드이다.

추상 메소드가 있는 경우, 추상 클래스를 상속받는 클래스에서 추상 메소드를 구현해야한다.

abstract class User {
    constructor(
        private firstName: string,
        private lastName: string,
        private nickname: string
    ) { }
    abstract getNickName(): void // 추상 메소드

    getFullName() {
        return `${this.firstName} ${this.lastName}`
    }
}

class Player extends User {
    getNickName() {
        console.log(this.nickName) // error
    }
}

const mi = new Player("first", "last", "nic")

mi.getFullName();

abstract class User {
    constructor(
        protected firstName: string,
        protected lastName: string,
        protected nickName: string
    ) { }
    abstract getNickName(): void

    getFullName() { // 추상클래스가 돼서 작동 안함
        return `${this.firstName} ${this.lastName}`
    }
}

class Player extends User {
    getNickName() {
        console.log(this.nickName)
    }
}

const mi = new Player("first", "last", "nic")

mi.getFullName();
mi.getNickName(); // "nic"

private를 protected를 변경하면 사용 가능함

 

2. Hash Map

type Words = {
    // Words type이 string만 property로 가지는 obj라고 선언
    // property의 이름은 모르지만, 타입만 알 때 적용 [key:number]: string
    [key:string]: string
}

class Dict {
    constructor(
        private words: Words
    ) {}
}

"use strict";
class Dict {
    constructor(words) {
        this.words = words;
    }
}

자바스크립트로 확인하니 words의 구조가 이상해서 변경함

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

class Dict {
    private words: Words
    constructor(){ // 수동으로 초기화
        this.words = {}
    }
}

"use strict";
class Dict {
    constructor() {
        this.words = {};
    }
}

응용 예제 사전만들기

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]
    }
    del(term: string) {
        if (this.words[term] !== undefined) {
            delete this.words[term]
        }
    }
    up(word: Word) {
        if (this.words[word.term] !== undefined) {
            this.words[word.term] = word.def
        }
    }
}

class Word {
    constructor(
        public term: string,
        public def: string
    ) { }
}

const kimchi = new Word("kimchi", "한국 음식")
const pasta = new Word("pasta", "면 요리")

const dict = new Dict()

dict.add(kimchi)
dict.add(pasta)
console.log(dict)
console.log(dict.def("kimchi"))
dict.del("kimchi")
console.log(dict)
dict.up(new Word("pasta", "이탈리아 음식"))
console.log(dict)