TypeScript基础数据类型
//Number 类型
const count:number=1;
//String 类型
const mynames:string='ping';
//Boolean 类型
const isDone:boolean=false;
Array 类型
let list:number[]=[1,2,3];
let kist:Array<number>=[1,2,3];
const stringArr:string[]=['1','2','3'];
const undefinedArr: undefined[] = [undefined, undefined];
const nullArr:null[]=[null,null];
const arr: (number | string)[] = [1, "string", 2];
Array-元祖类型(tuple)
元祖的表示和数组非常类似,只不过它将类型写在了里面 这就对每一项起到了限定的作用
元组就是固定长度的数组
let listTuple:[string,number]=['vikeing',123];
//sv或者excel格式的导出的文件,产生的数据结构转化成js时,用元组去管理比较合适
const jj:[string,string,number][]=[
["dajiao","tac",28],
["dajiao","tac",28],
["cuihua","tac",21],
]
定义元祖的语法 存储的元素数据类型不同,则需要使用元组;
type TurpleArr=[string,number,string];
const mixe:TurpleArr=['a',2,'c'];
const first=mixe[0];
const second=mixe[1];
枚举类型 -- enum
用于取值被限定在一定范围内的场景,TypeScript支持数字的和基于字符串的枚举
类型可以分成: 数字枚举 字符串枚举 异构枚举
enum xxx { ... }
/ 声明d为枚举类型Direction
let d: Direction枚举成员是只读的,枚举中的成员无法直接赋值
数字枚举
enum Direction {
Up, // 值默认为 0
Down, // 值默认为 1
Left, // 值默认为 2
Right // 值默认为 3
}
console.log(Direction.Up === 0); // true
console.log(Direction.Down === 1); // true
console.log(Direction.Left === 2); // true
console.log(Direction.Right === 3); // true
enum Direction {
Up = 10,
Down,
Left,
Right
}
console.log(Direction.Up, Direction.Down, Direction.Left, Direction.Right); // 10 11 12 13
字符串枚举
enum Direction {
Up = 'Up',
Down = 'Down',
Left = 'Left',
Right = 'Right'
}
console.log(Direction['Right'], Direction.Up); // Right Up
s[0]); // ON
异构枚举
enum BooleanLikeHeterogeneousEnum {
No = 0,
Yes = "YES",
}
函数参数和返回类型定义
显式指定函数参数和返回值的类型
//参数名后的 :number 表示参数类型都是数字类型,
//圆括号后的 : number'则表示返回值类型也是数字类型
const add=(a:number,b:number):number=>{
return a+b;
}
//在 TypeScript 中 使用void 类型来表示函数没有返回值的类型
function fun():void{
console.log('123);
}
//如果一个函数是永远也执行不完的,就可以定义返回值为never
function forNever():never{
throw new Error();
console.log('123')
}
//先定义了一个函数类型(这里使用了类型别名 type),并且使用箭头函数实现了这个类型
type Adder=(a:number,b:number)=>number;//TypeScript 函数类型定义
const adds:Adder=(a,b)=>a-b;
函数参数为对象(解构)时
//对象结构 定义多个属性
function add3({one,two}:{one:number,two:number}):number{
return one+two;
}
//对象结构 定义1个属性
function getNumber({one}:{one:number}):number{
return one;
}
const one=getNumber({one:1});
使用类似对象属性的简写语法来声明函数类型的属性
interface Entity{
add:(a:number,b:number)=>number;
del:(a:number,b:number)=>number;
}
const entity:Entity={
add:(a,b)=>a+b,
del(a,b){
return a-b
}
}
可缺省和可推断的返回值类型
function funcs(one:string,two:number){
const nums=[two];
const strs=[one];
return {
nums,
strs
}
}
可选参数、默认参数、剩余参数(...)
//可选参数
function funcs1(x?:string):void{
console.log(x);
}
//函数参数是不可缺省且类型必须是 xxx 或者 undfined
function funcs2(x: string | undefined) {
console.log(x);
}
//默认参数
function funcs12(x:number=8888){
console.log(x);
}
//剩余参数
function buildName(firstName: string, ...restOfName: string[]) {
return firstName + " " + restOfName.join(" ")
}
let aName = buildName("Lili", "John", "David", "Durban");
console.log(aName); // Lili John David Durban
函数重载
//最后这个函数的参数一定要是any,因为前连个函数的参数类型是不一定的
function funcs3(nameA:string,age:number):void;
function funcs3(age:number):void;
function funcs3(str:any,age?:any):void{
if (typeof str == 'string') {
console.log(`my name is ${str} ${age}`);
} else {
console.log(`my age is ${str}`);
}
}