typescript相关的其他知识点

typescript的类型

数据类型

面向对象

11111

数组中只有0和1，每过1代，0旁边只有1个1，当前0会变成1。每过1代，0旁边有2个1，当前0还是0。 比如10001，经过1代，会变成11011，再过1代，还是11011 。 求一个数组经过M代以后的数组。函数定义是void f(int[] arr,int m) 。

答案2022-01-08：

x里有有限个0。 1x1，中间0，x中有2m个0变成1，最中间的0不会变成1。 1x，右0，x中有m个0变成1。 x1，左0，x中有m个0变成1。 时间复杂度：O(N)。 空间复杂度：O(1)。

package mainimport "fmt"func main() {
    arr := []byte{0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0}
    f(arr, 2)
    fmt.Println(arr)
}func f(arr []byte, m int) {    //找中间0
    oneIndexList := make([]int, 0)    for i, a := range arr {        if len(oneIndexList) == 2 {
            oneIndexList = oneIndexList[1:]
        }        if a == 1 {
            oneIndexList = append(oneIndexList, i)
        }        if len(oneIndexList) == 2 {            for j := oneIndexList[0] + 1; j <= oneIndexList[1]-1; j++ {                if j-oneIndexList[0] != oneIndexList[1]-j &&
                    (j-oneIndexList[0] <= m ||
                        oneIndexList[1]-j <= m) {
                    arr[j] = 1
                }
            }
        }
    }

变量的作用域： 程序代码能访问该变量的区域 根据变量的有效范围可分为 ·局部变量 在函数内定义并使用变量，只在函数内有效， 局部变量使用global声明，这个变量就会变成全局变量 ·全局变量 函数体外定义的变量，可作用于函数内外的

学完了，很好看，很实用
学完了，很好看，很实用
学完了，很好看，很实用
学完了，很好看，很实用

学习技术，应该阅读文档，加上实际动手操作。

当然配合视频学习，也得有自己的代码输出。

感谢老师的讲解。

1、声明：

let 声明变量，解决 var 中带来的作用域混论的问题

const 声明常量

2、类型：

数字number

布尔boolean

字符串string

数组array

元组tupple 是一个特殊的数组，是固定长度固定类型的数组（固定长度、固定类型的数组，声明元组的时候一定要指明类型，bug：使用 .push() 可以突破元组的界限，无限的给元组添加长度）

联合union 本质上就是数组，既没有固定长度也没有固定类型（一个变量可以同时支持两个或多个不同的类型）

字面量literal

枚举enum（在默认情况下，枚举类型的表现形式与c++类似，枚举类型真正的类型数据是数字，也是从0开始计算）

any （支持并且兼容所有类型）使用any适合代码的快速成型快速上线，但是会遗留一些明显的安全隐患。

unknow（不保证类型，但能保证类型安全）使用unkonwn比any保险一点，可以保证类型的安全。

viod（函数在没有任何返回的情况下，函数就是一个 void 类型）

undefined（是一个未经初始化的值）

never（一个函数永远执行不完，这就是 never 的本质。实际开发过程中，never是用来控制逻辑流程的，大部分是用来处理异常或者处理promise）

类型适配 Type Assertions（使用方法：<> 或者 as）在使用类型适配 Type Assertions 的时候，一定要非常非常了解当前变量的类型，必须对自己的代码有百分之百的信心！否则引发严重的错误！

3、函数类型

typescript中，调用函数与JavaScript有个显著的不同，就是typescript调用函数过程中，如果函数定义了两个参数，调用时必须填写两个参数，并且类型要一致。typescript可以使用 ? 来表示参数的可选性，被用 ? 来指定的参数可以不填写，函数里面的这个参数就被设定为undefined；也可以给参数设定默认值

4、面向对象

对象object（以 {} 包括起来，用键值对的形式显示）在对象初始化的时候，就已经定义好类型了。typescript对对象类型的定义不是 key to value（键值对），而是 key to type（键类型对）

对象包括：公有属性、私有属性、参数、公有成员方法、私有成员方法、封装、继承、多态。

接口interface （对象的聚合问题：高内聚，低耦合。简单来说就是，功能相关的事物放在同一个集合中形成一个模块，这就叫高内聚；而这些又是互相独立的，不同模块之间保持低耦合的状态。）

类class（官方定义：在JavaScript中，类是一个特殊的函数，在这个函数中不仅可以定义函数表达，也可以声明这个函数，在类的语法中包含两个部分，定义与声明。）

访问修饰符 Access Modifier（public、private、protected）通过使用访问修饰符，在声明构造函数的同时，顺便完成成员变量的声明以及初始化。

在对象外部直接访问内部成员变量，甚至重新赋值是非常危险的！一般要避免外部直接操作class内部属性，修饰符可以限制外部直接访问class内部属性。

模块module（使用 export ）

泛型 generics（通过使用泛型，可以保持数组类型的一致性。）

1、声明：

let 声明变量，解决 var 中带来的作用域混论的问题

const 声明常量

2、类型：

数字number

布尔boolean

字符串string

数组array

元组tupple 是一个特殊的数组，是固定长度固定类型的数组（固定长度、固定类型的数组，声明元组的时候一定要指明类型，bug：使用 .push() 可以突破元组的界限，无限的给元组添加长度）

联合union 本质上就是数组，既没有固定长度也没有固定类型（一个变量可以同时支持两个或多个不同的类型）

字面量literal

枚举enum（在默认情况下，枚举类型的表现形式与c++类似，枚举类型真正的类型数据是数字，也是从0开始计算）

any （支持并且兼容所有类型）使用any适合代码的快速成型快速上线，但是会遗留一些明显的安全隐患。

unknow（不保证类型，但能保证类型安全）使用unkonwn比any保险一点，可以保证类型的安全。

viod（函数在没有任何返回的情况下，函数就是一个 void 类型）

undefined（是一个未经初始化的值）

never（一个函数永远执行不完，这就是 never 的本质。实际开发过程中，never是用来控制逻辑流程的，大部分是用来处理异常或者处理promise）

类型适配 Type Assertions（使用方法：<> 或者 as）在使用类型适配 Type Assertions 的时候，一定要非常非常了解当前变量的类型，必须对自己的代码有百分之百的信心！否则引发严重的错误！

3、函数类型

typescript中，调用函数与JavaScript有个显著的不同，就是typescript调用函数过程中，如果函数定义了两个参数，调用时必须填写两个参数，并且类型要一致。typescript可以使用 ? 来表示参数的可选性，被用 ? 来指定的参数可以不填写，函数里面的这个参数就被设定为undefined；也可以给参数设定默认值

4、面向对象

对象object（以 {} 包括起来，用键值对的形式显示）在对象初始化的时候，就已经定义好类型了。typescript对对象类型的定义不是 key to value（键值对），而是 key to type（键类型对）

对象包括：公有属性、私有属性、参数、公有成员方法、私有成员方法、封装、继承、多态。

接口interface （对象的聚合问题：高内聚，低耦合。简单来说就是，功能相关的事物放在同一个集合中形成一个模块，这就叫高内聚；而这些又是互相独立的，不同模块之间保持低耦合的状态。）

类class（官方定义：在JavaScript中，类是一个特殊的函数，在这个函数中不仅可以定义函数表达，也可以声明这个函数，在类的语法中包含两个部分，定义与声明。）

访问修饰符 Access Modifier（public、private、protected）通过使用访问修饰符，在声明构造函数的同时，顺便完成成员变量的声明以及初始化。

在对象外部直接访问内部成员变量，甚至重新赋值是非常危险的！一般要避免外部直接操作class内部属性，修饰符可以限制外部直接访问class内部属性。

模块module（使用 export ）

泛型 generics（通过使用泛型，可以保持数组类型的一致性。）

1、声明：

let 声明变量，解决 var 中带来的作用域混论的问题

const 声明常量

2、类型：

数字number

布尔boolean

字符串string

数组array

元组tupple 是一个特殊的数组，是固定长度固定类型的数组（固定长度、固定类型的数组，声明元组的时候一定要指明类型，bug：使用 .push() 可以突破元组的界限，无限的给元组添加长度）

联合union 本质上就是数组，既没有固定长度也没有固定类型（一个变量可以同时支持两个或多个不同的类型）

字面量literal

枚举enum（在默认情况下，枚举类型的表现形式与c++类似，枚举类型真正的类型数据是数字，也是从0开始计算）

any （支持并且兼容所有类型）使用any适合代码的快速成型快速上线，但是会遗留一些明显的安全隐患。

unknow（不保证类型，但能保证类型安全）使用unkonwn比any保险一点，可以保证类型的安全。

viod（函数在没有任何返回的情况下，函数就是一个 void 类型）

undefined（是一个未经初始化的值）

never（一个函数永远执行不完，这就是 never 的本质。实际开发过程中，never是用来控制逻辑流程的，大部分是用来处理异常或者处理promise）

类型适配 Type Assertions（使用方法：<> 或者 as）在使用类型适配 Type Assertions 的时候，一定要非常非常了解当前变量的类型，必须对自己的代码有百分之百的信心！否则引发严重的错误！

3、函数类型

typescript中，调用函数与JavaScript有个显著的不同，就是typescript调用函数过程中，如果函数定义了两个参数，调用时必须填写两个参数，并且类型要一致。typescript可以使用 ? 来表示参数的可选性，被用 ? 来指定的参数可以不填写，函数里面的这个参数就被设定为undefined；也可以给参数设定默认值

4、面向对象

对象object（以 {} 包括起来，用键值对的形式显示）在对象初始化的时候，就已经定义好类型了。typescript对对象类型的定义不是 key to value（键值对），而是 key to type（键类型对）

对象包括：公有属性、私有属性、参数、公有成员方法、私有成员方法、封装、继承、多态。

接口interface （对象的聚合问题：高内聚，低耦合。简单来说就是，功能相关的事物放在同一个集合中形成一个模块，这就叫高内聚；而这些又是互相独立的，不同模块之间保持低耦合的状态。）

类class（官方定义：在JavaScript中，类是一个特殊的函数，在这个函数中不仅可以定义函数表达，也可以声明这个函数，在类的语法中包含两个部分，定义与声明。）

访问修饰符 Access Modifier（public、private、protected）通过使用访问修饰符，在声明构造函数的同时，顺便完成成员变量的声明以及初始化。

在对象外部直接访问内部成员变量，甚至重新赋值是非常危险的！一般要避免外部直接操作class内部属性，修饰符可以限制外部直接访问class内部属性。

模块module（使用 export ）

泛型 generics（通过使用泛型，可以保持数组类型的一致性。）

1、声明：

let 声明变量，解决 var 中带来的作用域混论的问题

const 声明常量

2、类型：

数字number

布尔boolean

字符串string

数组array

元组tupple 是一个特殊的数组，是固定长度固定类型的数组（固定长度、固定类型的数组，声明元组的时候一定要指明类型，bug：使用 .push() 可以突破元组的界限，无限的给元组添加长度）

联合union 本质上就是数组，既没有固定长度也没有固定类型（一个变量可以同时支持两个或多个不同的类型）

字面量literal

枚举enum（在默认情况下，枚举类型的表现形式与c++类似，枚举类型真正的类型数据是数字，也是从0开始计算）

any （支持并且兼容所有类型）使用any适合代码的快速成型快速上线，但是会遗留一些明显的安全隐患。

unknow（不保证类型，但能保证类型安全）使用unkonwn比any保险一点，可以保证类型的安全。

viod（函数在没有任何返回的情况下，函数就是一个 void 类型）

undefined（是一个未经初始化的值）

never（一个函数永远执行不完，这就是 never 的本质。实际开发过程中，never是用来控制逻辑流程的，大部分是用来处理异常或者处理promise）

类型适配 Type Assertions（使用方法：<> 或者 as）在使用类型适配 Type Assertions 的时候，一定要非常非常了解当前变量的类型，必须对自己的代码有百分之百的信心！否则引发严重的错误！

3、函数类型

typescript中，调用函数与JavaScript有个显著的不同，就是typescript调用函数过程中，如果函数定义了两个参数，调用时必须填写两个参数，并且类型要一致。typescript可以使用 ? 来表示参数的可选性，被用 ? 来指定的参数可以不填写，函数里面的这个参数就被设定为undefined；也可以给参数设定默认值

4、面向对象

对象object（以 {} 包括起来，用键值对的形式显示）在对象初始化的时候，就已经定义好类型了。typescript对对象类型的定义不是 key to value（键值对），而是 key to type（键类型对）

对象包括：公有属性、私有属性、参数、公有成员方法、私有成员方法、封装、继承、多态。

接口interface （对象的聚合问题：高内聚，低耦合。简单来说就是，功能相关的事物放在同一个集合中形成一个模块，这就叫高内聚；而这些又是互相独立的，不同模块之间保持低耦合的状态。）

类class（官方定义：在JavaScript中，类是一个特殊的函数，在这个函数中不仅可以定义函数表达，也可以声明这个函数，在类的语法中包含两个部分，定义与声明。）

访问修饰符 Access Modifier（public、private、protected）通过使用访问修饰符，在声明构造函数的同时，顺便完成成员变量的声明以及初始化。

在对象外部直接访问内部成员变量，甚至重新赋值是非常危险的！一般要避免外部直接操作class内部属性，修饰符可以限制外部直接访问class内部属性。

模块module（使用 export ）

泛型 generics（通过使用泛型，可以保持数组类型的一致性。）

1、声明：

• let 声明变量，解决 var 中带来的作用域混论的问题

• const 声明常量

2、类型：

• 数字number

• 布尔boolean

• 字符串string

• 数组array

• 元组tupple 是一个特殊的数组，是固定长度固定类型的数组（固定长度、固定类型的数组，声明元组的时候一定要指明类型，bug：使用 .push() 可以突破元组的界限，无限的给元组添加长度）

• 联合union 本质上就是数组，既没有固定长度也没有固定类型（一个变量可以同时支持两个或多个不同的类型）

• 字面量literal

• 枚举enum（在默认情况下，枚举类型的表现形式与c++类似，枚举类型真正的类型数据是数字，也是从0开始计算）

any （支持并且兼容所有类型）使用any适合代码的快速成型快速上线，但是会遗留一些明显的安全隐患。

unknow（不保证类型，但能保证类型安全）使用unkonwn比any保险一点，可以保证类型的安全。

viod（函数在没有任何返回的情况下，函数就是一个 void 类型）

undefined（是一个未经初始化的值）

never（一个函数永远执行不完，这就是 never 的本质。实际开发过程中，never是用来控制逻辑流程的，大部分是用来处理异常或者处理promise）

类型适配 Type Assertions（使用方法：<> 或者 as）在使用类型适配 Type Assertions 的时候，一定要非常非常了解当前变量的类型，必须对自己的代码有百分之百的信心！否则引发严重的错误！

3、函数类型

typescript中，调用函数与JavaScript有个显著的不同，就是typescript调用函数过程中，如果函数定义了两个参数，调用时必须填写两个参数，并且类型要一致。typescript可以使用 ? 来表示参数的可选性，被用 ? 来指定的参数可以不填写，函数里面的这个参数就被设定为undefined；也可以给参数设定默认值

4、面向对象

• 对象object（以 {} 包括起来，用键值对的形式显示）在对象初始化的时候，就已经定义好类型了。typescript对对象类型的定义不是 key to value（键值对），而是 key to type（键类型对）

  对象包括：公有属性、私有属性、参数、公有成员方法、私有成员方法、封装、继承、多态。

• 接口interface （对象的聚合问题：高内聚，低耦合。简单来说就是，功能相关的事物放在同一个集合中形成一个模块，这就叫高内聚；而这些又是互相独立的，不同模块之间保持低耦合的状态。）

• 类class（官方定义：在JavaScript中，类是一个特殊的函数，在这个函数中不仅可以定义函数表达，也可以声明这个函数，在类的语法中包含两个部分，定义与声明。）

• 访问修饰符 Access Modifier（public、private、protected）通过使用访问修饰符，在声明构造函数的同时，顺便完成成员变量的声明以及初始化。

  在对象外部直接访问内部成员变量，甚至重新赋值是非常危险的！一般要避免外部直接操作class内部属性，修饰符可以限制外部直接访问class内部属性。
  

• 模块module（使用 export ）

• 泛型 generics（通过使用泛型，可以保持数组类型的一致性。）

1、声明：

• let 声明变量，解决 var 中带来的作用域混论的问题

• const 声明常量

2、类型：

• 数字number

• 布尔boolean

• 字符串string

• 数组array

• 元组tupple 是一个特殊的数组，是固定长度固定类型的数组（固定长度、固定类型的数组，声明元组的时候一定要指明类型，bug：使用 .push() 可以突破元组的界限，无限的给元组添加长度）

• 联合union 本质上就是数组，既没有固定长度也没有固定类型（一个变量可以同时支持两个或多个不同的类型）

• 字面量literal

• 枚举enum（在默认情况下，枚举类型的表现形式与c++类似，枚举类型真正的类型数据是数字，也是从0开始计算）

any （支持并且兼容所有类型）使用any适合代码的快速成型快速上线，但是会遗留一些明显的安全隐患。

unknow（不保证类型，但能保证类型安全）使用unkonwn比any保险一点，可以保证类型的安全。

viod（函数在没有任何返回的情况下，函数就是一个 void 类型）

undefined（是一个未经初始化的值）

never（一个函数永远执行不完，这就是 never 的本质。实际开发过程中，never是用来控制逻辑流程的，大部分是用来处理异常或者处理promise）

类型适配 Type Assertions（使用方法：<> 或者 as）在使用类型适配 Type Assertions 的时候，一定要非常非常了解当前变量的类型，必须对自己的代码有百分之百的信心！否则引发严重的错误！

3、函数类型

typescript中，调用函数与JavaScript有个显著的不同，就是typescript调用函数过程中，如果函数定义了两个参数，调用时必须填写两个参数，并且类型要一致。typescript可以使用 ? 来表示参数的可选性，被用 ? 来指定的参数可以不填写，函数里面的这个参数就被设定为undefined；也可以给参数设定默认值

4、面向对象

• 对象object（以 {} 包括起来，用键值对的形式显示）在对象初始化的时候，就已经定义好类型了。typescript对对象类型的定义不是 key to value（键值对），而是 key to type（键类型对）

  对象包括：公有属性、私有属性、参数、公有成员方法、私有成员方法、封装、继承、多态。

• 接口interface （对象的聚合问题：高内聚，低耦合。简单来说就是，功能相关的事物放在同一个集合中形成一个模块，这就叫高内聚；而这些又是互相独立的，不同模块之间保持低耦合的状态。）

• 类class（官方定义：在JavaScript中，类是一个特殊的函数，在这个函数中不仅可以定义函数表达，也可以声明这个函数，在类的语法中包含两个部分，定义与声明。）

• 访问修饰符 Access Modifier（public、private、protected）通过使用访问修饰符，在声明构造函数的同时，顺便完成成员变量的声明以及初始化。

  在对象外部直接访问内部成员变量，甚至重新赋值是非常危险的！一般要避免外部直接操作class内部属性，修饰符可以限制外部直接访问class内部属性。
  

• 模块module（使用 export ）

• 泛型 generics（通过使用泛型，可以保持数组类型的一致性。）