TS-SGG-基本类型

// 声明一个变量 a,同时指定他的类型为 number
let a: number;

// --------------------------------------------------------------------------------------------------------------------

// a 是一个 number.在以后的使用当中 a 的值只能是 number;
a = 10;
a = 30;
// a = ""; // 此行代码会报错,因为变量 a 的类型是 number, 不能设置为字符串

// --------------------------------------------------------------------------------------------------------------------

let b: string;
b = "123";
// b = 1;  // 不能将类型"number"分配给类型"string"

// --------------------------------------------------------------------------------------------------------------------

// 声明变量的时候直接赋值
// let c: boolean= false

// 如果变量的声明和赋值是同时进行的, ts 可以自动对变量类型进行检测
let c = false;
// c = 12; // 不能将类型"number"分配给类型"boolean"

// --------------------------------------------------------------------------------------------------------------------

function sum(d: number, e: number): number {
  // return d + 'hello'; // 不能将类型"string"分配给类型"number", 因为返回值必须是 number
  return d + e;
}
// sum(1, "123");   // 类型"string"的参数不能赋给类型"number"的参数
// sum(1);          // 应有 2 个参数,但获得 1 个.
// sum(1,2,3)       // 应有 2 个参数,但获得 3 个
sum(1, 2);

// 也可以直接使用字面量进行类型声明
let a: 10;
a = 10;
// a = 11;    // 不能将类型"11"分配给类型"10"

// --------------------------------------------------------------------------------------------------------------------

// 可以使用 | 连接多个类型
let b: "hello" | "world";
b = "hello";
// b = "world1";  // 类型""world1""不可分配给类型""hello" | "world""

let c: boolean | string;
c = false;
c = "112";
// c = 12;   // 不能将类型"12"分配给类型"string | boolean"

// --------------------------------------------------------------------------------------------------------------------

// any 标识的是任意类型,一个变量设置了 any 后,相当于关闭了对这个变量的类型检测
let d: any;
d = 12;
d = "12";
d = false;
d = function () {};

// 这种就是隐式的 any
let f;
f = 12;
f = "12";
f = false;
f = function () {};

// --------------------------------------------------------------------------------------------------------------------

// unknown 表示未知类型, 实际上就是一个类型安全的 any, 他不能赋值给其他的变量
let e: unknown;
e = 12;
e = "12";
e = false;
e = function () {};

// d 的类型是 any,他可以赋值给任何变量
let s: string;
s = d;

// e 的类型是 unknown,他不可以赋值给 string
e = "123";
if (typeof e === "string") {
  // 加个判断就可以了
  s = e; // 不能将类型"unknown"分配给类型"string"
}

// --------------------------------------------------------------------------------------------------------------------

// 类型断言(可以用来告诉解析器变量的实际类型)
// 如下两种语法
s = e as string;
s = <string>e;

// --------------------------------------------------------------------------------------------------------------------

// void 用来表示空, 以函数为例, 就表示函数没有返回值
function fn(): void {
  // return true // 不能将类型"boolean"分配给类型"void"
  // return 123   //不能将类型"number"分配给类型"void"
  // return null // 不能将类型"null"分配给类型"void"
  return; // 不报错
  return undefined; // 不报错
}

// --------------------------------------------------------------------------------------------------------------------

// never 表示永远不会返回结果
function fn1(): never {
  // return  // 不能将类型"undefined"分配给类型"never"
  // return 12132  // 不能将类型"number"分配给类型"never"
  throw new Error("112");
}

// 也可以直接使用字面量进行类型声明
let a: 10;
a = 10;
// a = 11;    // 不能将类型"11"分配给类型"10"

// --------------------------------------------------------------------------------------------------------------------

// 可以使用 | 连接多个类型
let b: "hello" | "world";
b = "hello";
// b = "world1";  // 类型""world1""不可分配给类型""hello" | "world""

let c: boolean | string;
c = false;
c = "112";
// c = 12;   // 不能将类型"12"分配给类型"string | boolean"

// --------------------------------------------------------------------------------------------------------------------

// any 标识的是任意类型,一个变量设置了 any 后,相当于关闭了对这个变量的类型检测
let d: any;
d = 12;
d = "12";
d = false;
d = function () {};

