安装 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()//坦克移动