TypeScript
제네릭
수색…
통사론
- 삼각형 괄호 안에 선언 된 제네릭 타입 :
<T>
- 제네릭 형식을 제한하는 것은 extends 키워드로 수행됩니다 :
<T extends Car>
비고
일반 매개 변수는 런타임에 사용할 수 없으며 컴파일 시간에만 사용됩니다. 이는 다음과 같이 할 수 없다는 것을 의미합니다.
class Executor<T, U> {
public execute(executable: T): void {
if (T instanceof Executable1) { // Compilation error
...
} else if (U instanceof Executable2){ // Compilation error
...
}
}
}
그러나 클래스 정보는 여전히 보존되어 있으므로 항상 다음과 같이 변수 유형을 테스트 할 수 있습니다.
class Executor<T, U> {
public execute(executable: T): void {
if (executable instanceof Executable1) {
...
} else if (executable instanceof Executable2){
...
} // But in this method, since there is no parameter of type `U` it is non-sensical to ask about U's "type"
}
}
일반 인터페이스
일반 인터페이스 선언
interface IResult<T> {
wasSuccessfull: boolean;
error: T;
}
var result: IResult<string> = ....
var error: string = result.error;
여러 유형 매개 변수가있는 일반 인터페이스
interface IRunnable<T, U> {
run(input: T): U;
}
var runnable: IRunnable<string, number> = ...
var input: string;
var result: number = runnable.run(input);
일반 인터페이스 구현
interface IResult<T>{
wasSuccessfull: boolean;
error: T;
clone(): IResult<T>;
}
일반 클래스로 구현하십시오.
class Result<T> implements IResult<T> {
constructor(public result: boolean, public error: T) {
}
public clone(): IResult<T> {
return new Result<T>(this.result, this.error);
}
}
비 제너릭 클래스로 구현 :
class StringResult implements IResult<string> {
constructor(public result: boolean, public error: string) {
}
public clone(): IResult<string> {
return new StringResult(this.result, this.error);
}
}
일반 수업
class Result<T> {
constructor(public wasSuccessful: boolean, public error: T) {
}
public clone(): Result<T> {
...
}
}
let r1 = new Result(false, 'error: 42'); // Compiler infers T to string
let r2 = new Result(false, 42); // Compiler infers T to number
let r3 = new Result<string>(true, null); // Explicitly set T to string
let r4 = new Result<string>(true, 4); // Compilation error because 4 is not a string
제네릭 제약
단순 제약 조건 :
interface IRunnable {
run(): void;
}
interface IRunner<T extends IRunnable> {
runSafe(runnable: T): void;
}
더 복잡한 제약 :
interface IRunnble<U> {
run(): U;
}
interface IRunner<T extends IRunnable<U>, U> {
runSafe(runnable: T): U;
}
더욱 복잡한 :
interface IRunnble<V> {
run(parameter: U): V;
}
interface IRunner<T extends IRunnable<U, V>, U, V> {
runSafe(runnable: T, parameter: U): V;
}
인라인 유형 제약 조건 :
interface IRunnable<T extends { run(): void }> {
runSafe(runnable: T): void;
}
일반 함수
인터페이스에서 :
interface IRunner {
runSafe<T extends IRunnable>(runnable: T): void;
}
수업 시간 :
class Runner implements IRunner {
public runSafe<T extends IRunnable>(runnable: T): void {
try {
runnable.run();
} catch(e) {
}
}
}
간단한 기능 :
function runSafe<T extends IRunnable>(runnable: T): void {
try {
runnable.run();
} catch(e) {
}
}
제네릭 클래스 및 함수 사용 :
제네릭 클래스 인스턴스 만들기 :
var stringRunnable = new Runnable<string>();
일반 함수 실행 :
function runSafe<T extends Runnable<U>, U>(runnable: T);
// Specify the generic types:
runSafe<Runnable<string>, string>(stringRunnable);
// Let typescript figure the generic types by himself:
runSafe(stringRunnable);
제약 조건으로 매개 변수 입력
TypeScript 1.8을 사용하면 형식 매개 변수 제약 조건이 동일한 형식 매개 변수 목록의 형식 매개 변수를 참조 할 수 있습니다. 이전에는 이것이 오류였습니다.
function assign<T extends U, U>(target: T, source: U): T {
for (let id in source) {
target[id] = source[id];
}
return target;
}
let x = { a: 1, b: 2, c: 3, d: 4 };
assign(x, { b: 10, d: 20 });
assign(x, { e: 0 }); // Error
Modified text is an extract of the original Stack Overflow Documentation
아래 라이선스 CC BY-SA 3.0
와 제휴하지 않음 Stack Overflow