Call signatures
type Num = (a: number, b: number) => number;
// type Num = {
(a: number, b: number) : number
};
const num: Num = (a, b) => a + b;Overloading
: 이름은 같지만 시그니처(매개변수의 자료형/수/나열순서)는 다른 메소드를 중복으로 선언할 수 있는 방법.
함수가 여러개의 call signatures를 갖고 있을 때 발생한다.
- 같은 이름이나, 다른 매개변수(또는 타입)을 가지는 메소드
- 리턴 값만 다른 것은 오버로딩 X (메소드의 리턴 값은 메소드를 호출하는 시점에서는 알 수 없으므로 오버로딩의 대상이 될 수 없다)
- 매개변수가 다르면 이름이 같아도 서로 다른 메소드
type Num = {
(a: number, b: number) : number
(a: number, b: string) : number
};
const num: Num = (a, b) => {
if(typeof b === "string") return a;
return a + b;
};Next.js에서 볼 수 있는 overloading
Router.push({
path : "/main",
state : 1
})type RouterObj = {
path : string,
state : number
};
type Push = {
(path : string): void, // void = 아무것도 return하지않음.
(routerObj : RouterObj): void
};
const push: Push = (routerObj) => {
if(typeof routerObj === "string"){
console.log(routerObj); // routerObj : sting
} else {
console.log(routerObj.path, routerObj.state); // routerObj : RouterObj
}
}※ 오버로딩(Overloading)과 오버라이딩(Overriding)
-
오버로딩(Overloading)
- 동일 클래스 내 / 상속 관계 둘 다 가능
- 리턴타입은 상관없음
-
오버라이딩(Overriding)
- 상위 클래스로부터 상속받은 메서드를 하위 클래스가 재정의해서 사용하는 것
- 상속 관계에서만 가능
- 매개변수/리턴타입이 같아야 가능
오버라이드... 묘하게 구면인데...했더니 react-native안에 java코드에 나온다
Generic
: typescript에게 type을 유추하도록 한다.
- concrete type X, placeholder type O
- any와 비슷해보이나 작동방식이 다름
(generic은 작성자의 요청에 따라 call signature를 생성한다)
① type TestPrint = {
<T>(arr: T[]): T;
// (arr: T[]): T; ▶ X(placeholder를 사용해야 한다.)
}
② function TestPrint<T>(arr : T[]){
return arr[]
}
const testPrint: TestPrint = (arr) => {
arr.forEach(i => console.log(i));
}
testPrint([1, 2, "string", false]);type Player<E> = {
name: string;
extraInfo: E;
}
type Favor = {
food: string;
}
type HotPlayer = Player<Favor>
const Jake: HotPlayer = {
name: "nico";
extraInfo: {
food: "bread";
}
}function printNumberArr(arr: number[]){
}이 녀석과
function printNumberArr(arr: Array<number>){
}이 녀석은 같다
Class
class Player {
constructor(
private firstName:string,
private lastName:string,
public nickName:string
){}
}
const Bella = new Player("a","b","c")
Bella.nickName;
Bella.firstName; // error
Bella.lastName; // error📌 추상클래스
- 추상 메소드(abstract method)
자식 클래스에서 반드시 오버라이딩해야만 사용할 수 있는 메소드
구현이 되어 있지 않은/코드가 없는 메소드(call signature만 가지고 있다)
추상클래스를 상속받는 모든 메소드들이 구현해야 하는 메소드
※ 메소드 = 클래스 안에 존재하는 함수
- 추상 클래스(abstract class)
하나 이상의 추상 메소드를 포함하는 클래스.
다른 클래스가 상속받을 수 있는(상속받는 것만 가능한) 클래스.
상속받는 클래스가 property, 메소드를 지정하도록 한다.
추상클래스의 인스턴스를 만들 수는 없다.
메소드를 구현하여서는 안되고 메소드의 call signature만 적어야 한다.
abstract class User{
constructor(
private firstName:string,
protected lastName:string,
public nickName:string // default
){}
abstract getNickName():void
getFullName(){
return `${this.firstName} ${this.lastName} ${this.nickName}`
}
}
class Player extends User{
getNickName(){
console.log(this.lastName, this.nickName)
}
}
const Bella = new Player("a","b","c")
Bella.getFullName;
Bella.getNickName;
Bella.firstName; // error : Property 'firstName' is private and only accessible within class 'User'.(2341)
Bella.lastName; // error : Property 'lastName' is protected and only accessible within class 'User' and its subclasses.(2445)
Bella.nickName;
Polymorphism(다형성)
: 하나의 객체가 여러 가지 타입을 가질 수 있는 것을 의미한다. 다형성은 상속, 추상화와 더불어 객체 지향 프로그래밍을 구성하는 중요한 특징 중 하나이다.
interface MyStorage<T> {
[key:string]:T
}
class LocalStorage<T>{
private storage:MyStorage<T> = {}
set(key:string, value:T){
this.storage[key] = value;
}
remove(key:string){
delete this.storage[key]
}
get(key:string):T{
return this.storage[key]
}
clear(){
this.storage = {}
}
}
// 제네릭을 클래스로 보내고, 클래스는 제네릭을 인터페이스로 보내고, 인터페이스는 제네릭을 사용한다??
const stringsStorage = new LocalStorage<string>()
stringsStorage.get("cat")
stringsStorage.set("cat", "dog")
const numbersStorage = new LocalStorage<number>()
numbersStorage.get("cat")
numbersStorage.set("cat", 7)
const booleansStorage = new LocalStorage<boolean>()
booleansStorage.get("cat")
booleansStorage.set("cat", false)
v_v