函数 ​

// 简单形式
function greeter(fn: (a: string) => void) {
  fn("Hello, World");
}

// 类型别名
type Fn = (a: string) => void

// 带属性的函数，和对象还是有点不同的
type Fn = { 
  foo: string,
  (a: string): void
}

// 对象类型
type Obj = {
  foo: string,
  fn: (a: string) => void,
}

// 构造函数
type Fn = {
  new (a: string): void
}

// 有些对象，例如 JavaScript 的Date对象，可以使用或不使用new. 您可以任意组合同一类型的调用和构造签名：
interface CallOrConstruct {
  new (s: string): Date;
  (n?: number): string;
}

// 通用函数，利用泛型实现
function firstElement<Type>(arr: Type[]): Type | undefined {
  return arr[0];
}

function longest<Type extends { length: number }>(a: Type, b: Type) {
  if (a.length >= b.length) {
    return a;
  } else {
    return b;
  }
}
 
// longerArray is of type 'number[]'
const longerArray = longest([1, 2], [1, 2, 3]);
// longerString is of type 'alice' | 'bob'
const longerString = longest("alice", "bob");
// Error! Numbers don't have a 'length' property
const notOK = longest(10, 100);

function combine<Type>(arr1: Type[], arr2: Type[]): Type[] {
  return arr1.concat(arr2);
}

const arr = combine([1, 2, 3], ["hello"]);
// Type 'string' is not assignable to type 'number'.

// 可以手动指定Type
const arr = combine<string | number>([1, 2, 3], ["hello"]);

function firstElement1<Type>(arr: Type[]) {
  return arr[0];
}
 
function firstElement2<Type extends any[]>(arr: Type) {
  return arr[0];
}
 
// a: number (good)
const a = firstElement1([1, 2, 3]);
// b: any (bad)
const b = firstElement2([1, 2, 3]);

// good, 只有一个Type泛型
function filter1<Type>(arr: Type[], func: (arg: Type) => boolean): Type[] {
  return arr.filter(func);
}
 
// bad 有2个泛型 Type和Func
function filter2<Type, Func extends (arg: Type) => boolean>(
  arr: Type[],
  func: Func
): Type[] {
  return arr.filter(func);
}

// 这里Str只被用到了一次
function greet<Str extends string>(s: Str) {
  console.log("Hello, " + s);
}
 
greet("world");

// 更简单的版本
function greet(s: string) {
  console.log("Hello, " + s);
}

function myForEach(arr: any[], callback: (arg: any, index?: number) => void) {
  for (let i = 0; i < arr.length; i++) {
    callback(arr[i], i);
  }
}
myForEach([1, 2, 3], (a, i) => {
  console.log(i.toFixed());
  // 'i' is possibly 'undefined'.
});

// 此示例中，我们编写了两个重载：一个接受一个参数，另一个接受三个参数。前两个签名称为重载签名
// 从外部看不到实现的签名。当编写重载函数时，您应该始终在函数的实现之上有两个或多个签名。
function makeDate(timestamp: number): Date; // 函数签名
function makeDate(m: number, d: number, y: number): Date; // 函数签名
function makeDate(mOrTimestamp: number, d?: number, y?: number): Date { // 实际函数体
  if (d !== undefined && y !== undefined) {
    return new Date(y, mOrTimestamp, d);
  } else {
    return new Date(mOrTimestamp);
  }
}
const d1 = makeDate(12345678);
const d2 = makeDate(5, 5, 5);
const d3 = makeDate(1, 3);
// No overload expects 2 arguments, but overloads do exist that expect either 1 or 3 arguments.

function fn(x: boolean): void;
// Argument type isn't right
function fn(x: string): void;
// 实现签名的参数类型与重载签名不兼容
function fn(x: boolean) {}

function fn(x: string): string;
// Return type isn't right
function fn(x: number): boolean;
// 实现签名的返回类型与重载签名不兼容
function fn(x: string | number) {
  return "oops";
}

function len(s: string): number;
function len(arr: any[]): number;
function len(x: any) {
  return x.length;
}

function len(x: any[] | string) {
  return x.length;
}

interface DB {
  filterUsers(filter: (this: User) => boolean): User[];
}
 
const db = getDB();
const admins = db.filterUsers(function (this: User) {
  return this.admin;
});

// 返回never意味着函数抛出异常或终止程序
function fn(x: string | number) {
  if (typeof x === "string") {
// do something
  } else if (typeof x === "number") {
// do something else
 } else {
    x; // has type 'never'!
  }
}

// Inferred type is number[] -- "an array with zero or more numbers",
// not specifically two numbers
const args = [8, 5];
const angle = Math.atan2(...args);
// A spread argument must either have a tuple type or be passed to a rest parameter.

// 解决办法
const args = [8, 5] as const; // 将args变成只读元组(tuple)

function sum({ a, b, c }: { a: number; b: number; c: number }) {
  console.log(a + b + c);
}

// 或者
// Same as prior example
type ABC = { a: number; b: number; c: number };
function sum({ a, b, c }: ABC) {
  console.log(a + b + c);
}

type voidFunc = () => void;
 
const f1: voidFunc = () => {
  return true; // ok
};

function f2(): void {
  return true; // error
}
 
const f3 = function (): void {
  return true; // error
};