typescript基础类型

类型 ：

1. 布尔
2. 数字
3. 字符串
4. 数组
5. 元组
6. 枚举
7. any
8. viod
9. never
   10.undefind
   11.null

布尔 boolean

这个就不用说了

数字 number

支持二进制和八进制字面量
let dexn：number = 6；

字符串 string

1. 可以使用模板字符串
2. 一般字符串 单引号双引号都行

let name: string = `Gene`;
let age: number = 37;
let sentence: string = `Hello, my name is ${ name }.

I'll be ${ age + 1 } years old next month.`;

数组

两种定义方式：
1.元素类型加[ ] ：

let list:number[]={1,2,3}

2.数组泛型: Array<元素类型> :

let list: Array<number> = [1, 2, 3];

如果是JS的话，这里会更加灵活。JS的数组元素之间类型可以完全不同，也当然也容易出意外。

元组 tuple

元组类型允许表示一个已知元素数量和类型的 数组
元组的元素类型可以不同！
但是也不像C#的object数组或者python中的元组那样完全自由，比如这里定义一个字符串和数字的元组：

// Declare a tuple type
let x: [string, number];
// Initialize it
x = ['hello', 10]; // OK
// Initialize it incorrectly
x = [10, 'hello']; // Error

当访问一个越界的元素，会使用联合类型替代：

x[3] = 'world'; // OK, 字符串可以赋值给(string | number)类型

console.log(x[5].toString()); // OK, 'string' 和 'number' 都有 toString

x[6] = true; // Error, 布尔不是(string | number)类型

这里我觉得是，元组变量默认只认其生命时候包括的类型，添加新元素的时候也会有限制。

枚举

enum类型 类似于C#中

//默认元素从0开始
enum Color1 {Red, Green, Blue}
let c: Color1 = Color1.Green;
//或者也可以为其手动赋值
enum Color2 {Red = 1, Green, Blue}
enum Color3 {Red = 1, Green=2, Blue=4}
let c: Color2 = Color2.Green;

//枚举类型提供的一个便利是你可以由枚举的值得到它的名字。
let colorName: string = Color2[2];
console.log(colorName);  // 显示'Green'因为上面代码里它的值是2

Any

就是程序到这，还不知道这个变量是什么类型的，而又不希望因为类型检查给扣下来，就用这个any告诉类型检查器通过编译吧。
相当于声明一个弱类型的变量了。

let notSure: any = 4;
//后面可以为他赋予不同类型的值，并且第一次赋值之后类型可以变，弱类型特点
notSure = "maybe a string instead";
notSure = false; // okay, definitely a boolean

它比万物之祖Object还更灵活，因为object还会检查里面是否真的有相应的函数方法或者属性，但any默认一切均有可能会存在。

let notSure: any = 4;
notSure.ifItExists(); // 假设它在运行时候会存在
notSure.toFixed(); // 实际存在，但它不会检查

let prettySure: Object = 4;
prettySure.toFixed(); 
// Error: Property 'toFixed' doesn't exist on type 'Object'.

而且使用any可以构建像JS那样数据类型可以不用相同的数组：

let list: any[] = [1, true, "free"];
list[1] = 100;

void

和一般语言一样，修饰函数的时候表示函数没有返回值；
但TS还可用void修饰变量，相当于这个变量没有任何类型，
后续只能为它赋值null和undefined

function warnUser(): void {
    console.log("This is my warning message");
}
let unusable: void = undefined;

默认情况下null和undefined是所有类型的子类型。 就是说你可以把 null和undefined赋值给number类型的变量。

never

这个更有意思，表示永不存在的类型：
1、那些总是会抛出异常或根本就不会有返回值的函数表达式
2、箭头函数表达式的返回值类型；
3、变量也可能是 never类型，当它们被永不为真的类型保护所约束时。

never类型是任何类型的子类型，也可以赋值给任何类型；然而，没有类型是never的子类型或可以赋值给never类型（除了never本身之外）。 即使 any也不可以赋值给never。

// 返回never的函数必须存在无法达到的终点
function error(message: string): never {
    throw new Error(message);
}
// 推断的返回值类型为never
function fail() {
    return error("Something failed");
}
// 返回never的函数必须存在无法达到的终点
function infiniteLoop(): never {
    while (true) {
    }
}

object

表示非原始类型，除number，string，boolean，symbol，null或undefined之外的类型。
使用object类型，就可以更好的表示像Object.create这样的API。例如：

declare function create(o: object | null): void;

create({ prop: 0 }); // OK
create(null); // OK

create(42); // Error
create("string"); // Error
create(false); // Error
create(undefined); // Error

类型断言：
通过类型断言这种方式可以告诉编译器，“相信我，我知道自己在干什么”。
类型断言好比其它语言里的类型转换，但是不进行特殊的数据检查和解构。
它没有运行时的影响，只是在编译阶段起作用。

//尖括号：
let someValue: any = "this is a string";
let strLength: number = (<string>someValue).length;
//as
let someValue: any = "this is a string";
let strLength: number = (someValue as string).length;

参考官网文档：