typescript基础类型

基础类型

1.布尔类型

const isFlag: boolean = true;//正确
const isFlag: boolean = 11111;//错误

2.数字类型

let t_number: number = 1;//正确
t_number = 12.3; //正确
t_number = '我的世界';  //错误

3.字符串类型

let str: string = 'this is typescript'; //正确
str = 1; //错误

4.数组类型

在一下定义中数组只能存指定类型的数据

let newArr: number[] = [1,2,3,4,5,6,7,8,9,0];
let twoArr: Array<number> = [1,2,3,4];

4.1.元祖类型（tuple),属于数组的一种

指定相对应的数据类型

let treeArr: [string,number,boolean] = ['nihao',1,true];

5.枚举类型（unum）

当给对应的枚举赋值时，取得的是对应的值，没有赋值时，是其下标值，部分赋值时，时前一个枚举的值加一

enum enumFlag {success=1,error=-1};
let value =enumFlag.error;
enum color {red,yellow,orange}
let valueC: color = color.orange;

6.任意类型

let all： any =1;
all = 'string';
all = 1;
all =null;
all=undefined;
all=true;
all =[1,2,3];

7.void类型

typescript中的void表示没有任何类型，一般用于定义方法的时候没有返回值

let a=(): void =>{
    console.log('你可真是个小天才呢~')
}

8.never类型

是其他类型(包括null和undefined）的子类型，代表从不会出现的值,声明never的变量之鞥呢被never类型所赋值

let tNever: never;
let a: never =(()=>{
    throw new Error('cuo')
})()

函数定义

1.函数声明法

function ts_run(): string {
    return 'hello world';
}

2.匿名函数法

let ts_run2 = function (): nunber{
    return 1;
}

3.函数传参(必选参数）

let ts_run3 = (name:string,age: number): number =>{
    console.log(name,age);
    return 123;
}
ts_run3('xiaojiebin',123);

4.可选参数

age？:number 是可选参数，

let ts_run4 = (name:string,age?:number): string =>{
    console.log(name,age);
    return 'very good';
}
ts_run4('好喜欢这个世界',12);

5.默认参数

age: number = 20;

let ts_run5 = (name: string,age: number = 20): string =>{
    console.log(name,age);
    return '我想哭'
}
console.log(ts_run5('这个世界真的很温柔。',30));

6.剩余参数

当一二两个参数是单独的，其他多被放入剩余参数

let ts_run6 = (a:number,b:number,...result: number[]): number =>{
    let sum: number = a+b;
    result.forEach(element =>{
        sum +=element;
    });
    sonsole.log(sum);
    return sum;
}
ts_run6(1,2,3,4,5,6)

7.ts方法的重载

function getInfo(name: string): string;
function getInfo(age: number):number;
function getInfo(str:any): any{
    if(typeof str === 'string'){
        cosnole.log('我的名字是：'+str);
    }else{
        console.log('我的年龄的是：'+str);
    }
}
getInfo("hahahah")

类（class）

1.定义类

class Person{
    name: string;
    age: number;
    constructor(name: string,age: number){
        this.name = name;
        this.age = age;
    }
    run(): void{
        console.log(this.name,this.age);
    }
    getName(): string{
        return this.name;
    }
    setName(name: string)：void{
        this.name = name;
    }
	getAge():number{
        return this.age;
    }
	setAge(age: number):void{
        this.age=age;
    }
}
let person = new Person("卑微的自己",1213);
person.setName('肖杰斌')；
person.setAge(2);
person.run();

2.继承

class People {
    name: string;
    constructor(name: string) {
        this.name = name;
    }

    run(): string {
        console.log(this.name);
        return this.name;
    }
}

class Biological extends People {
    constructor(name: string) {
        super(name);
    }
}
let biological = new Biological("讨好你~");
biological.run();

3.修饰符

• public : 共有 类里面和外面多可以访问
• protected：保护类型 在类里面，子类里面可以访问，在类外部没法访问
• private： 私有 在类里面可以访问，类外部无法访问
• 属性如果不加修饰符，默认就是共有的。

class Car {
    public name: string;
    protected color: string;
    private price: number;

    constructor(name: string, color: string, price: number) {
        this.name = name;
        this.color = color;
        this.price = price;
    }
}
let car = new Car('劳斯莱斯', '红色的', 100000000);
console.log(car.name);

class Tool extends Car {
    constructor(name: string, color: string, price: number) {
        super(name, color, price);
    }
    run(): void {
        console.log(this.color);//正确
        this.price;//错误
    }
}

let tool = new Tool('劳斯莱斯', '红色的', 100000000);
tool.name;  //正确
tool.color; //错误
tool.price; //错误
tool.run();