// console.log('first hhhh')
let flag: boolean = true;
/**
 * boolead
 * number
 * string
 * number[]
 * let a:Array<number> = [1,2,3]
 * 元祖： let arr: [string, number,boolean] = ['ts', 3, true]
 * 
 */
/**
 * 枚举：
 */
enum Flag{
  success=1, error=-1
}
var f:Flag = Flag.success
// console.log(f)
/**
 * 任意类型
 * var nember:any = 2
 */
/**
 * null undefined (never 其他类型的子类型)
 * 
 * var num:number | undefined
 */
/**
 * void 类型
 */
// function run():void {
//   console.log('wu')
// }
// run()

/**
 * function run():number {
    return 123;
  }
  run()
 */

/**
 * 函数
 */

 /**
  * 类
  * abstract  多态
  * super  extends this   public protected private 写法类似 
  */

  /**
   * ts 接口：（类也可以作为约束）
   * 1、属性类接口 => 对json的约束
   * 2、函数类型接口=> 
   * interface encrypt{
   *    (key:string, value: string):string;
   * }
   * var md5:encrypt = function(key:stringk value:string):string{
   *  return 'duudfhudfhudhf
   * }
   * 3、可索引接口  数组、对象的约束（不常用）
   *      interface UserArr {
   *        [index:number]: string   // 索引值是number，值是string  
   *      }
   *      var arr:UserArr = ['aaa','bbb']
   *      console.log(arr[0])
   * 4、类类型接口
   *    interface Animal{
   *      name:string;
   *      eat(str:string):void;
   *    }
    *   class Dog implements Animal{
    *     name: string;
    *     constructor(name:string){
    *       this.name = name
    *      }
    *     eat(){
    *       console.log('rrrr')
    *     }
    *   }
   * 5、接口扩展 接口可以继承接口
   * interface Animal{
   *    eat():void;
   * }
   * interface Person extends Animal{
   *    work():void;
   * }
   * class Web implements Person{
   *    public name:string;
   *    constructor(name:string){
   *      this.name = name
   *    }
   *    eat(){
  *       console.log('eat')
  *     } 
  *     work(){
  *       console.log('work')
  *     }  
   * }
   */

   /**
    * 可扩展,泛型可以帮组我们避免重复的代码以及对不特定数据类型的支持
    * 大型系统十分灵活的功能
    * 创建可重用的组件
    * 泛型   解决类、接口、方法的复用性，以及对不特定数据类型的支持
    */
  //  function getData(value:any): any {
  //     return value
  //  }
  // 泛型方法:  eg.传入的参数和返回的参数一致 
  // function getData<T>(value:T): T {
  //   return value
  // }
  // getData<number>(123);
// 泛型类
/*class MinClass<T>{
  public list:T[] = [];
  add(value:T):void{
    this.list.push(value);
  }
  min():T{
    // dosomething
    let min = this.list[0];
    return min;
  }
}

let a = new MinClass<number>();
*/
// interface ConfigFn{
//   (value:string, value2:string):string;
// }
// var setData:ConfigFn = function(value:string, value2:string):string{
//   return value+value2;
// }
// setData('name', 'zs')
// 泛型接口 第一种
/*interface ConfigFn{
  <T>(value:T):T;
}
var setData:ConfigFn = function<T>(value:T):T{
  return value;
}
alert(setData<string>('444334'))
*/
//泛型接口 第二种
interface ConfigFn<T>{
  (value:T):T;
}
// function getData<T>(value:T):T{
//   return value
// }
// var setData:ConfigFn<string> = function(value:string):string{
//   return value;
// }
// alert(setData('4'))

// 把类作为参数来约束数据传入的类型
/*class User{
  username:string = '';
  password:string = '';
}
class MysqlDb{
  add(user:User):boolean{
    console.log(user);
    return true;
  }
}
var u = new User();
u.username = 'zs';
u.password = '123444';
var db = new MysqlDb();
db.add(u);
*/
// class MysqlDb<T>{
//   add(info:T):boolean{
//     console.log(info);
//     return true;
//   }
// }
/** 
 * 模块：export 同es6
 * export default
 */
/**
 * 命名空间
 * namespace XXX{
 *  export class B{
 *  
 *  }
 * }
 * //使用
 * var a = new XXX.B()
 * 
 */
/**
 * typescript 装饰器
 * 特殊类型的声明
 * 装饰器是一个方法，可以注入到类、方法、属性参数上来扩展类、属性、方法、参数的功能
 * 类装饰器、属性装饰器、方法装饰器、参数装饰器
 * 无参（普通方法）和有参（装饰器工厂）
 * 
 */
// 类装饰器
//装饰器工厂
function logClass(parames:any) {
  return function(target:any){
    console.log(target);
    target.prototype.apiUrl = 'ccccc';
  }
}

@logClass('http://eeeee')
class Test {
  constructor(){

  }
}
// 执行顺序 属性》方法》类