ts学习记录

记录ts学习过程

数据类型定义

const a: string = "1";

const b: number = 1;

const c: Array<number> = [1];

const d: number[] = [1];

const f: any[] = [1, "1"];

// const g: Array<T> = [] as T;
//泛型
const h = <T>(a: T, b?: string, ...args: any[]): T => {
    return a;
};

console.log(h(1, "1", a, b));

const g: boolean = true;

const e: null = null;

//元组
let x: [string, number];

//枚举
enum Person {
    name,
    age,
    sex,
} //默认从零开始

enum Child {
    name = 1,
    age = 2,
    sex = 3,
}
console.log(Child[3]);

const vb: object = {}; //表示所有的非原始类型

const fv: Object = {}; //所有原始类型、非原始类型集合

Function定义

//柯里化函数  将函数参数复用
const n = (a: any[]): Function => {
    return (b: number): boolean => {
        return a.includes(b);
    };
};

//递归、尾递归
const fn = (n: number): number | Function => {
    if (n > 10) {
        return n;
    }
    return fn(n + 1);
};

/**
 * @description: 两数之和
 * @param {Array} nums
 * @param {number} target
 * @return {Array}
 */
//哈希表优化   差值是否在哈希表中
const twoSum1 = (nums: number[], target: number) => {
    const map = new Map();
    for (let i = 0; i < nums.length; i++) {
        let deff = target - nums[i];
        if (map.has(deff)) {
            return [map.get(deff), i];
        } else {
            map.set(nums[i], i);
        }
    }
    return [];
};

// 数组扁平化
const fla = (df: any[]): number[] => {
    while (df.some((item: any) => Array.isArray(item))) {
        df = [].concat(...df);
    }
    return df;
};

//无返回 函数定义
const fg = (): void => {
    console.log("1");
};

interface定义

interface A {
    a: number;
    b?: string; //可选
    readonly c: []; //只读 只能在对象刚刚创建的时候修改其值
    [propName: string]: any; //字符串索引签名
    d: (...args: any[]) => void; //  函数类型声明
}

//引用数据类型
const o: A = {
    a: 1,
    b: "1",
    c: [],
    d: (args) => {},
};

//断言
const p = {
    a: 1,
    b: "1",
    c: [],
} as A;

console.log(o.b);

interface List {
    [x: number]: any; //数组可索引的类型
}

const list: List[] = [];

console.log(list[0]);

class定义

class PanQuan {
  public name: string;
  private sex: string;
  private age: number;

  constructor(name: string, sex: string, age: number) {
    this.name = name;
    this.sex = sex;
    this.age = age;
  }

  userInfo() {
    console.log(`${this.name}, ${this.sex}, ${this.age}`);
  }

  work() {
    console.log('9点开始工作...');
  }

  paly() {
    console.log('play Genshin Impack');
  }
}

class Son extends PanQuan {
  constructor(name: string, sex: string, age: number) {
    super(name, sex, age)
  }

  getName() {
    return `${this.name}`
  }

  warp() {
    let str = '中南财经政法大学/n南湖校区文波楼'

    // str = str.length > 9 ? str.padStart(8, '111') : ''
    console.log(str);

  }
}

const panquan = new PanQuan('panquan', 'boy', 18)
const son = new Son('11', 'boy', 18)

console.log(son.warp());

枚举定义

enum Direction {
  Up = 1,
  Down,
  Left,
  Right,
}

const asa: number = 1;

console.log(Direction);

function as() {
  if (asa === Direction.Up) {
  }
}