typeScript的语法类型

类型断言，可以用来解析变量的实际的类型

语法 as 类型

tsc 文件名.ts            启动Ts转换JS

any 任意类型 可以是任意类型的数据

let aq = true
let ad: any;

ad = "12345"     可以将自己的类型赋值给其它变量的的类型

aq = ad
console.log(typeof aq)

unknown 表示未知类型的变量

unknown 类型的变量 不能直接辅助给其它变量

let as: unknown;
as = 10 ;
as = "hello"
as = true

e = as   × × × ×   不能直接赋值

void 表示空 再函数中 可以表示没有返回值的函数

never 表示永远不会返回结果

let ar: never;
console.log(typeof ar)

let ar: void ;
console.log(typeof ar)
				转为JS为 undefined

var ar;
console.log(typeof ar);

object 对它没有任何限制 Js中一切皆对象

let obj = {}
console.log(typeof obj)

指定对象的属性和类型

let b: {num: string}  b指向一个对象 且要有name属性 为字符

b = {num: "123"}

===============================================》》》》


let b: {num: string, age?: number}  

在属性名后面加一个问好 表示这个属性是可以选的 快写可不写

b = {num: "123"}

let b: {num: string, age?:18}  将age分配给18且只能是18

b = {num: "123", age: 18}
console.log(b)

[ propName: string ] : string 表示属性必须是字符串，值也是字符串

let c: {[sos: string]: any}

表示属性必须是字符串，值是任意类型

c = {num: "123", age: "18"}
console.log(c)

设置函数结构的类型声明

​ 语法： （ 形参：类型， 形参： 类型 ）=> { 返回值 }

let g: ( a: number, b: number ) => number
g = function fn(n1:number, n2: number) {
    return 10
}

console.log(g(11,23))

数组Array

let e: string[];  表示e 声明的数组里面只能存放字符
e = ['2131']

表示数值类型的数组			语法 w： 数组<存放的数据类型>
let w: Array
w = [1,2]

元组， 元组就是产固定长度的数组 转为js为object

let h: [*string*, *number*]  /* 定义了一个元组 */ 

h=["12",123]

console.log(h)

console.log(typeof h)

枚举 enum

enum Gendedr{
    Male = 0,
    Fmale = 1          /*枚举里面两个值 0 是男 1 是女*/
}

let i:{name: string, genet: Gendedr};

i = {
    name: "五条悟",
    genet: Gendedr.Male         返回一个 0
}

console.log(i.genet)			

| 或    &  且

JS中的&&且    JS中的或 ||

TS的编译

tsc 文件名.ts

tsc 文件名.ts -w   会监听文件变化


创建一个tsconfig.json 配置文件    ts会根据它来进行编译

tsc 将文件夹所有ts转为js

指执行tsc -w  监听文件夹所有的文件

在 JSON 文件中

”include“ 表示指定文件执行编译

{
    "include": [		指定你要tsc 编译的文件
        "./src/**		**任意任意目录 * 表示任意文件
    ]
}

excluded 表示不包含 指定不转换js的文件

compilerOptions 编译器的选项

strict 所有严格检查的开关

"  strict ": true    如果true 就表示开

​ target : 指定ES版本

compilerOptions : {

	"target": ES6   指定ES版本 ES3 ES6 ESNext
		
}

​ （ 如果不知道的版本 写错会有相关提示 ES2015也就是ES6 ）

moule: 指定要使用的模块化的规范

compilerOptions : {

	" moule": ES6   指定ES版本 ES3 ES6 ESNext
		
}

" lib " 指定使用什么库 类似 dom document.getElementById

" lib " :  [  "dom" ]  正常都不会修改 

outDir 用来指定编译后文件所在的目录

outDir : " ./地址 "

outFile 将代码合并为一个文件

全局作用域中的代码会合并

" outFile " :  "  ./ 合并成什么文件/app.js  "

allowJs 是否对JS文件进行编译 默认是false

' allowJs ' :  false

如果改成true 把JS也编译

checkJs 检查js 代码是否符合语法规范

' checkJs : false

改成true 会检测js代码

removeComments 是否移出注释

"removeComments" :  " true "   如果是true会将注释移出

noEmit 不生成编译后的文件

" noEmit "  不生成编译后的文件

noEmitOnError 当有错误的时候不生成编译后的文件

" noEmitOnError " : true

alwaysStrict 用来设置编译后的js文件是否使用严格模式

" use strict  "

" alwaysStrict " :  false

noImplicitAny 不允许隐式的any类型

" noImplicitAny " : true		出现直接报错

noImplicitThis 默认值false 如果为true 不允许不明确的this

" noImplicitThis " : true		出现直接报错

strictNullChecks 严格检查 空 值

" strictNullChecks " : true		出现直接报错

使用泛型可以创建泛型函数、泛型接口，泛型类

function fn (a: number): number {
限制传入参数 返回值类型
	return a;
}

//只有在函数执行的时候才会确定类型
//定义T  传参限制T 返还值类型T
function fn<T>(a: T): T{
	return a
}

fn（10）
//可以直接调用具有泛型的函数
//会自动判断出上面a的参数类型为Number 把Number赋值给了T
//TS的类型的自动判断

fn<string>( "hello" )
//指定泛型
//指定T传入的参数为string类型 同时把String赋值给T

//指定了T 和 K 的类型
function fn2<T, K>( a:T, b: T ): T{
	return a;
}

//手动指定泛型  类型为 number 和 string
fn2<number, string>(123, 'hello')

interface Inter{
	length: number;
}

function fn3< T extends Inter >（）{
	return a.length
//	给fn3传参的时候必需要有length的属性
}

fn3（123）
fn3（1）×
//必需要有length属性

类的泛型

class MyClass <T>{
	name: T,
	//属性类型为T
	//传入参数类型为T
	constructor(name: T){
	this.name = name 
}

//传入123 指定T的类型
new MyClass <number>（123）

类型的别名 type

type myType = string;

let m: myType   =   let m: string

//别名

type myType = {
	name: string,
	age: number,
	[propType: string]: any    //属性名为string类型 值为任意类型
}

//对obj的类型做一个限制
const obj: myType = {
	name:"sss",
	age:123,
	propType: "1231"
}

TS中的抽象类 abstract

已abstract开头的类是抽象类 用来给子继承的类

		抽象类只是用来创建对象
		抽象类是专门用来继承的类

abstract class Parent {
	name: string;
	constructor ( name: string ){
						//传进来的参数是字符类型
		this.name = name 
	}
}

接口 inteface

（用来定义一个类的结构,对象的结构 对类的限制）

定义接口 interface 接口只定义对象的结构

必传

interface myInteface{
	name:string
	age: number
}

**可选**

interface myInteface{
	name?:string
	age?: number
	say: () => void //定义一个无返回值的函数
}

//===============================》》》
class newTest implements test{

里面就必须要有 test 设定的参数和方法
}


//假如创建同名接口 接口对象会合并为一个规则

const my: myInteface = {
	name:"名字",
	aget: 123
}
//如果少或者多或者类型不对都会报错
//定义了一个接口
//规定了定义一个类,类里面有两个属性 一个市name 为string 一个age 为 number

类型断言 as

let aType = string;
aType 遍历的类型为string 

let e = "hello"
s = e as string        ==            s = <string>e
//as的作用就是告诉编译器 e 的类型就是string
<string>e  就是e的类型为string


//然而，当你在TypeScript里使用JSX时，只有 as语法断言是被允许的。