TypeScript基础语法

//string

let str:string="wc"

 

//数字类型

let numb:number=1

 

//布尔

let bool:boolean=false

 

//数组类型

let arr:number[]=[1,2,3,4]

// let arr2:[]number=[1,2,3] 不支持，和java有区别

 

//枚举

enum Weeks{Mon,Tue,Wed}

let day=Weeks.Mon;

console.log(day) //0

console.log(Weeks[0]) //Mon

console.log(Weeks["Mon"]) //0

 

//any任意类型

let anye:any=new Array();

anye=2

 

//undefined,null

let def:undefined=undefined

 

//联合类型

let wc:number |string |boolean

 

//元祖 来自于C#

let ele:[string,number]=["sb",19]

 

//类型推论

let ww=3 //number

let mm; //any

 

//类型断言

let dsw:number|string|boolean="this sssjsj"

let strlen:number=dsw.length

strlen=(<string>dsw).length //有泛型的意思

strlen=(dsw as string).length

 

//接口 行为的抽象，只是定义一个规范并不实现

// 一定义接口

interface Animal {

Eat(food:string):string; //定义一个接口方法，具体的实现需要实现接口 体现多态的根源

}

interface Sleep {

wok(food:string):string; //定义一个接口方法，具体的实现需要实现接口 体现多态的根源

}

//实现,需要实现所有方法，否则是抽象类，接口可以多继承

class People implements Animal,Sleep{

Eat(food:string):string{

return "肉" +food;

}

wok(food:string):string{

return "睡觉"

}

 

}

let p=new People();

console.log(p.Eat("主"));

 

//接口二多函数的约束

interface CheckFunction{

(a:string,b:number):boolean

}

let func:CheckFunction=(str:string,num:number)=> false;

 

//接口三多数组的约束

interface CheckArray {

[index:number]:String

}

 

let arr2:CheckArray=["222","22","1"]

 

//接口四多json的约束

interface CheckJson{

name:string,

readonly age:number, //只读属性

sex?:string //可选属性

}

function showJson(n:CheckJson){

console.log(JSON.stringify(n))

}

showJson({name:"李洋",age:24})

 

//类的定义 public 公共的，private 私有的 protected 受保护的，只能在子类和内部访问

class Person{

name:string;

age:number;

constructor(name:string,age:number){

this.name=name;

this.age=age;

}

pint():string{

return this.name+":"+this.age;

}

}

let ppd=new Person("ppd",35);

console.log(ppd.pint())

 

//类的继承

class Student extends Person {

static em="wu";//静态属性

school:string;

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

super(name,age);

this.school=school;

}

pint():string{ //多态的具体实现

return this.name+":"+this.age+":"+this.school;

}

static funccc(){//静态方法

 

}

}

let ppd2=new Student("ppd",35,"神大");

console.log(ppd2.pint())

 

// js静态方法/属性

// function Funcc(){

// //实例属性

// this.name="jj";

// //实例方法

// this.pint(){

// }

// }

// Funcc.age=19;//静态属性

// Funcc.pint2=()=>{} //静态方法

 

//抽象类/抽象方法

//1：抽象类是提供其他继承的基类，不能被实例化

//2：抽象方法只能包含在抽象类中，抽象类包含抽象方法和非抽象方法

//3：子类继承抽象类，实现抽象方法

abstract class Workenr{

abstract eat():string;

run(){

console.log("1")

}

}

 

//函数定义

function addp(x,y):number{

return x+y;

}

//匿名函数

let show=(a,b):number=>a+b;

 

function add3(a:number,b:number):number{

return a+b;

}

function add4(a:string,b:number=20,c?:string):string{ //默认 和 可选 参数

return a+b;

}

console.log(add4("wc"))

//剩余参数

function spadd(a:number,b:number,...arr:number[]):number{

var sum=arr.reduce((pre,cur)=>pre+cur)

return a+b+sum;

}

console.log(spadd(1,2,3,4,5,6));

 

//函数重载

function getInfo(name:string):void;

function getInfo(age:number):void;

function getInfo(str:any):void{

if(typeof str==="string"){

console.log(1)

}else if(typeof str==="number"){

console.log(2)

}

}

getInfo("sssskk")

 

//泛型函数

function pintnum<T>(arr:T[]):void{

for(var v of arr){

console.log(v)

}

}

pintnum<string>(["wu","li","sb"])

pintnum<number>([1,2,3,4])

 

//泛型类

class MyArray<T>{

public name:T;

public list:T[]=[]

add3(v:T):void{

this.list.push(v)

}

}

var arr6=new MyArray<number>();

arr6.add3(1);

console.log(arr6.list)

 

//泛型接口

interface Iadd<T>{

(x:T,a:string):void;

}

var add8:Iadd<number>=(a:number,y:string):void{

console.log(a,y);

}

console.log(add8(5,"sd"))