typescript

let a : number = 10
let b : boolean = false
let c : string = 'zzh'
let d : number[] = [1,2,3]
let e : Array<string> = ['zz','aa']
let f : [number, string, boolean] = [1,'zz',false]

function add (a:number,b:number) { 
      return a + b
}
var result = add(10,20)

function add1 (a : any):number { //可以传入任意类型的值， 返回的结果必须是number类型
      return a + b
}
var result1 = add1(10)

// 枚举
enum Gender { man , women}
let gender:Gender = Gender.man

let g : string | number
g = 10
g = 'zz'


function get(url:string, data:object, success:Function) :boolean {
      return false
}



interface AjaxConfig {
      readonly url: string, //readonly 相当于 const
      type: string,
      async?:boolean  // ?可以写boolean值 或者 不写
      [propName: string] :any  //字符串索引签名（可以多写不报错）
}

function ajax(options:AjaxConfig) {           
}

ajax({
      url:'a',
      type:'zz',
      success(){},
      abc(){}
} as AjaxConfig) // 忽略不检查



let h : ReadonlyArray<number> = [1,2,3]  //只读数组



function zz():void { //void 代表没有返回值

}
var res = zz()




function aa():number { 
      return 11
}
var res1 = aa()


function bb(name:string):string {  //传入参数要string类型，返回值也要string类型
      return 'aa'
}
var res2 = bb('1')


let say = function (a:number, b?:number) {//b可传可不传
      if(b){
            return a + b
      }else{
            return a 
      }
}
say(1,2)


let say1 = function (a:number, b :number = 0 ) {//b可传可不传
            return a + b
}
say1(1,2)



let say2 = function (...arys:number[]) {
      return arys.reduce((a,b) => {
            return a +b
      })
}
var res3 = say2(1,2,3,4,5,6)
console.log(res3)




// 类

// function Person(){
//       this.sayHi =function (){

//       }
// }

// let p1 = new Person()
class Person {
      static img : string = 'zzz' //直接把属性挂在了类上面，new 出来的对象获取不到  ， 静态属性static
      readonly name : string  //只读      
      constructor(name : string){
            this.name = name
      }  
      sayHi(){
            console.log('my name is wang duo yu')
      }   
}
let p1 = new Person('wang duo yu')
console.log(p1)
console.log(p1.sayHi())
console.log(Person.img)


// 类继承
class Dog {
      wang(){
            console.log('wang wang wang   ')
      }
}

class Jinmao  extends Dog { //从 Dog中继承 
      hh (){
            console.log('jmjmjm')
      }
}

let J1 = new Jinmao()
J1.hh()
J1.wang()

class Bog {
      private name : string = 'wangduoyu' //私有的private    public公有的
      setName( val:string ){
             this.name = val
      }
      say1(){
            console.table(this.name + '-----wdy') 
      }
}
let B1 = new Bog()
B1.setName('WANGDUOYUDE BABA')
B1.say1()


class Mao {
      name : string = 'xiaomao'
      private _age  : number = 9

      get Age () :number {    // get  存取器
            return this._age
      }

      set Age ( val : number ) { // 存取器
            if( val < 1 ) return
            if( val > 30 ) return
            this._age = val
            
      }

}
let M1 = new Mao()
console.log(M1.Age)



abstract class Dog1 { //abstract抽象类   若要继承这个类，必须实现里面的方法
      abstract jiao() : void  //void 无返回
      
}

class jingmao extends Dog1 {
      jiao(){

      }
}

class zangao extends Dog1 {
      jiao(){

      }
}



// 接口与类的组合
interface ifly {
      fly() : void
}
interface ieac{
      fly() : void
}

interface izzz extends ifly, ieac{
      
}

class Bird implements ifly, ieac {
      eat()  : void {

      }
      fly () : void {

      }
}