数据类型
原始数据类型
String 、Number、Bigint、Boolean、symbol、null、undefined
Typescript中定义原始类型
//定义布尔值
let isDone:boolean = false;
//注意 使用构造函数构造的不是原始类型 如下
let isDoneWraper: Boolean = new Boolean(1);//返回一个Boolean对象
//也可以直接调用Boolean()返回boolean类型
let isDoneFinsih:boolean = Boolean(0);
//定义数值
let d:number = 6;
let hexD:number = 0xff0d;
let notNumber:number = NaN;
let inNumber:number = Infinity;
//定义字符串
let str:string = "Tom";
//模板字符串
let sentence:string = `Hello , my name is ${str}`;
//空值 js中没有空值的概念，Ts中可以用空值来表示没有任何返回值的函数
function test():void {
console.log('this is a test log');
}
//也可以将空值赋值为Null、undefined
let unsuable:void = null;
//Ts中Null、undefined
let u:undefined = undefined;
let n:null = null;
//📢注意：null、undefined与void的区别
//null、undefined是所有类型的子类型，因此可以赋值给其他类型，而void不能赋值给其他类型
let num1:number = null; //✅非严格模式下，这是合法的
let num3:number = undefined; //严格模式下，也是合法的
let vTest:void;
let num2:number = vTest; //❎这是非法的
任意值
Any用来表示允许赋值为任意类型。可以赋值为任意类型。
联合类型
let s:string | number;
s = "hello";
s = 7;
s.length //会报错 因为length 不是联合属性共有的
s.toString() //不会报错，因为toString是联合属性都有的方法
对象类型
接口
定义：是对类的行为的抽象。
interface Person {
readonly id:number; //只读属性，实现变量里面不能赋值
name:string; //name、age这两个属性变量必须要有
age:number;
desc?:string; //可选属性
// [propName:string]:any; //任意属性
[propName:string]:string | number //任意string | number联合属性
}
let tom : Person = {
name : "tom",
age :16, //此时，age不为string会报错。不符合任意属性。 此时若为任意联合属性，则不会报错
gender: "famle" //任意属性 string类型
}
数组
let fArray:number[] = [1,2,3,4,5]; //只能传入number
//数组泛型
let kArray:Array<number> = [1,2,4,5,6];
//使用接口来表示数组
interface NumberArray {
[index:number]:number; //index为数字，值的类型也为数字
}
let nArray:NumberArray = [1,2,3,4,5,6];
//类数组 js中的arguments
function sum(){
let args:{
[index:number]:number;
length:number;
callee:Function;
} = arguments;
}
//实际上以上类数组有其内置对象，不用写那么多
function sum(){
let args:IArguments = arguments;
}
//any在数组中的常见运用
let anyArray:any[] = ["hello",1,{age:22}];
函数
function sum(x:number,y:number):number {
return x + y;
}
//函数表达式
//个人理解 此处sum为类型推断
let sum = function(x:number,y:number):number {
return x + y;
}
//手动赋予sum number类型
let mySum: (x: number, y: number) => number = function (x: number, y: number): number {
return x + y;
};
//用接口定义函数
interface SearchFunc {
(source:string,substring:string):boolean;
}
let mySearch:SearchFunc;
mySearch = function(source:string,substrig:string){
return source.search(substring) !== -1;
}
//函数的可选参数与默认值 (默认值和可选参数不能同时存在于一个参数上)
let test = (age:number,name:string="lihua",context?:string){
console.log(`age:${age} && context:${context}`);
}
//严格模式下
let test = (age:number,name:string="lihua",context?:string) => {
console.log(`age:${age} && name = ${name} && context:${context}`);
}
test(12) //age:12 && name = lihua && context:undefined
//剩余参数 ...rest 只能为最后一个参数
function push(array,...items){
item.forEach(function(item){
array.push(item);
})
}
let a:any[] = [];
push(a,1,3,4);
//类型重载
function reverse(x: number): number;
function reverse(x: string): string;
function reverse(x: number | string): number | string | void {
if (typeof x === 'number') {
return Number(x.toString().split('').reverse().join(''));
} else if (typeof x === 'string') {
return x.split('').reverse().join('');
}
}
//类型断言 值 as 类型
//类型声明（常用于联合类型）
type Name = string;
type NameResolver = () => string;
type NameOrResolver = Name | NameResolver;
function getName(n: NameOrResolver): Name {
if (typeof n === 'string') {
return n;
} else {
return n();
}
}
泛型
定义：泛型是指在定义函数、接口或类的时候，不预先指定具体的类型，而在使用的时候再指定类型的一种特性。
function createArray<T>(length:number,value:T):Array<T>{
let result : T[] = [];
for(let i=0;i<length;i++){
result[i] = value;
}
return result;
}
console.log(createArray(5,1))//[1,1,1,1,1]
//定义泛型多个类型参数
function swap<T, U>(tuple: [T, U]): [U, T] {
return [tuple[1], tuple[0]];
}
swap([7, 'seven']); // ['seven', 7] 交换了元组
泛型约束
在函数内部使用泛型时，因为不知道他是哪种类型，因此不能随意操作他的属性或方法，有可能会报错。因此需要泛型约束
interface Lengthwise {
length:number;
}
function test<T extends Lengthwise>(arg:T):T{
console.log(arg.length);
return arg;
}
//泛型接口
interface CreateArrayFunc<T> {
(length: number, value: T): Array<T>;
}
let createArray: CreateArrayFunc<any>;
createArray = function<T>(length: number, value: T): Array<T> {
let result: T[] = [];
for (let i = 0; i < length; i++) {
result[i] = value;
}
return result;
}
createArray(3, 'x'); // ['x', 'x', 'x']
//泛型类
class GenericNumber<T> {
zeroValue: T;
add: (x: T, y: T) => T;
}
let myGenericNumber = new GenericNumber<number>();
myGenericNumber.zeroValue = 0;
myGenericNumber.add = function(x, y) { return x + y; };
