ts之函数

// function hellow(){}

// 1: 设置没有返回值
function hellow():void{
    // return 1  // bug 
}

// 1.1: 设置有返回值，并指定静态类型
//  设置返回值的类型为number类型
function hellow1():number{ 
    return 1
}

// 1.2.1 返回值为数组 数组中元素为【任意类型】???
// 1.2.2 返回值为对象 函数
function hellow2():any{
    // return {}
    return []
}

// 1.3 :never 函数永远都不能执行到最后
function hellow3():never{
//    throw new Error(); // 场景1 有错误了；所以不可能执行完毕
    while(true){}        //  场景2 一直为true 所以下面一直不可能执行完毕

    if(true){
        console.log('123');
        
    }
}

// 2 参数的类型注解
function foo(params:number,a:string) {
    
}
// 2.1参数为对象
function ajax(options:{url:string,method:string,data:{},success:Function}) {
    
}
// 2.2 参数结构赋值
function foo1({a,b}:{a:number,b:number}) {
    
}
// foo2 参数为对象 对象中属性 a numebr  b string  返回值 number
function foo2({a,b}:{a:number,b:string}):number {
    return 1
}

// 2.3 类型别名
type ajax =  {url:string,method:string,data:{},success:Function}
// 使用类型别名 指定形参的类型
function ajax1(options:ajax) {
    
}
// 类型别名 的赋值可以为任意静态类型
type zy = number;
let zy:zy = 123;

// 2.4 interface 接口
//  interface 定义一个interface接口 名字叫做 blc
interface blc {
    a:number,
    b:string
}

function foo3({a,b}:blc):number {
    return 1
}

// 1:变量wwl 类型函数 
// 1.1:函数形参1个类型string 
// 1.2:函数没有返回值
let wwl:(name:string)=>void = (name)=>{
}

// zyfoo 赋值类型是什么
let zyfoo:(option:blc)=>blc=()=>{
    return {
        a:1,
        b:'123+'
    }
}
// zyfoo 相当于 下面的写法
// let zyfoo1:(options:{a:number,b:string})=>{a:number,b:string} =()=> {
//     return {
//         a:1,
//         b:'ss'
//     }
// }

// 类名别名 与 interface 接口区别
// 都是为了制定静态类型
// type 可以定义任意类型 比如 number 对象类型
// interface 只能定义 对象或者函数
// 在ts开发规范中；能用 interface 绝不用type

class类

// 定义一个 Student类
class Student {
    // 类中静态属性
    // 将来实例化的对象都具备 name  getName属性 
    a = 'name';
    getName() {
        return this.a
    }

    // 注意：指定构造器中 this.xx 类型 (key的类性)
    eye:string;
    bizi:string;
    zuiba:string;
    // constructor  Student 构造器
    // 1:形参赋值在Student类执行时，传入的实参
    // 2 每个class类都有构造器
    constructor(eye:string,bizi:string,zuiba:string){
        // this 是 Student 实例的对象 blc/wwl
        this.eye = eye;
        this.bizi = bizi;
        this.zuiba = zuiba
    }
  
}

let blc = new Student('大眼睛','高鼻梁','小嘴');
console.log(blc);
console.log(blc.getName());
console.log(blc.eye);


let wwl = new Student('小眼睛','大鼻子','大嘴巴');
console.log(wwl);
console.log(wwl.getName());
console.log(wwl.eye);


// 类的继承
//  extentds 继承
// 1 zy 类中将具有  Student 中的所有 属性
// 2 zy 创建的对象  中具有  Sudent和zy 中的属性
class zy extends Student {
    age = 12;
    getName() {
        // super 相当于父类；super 一搬用来干什么呢？ 一般用来调用父类的方法
        return super.getName() + 'yan'
    };
    // 继承， 注意 子类中的constuctor 必须执行super 
    constructor(){
        // super 触发父类中的构造器
        super()
    }
}
let wlj = new zy('aa','cc','cc')
console.log(wlj);
console.log(wlj.getName());

// 限制 class类中属性的访问权限: 
// private   私有属性，允许在【自己类内】被调用
// protected 私有属性 允许在【自己类预计子类内部】调用
// public    公共属性，哪里都可以调用
// 以上 为  ts 中语法 
class a {
    private name = '123';
    protected age(){
        console.log('age');
    }
    public c = 45;
    getName(){
        // 类的内部 获取 类的属性  
        console.log(this.name);
        console.log(this.age());
        console.log(this.c);
        
        
        return this.name
    }
}

let zy = new a();
// console.log(zy.name);  // bug 
// console.log(zy.age());   // bug
console.log(zy.getName());
console.log(zy.c);

class b extends a{
    num = 1;
    getAage(){
        // console.log(this.name); // roperty 'name' is private and only accessible within class 'a'
        console.log(super.age());
        console.log(this.c,'===================');
    
    }    
}
let blc = new b()
console.log(blc);
console.log(blc.getName());
// a 类的外币获取 name
// console.log(blc.name);  // bug 
// console.log(blc.age);   // bug
console.log(blc.getAage());

console.log(blc.c);