把类作为参数  结合泛型类 来约束数据传入的类型

class User{
    name:string | undefined;
    token:string | undefined;
    userId:number | undefined;
}

class SqlDb{
    add(info:User):boolean{
        console.log(info);
        return false
    }
}

let u = new User();
u.name = '临枫';
u.token = 'LinF0120',
u.userId = 154;

let db = new SqlDb();
db.add(u);
// 打印: User {name: "临枫", token: "LinF0120", userId: 154}



class People25{
    name:string | undefined;
    sex:boolean | undefined;
    age:number | undefined;
}

class Sql02<T>{
    add(user:T):boolean{
        console.log(user)
        return true
    }
}

let lf25 = new People25();
lf25.name = '临枫';
lf25.sex = true;
lf25.age = 18;


// let sql = new Sql02();
// sql.add('56454');//传错误类型  但是不报错

let sql = new Sql02<People25>(); //这样就不报错了
sql.add(lf25);

模块  把一些公共的功能单独抽离成一个文件作为一个模块

// 模块导出
    export function lf001(){
        console.log('lf001')
    }
    // 或者
    function lf0002(){
        console.log('lf002')
    }
    export { lf0002 }

 模块引入

// 引入模块
import { lf001, lf0002 as lalala } from "模块文件路径";
lf001();
lalala();

namespace LF{
    interface User{
        name:string;
        age?:number;
        study():void;
    }
   export class People30 implements User{
        name:string;
        age:number;
        constructor(name:string,age:number){
            this.name = name;
            this.age = age;
        }
        study():void{
            console.log(this.name + '正在学习')
        }
    }
}

let lfy = new LF.People30("临枫",18);

lfy.study(); //临枫正在学习


namespace DY{
    interface User{
        name:string;
        age?:number;
        study():void;
    }
   export class People30 implements User{
        name:string;
        age:number;
        constructor(name:string,age:number){
            this.name = name;
            this.age = age;
        }
        study():void{
            console.log(this.name + '正在学习')
        }
    }
}

let Dy = new DY.People30("大眼",18);

Dy.study(); //大眼正在学习

// 装饰器是一种特殊类型的声明，他能够被附加到类声明，方法，属性或者参数上，可以修改类的行为。
// 通俗的将装饰器就是一个方法，可以注入到类、方法、属性参数上来扩展类、属性、方法、参数的功能。
// 常见的装饰器有：类装饰器、属性装饰器、方法装饰器、参数装饰器
// 装饰器的写法：普通装饰器（无法传参）、装饰器工厂（可传参）
// 装饰器是过去几年中js最大的成就之一，已经是ES7的标准特性之一


// 普通装饰器：
interface Folk {
    name: string;
    age?: number;
}
function APPConfig(params: any) {
    console.log(params);//params就是当前类
    params.prototype.motto = '今天学了习，明天更牛逼';
    params.prototype.say = function():void{
        console.log(this.name + this.motto)
    };
}
namespace LF {
    @APPConfig
    export class LinFengYa implements Folk {
        name: string;
        age?: number;
        constructor(name: string) {
            this.name = name
        }
        play():string{
            return this.name +"再也不打游戏了"
        }
    }
}
let xff:any = new LF.LinFengYa("小枫枫");
console.log(xff.play());  //输出 : 小枫枫再也不打游戏了
console.log(xff.motto);//这里会报错   指定xff为any类型就好了  输出：今天学了习，明天更牛逼
xff.say();//小枫枫今天学了习，明天更牛逼

// 装饰器工厂（可传参）

function LfConfig(params:any){
    return function(data:any){
        console.log(data);
        //打印 ƒ People31(name) {
        //     this.name = name;
        // }
        console.log(params);//打印www.linfengya.cn
        data.prototype.baseUrl = params;
    }
}

interface Folk0{
    name:string;
    age?:number;
}
@LfConfig("www.linfengya.cn")
class People31 implements Folk0{
    name:string;
    age?:number;
    constructor(name:string){
        this.name = name
    }
}

