ts语法入门-1

记录今天学习–Ts
1、安装ts— npm i -g typescript
2、查看tsc版本— tsc -v
3、创建ts文件 index.ts 写入以下代码；终端运行—tsc index.ts 可得到index.js
4、如果出现tsc命令报错，则需要在powershell中查看执行策略— get-ExecutionPolicy
如果是restricted：表示是受限制的
运行set-ExecutionPolicy RemoteSigned
再次运行tsc命令— tsc index.ts应该就可以了

// const dataset = [
//   '类型声明',
//   '自动类型判断',
//   '字面量声明',
//   'any类型',
//   'unknown类型',
//   '类型断言',
//   '函数',
//   '对象类型声明',
//   '数组类型声明',
//   '扩展类型元组(tuple)',
//   '枚举(Enum)',
//   '联合类型声明',
//   '类型别名',
// ]

{
  // 类型声明
  let a: number;
  a = 10;
  // a='hello'

  let b: boolean = true;

  function func(name: string) {
    console.log("类型声明: " + name);
  }
  func("hello");
  // func(111)
}

{
  //  自动类型判断
  let a: number = 100;
  let b = 111;
  // b = 'sss'
  console.log("自动类型判断: " + typeof b);
}

{
  // 字面量声明 --类似于常量
  let a: 10;
  // a = 11;
  console.log("字面量声明: " + a);
}

{
  // any类型 --不推荐使用
  let a: any;
  a = 1;
  a = "sss";
  a = [];
  a = true;

  let b;
  b = 1;
  b = "关闭了自身的ts校验，在把当前值赋值给别人的时候也影响了别人的类型校验";

  let c: number;
  c = 100;
  c = b;

  console.log("any类型: " + c);
}

{
  // unknown类型
  let a: unknown;
  a = 1;
  a = true;
  a = "unknown可以理解为安全的any类型";

  let b: string;
  // b = a
  if (typeof a === "string") {
    b = a;
  }
  console.log("unknown类型: " + b);
}

{
  // 类型断言
  let a: unknown;
  a = "用as代替typeof判断，实现unknown类型赋值";
  let b: string;

  b = a as string;
  console.log("类型断言: " + b);
}

{
  // 函数声明
  // 函数形参类型声明
  function func1(name: string, params: object) {
    console.log("函数声明: " + name);
  }

  // func1('tom', 1)
  // func1('tom', {},12)
  func1("函数参数个数、类型必须和形参保持一致", {});

  // 函数中返回值的声明
  // function func2():string {
  //   console.log(123)
  // }
  function func3(): string {
    return "函数返回值类型声明之后必须返回对应的类型的值，不过void表示不返回或者返回null、undefined";
  }
  let a = func3();
  console.log("函数返回值声明: " + a);

  // void表示不返回或者返回null、undefined
  function func4(): void {
    // return 1   // 报错
    // return 'ss'  // 报错
    // return NaN   // 报错
    // return null
    // return undefined
    // return
  }

  function func5(): never {
    throw new Error("设置返回值类型为never，直接抛出");
  }

  func5();
}

{
  // 对象类型声明
  // let propName: string;
  let a: {
    name: string;
    age?: number;
    obj?: {};
    [propName: string]: unknown;
  };
  a = {
    name: "用{}来校验对象类型;  ?可表示可选择， [propName: string]表示任意的字符串可作为对象a的键名",
    sayHello() {
      console.log("对象类型声明: " + this.name);
    },
  };
  if (typeof a.sayHello === "function") {
  //  此处如果报错，则修改[propName: string]: unknown 为[propName: string]:any  暂时还不明白原因
    a.sayHello(); 
  }
}

{
  // 数组类型声明
  let a: string[] = [];
  a[0] =
    "数组类型声明: string[]或者Array<string>意思是数组中的元素必须都是string类型";
  // a[1] = 1
  // a[1] = {}

  let b: Array<number> = [];
  b[0] = 123;
  // b[1] = function(){}
  console.log(a[0]);
}

{
  // 扩展类型元组(tuple)
  let a: [string, number, boolean];
  a = ["元素个数需要和声明时候的个数一致，类型顺序需要一致", 123, true];
  // a = [1,2,3]
  console.log("扩展类型元组(tuple): " + a[0]);
}

{
  // 枚举(Enum) -- 一种特定类型的计数
  enum a {
    x,
    y
  }
  console.log(a); // {0: "x", 1: "y", x: 0, y: 1}

  enum b {
    x = 3,
    y,
    z
  }
  console.log(b); // {3: "x", 4: "y", 5: "z", x: 3, y: 4, z: 5}  可以看到自增规则

  // 字符串类型的枚举
  enum c {
    x = "x",
    // y, 报错--枚举成员必须具有初始化表达式
    // z
    y = "y",
    z = "z"
  }
  console.log(c); // {x: "x", y: "y", z: "z"}
}

{
  // 联合类型声明 --- |
  let a: number | string | boolean;
  a = 1;
  a = false;
  a = "联合类型声明: 赋值范围需要在声明的类型中";

  console.log(a);

  // 字面量相同
  let b: 1 | 2 | 3;
  b = 1;
  b = 2;
  // b = 4;
}

{
  // 类型别名
  type myVariable = string | number | 1 | 2 | {} | 3 | 4 | boolean;
  type myVariable2 = string | number | 1 | 2 | 3 | 4 | boolean;
  let a: myVariable = function () {};
  a = true;

  // let b: myVariable2 = function(){} //报错
  let c: myVariable;
  c = '类型别名：类似于js全局变量，赋值的时候需要看清楚类型限制'

  console.log(c);
}