// void、undefined 与 never

function printResult () : void {

    console.log("lalala");

}

console.log(printResult()); // 报错

function printResult () : undefined  {

    console.log("lalala");

}

console.log(printResult()); 

function throwError(message: string, errorCode: number) ：never{

    throw {

        message,

        errorCode

    }

}

throwError("not found", 404);

function whileLoop(): never {

     while(true) {

        console.log("hahah")

    }

}

// any 和 unkonwn

let randomValue: any = 666;

randomValue = true;

randomValue = "asdga";

randomValue = {};

randomValue(); // 报错

randomValue.toUpperCase(); // 报错

let randomValue: unknown= 666;

randomValue = true;

randomValue = "asdga";

randomValue = {};

if(typeof randomValue === 'function') {

    randomValue(); 

}

if(typeof randomValue === 'string') {

    randomValue.toUpperCase(); // 报错

}

// 枚举类型 Enum

enum Color {

    red,

    green,

    blue

}

let color = Color.blue;

console.log(color);

enum Color2 {

    red = 2,

    green = 10,

    blue = 1

}

enum Color3 {

    red = "red",

    green = "green",

    blue = 1

}

// 联合(Union)与文献[Literal]类型

let union: string | number

union = 2;

union = "uuhkd";

union = true; // 报错

let union2: number | string | boolean | string[];

const merge = (n1:  number | string, n2: number | string, resultType: "as-number" | "as-string" ) => {

    if(resultType === "as-string" {

        return n1.toString() + n2.toString();

    }

    if(typeof n1 === "string" || typeof n2 === "string") 

        return n1.toString() + n2.toString();

    else 

        return n1 + n2

}

let mergeNumber = merge(2, 5, "as-number");

let mergeNumber = merge(2, 5, "as-string");

let mergeString = merge("hello", "world", "as-string");

// 字面量类型（literal）

let union3: 0 | 1 | 2

union3 = 1;

let list1: number[] = [1, 2, 3, 4, 5]; // number数组类型

let list2: Array<number> = [1, 2, 3, 4, 5]; // 泛型

let list3= [1, 2, 3, 4, 5];

let list4 = [1, "dd"];

let list5: any[] = [1, "dss", true];  // any数组类型

// tuple  固定长度、固定类型的array

let person1: [number, string] = [1, "hhh"]; // 元组(特殊数组，固定长度，固定类型)

lite-server快速搭建本地服务器

通过使用泛型，完美的保证代码中类型的一致性

let message = <T>(arr: T[]) => {

   return arr[arr.length -1]

}

const a1 = message([1,2,3,4])

const a2 = message(["1","2","3"])

const a3 = message<string | number>(["a","b","c",4])

let makeTuple = <T,Y>(x: T, y:Y) => [x, y]

const v1 = makeTuple(1, "one")

const v2 = makeTuple<number | string>(1, "one")

类型适配（类型断言）Type Assertions

let message : any;

message = 'abc';

message.endsWith('c'); // 此时不会生效，虽然上面已经指定了字段为字符串，但是字段默认初始类型为any.

let ddd = (<string>message).endsWith('c') // 类型断言为string，此时可以调用字符串的方法了

let ddd = (message as string).endsWith('c') // 类型断言为string，此时可以调用字符串的方法了

联合类型(union)

let union: string | number | boolean | string[] = 5

let union: 0 | 1 | 2 //不仅联合类型确定了，值也确定了

字面量类型（literal）

let literal : 1 || '2' || true || [1,2,3]

let array: Array<number> = [1,2,3] // 泛型

let array: any[] = [1,2,3,'ddd',true] // any数组类型

let array: number[] = [1,2,3] // number数组类型

let person1: [number, string] = [1,'ddd'] // 元组(特殊数组，固定长度，固定类型)

课程大纲

高级类型

类型记录

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
                }
            }
        }
    }