TS快速入门

console.log("hello");

 

//TS 的类型

let a:number;

a = 11;

console.log(a);

 

// a = 'acx';

 

function sum(x:number,y:number):number{

    return x + y;

}

 

//字面量

let a1:10;

//a1 = 11; 报错

 

let b:number | string //b的值可以是数字或者字符串

b = 11;

b = 'ccc';

 

let z:any; //z为任意值类型

let zy;  //隐式的any

 

let s:string;

s = z;

 

let zu:unknown //unknown 是一个类型安全的any，不能直接赋值给其他变量，any类型的变量可以赋值给其他的变量

//s = zu;

 

//类型断言，告诉解析器变量的类型

s = zu as string; 

s = <string>zu;

 

function fn(): void{}

function fun():never {

    throw console.error("error");    

}

 

let Ob1:{name:string,age?:number}; //有name属性，或者name和age属性（？表示可选，可有可无） 

let Ob2:{name:string,[propName:string]:any} //Ob2里有name属性，和其他任意属性

 

//数组

let ar1:Array<number>;

let ar2:number[];

let ar3:string[];

 

//元祖

let yz1:[number,string];

//yz1 = [123,123];

yz1 = [1,'a'];

//yz1 = [1,'a',123]

 

//枚举

enum Gender{

    male = 0,

    female = 1

}

let obenum:{name:string,gender:Gender}

obenum = {name:'aaa',gender:Gender.male}

 

let obj1:number|string;

 

//没有意义

let obj2:number & string;

//这样用

let obj3:{name:string} & {age:number};

 

//类型别名

type mytype = 1|2|3|4|5;

let k:mytype;

//k = 6;

 

//TS编译参数

/*

 tsc app.ts -w 监视模式

 

*/

 

import { hi } from "./m"

console.log(hi);

 

// 类和对象

class Person{

 

    name:string; 

    age:number;

 

    static tip:string = '人类';

 

    say(){

 

        console.log(this.name,this.age);

    }

}

 

let p1 = new Person();

p1.name = 'aaa';

p1.age = 11;

 

console.log(p1);

console.log(Person.tip);

 

p1.say();

 

class Dog{

 

    public name:string;

    protected age:number;//protected 修饰的属性只能在类内部访问

    private tip:string;//private 修饰的属性只能在类内部访问

    

 

    constructor(name:string,age:number,tip:string){

        this.name = name;

        this.age = age;

        this.tip = tip;

    }

 

    //提供方法访问和修改Protected和private的属性

    getAge():number{

        return this.age;

    }

 

    setAge(age:number){

 

        if(age < 0 ){

            console.log("age必须大于0");

        }else{

 

            this.age = age;

        }

        

    }

 

    //TS中设置get和set方法写法：

    get AGE():number{

        return this.age; 

    }

 

    set AGE(age:number){

        this.age = age;

    }

 

}

 

const dog1 = new Dog("aa",1,'dog1');

const dog2 = new Dog("ab",2,'dog2');

const dog3 = new Dog("ac",3,'dog3');

 

dog1.name = 'dogg1';

//dog1.tip = 'dogg1';

//dog1.age = 11;

dog1.setAge(-11);

console.log(dog1.getAge());

console.log(dog1.AGE);

dog1.AGE = 100;

 

console.log(dog1);

console.log(dog2);

console.log(dog3);

 

//继承

class Animal {

 

    name:string;

    age:number;

 

    constructor(name:string,age:number){

 

        this.name = name;

        this.age = age;

    }

 

    sayHello(){

        console.log("动物在叫~");

 

    }

 

}

 

class Lion extends Animal{

 

    //从写了父类的方法

    sayHello(){

 

        console.log(`${this.name}嗷嗷嗷`);

    }

 

    //新增子类自己的方法

    run(){

        console.log(this.name + "在跑");

    }

 

}

 

class Tigger extends Animal{

 

}

 

const lion1 = new Lion("辛巴",10);

const tigger1 = new Tigger("dongbei",11);

 

console.log(lion1);

lion1.sayHello();

lion1.run();

 

console.log(tigger1);

tigger1.sayHello();

 

//supper关键字

//当子类重写父类的方法时，如果参数不一样，就需要调用父类supper(),将参数传给supper(),然后写子类的方法.

class Bird extends Animal{

 

    type:string;

 

    constructor(name:string,age:number,type:string){

    

        super(name,age);

        this.type = type;

 

    }

 

}

 

const bird1 = new Bird("gugu",11,"longlong");

console.log(bird1);

 

//抽象类 abstract 修饰的类，不能创建对象，就是专门用来继承的类

abstract class Pepole{

 

    name:string;

    age:number;

 

    constructor(name:string,age:number){

        this.name = name;

        this.age = age;

    }

 

    talk(){

        console.log("can talk");

    }

 

    abstract walk():void;

 

}

 

//const pe1 = new Pepole();

 

class Student extends Pepole{

 

    walk(): void {

        console.log(`${this.name}能够行走`);

    }

 

}

 

const student1 = new Student("小明",10);

console.log(student1);

student1.walk();

 

//类型申明

type myType = {

 

    name:string;

    age:number;

}

 

//接口，用来定义一个类的或者对象的结构,同时也可以当成类型申明来用,接口可以重复申明。

//接口中的所有属性都不能有实际的值，接口中的所有方法都是抽象方法。

//类使接口生效时，implements 链接接口，类要实现接口的属性和方法。

interface myinterface{

 

    name:string;

    age:number;

 

}

interface myinterface{

 

    gender:string;

 

    say():void;

 

}

 

const objInterface:myinterface = {

    name:"aaa",

    age:11,

    gender:"man",

    say(){

        console.log("say");

    }

 

}

 

class MyClass implements myinterface {

 

    name: string;

    age: number;

    gender: string;

 

    constructor(name:string,age:number,gender:string){

        this.name = name;

        this.age = age;

        this.gender = gender;

 

    }

 

    say(): void {

        console.log("i can say");

    }

    

}

const myclass1 = new MyClass("aaa",12,"gg");

console.log(myclass1);

myclass1.say();