安装 npm i typescript
tsc --help脚手架帮助命令
tsc --init初始化文件
tsc --watch自动检测
把ts文件编译成js文件:tsc ./src/app.ts --outFile ./dist/app.js
基础
//常量定义
let hd:string = 'hd'
let hd:number = 123
let hd:boolean = true
//数组定义
//定义一个数组的值，只能是nmber | string
const hd (nmber | string)[] = []
//范性
const hd :Array<string> = []//里面必须是字符串
//对象定义
let hd:object
//url后的问号表示这个参数是可选项
let hd:{ name:string , age:number , url?:string }
hd = { name:'string' , age:123 }
//组合定义 定义的变量可以是多种类型
let hd: string | number //定义字符串或者数字都行
let hd: (string | number)[]
let day: string | number | boolean
day = 'da'
day = 1
day = true
//范性
let hd :Array<string | number> = []
//any 任何类型都可 不会进行校验
let hd:any[] = []
//unknown
let hd:string = '99'
let a:number = hd as unkonwn as number
//void 函数返回结果为null或者undefeated
function hd():void{}
//never 什么都没有 就是不会执行到头 用于死循环 无返回值类型（不确定值类型）
function hd():never{
throw new Error('err')
}
//null undefeated
//Null Undefined是所有类型的子类型
let hd:null = null
let hd:undefeated = undefeated
//函数声明
let func:Function = (a:number,b:number,c?:number)=>{
//c是可选参数
return a + b + c
}
//设定返回值 void表示没有返回值
function msg():void {console.log(123)}
function sum(a:number,b:number):number {return a + b}
//使用type对函数进行声明
type userType = {name:string,age:number}
let addUser = (user:userType):void ={ console.log('添加用户')}
//函数的结构定义
type userType = {name:string,age:number}
type userAddFun = (user:userType) => boolean
let addUser:userAddFun = (user:userType):boolean =>{
console.log('add')
return true
}
addUser({name:'hd',age:123})
//函数剩余参数
function sum(...args:number[]):number {
return args.reduce((s,n)=>s+n,0)
}
sum(1,2,3)
枚举
enum Sextype {
BOY,
GIRL
}
console.log(Sextype.BOY)//0 打印出来的是默认下标 如果赋值则是值
//-——————————————————
enum Color {
Red=2, Green=5, Blue=9
}
let c: Color = Color.Green
console.log(c)//5
let Colorname: string = Color[5]
console.log(Colorname)//Green
断言
把结果输出为指定的值
function hd (arg:boolean):'指定的值'{
//return arg //报错
return '指定的值'
}
const res = hd(true)
//元组 Tuple
let a = 'string'
let b = 123
let hd = <const>[a,b]
let f = hd[1] //这时候的类型是数字 如果不加const就是数字或字符串
let x: [string,number]
//只能这个位置来加元素，而且只能加两个元素(数组有顺序)
x = ['hello',2]//不能越界访问，比如访问x的第四个元素
类
class User {
name:string
age:number
constructor(n:string,a:number){
this.name = n
this.age = a
}
info():string{
return this.name
}
}
const hd = new User('kk',1)
const hd2 = new User('cc',2)
const users:User[] = [] // 给数组定义元素为当前这个user类
users.push(hd,hd2)
泛形 generics
不确定类型
//T就表示泛形 string就是设置的类型
function dump<T>(arg:T):T {
return arg
}
let hd = dump<string>('hd') // string
//public 公开
class User {
//readonly只能取不能改
public readonly name:string // 都可以用
protected age:number //protected可以在子类中访问，不能在实现对象中访问 子类能覆盖但是权限不能大于父类 只能public
private gender:string //。在子类和类的实现的对象中都不能访问。在子类可以通过调用使用这个属性的方法来间接来使用这个属性。 子类不能覆盖
constructor(n:string,a:number){
this.name = n
this.age = a
}
info():string{
return this.name
}
}
//继承
function getLength<T extends any[] | string>(agr:T):T{
return arg.length
}
getLength('sadas')
getLength(['sadas'])
// 定义为有长度的值
type sType = { length:number }
let a:sType = '131'
let a:sType = 131 // 报错 因为数字没有长度
//类
class Collection<ZY> {
data:ZY[] = []
public push(...items:ZY[]){
this.data.push(...items)
}
public shift():ZY {
return this.data.shift()
}
}
type User = { name:string,age:number }
const user:User = { name:'kk',age:12 }
const collections = new Collection<User>
collections.push(user) // { name:'kk',age:12 }
//构造函数用泛形
class User<ZY> {
public constructor(private _user){
public get():ZY{
return _user
}
}
}
//interface跟type大致一样
//interface能够创建一个新的类型，type不能创建一个新的类型
interface UserInterface {
name:string,
age?:number,//加了？表示这个属性为可选
[propName: string]:any //索引签名，后面定义的属性的类型可以是任意 propName为随意定义的值
}
const obj = new User<UserInterface>( { name:'kk',age:123 } )
obj.get().age // 123
//定义接口
interface jiekou<B,C>{
title:B,
isLock:C,
comments:C[]
}
type CommentType = {
content:string,
author:string
}
const hd :jiekou<boolean,CommentType> = {
title:'kk',
isLock:true,
comments:[{content:'123',author:'234'}]
}
get set
class User {
private _name:string
constructor(name:string){
this._name = name
}
//get set 计算数据处理
public get name():string {
return this._name.substr(0,1)
}
public set name(name:string){
this._name = name
}
}
const hd = new User('kkk')
hd.name = 'air'
抽象abstract
abstract class Animation {
//abstract只能在abstract类里定义 就是定义个模糊的东西 不具体 可以继承 但是如果继承的子类不用回报错
abstract name:string
abstract move():void
protected getPods():number[]{
return [2,3]
}
}
let animal = new Animal()//报错，抽象类不能有实例化
class Tank extends Animation {
name:string = '坦克'
public move():void {
console.log(`${this.name}移动`)
}
}
let tank = new Tank()
tank.move()//坦克移动
