TypeScript函数类型 #

function add(a: number, b: number): number {
    return a + b;
}

const result = add(1, 2);

const add = function(a: number, b: number): number {
    return a + b;
};

const add2 = (a: number, b: number): number => a + b;

type Add = (a: number, b: number) => number;

const add: Add = (a, b) => a + b;

interface Calculator {
    add: (a: number, b: number) => number;
    subtract: (a: number, b: number) => number;
}

function greet(name: string): string {
    return `Hello, ${name}!`;
}

greet('Alice');
greet();

function greet(name: string, greeting?: string): string {
    if (greeting) {
        return `${greeting}, ${name}!`;
    }
    return `Hello, ${name}!`;
}

greet('Alice');
greet('Alice', 'Hi');

function greet(name: string, greeting: string = 'Hello'): string {
    return `${greeting}, ${name}!`;
}

greet('Alice');
greet('Alice', 'Hi');

function sum(...numbers: number[]): number {
    return numbers.reduce((acc, num) => acc + num, 0);
}

sum(1, 2, 3, 4, 5);

function printCoord({ x, y }: { x: number; y: number }): void {
    console.log(`(${x}, ${y})`);
}

printCoord({ x: 10, y: 20 });

interface Coord {
    x: number;
    y: number;
}

function printCoord2({ x, y }: Coord): void {
    console.log(`(${x}, ${y})`);
}

function add(a: number, b: number): number {
    return a + b;
}

function greet(name: string): string {
    return `Hello, ${name}!`;
}

function log(message: string): void {
    console.log(message);
}

function createUser(name: string, age: number): { name: string; age: number } {
    return { name, age };
}

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

function createUser2(name: string, age: number): User {
    return { name, age };
}

function createPair<T>(first: T, second: T): [T, T] {
    return [first, second];
}

const pair = createPair(1, 2);

function createMultiplier(factor: number): (value: number) => number {
    return (value: number) => value * factor;
}

const double = createMultiplier(2);
console.log(double(5));

async function fetchData(url: string): Promise<Response> {
    return fetch(url);
}

async function getUser(id: number): Promise<User> {
    const response = await fetch(`/api/users/${id}`);
    return response.json();
}

type Callback = (data: string) => void;
type Handler = (event: Event) => void;
type Compare = (a: number, b: number) => number;

const callback: Callback = (data) => console.log(data);
const handler: Handler = (event) => console.log(event.type);
const compare: Compare = (a, b) => a - b;

interface Add {
    (a: number, b: number): number;
}

const add: Add = (a, b) => a + b;

interface SearchFunc {
    (source: string, subString: string): boolean;
}

const search: SearchFunc = (source, subString) => {
    return source.indexOf(subString) !== -1;
};

interface AnimalConstructor {
    new (name: string): Animal;
}

interface Animal {
    name: string;
}

function createAnimal(ctor: AnimalConstructor, name: string): Animal {
    return new ctor(name);
}

const add = (a: number, b: number): number => a + b;

const greet = (name: string): string => `Hello, ${name}!`;

const log = (message: string): void => {
    console.log(message);
};

const add = (a: number, b: number) => a + b;

const greet = (name: string) => `Hello, ${name}!`;

const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(n => n * 2);

class Counter {
    count = 0;
    
    increment = (): void => {
        this.count++;
    };
    
    decrement(): void {
        this.count--;
    }
}

const counter = new Counter();
const increment = counter.increment;
increment();

const decrement = counter.decrement;
decrement();

function fetchData(callback: (data: string) => void): void {
    setTimeout(() => {
        callback('Data loaded');
    }, 1000);
}

fetchData((data) => {
    console.log(data);
});

type AsyncCallback = (error: Error | null, data?: string) => void;

function fetchData(callback: AsyncCallback): void {
    setTimeout(() => {
        callback(null, 'Data loaded');
    }, 1000);
}

fetchData((error, data) => {
    if (error) {
        console.error(error);
    } else {
        console.log(data);
    }
});

function fetchData(): Promise<string> {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('Data loaded');
        }, 1000);
    });
}

async function main(): Promise<void> {
    const data = await fetchData();
    console.log(data);
}

function add(a: number, b: number): number;
function add(a: string, b: string): string;
function add(a: any, b: any): any {
    return a + b;
}

const num = add(1, 2);
const str = add('hello', 'world');

function createElement(tag: 'a'): HTMLAnchorElement;
function createElement(tag: 'canvas'): HTMLCanvasElement;
function createElement(tag: string): HTMLElement {
    return document.createElement(tag);
}

const anchor = createElement('a');
const canvas = createElement('canvas');

function format(value: string): string;
function format(value: number): string;
function format(value: string | number): string {
    if (typeof value === 'string') {
        return value.toUpperCase();
    }
    return value.toFixed(2);
}

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

function getUser(): User[];
function getUser(id: number): User;
function getUser(id?: number): User | User[] {
    if (id === undefined) {
        return [
            { id: 1, name: 'Alice' },
            { id: 2, name: 'Bob' }
        ];
    }
    return { id, name: 'User' };
}

const users = getUser();
const user = getUser(1);

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

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

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 pair<K, V>(key: K, value: V): [K, V] {
    return [key, value];
}

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

function createArray<T = string>(length: number, value: T): T[] {
    return Array(length).fill(value);
}

const arr1 = createArray(3, 'x');
const arr2 = createArray<number>(3, 1);

function debounce<T extends (...args: any[]) => any>(
    func: T,
    wait: number
): (...args: Parameters<T>) => void {
    let timeout: ReturnType<typeof setTimeout> | null = null;
    
    return function(this: any, ...args: Parameters<T>): void {
        if (timeout) {
            clearTimeout(timeout);
        }
        timeout = setTimeout(() => {
            func.apply(this, args);
        }, wait);
    };
}

function throttle<T extends (...args: any[]) => any>(
    func: T,
    limit: number
): (...args: Parameters<T>) => void {
    let inThrottle = false;
    
    return function(this: any, ...args: Parameters<T>): void {
        if (!inThrottle) {
            func.apply(this, args);
            inThrottle = true;
            setTimeout(() => {
                inThrottle = false;
            }, limit);
        }
    };
}

function curry<T extends (...args: any[]) => any>(fn: T): (...args: any[]) => any {
    return function curried(...args: any[]): any {
        if (args.length >= fn.length) {
            return fn(...args);
        }
        return (...moreArgs: any[]) => curried(...args, ...moreArgs);
    };
}

const add = (a: number, b: number, c: number) => a + b + c;
const curriedAdd = curry(add);

console.log(curriedAdd(1)(2)(3));
console.log(curriedAdd(1, 2)(3));
console.log(curriedAdd(1)(2, 3));