TypeScript 基本数据类型

TypeScript: 基本数据类型

在 typescript 中声明一个变量，同时指定它的类型，在以后的使用过程中，该变量的值只能是这种类型

字符串类型

ts 中字符串也可以使用 反引号，用法和 js 一样

let a: string = "aaa";

数字类型

数字类型支持 十进制、十六进制、二进制、八进制

let b: number = 100;

布尔类型

let c: boolean = true;

数组

// 语法一:   string[] 表示该变量全是由字符串组成的数组，同理 number[], boolean[]
let arr1: string[] = ["a","b","c"];

// 语法二:   数组泛型, 同理 Array<string>, Array<boolean>
let arr2: Array<number> = [1,2,3,4,5];

对象

// 语法一: object,定义的对象中可以存放任意个数和类型的属性
let obj1: object = { name: "zs", age: 18 };

// 语法二: { }, 作用同 object
let obj2: {} = { name:"ls",hobby:"code" };

// 语法三: 限制对象中的属性
// 以 obj3 为例，赋值的时候，对象中的属性的个数和类型需要和声明时一致
let obj3: { name:string } = { name:"zs" }

// 语法四: 可选属性，通过在属性名后加 ?，表示该属性是可选的
let obj4: { name: string, age?: number };
obj4 = {
    name: "zs"
}

// 语法五(尽量不用): 通过any设置
// 以 obj5 为例，表示该对象需要name属性，其他属性的个数和类型任意
// [aaa: string] 表示字符串类型的任意属性名
// any 表示任意类型的属性值
let obj5: { name:string, [aaa:"string"]: any }
obj5 = {
    name:"zs",
    age: 18,
    hobby: "code"
}

函数

// 语法一
// 表示 fn1 有两个参数，都是number类型，并且返回值为number类型
let fn1: (a: number,b: number) => number;

fn1 = function(num1,num2) {
    return num1+num2;
}

//语法二
// 表示 fn2 有两个参数，第一个是number类型，第二个是string类型，返回值为string类型
// 括号后面的类型为返回值的类型，默认为 void，表示没有返回值,如果为 never ，表示永远不会返回结果
function fn2(a: number, b: string): string {
    retrun a+b;
}

any 类型

• any 表示任意类型，一般不建议使用
• 一个变量设置类型为 any 后，相当于 ts 关闭了对该变量的类型检测
• any 类型的变量，可以赋值给任意变量，被赋值的变量也会转变成 any
• 如果只声明变量，不赋值并且不指定类型，则 ts 解析器会自动判断变量的类型为 any

let p: any;
p = 100;
p = true;
p = "hello";

unknown 类型

• unknown 表示未知类型的值
• 和 any 的区别就是不会改变其他变量的类型
• unknown 实际上是一个类型安全的 any

let q: unknown;
q = 123;
q = "hello";
q = true;
-----------------------------------------------------------------------------
//unknown 类型的变量，不能直接赋值给其他变量，需要进行转换
    
let r: string = "aaa";
let s: unknown = "hello";

// 方式一
if(typeof s === "string") {
    r = s;
}

// 方式二: 通过类型断言
r = <string>s;

元组

元组就是固定长度的数组

语法：[类型,类型,…]

let t: [string,string];
t = ["aaa","bbb"];

枚举

enum Gender {
    Male = 0,
    Female = 1
}

let u: { name:string, gender:Gender}
u = {
    name:"zs",
    gender: Gender.Female
}

补充

省略变量类型

如果变量的声明和赋值是同时进行的，那么可以省略变量的类型，ts解析器 会自动解析变量的类型

let d = 100;

只声明变量

如果只声明变量，不对其赋值并且不指定其类型的时候，那么 ts解析器 会将变量的类型解析成 any

即： 变量隐式具有 ”any“ 类型

let e;

不能省略声明变量的关键字

f = 100;   // 这样的书写方式是错误的

联合类型

通过 | 给变量设置多种类型，赋值时可以根据设置的类型来赋值

// f 可以赋值成字符串，数字或布尔值

let f: boolean | string | number;
f = 100;
f = "abc";

交叉类型

通过 & 设置类型，表示该变量既是前者又是后者

let b: { name: string } & { age: number }   表示 j 中要同时有 name属性 和 age属性

通过字面量进行类型声明

使用字面量声明后，该变量只能赋给出的值

let g: 10;
let h: "male" | "female";

g = 10;
h = "male";
h = "female";

类型断言

用于告诉 ts解析器 该变量的实际类型

let r: string = "aaa";
let s: unknown = "hello";
// 语法一： 变量 as 类型
r = s as string;

// 语法二： <类型>变量 
r = <string>s;

类型别名

// 语法： (表示 string类型 起了个别名叫 myType ,可以用 myType 代表 string )
// 如： type myType = string;

type myType = "a" | "b" | "c"| "d"| "e";

let v: myType = "c";

;

// 语法二： <类型>变量
r = s;

##### 类型别名

```typescript
// 语法： (表示 string类型 起了个别名叫 myType ,可以用 myType 代表 string )
// 如： type myType = string;

type myType = "a" | "b" | "c"| "d"| "e";

let v: myType = "c";