TypeScript记录1. 申明 2. 作用域可以看到let申明的变量i是由2个变量替代了，而var申明的变量i用的

变量let 和 var

1. 申明

var 变量名: 类型 = 值

let变量不能重复定义
var取最后定义的值

//报错
let x = 1;
let x = 2;

//正常 y = 4
var y = 3;
var y = 4;

在类里面声明变量不能加 var、 let ?

2. 作用域

let是函数作用域
var是块级作用域

demo.ts文件

function funLetVar() {
  let nums: number[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

  console.log("\n-----let--------\n");
  for (let i = 0; i < 4; i++) {
    console.log("llll");
    for (let i = 0; i < 2; i++) {
      console.log(`i = ${i}`);
    }
  }
  
  console.log("\n-----var--------\n");
  for (var i = 0; i < 2; i++) {
    console.log("vvvvv", i);
    for (var i = 0; i < 10; i++) {
      console.log(`i = ${i}`);
    }
  }
}
funLetVar()

//打印
-----let--------

llll
i = 0
i = 1
llll
i = 0
i = 1
llll
i = 0
i = 1
llll
i = 0
i = 1

-----var--------

vvvvv 0
i = 0
i = 1
i = 2

执行命令tsc demo.ts编译得到demo.js文件
可以看到let申明的变量i是由2个变量替代了，而var申明的变量i用的就是同一个变量。

deom.js文件

function funLetVar() {
    var nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    console.log("\n-----let--------\n");
    for (var i_1 = 0; i_1 < 4; i_1++) {
        console.log("llll");
        for (var i_2 = 0; i_2 < 2; i_2++) {
            console.log("i = " + i_2);
        }
    }
    console.log("\n-----var--------\n");
    for (var i = 0; i < 2; i++) {
        console.log("vvvvv", i);
        for (var i = 0; i < 10; i++) {
            console.log("i = " + i);
        }
    }
}
funLetVar();

类型

1. 基本类型

  let bl: number = 0b10011;
  let name: string = "aa";
  let years: number = 5;
  let words: string = `name is ${name} year is ${years}`;
  console.log(words);
  
  //数组
  let x: number[] = [1, 2.0];
  let x1: Array<number> = [1, 3.3]

  //元祖
  var tuple: [string, number]
  tuple[0] = "jjk" //未整体赋值前不能修改单个下标的值
  tuple = ["a1b2c3", 3456]
  tuple[1] = 123
  console.log(tuple[0], tuple[1]);
  
  //枚举
  enum Color {
    Red,
    Green,
    Blue
  };
  var color = Color.Red
  color = Color.Green
  let c1: Color = Color.Blue


  //方法
  function fun1(str:string):void {
    console.log(str)
  }
  fun1("fun 1");
  
  function fun2(str: string):string {
    return str+" halo"
  }
  let rst = fun2("fun 2")
  console.log(rst);

2. Any 类型

任意值类型可以让这些变量跳过编译阶段的类型检查

function funAny() {
  let x: any = 4
  x = "abc"
  x = true

  let arrayAny: any[] = [12, "a0d", false, [12, "a"]]
  arrayAny[0] = null
  arrayAny[1] = 44
  arrayAny[2] = "a"
  arrayAny[3] = "a";
  console.log(arrayAny);
}
funAny()

3. Null 和 Undefined 类型

null是一个只有一个值的特殊类型,表示一个空对象引用;
undefined 是一个没有设置值的变量;

function funNullUndefined() {
  //变量 x 只能是number类型
  var x: number
  x = 4
  x = null
  x = undefined

  //如果一个类型可能出现 null 或 undefined， 可以用 | 来支持多种类型
  var y: number | null  | undefined
  y = 1
  y = null
  y = undefined

}
funNullUndefined()

4. never 类型

never 是其它类型（包括 null 和 undefined）的子类型，代表从不会出现的值。这意味着声明为 never 类型的变量只能被 never 类型所赋值，在函数中它通常表现为抛出异常或无法执行到终止点（例如无限循环）。

function funNever() {
  let x: never
  let y = 5

  // x = 44
  y = 14

  //运行正确，never 类型可以赋值给 never类型
  x = (()=>{throw new Error("err msg")})()
  x = (()=>{throw "err msg"})()

  //返回值为 never 的函数可以是无法被执行到的终止点的情况
  function loopFun(): never {
    while (true) {}
  }
  x = loopFun()
}
funNever()

类型断言

类型推断

函数

1. 可变参数`...`

//x接受第一个值
function funSum(x: number, ...num: number[]): number {
  var rst: number = x;
  console.log(rst);

  for (let index = 0; index < num.length; index++) {
    rst += num[index];
  }

  return rst
}
console.log(funSum(13, 2, 3, 4, 5))

TypeScript记录