基础

1. 数据类型

//Boolean
let isDone: boolean = false;

//Number
let decimal: number = 6;
let hex: number = 0xf00d;
let binary: number = 0b1010;
let octal: number=0o744;//8进制
let big: bigint = 100n; //bigint类型

//String
//双引号，单引号都可以
//若要使用嵌入式表达，需使用`  数字1左边符号
let color: string = "blue";
color = "red";

let fullName: string = `Bob Bobbington`;
let age: number = 37;
let sentence: string = `Hello, my name is ${fullName}.
I'll be ${age + 1} years old next month.`;
//same as follow
let sentence: string =
  "Hello, my name is " +
  fullName +
  ".\n\n" +
  "I'll be " +
  (age + 1) +
  " years old next month.";

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

//Tuple 元组,可设置不止2个类型
let x: [string, number];
x = ["hello", 10]; //ok
y = [10, "hello"]; //error

//Enum
//默认从0开始排序，可以通过手动对第一个元素设置初始值来改变初始排序值，或者完全手动设置
enum Color {
    Red,
    Green,
    Blue,
}
let c: Color = Color.Green;

enum Color {
  Red = 1,
  Green,
  Blue,
}
let c: Color = Color.Green;

enum Color {
  Red = 1,
  Green = 2,
  Blue = 4,
}
let c: Color = Color.Green;
//可以在枚举中从数字值转到该值的名称。
enum Color {
  Red = 1,
  Green,
  Blue,
}
let colorName: string = Color[2];
// Displays 'Green'
console.log(colorName);

//Unknown
let notSure: unknown = 4;
notSure = "maybe a strign instead"
notSure = false;
//在类型不确定时，可以通过typeof来进行判断
declare const maybe: unknown;
const aNumber: number = maybe;
if(typeof maybe === true) {
    const aBoolean: boolean = maybe;
    const aString: string = maybe; //出错
}
if(typeof maybe === "string") {
    const aString: string = maybe;
    const aBoolean: boolean = maybe; //出错
}

//Any
/*
在某些情况，如三方库或者不是用TypeScript编写的代码的类型信心可能无效。在这些情况下，我们可能要选择退出类型检查。 为此，将这些值标记为any类型
*/
declare function getValue(key: string): any;
// OK, return value of 'getValue' is not checked
const str: string = getValue("myString");

let looselyTyped: any = 4;
looselyTyped.ifItExists();
looselyTyped.toFixed();

let strictlyTyped: unknown = 4;
strictlyTyped.toFixed();

//Void
//void表示：根本没有任何类型。 通常，您可能会将此视为不返回值的函数的返回类型：
function warnUser(): void {
    console.log("This is my warning message");
}

//Null and Undefined
let u: undefined = undefined;
let n : null = null;
//推荐使用严格检查null  --strictNullChecks
//null,undefined 只能被赋值给unknown，any类型以及其本身的类型
//undefined也可以赋值给void类型
//若要传递null或者undefined，可以使用联合类型 string|null|undefined

//never
//对于一个函数或者箭头，使用此类型表示永远不会返回或者总是抛出异常。
//never是每个类型的子类型，并且可以分配给每个类型。但是没有类型是never的子类型，没有类型可以复制给never,即便是any也不行
function error(message: string): never{
    throw new Error(message);
}
function fail(){
    return error("something failed");
}
function infiniteLoop():never{
    while(true){}
}

//object
//object是代表非原始类型的类型，即不是数字，字符串，布尔值，符号，null或undefined的任何类型。
//使用object类型可以更好的表示例如Object.create这样的接口
declare function create(o: object | null): void;
create({prop: 0});
create(null);
create(42);//error
create(false);//error
create(undefined);//error

//Type assertions 类型断言 as
//使用TypeScript以及JSX时仅允许使用as
let someValue:any = "this is a string";
let strLength: number = (someValue as string).length;
//另外一种表示，类型转换？
let someValue: any = "this is a string";
let strLength: number = (<string>somevalue).length

//let可以理解为TypeScript里面的一种比较新的构造器，可以缓解许多js中的问题，应尽量使用let 而不是var

参考：https://www.typescriptlang.org/docs/handbook/interfaces.html
To be finished...