TS基础知识

1. 原始数据类型

//布尔
let isDone:boolean=true
//数字
let age:number=18
//字符串
let firstName:string="张三"
//undefined
let u:undefined=undefined
//null
let n:null=null
//undefined和null是任意类型的子类，所以下面写法不会报错
let num:number=undefined
// 字面量 |：或 &：与
let d:'man'|'woman';
d="man";
d="woman";
let e:number|boolean;
e=1
e=false;

2.unknown类型（unknown相对于any是安全的）

let a: unknown =5
if(typeof a=="number"){
console.log(a*2)
}

3.数组

let arr:number[]=[1,2,3,4,5]
//对象数组
const objArr: { name: string, age: Number }[] = [
{ name: "小明", age: 18 },
{ name: "小红", age: 28 },
];

4. 对象

属性后面加问号，代表该属性可有可无

一个对象必须具有 name 属性，其他的属性有没有随意

可选属性的类型一定是其他类型的父类

let a:{name:string,age?:number,[propName:string]:any}
a={name:"张三",age:18,salary:3500}

5、函数

如果函数没有返回值，就是void类型，表示没有返回值

void与any正好相反, 表示没有任何类型, 一般用于函数返回值。在TS中只有null和undefined可以赋值给void类型

function fn(a:number,b:string):string{ return "hello" }

//如果返回值是函数：
function fn(a:number):(b:number)=>number{ 
    return function(b){
        return a+b
    } 
}
fn(10)(20);


interface SumInterface {
  (a:number, b:number):number
}

// 建议使用这种写法
let sum:SumInterface= function(x,y) {
  return x + y;
}

let res = sum(10, 20);


// 匿名函数

let say2 = function (name:string):void {

  console.log(name);

}

// 箭头函数

let say3 = (name:string):void =>{

  console.log(name);

}



function test():void {
    console.log("hello world");
}
test();

let value:void; // 定义了一个不可以保存任意类型数据的变量, 只能保存null和undefined



利用type声明函数
// 先利用type声明一个函数
type AddFun = (a:number, b:number)=>number;
// 再根据声明去实现这个函数
// 此时函数的参数和返回值可以不需要写类型声明了，因为ts可以通过这个函数声明推断出来类型了
let add:AddFun = function (x, y) {
    return x + y;
};
let res = add(30, 20);
console.log(res);

利用interface声明函数
// 先利用interface声明一个函数
interface AddFun {
 	 (a:number, b:number):number   
}
let add:AddFun = function (x, y) {
    return x + y;
};
let res = add(30, 20);
console.log(res);


默认参数
function add(x:number, y:number=10):number {

  return x + y;

}
let res = add(10);
let res = add(10, 30);

6. 类型推论

let a=1; a="hello" 
//error: Type 'string' is not assignable to type 'number'.

7. 联合类型

使用 | 分隔每个类型。

var val:string|number
val = 12 //ok
val = "Runoob" //ok

8.接口

interface girl {
    height: number,
    like: boolean,
    money?:number, //可选属性
    readonly age:number //只读属性
    make: () => void,
}
//对象数组
let arr:girl[]

使用 extends 来继承

interface person{
    name:string,
    age:number
}
interface boyFriend extends person{
    money:number,
    hobby:string[]
}

//一个接口可以被多个接口继承，同样，一个接口也可以继承多个接口，多个接口用逗号隔开
interface Dog extends Animals,Friends{
    name:string,
    color:string
}

9. 类型断言

//将一个联合类型断言为其中一个类型
interface Cat {
    name: string;
    run(): void;
}
interface Fish {
    name: string;
    swim(): void;
}
function isFish(animal: Cat | Fish) {
    if (typeof (animal as Fish).swim === 'function') {
    return true;
    }
    return false;
}

-------------------------------------------------------------------
interface Person{
    name:string;
    age: number
}
let student = {} as Person
student.name = 'jack'
student.age = 18

--------------------------------------------------------------------
//非空断言
let num:number | null | undefined 
let num2 = num.toFixed(2) //报错
let num2 = num!.toFixed(2) 

10. 元祖

严格限制类型和长度的元祖数组

const list : [ string , number ] = [ 'Sherlock' , 1887 ] // ok

11. 枚举

// 修改起始编号
enum Color {
    Red = 2,
    Blue,
    Yellow
}
console.log(Color.Red, Color.Blue, Color.Yellow); // 2 3 4

-------------------------------------------------------------

// 指定任意字段的索引值
enum Status {
    Success = 200,
    NotFound = 404,
    Error = 500
}

------------------------------------------------------------

enum Days {Sun, Mon, Tue, Wed, Thu, Fri, Sat};
console.log(Days["Sun"] === 0); // true
console.log(Days[0] === "Sun"); // true

------------------------------------------------------------

如果某个字段使用了计算值或 常量，那么该字段后面紧接着的字段必须设置初始值
const Start = 1;
enum Index {
    a = Start,
    b, // error 枚举成员必须具有初始化的值
    c
}

12. 泛型

identity 函数叫做泛型，因为它可以适用于多个类型。 不同于使用 any ，它不会丢失

信息，像第一个例子那像保持准确性，传入数值类型并返回数值类型。

function genericDemo(data: number): number { 
    return data; 
}

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

------------------------------------------------------------------

interface Person<N> { 
    name: string; 
    age: N; 
}

const xiong: Person<string> = { 
    name: "xiong", 
    age: "18" 
};

泛型约束

interface Person {
    name: string;
    age: number;
}
//extends 约束了泛型 T 必须符合接口 Person 的形状，
function createPerson<T extends Person>(person: T) {
    return person;
}
interface Xiaohong { 
    name: string; 
    age: number; 
    count: number; 
}
createPerson<Xiaohong>({ name: "xiongxiong", age: 18, count: 2021 });//正确

------------------------------------------------------------------------

//类型参数约束
function getValue<T, U extend keyof T>(obj: T, key: T){
    return obj[key]
}
let a = {a: 1, b: 2, c: 3}
getValue(a,"a");