1.布尔类型
let bool:boolean = false;
2.数值类型
let num:number=123;
3.字符串类型
let str:string="Lison"
4.null和undefined (所有类型的子类型）
let u:undefined=undefined;
let n:null=null;
let num:number = undefined;
5.Any任意类型 (可以调用属性和方法--万金油） ----对比 unknown类型(相似） ----对比never(对立）
let notsure:any;
value=123;
value="string";
value=false;
let array:any[]=[1,"string",true]
6.never 永不存在的值得类型
7.数组类型
let list1:number[]=[1,2,3]
let liat2:Array=[4,5,6]
8.元祖类型(类型和个数一一对应）
let tuple:[string,number,boolean]=["asd",123,false];
9.枚举
enum Roles{
A=1,
B=2,
c=3
}
console.log(Roles.A) ---1
10.void 没有任意类型（函数没有返回值return的时候会用到）*
var consoleText =(text:string):void=>{
console.log(text);
};
//注意：(void 类型的变量只能赋值为 undefined 和 null，其他类型不能赋值给 void 类型的变量)
const errorFunc = (message: string): never => {
throw new Error(message);
};
11定义object类型 ---interface接口定义对象类型（鸭子类型）（不存在与js，ts中编译不会转换做js，只做类型静态检查）
interface Person{
//定义接口 声明接口interface
readonly id:number; // readonly定义只读属性，被创建时才可赋值
name:string;
age?:number; //?为可选属性，加了后，定义的变量中可以有age属性，也可以没有这个属性
}
let viking:Person ={
id：1，
name:'viking',
age:20
} //定义变量，并用PersonA约束这个变量
viking.id =9527 //出错，因为id之前被赋值，不可再次赋值
12.function函数
function add(x:number,y:number,z?:number):number{
//声明一个函数
if(typeof z === 'number'){
return x + y + z
}else{
return x + y
}
}
add(1,2);
const add=(x:number,y:number,z?:number):number=>{ //函数表达式（箭头函数）
if(typeof z === 'number'){
return x + y + z
}else{
return x + y
}
}
let add2:(x:number,y:number,z?:number)=>number =add
//第一个箭头是es6中箭头函数
//第二个就箭头是声明函数类型返回值的方法
interfince 描述函数类型
interface ISum {
(x:number,y:number,z?:number)；number
}
let add2: ISum = add
//类型推论
let str = 'str'
str =21 //错误，是string 类型
//联合类型 (要求只要符合联合类型中任意一种类型即可) union types 可以访问共有类型属性和方法
const getLenghe =(content:number|string)=>{
if(typeof content ==="string"){
return content.length;
}else{
return content.toString().length;
}
console.log(getlenghe("asd"); ---3
//类型断言 用as
function getLength(input:string|number):number{
const str =input as string
if(str.lenght){
return str.length
}else {
const number = input as number
return number.toString().length
}
}
//泛型----约束泛型 （extends继承）
interface ength {
length:number
}
function echo(arg :T):T{
console.log(arg.length)
return arg
}
使用泛型函数（T：类型变量）
function myfn(args: T): T { return args; let output = myfn("Hello"); //明确传入类型参数 let output2 = myfn("Hello") //不传入类型参数，TS根据上下文自动推断类型}
使用泛型变量（这可以让我们把泛型变量T当做类型的一部分使用，而不是整个类型）
function myfn(args: T[]): T[] { console.log(args.length) return args; } function myfn2(args: Array): Array { console.log(args.length); return args; }
interface Test { (args: T): T } function myfn(args: T): T { return args; } let myTest: Test = myfn;
泛型类（这里没有限定T的类型，可以传入任意类型）
class add{ value: T; add: (x: T, y: T) => T; } let myTest = new add(); myTest.value = 0; myTest.add = function (x, y) { return x + y }
泛型约束（类型变量继承接口）
interface Test{ length:number; } function myfn(args:T):T{ console.log(args.length) return args; } myfn(3); //error myfn("abc") //3
