类型断言,可以用来解析变量的实际的类型
语法 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 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"
}
已abstract开头的类是抽象类 用来给子继承的类
抽象类只是用来创建对象
抽象类是专门用来继承的类
abstract class Parent {
name: string;
constructor ( name: string ){
//传进来的参数是字符类型
this.name = name
}
}
(用来定义一个类的结构,对象的结构 对类的限制)
定义接口 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
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语法断言是被允许的。