let xffy:any = new People31("临枫呀");

console.log(xffy.baseUrl);//输出 www.linfengya.cn

 使用类装饰器   重载构造函数  一个参数 即构造函数

function zsq(data: any) {
    console.log(data);
    return class extends data{
        apiUrl:any = '我被修改了额';
        getUrl(){
            return this.apiUrl;
        }
    }
}

@zsq
class HttpClient {
public apiUrl: string | undefined
    constructor() {
        this.apiUrl = 'www.linfengya.cn'
    }
    getUrl() {
        console.log(this.apiUrl)
    }
}

let linfeng:any = new HttpClient();
console.log(linfeng.getUrl()); //打印 我被修改了额

// 属性装饰器 表达式会在运势是当做函数被调用 传入一下两个参数:

//     1.对于静态成员来说是类的构造函数 对于实例的成员是类的原型对象
//     2.成员的名字

function lfProto(params:any) {
    return function(target:any,attr:any){
        console.log(target); //输出 ：{getUrl: ƒ, constructor: ƒ}
        console.log(attr); // 输出： url
        console.log(params);//输出：  www.linfengya.cn
        target[attr] = params
        
    }
}

class People32{
    @lfProto("www.linfengya.cn")
    static url:string = '嘟嘟嘟嘟'
    constructor(){

    }
    static getUrl(){
        console.log(this.url);
    }
}

People32.getUrl();//输出  www.linfengya.cn

function LfMethod(params:any){
    return function(target:any,methodName:any,desc:any){
        console.log(target);  //当前原型对象  {getUrl: ƒ, constructor: ƒ}
        console.log(methodName); //当前类中的方法
        console.log(desc);//描述{writable: true, enumerable: true, configurable: true, value: ƒ}
        target.testUrl = '滴滴滴滴滴';
        target.study = function(){
            console.log("学习");
        }


        console.log(desc.value);
        // 打印的是当前方法：
        // ƒ () {
        //     console.log(this.baseUrl);
        // }


        // 修改装饰器的方法  把装饰器方法传入参数改为string类型
        // 1.保存当前方法
        let oMethod = desc.value;
        desc.value = function(...args:any[]){
            args = args.map((v)=>{
                return v.toString();
            })
            console.log(args);//输出 (2) ["sds", "4444"]
            oMethod.apply(this,args)
        }

    }
}
class People33 {
    public baseUrl:string|undefined;
    constructor() {
        
    }
    @LfMethod('www.linfengya.cn')
    getUrl(...args:any[]){
        console.log('我是getUrl',args);
    }
}
let lf33:any = new People33();
lf33.getUrl('sds',4444); //打印    我是getUrl (2) ["sds", "4444"]

// 装饰器执行顺序
// 属性 > 方法 > 方法参数 > 类
function logClass1(params:any){
    return function(target:any){
        console.log("类装饰器1");
        
    }
}

function logClass2(params:any){
    return function(target:any){
        console.log("类装饰器2");
    }
}
function logAttr(params?:any){
    return function(target:any,attrName:any){
        console.log("属性装饰器");
    }
}
function logMeth(params?:any){
    return function(target:any,attrName:any,desc:any){
        console.log("属性装饰器");
    }
}
function logParams(params?:any){
    return function(target:any,attrName:any,desc:any){
        console.log("方法参数装饰器1");
    }
}
function logParams2(params?:any){
    return function(target:any,attrName:any,desc:any){
        console.log("方法参数装饰器2");
    }
}
@logClass1("/*****")
@logClass2("------")
class HttpClient01{
    @logAttr()
    public url:any | undefined;
    constructor(){    
    }
    @logMeth()
    getData(@logParams("xxxx") uuid:any,@logParams2("xxxx") dd:any){
    }
}

var llllffff = new HttpClient01();

// 先后输出：
//              属性装饰器
// index.js:981 方法参数装饰器2
// index.js:976 方法参数装饰器1
// index.js:971 属性装饰器
// index.js:961 类装饰器2
// index.js:956 类装饰器1