TypeScript泛型 #

function identity<T>(arg: T): T {
    return arg;
}

const str = identity<string>('hello');
const num = identity(123);

function identityAny(arg: any): any {
    return arg;
}

const result = identityAny('hello');
result.toUpperCase();

function identity<T>(arg: T): T {
    return arg;
}

const result2 = identity('hello');
result2.toUpperCase();

function identity<T>(arg: T): T {
    return arg;
}

const output1 = identity<string>('hello');
const output2 = identity(123);

const identity = <T>(arg: T): T => {
    return arg;
};

const identity2 = <T,>(arg: T): T => arg;

type Identity = <T>(arg: T) => T;

const identity: Identity = (arg) => {
    return arg;
};

interface GenericIdentityFn {
    <T>(arg: T): T;
}

function pair<K, V>(key: K, value: V): [K, V] {
    return [key, value];
}

const p1 = pair('name', 'Alice');
const p2 = pair(1, 'first');

interface Box<T> {
    value: T;
}

const stringBox: Box<string> = { value: 'hello' };
const numberBox: Box<number> = { value: 123 };

interface Container<T> {
    value: T;
    getValue(): T;
    setValue(value: T): void;
}

class Box<T> implements Container<T> {
    constructor(public value: T) {}
    
    getValue(): T {
        return this.value;
    }
    
    setValue(value: T): void {
        this.value = value;
    }
}

interface GenericFn {
    <T>(arg: T): T;
}

interface GenericFn2<T> {
    (arg: T): T;
}

const identity: GenericFn = (arg) => arg;
const identity2: GenericFn2<string> = (arg) => arg;

interface Lengthwise {
    length: number;
}

function logLength<T extends Lengthwise>(arg: T): T {
    console.log(arg.length);
    return arg;
}

logLength('hello');
logLength([1, 2, 3]);
logLength({ length: 10 });
logLength(123);

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
    return obj[key];
}

const user = { name: 'Alice', age: 25 };

const name = getProperty(user, 'name');
const age = getProperty(user, 'age');
getProperty(user, 'email');

function hasKey<T, K extends string>(obj: T, key: K): key is K & keyof T {
    return key in obj;
}

const user = { name: 'Alice', age: 25 };

if (hasKey(user, 'name')) {
    console.log(user.name);
}

function create<T>(c: { new (): T }): T {
    return new c();
}

class User {
    name = 'Default';
}

const user = create(User);
console.log(user.name);

interface Serializable {
    serialize(): string;
}

interface Cloneable {
    clone(): this;
}

function process<T extends Serializable & Cloneable>(obj: T): void {
    console.log(obj.serialize());
    obj.clone();
}

interface Container<T = string> {
    value: T;
}

const container1: Container = { value: 'hello' };
const container2: Container<number> = { value: 123 };

interface ApiResponse<T = any, E = Error> {
    data: T;
    error: E | null;
}

const response1: ApiResponse = { data: 'success', error: null };
const response2: ApiResponse<string, string> = { data: 'success', error: '' };

interface Config<T, U = T[]> {
    value: T;
    items: U;
}

const config1: Config<string> = { value: 'hello', items: ['a', 'b'] };
const config2: Config<string, Set<string>> = { value: 'hello', items: new Set() };

type Partial<T> = {
    [P in keyof T]?: T[P];
};

interface User {
    name: string;
    age: number;
}

type PartialUser = Partial<User>;

const user: PartialUser = {
    name: 'Alice'
};

type Required<T> = {
    [P in keyof T]-?: T[P];
};

interface User {
    name: string;
    age?: number;
}

type RequiredUser = Required<User>;

const user: RequiredUser = {
    name: 'Alice',
    age: 25
};

type Readonly<T> = {
    readonly [P in keyof T]: T[P];
};

interface User {
    name: string;
    age: number;
}

type ReadonlyUser = Readonly<User>;

const user: ReadonlyUser = {
    name: 'Alice',
    age: 25
};

user.name = 'Bob';

type Pick<T, K extends keyof T> = {
    [P in K]: T[P];
};

interface User {
    id: number;
    name: string;
    email: string;
}

type UserPreview = Pick<User, 'id' | 'name'>;

const preview: UserPreview = {
    id: 1,
    name: 'Alice'
};

type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

interface User {
    id: number;
    name: string;
    password: string;
}

type PublicUser = Omit<User, 'password'>;

const publicUser: PublicUser = {
    id: 1,
    name: 'Alice'
};

type Record<K extends keyof any, T> = {
    [P in K]: T;
};

type UserMap = Record<string, User>;

const users: UserMap = {
    'user1': { id: 1, name: 'Alice', password: '123' },
    'user2': { id: 2, name: 'Bob', password: '456' }
};

function getKeys<T extends object>(obj: T): (keyof T)[] {
    return Object.keys(obj) as (keyof T)[];
}

const user = { name: 'Alice', age: 25 };
const keys = getKeys(user);

function assign<T extends object>(target: T, ...sources: Partial<T>[]): T {
    return Object.assign(target, ...sources);
}

const user = { name: 'Alice', age: 25 };
const updated = assign({}, user, { age: 26 });

async function fetchJson<T>(url: string): Promise<T> {
    const response = await fetch(url);
    return response.json();
}

interface User {
    id: number;
    name: string;
}

const user = await fetchJson<User>('/api/users/1');
console.log(user.name);

type EventMap = {
    [key: string]: any;
};

class EventEmitter<T extends EventMap> {
    private listeners: Map<keyof T, Function[]> = new Map();
    
    on<K extends keyof T>(event: K, listener: (data: T[K]) => void): void {
        if (!this.listeners.has(event)) {
            this.listeners.set(event, []);
        }
        this.listeners.get(event)!.push(listener);
    }
    
    emit<K extends keyof T>(event: K, data: T[K]): void {
        const listeners = this.listeners.get(event);
        if (listeners) {
            listeners.forEach(listener => listener(data));
        }
    }
}

interface MyEvents {
    userCreated: { id: number; name: string };
    userDeleted: number;
}

const emitter = new EventEmitter<MyEvents>();

emitter.on('userCreated', (data) => {
    console.log(data.name);
});

emitter.emit('userCreated', { id: 1, name: 'Alice' });