// 这种就是隐式的 any
let f;
f = 12;
f = "12";
f = false;
f = function () {};

// --------------------------------------------------------------------------------------------------------------------

// unknown 表示未知类型, 实际上就是一个类型安全的 any, 他不能赋值给其他的变量
let e: unknown;
e = 12;
e = "12";
e = false;
e = function () {};

// d 的类型是 any,他可以赋值给任何变量
let s: string;
s = d;

// e 的类型是 unknown,他不可以赋值给 string
e = "123";
if (typeof e === "string") {
  // 加个判断就可以了
  s = e; // 不能将类型"unknown"分配给类型"string"
}

// --------------------------------------------------------------------------------------------------------------------

// 类型断言(可以用来告诉解析器变量的实际类型)
// 如下两种语法
s = e as string;
s = <string>e;

// --------------------------------------------------------------------------------------------------------------------

// void 用来表示空, 以函数为例, 就表示函数没有返回值
function fn(): void {
  // return true // 不能将类型"boolean"分配给类型"void"
  // return 123   //不能将类型"number"分配给类型"void"
  // return null // 不能将类型"null"分配给类型"void"
  return; // 不报错
  return undefined; // 不报错
}

// --------------------------------------------------------------------------------------------------------------------

// never 表示永远不会返回结果
function fn1(): never {
  // return  // 不能将类型"undefined"分配给类型"never"
  // return 12132  // 不能将类型"number"分配给类型"never"
  throw new Error("112");
}

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

// --------------------------------------------------------------------------------------------------------------------

// {} 用来指定对象中国可以包含哪些属性
// 语法: {属性名: 属性值, 属性名: 属性值, } { name: string; age: number };
// age?: number 在属性名后面加上一个?,表示这个属性是可选的.可有可无
let b: { name: string; age?: number };
// b = {}; // 类型 "{}" 中缺少属性 "name",但类型 "{ name: string; }" 中需要该属性.
b = { name: "aaa" };

// --------------------------------------------------------------------------------------------------------------------

// [propName: string]: any 表示任意类型的属性,这个表示name必须,其他非必须
let c: { name: string; [propName: string]: any };
c = { name: "TOM" };

// --------------------------------------------------------------------------------------------------------------------

// 函数结构的类型声明
// 语法: (形参:类型, 形参:类型, ....) => 返回值
let d: (a: number, b: number) => number;
// d = function () {}; // 不能将类型"void"分配给类型"number".
d = function (n1: number, n2: number): number {
  return n1 + n2;
};

// d = function (n1: number, n2: number, n3): number { // 参数不能超过 2
// return n1 + n2;
// };

// --------------------------------------------------------------------------------------------------------------------

/**
 * 数组的声明方法
 * 1. 类型[]
 * 2. Array[]
 */

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

// string[] 和 Array<number> 表示数值数组
let f: number[];
let g: Array<number>;
f = [1, 2, 3];
g = [1, 2, 3];

// --------------------------------------------------------------------------------------------------------------------

/**
 * 元祖: 就是长度固定的数组
 * 语法: [类型, 类型]
 */

let h: [string, string];
h = ["123", "456"];
// h = ["123", "456", "789"];  // 源具有 3 个元素,但目标仅允许 2 个.
// h = ["123123", 1223];   // 不能将类型"number"分配给类型"string"

// --------------------------------------------------------------------------------------------------------------------

/**
 * enum 枚举
 */
enum Sex {
  man = 0,
  woman = 1,
}
let i: { name: string; sex: Sex };
i = {
  name: "123",
  // sex: 2,   // 不能将类型"2"分配给类型"0 | 1"
  sex: Sex.man,
};
i.sex === Sex.man;
console.log(i.sex === Sex.man);

// --------------------------------------------------------------------------------------------------------------------

// | 表示或,满足一个即可
let j: string | number;

// & 表示同时 满足
let k: { name: string } & { age: number };
k = { name: "tom", age: 12 };

// --------------------------------------------------------------------------------------------------------------------

// 类型的别名
type myType = 1 | 2 | 3 | 4;
let l: myType;
let p: myType;
let m: myType;
l = 4;
// l = 6   // 不能将类型"6"分配给类型"myType"