TypeScript——类型声明

类型声明

• typescript中所有的数据类型

/**
 * typescript中的数据类型
 * number：任意数字
 * string：任意字符串
 * boolean：布尔值，true或false
 * 字面量：限制变量的类型就是该字面量的类型
 * any：任意类型
 * unknow：类型安全的any
 * void：没有值或undefined
 * never：不能是任何值
 * object：任意的js对象
 * array：任意的js数组
 * tuple：元组；TS新增类型；固定长度的数组
 * enum：枚举；TS中新增类型
 */

// 声明变量a是一个number类型的值
let a: number;
a = 10;
a = 11;
a = 'hello';    // 那么在后面给其赋值为字符串时，会报错

// 声明变量b是一个string类型
let b: string;
b = "hello world";
b = 1; // 赋值为数字则会报错

// 不声明类型，直接赋值boolean
let c = false;
c = 1; // 当变量首次被赋值后，就确定其类型了，再赋值其他类型，则报错

// 原始的js定义方法，是不需要考虑参数类型，会导致计算结果不是预期的
function add(a, b) {
    return a + b;
}
add(1, "2");

// 而typescript可以对方法的参数进行类型定义，防止出现错误的结果
// 方法后面的:number表示返回值是一个number类型
function sum(a: number, b: number): number {
    return a + b;
}
sum(1, "2"); // 这里当参数传入的是String，但是定义的是number，所以会报错

let a: string = sum(1, 2) // 因为方法的返回值是一个number，所以不能用一个string去进行接收

• typescript中的基本数据类型
  

{
    // 使用字面量当作类型，那么变量相当于只能使用该值，不能赋值为其他的值
    let a: 10;
    a = 11; // 报错：不能将类型“11”分配给类型“10”

    // 使用 | 连接多个类型或多个值（联合类型）
    let b: "male" | "female";
    b = "male";
    b = "female";
    let c: number | string;
    c = 1;
    c = "hello"

    // any表示任意的类型，相当于对该变量关闭了ts对其的类型检查，不推荐使用
    // 这是显式的any
    let d: any;
    d = 1;
    d = "string"

    // 声明一个变量，这个是隐式的any
    let e;
    e = 1;
    e = "string";

    // unknown表示未知的类型；和any类似，也可以赋值为任意类型
    let f: unknown;
    f = 1;
    f = "string";

    // 但是any类型的变量可以赋值给任意变量，unknown则不行
    let s: string;
    s = d;
    s = e; 
    s = f; // 将string赋值为unknown时，报错：不能将类型“unknown”分配给类型“string”
    // 可以如下操作，不会报错
    if (typeof f === 'string') {
        s = f;
    }
    // 或者使用类型断言，告诉解析器f是什么类型
    s = f as string;
    s = <string>f; // 同上

    // void：表示空，以函数为例子
    function fn(): void {
        return 123; // 报错：不能将类型“number”分配给类型“void”。
    }
}

• typescript中的对象，数组，元组，枚举等类型

{
    // object表示一个对象
    let a: object;
    a = {};
    a = function() {};

    // {}用来指定对象中可以包含哪些属性
    let b: {name: string, age: number};
    b = {}; // 报错：类型“{}”缺少类型“{ name: string; age: number; }”中的以下属性: name, age
    b = {name: "贵永康", age: 27};
    // 属性多了也报错
    b = {name: "贵永康", age: 27, class: "6年级1班"} // 对象文字可以只指定已知属性，并且“class”不在类型“{ name: string; age: number; }”中。

    // 现在有一个需求，我们要定义个必须有name属性，也可以有其他属性的对象，怎么办？
    // 其中（propName）：表示变量名，（: string）：表示任意字符串的变量名，（: any）表示任意类型的值
    let c: {name: string, [propName: string]: any};
    c = {name: "贵永康", age: 10, class: "6年级1班"}

    // 设置函数结构的类型声明
    /**
     * 语法如下：
     *  (形参: 类型, 形参: 类型, ...)=>类型
     */
    let d: (a: number, b: number)=>number;
    d = function (n1, n2) {
        return n1 + n2;
    }

    // string[]:表示字符串数组
    let e: string[];
    e = ["a", "b", "c"];

    // Array<number>：表示数字数组
    let f: Array<number>;
    f = [1, 2, 3];

    /**
     * tupple：元组，长度固定的数组
     */
    let h: [string, string]; // 表示定义一个存储两个字符串的数组
    h = ["123", "456", "566"]; // 不能将类型“[string, string, string]”分配给类型“[string, string]”。源具有 3 个元素，但目标仅允许 2 个。

    /**
     * enum：枚举，
     */
    enum Gender {
        male,
        female
    }
    let j: {name: string, sex: Gender};
    j = {name: "贵永康", sex: Gender.male};

    // 类型别名，给一个类型起别名，如下，就是给右边连接的三个类型起了别名
    type myType = string | number | boolean;
    let k: myType;
    k = "1";
    k = 1;
    k = true;
    k = {}; // 不能将类型“{}”分配给类型“myType”。
}