一、string字符串

  1. // 声明一个变量a，同时指定他的类型为string
  2. var a:string;

二、number数字

  1. // 声明一个变量a，同时指定他的类型为number
  2. var a:number;
  4. // a的类型设置为了number，在以后的使用过程中a的值只能是数字
  5. a=10;
  6. a=33;
  7. // a="hello";
  8. var b:string;
  9. b="hello";
  10. // b=123

三、boolean布尔值

  1. 如果变量的声明和赋值是同时进行的，TS可以自动对变量进行类型检测
  1. // var c:boolean = false;
  2. // 如果变量的声明和赋值是同时进行的，TS可以自动对变量进行类型检测
  3. var c = true;
  4. // var c = 10;

四、function函数

  1. 设置传参数据类型以及返回值数据类型
  2. 设置函数结构的类型声明：
  3.         语法：(形参:类型,形参:类型 ...) => 返回值
  5. function sums(a:number,b:number):number{
  6.     return a+b
  7. }
  9. let d: (a: number, b: number) => number;
  10. d = function (n1: number, n2: number) {
  11.     return n1 + n2
  12. }
  1. /* function sum(a,b){
  2.     return a+b
  3. }
  4. console.log(sum(123,456));  //579
  5. console.log(sum(123,"456"));    //123456 */
  7. function sums(a:number,b:number):number{
  8.     return a+b
  9. }
  10. console.log(sums(123,456));
  11. // console.log(sums(123,"456"));
  12. var result = sums(123,456)
  13. // var result = sums(123,"456")

五、字面量声明

  1. 使用字面量进行类型声明，表面该变量只能是声明时的值，或者使用|声明多个类型
  1. // 也可以使用字面量进行类型声明
  2. let a: 10;
  3. a = 10;
  4. a = 11;
  6. let b: "male" | "female"
  7. b = "male";
  8. b = "female";
  9. // b="hello"
  11. let c: boolean | string;
  12. c = true;
  13. c = "hello"

六、any任意类型

  1. any 表示的是任意类型，一个变量设置为any后相当于对该变量关闭了TS的类型检测
  2. // let d  --声明变量如果不指定类型，则TS解析器会自动判断变量的类型为any（隐式any）
  3. // d的类型是any，它可以赋值给任意变量使其改变类型
  4. ！！！不建议使用
  1. // any 表示的是任意类型，一个变量设置为any后相当于对该变量关闭了TS的类型检测
  2. let d:any;
  3. d = 10;
  4. d = "hello";
  5. d = true
  7. // unknown    实际上就是一个类型安全的any
  8. // unknown类型的变量，不能直接赋值给其他变量
  9. let e:unknown;
  10. e = 10;
  11. e = "hello"
  12. e = true
  14. let s:string
  15. e = "hello"
  17. //类型断言，可以用来告诉解析器变量的实际类型
  18. 变量 as 类型
  19. <类型>变量
  21. s = e as string
  22. s = <string>e

七、object对象

  1. // oject表示一个js对象
  2. let a: Object
  3. {}用来指定对象中可以包含哪些属性
  4. 语法：{属性名:属性值 ,属性名:属性值}
  5. 在属性名后面加上?,表示属性是可选的
  6. [proName: string]: any 表示除了必须的name属性，可选任意类型的属性
  1. // oject表示一个js对象
  2. let a: Object
  3. a = {};
  4. a = function () {
  6. };
  8. // {}用来指定对象中可以包含哪些属性
  9. // 语法：{属性名:属性值 ,属性名:属性值}
  10. // 在属性名后面加上?,表示属性是可选的
  11. let b: { name: string, age?: number };
  12. b = { name: "孙悟空", age: 18 };
  14. // [proName: string]: any 表示除了必须的name属性，可选任意类型的属性
  15. let c: { name: string, [proName: string]: any };
  16. c = { name: "猪八戒", age: 18, sex: "男" }

八、数组与元组

  1. 数组的类型声明：
  2.         类型[]
  3.         Array<类型>
  4. string[] 表示字符串数组
  5. number[] 表示数值数组
  1. 元组：元组就是固定长度和元素类型的数组
  2.         语法：[类型,类型]
  1. /* 
  2.     数组的类型声明：
  3.         类型[]
  4.         Array<类型>
  5. */
  6. // string[] 表示字符串数组
  7. let e: string[];
  8. e = ['a', 'b', 'c']
  10. // number[] 表示数值数组
  11. let f: number[];
  13. let g: Array<number>
  14. g = [1, 2, 3]
  16. /* 
  17.     元组：元组就是固定长度的数组
  18.         语法：[类型,类型]
  19. */
  20. let h: [string, number];
  21. h = ['hello', 123]

九、枚举

  1. enum    枚举
  2. enum Gender {
  3.     Male = 0,
  4.     Female = 1
  5. }
  6. &表示同时
  1. /* 
  2.     enum    枚举
  3. */
  4. enum Gender {
  5.     Male = 0,
  6.     Female = 1
  7. }
  8. let i: { name: string, gender: Gender }
  9. i = {
  10.     name: '孙悟空',
  11.     gender: Gender.Male  //'male' 自动转化为0传递
  12. }
  13. console.log(i.gender === Gender.Male);
  15. // &表示同时
  16. let j: { name: string } & { age: number };
  17. j = { name: '孙悟空', age: 18 }
  19. // 类型的别名
  20. type myType = 1 | 2 | 3 | 4 | 5;
  21. let K: myType;
  22. let o:myType;
  24. o = 3;

十、class类

  1. 指定类的属性的类型及方法
  1. class Student{
  2.     "name":string;
  3.     "age":number;
  4.     constructor(name:string,age:number){
  5.         this.name = name;
  6.         this.age = age
  7.     }
  8.     getName():void{
  9.         console.log(this.name);
  11.     }
  12. }
  14. var s:Student = new Student("张三",18);
  15. s.getName();