【文末送书】Typescript 使用日志

let a: number;let b: string;let c: null;let d: undefined;let e: boolean;let obj: Ixxx = {  a: 1,  b: 2,};let fun: Iyyy = () => {};

class Greeter {    static name:string = 'Greeter'    static log(){console.log(‘log')}    greeting: string;    constructor(message: string) {        this.greeting = message;    }    greet() {        return "Hello, " + this.greeting;    }}let greeter = new Greeter("world");

interface IData {  name: string;  age: number;  func: (s: string) => void;}

// 函数参数function a(all: string) {}// 函数返回值function a(a: string): string {}// 可选参数function a(a: number, b?: number) {}

class Animal {  // 公有，私有，受保护的修饰符  protected AnimalName: string;  readonly age: number;  static type: string;  private _age: number;  // 属性存储器  get age(): number {    return this._age;  }  set age(age: number) {    this._age = age;  }  run() {    console.log("run", this.AnimalName, this.age);  }  constructor(theName: string) {    this.AnimalName = theName;  }}Animal.type = "2"; // 静态属性const dog = new Animal("dog");dog.age = 2; // 给 readonly 属性赋值会报错dog.AnimalName; // 实例中访问 protected 报错dog.run; // 正常

class Cat extends Animal {  dump() {    console.log(this.AnimalName);  }}let cat = new Cat("catname");
cat.AnimalName; // 受保护的对象，报错cat.run; // 正常cat.age = 2; // 正常

abstract class Animal {  abstract makeSound(): void;  // 直接定义方法实例  move(): void {    console.log("roaming the earch...");  }}class Cat extends Animal {  makeSound() {} // 必须实现的抽象方法  move() {    console.log('move');  }}new Cat3();

interface Ia {  a: string;  b?: string; // 可选属性  readonly c: number; // 只读属性  [key: number]: string; // 索引类型}// 接口继承interface Ib extends Ia {  age: number;}let test1: Ia = {  a: "",  c: 2,  age: 1,};test1.c = 2; // 报错，只读属性const item0 = test1[0]; // 索引类型

// 接口定义函数类型interface SearchFunc {  (source: string, subString: string): boolean;}let mySearch: SearchFunc = function (x: string, y: string) {  return false;};// 接口中编写类的构造函数类型检查interface IClass {  new (hour: number, minute: number);}let test2: IClass = class {  constructor(x: number, y: number) {}};

// 函数重载function doSomeThing(x: string, y: number): string;function doSomeThing(x: number): string;function doSomeThing(x): any {}
let result = doSomeThing(0);let result1 = doSomeThing("", 2);

// 全局函数调用 - windowfunction doSomeThing() {  return this;}const result2 = doSomeThing();
// 对象调用 - 对象interface IObj {  age: number;  // 手动指定 this 类型  doSomeThing(this: IObj): IObj;  doSomeThing2(): Function;}
const obj: IObj = {  age: 12,  doSomeThing: function () {    return this;  },  doSomeThing2: () => {    console.log(this);  },};const result3 = obj.doSomeThing();let globalDoSomeThing = obj.doSomeThing;globalDoSomeThing(); // 这样会报错，因为我们只允许在对象中调用
// call apply 绑定对应的对象function fn() {  console.log(this);}fn.bind(document)();
// dom.addEventListenerdocument.body.addEventListener("click", function () {  console.log(this); // body});

// 使用泛型function doSomeThing(param: T): T {  return param;}
let y = doSomeThing(1);
// 泛型类class MyClass {  log(msg: T) {    return msg;  }}
let my = new MyClass();my.log("");
// 泛型约束，可以规定最终执行时，只能是哪些类型function d2(param: T): T {  return param;}let z = d2(true);

// 以下四种方法，表达的含义是一致的，都是把对象中的某一个属性的 value 取出来，组成一个数组function showKey1(items: K[], obj: T): T[K][] {  return items.map((item) => obj[item]);}
function showKey2(items: K[], obj: T): Array {  return items.map((item) => obj[item]);}
function showKey3(  items: K[],  obj: { [K in keyof T]: any }): T[K][] {  return items.map((item) => obj[item]);}
function showKey4(  items: K[],  obj: { [K in keyof T]: any }): Array {  return items.map((item) => obj[item]);}
let obj22 = showKey4<"age", { name: string; age: number }>(["age"], {  name: "yhl",  age: 12,});

let obj1 = {  a: 1,  b: "b",  c: true,};
let obj2 = {  a: 1,};
obj2 = obj1;obj1 = obj2; // 报错，因为 obj2 属性不够

let fun1 = function (): { a: number; b: string } {  return { a: 1, b: "" };};let fun2 = function (): { a: number } {  return { a: 1 };};
fun1 = fun2; // 报错，fun2 中没有 b 参数fun2 = fun1;

// 如果函数中的所有参数，都可以在赋值目标中找到，就能赋值let fun1 = function (a: number, b: string) {};let fun2 = function (a: number) {};
fun1 = fun2;fun2 = fun1; // 报错， fun1 中的 b 参数不能再 fun2 中找到

let fn1 = (a: { name: string; age: number }) => {  console.log("使用 name 和 age");};let fn2 = (a: { name: string }) => {  console.log("使用 name");};
fn2 = fn1; // 正常fn1 = fn2; // 正常

enum EventType { Mouse, Keyboard }interface Event { timestamp: number; }interface MouseEvent extends Event { x: number; y: number }
function listenEvent(eventType: EventType, handler: (n: Event) => void) {  /* ... */}listenEvent(EventType.Mouse, (e: MouseEvent) => console.log(e.x + "," + e.y));

class Student1 {  name: string;  // private weight:number}
class Student2 {  // extends Student1  name: string;  age: number;}
let student1 = new Student1();let student2 = new Student2();
student1 = student2;student2 = student1; // 报错，student1 没有 age 参数

interface Empty {}let x1: Empty;let y1: Empty;
x1 = y1;y1 = x1;

// 自定义类型保护function isFish(pet: Fish | Bird): pet is Fish {  return (pet).swim !== undefined;}if (isFish(pet)) {  pet.swim();} else {  pet.fly();}

//定义toPromise映射type ToPromise = { [K in keyof T]: Promise };type NumberList = [number, number];type PromiseCoordinate = ToPromise;// [Promise, Promise]