变量的值应该与声名类型一致，如果不一致，TypeSctip就会报错
TypeScrip规定，变量只有复制后才能使用，否则会报错
布尔值
let isDone:boolean = false
数字
let hex:number = 2023
字符串
let name:string = 'xiaolibao'
数组
两种方式
// 可以在元素类型后面接上[]
let list: number[] = [1,2,3]
// 使用数组泛型，Array<元素类型>
let list :Arrar<number>=[1,2,3]
元组
已知元素数量和类型的数组，
let x:[string,number];
x = ['hello',10]
x = [10, 'hello']
枚举
enum Color {Red, Green}
let c: Color = Color.Green
Unkown ----表示类型不确定
let notSure: unknown = 4;
notSure = 'maybe a string instead';
notSure = false;
any类型标识没有任何限制，该类型的变量可以赋予任意类型的值。
缺点：
会“污染”其他变量
let x:any = 'hello';
let y:number;
y = x; // 不报错
y * 123 // 不报错
y.toFixed() // 不报错
上面示例中，变量x的类型是any，实际的值是一个字符串。变量y的类型是number，表示这是一个数值变量，但是它被赋值为x，这时并不会报错。然后，变量y继续进行各种数值运算，TypeScript 也检查不出错误，问题就这样留到运行时才会暴露。
污染其他具有正确类型的变量，把错误留到运行时，这就是不宜使用any类型的另一个主要原因。
unknown类型的变量，不能直接赋值给其他类型的变量
let v:unknown = 123;
let v1:boolean = v; // 报错
let v2:number = v; // 报错
never是一个表示永远不会发生的值的类型。
通常表示函数的返回值，这个函数永远不会正常返回。
void表示函数的返回值为空，或者变量的值可以是undefined或null。never表示函数永远不会正常返回，或者值是不可达的。
Void
当一个函数没有返回值时
function test(): void {
console.log('This is function is void');
}
Null Undefined
let u: undefined = undefined;
let n: null = null;
联合类型
联合类型（union types）指的是多个类型组成的一个新类型，使用符号|表示。
let myFavoriteNumber: string | number;
myFavoriteNumber = 'seven';
myFavoriteNumber = 7;
交叉类型
交叉类型（intersection types）指的多个类型组成的一个新类型，使用符号&表示。
交叉类型A&B表示，任何一个类型必须同时属于A和B，才属于交叉类型A&B，即交叉类型同时满足A和B的特征。
let x:number&string;
type命令
用来定义一个类型的别名
type Age = number;
let age:Age = 55;
条件语句
if…else if…else 语句
var num:number = 2
if(num > 0) {
console.log(num+' 是正数')
} else if(num < 0) {
console.log(num+' 是负数')
} else {
console.log(num+' 为0')
}
switch…case 语句
var grade:string = 'A';
switch(grade) {
case 'A': {
console.log('优');
break;
}
case 'B': {
console.log('良');
break;
}
case 'C': {
console.log('及格');
break;
}
case 'D': {
console.log('不及格');
break;
}
default: {
console.log('非法输入');
break;
}
}
函数
function getEmployeeName(firstName: string, ...restOfName: string[]) {
return firstName + ' ' + restOfName.join(' ');
}
let employeeName = getEmployeeName('Joseph', 'Samuel', 'Lucas', 'MacKinzie');
类
定义类的关键字是classs
class Person {
private name: string
private age: number
constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
public getPersonInfo(): string {
return `My name is ${this.name} and age is ${this.age}`;
}
}
let person1 = new Person('Jacky', 18);
person1.getPersonInfo();
继承
class Employee extends Person {
private department: string
constructor(name: string, age: number, department: string) {
super(name, age);
this.department = department;
}
public getEmployeeInfo(): string {
return this.getPersonInfo() + ` and work in ${this.department}`;
}
}
let person2 = new Employee('Tom', 28, 'HuaWei');
person2.getPersonInfo();
person2.getEmployeeInfo();
模块
随着应用越来越大，通常要将代码拆分成多个文件，即所谓的模块（module）。模块可以相互加载，并可以使用特殊的指令 export 和 import 来交换功能，从另一个模块调用一个模块的函数。
两个模块之间的关系是通过在文件级别上使用 import 和 export 建立的。模块里面的变量、函数和类等在模块外部是不可见的，除非明确地使用 export 导出它们。类似地，我们必须通过 import 导入其他模块导出的变量、函数、类等。
export class NewsData {
title: string;
content: string;
imagesUrl: Array<NewsFile>;
source: string;
constructor(title: string, content: string, imagesUrl: Array<NewsFile>, source: string) {
this.title = title;
this.content = content;
this.imagesUrl = imagesUrl;
this.source = source;
}
}
import { NewsData } from '../common/bean/NewsData';
迭代器
当一个对象实现了Symbol.iterator属性时，我们认为它是可迭代的。一些内置的类型如Array，Map，Set，String，Int32Array，Uint32Array等都具有可迭代性。
