cocos creator TS 的使用详解一

Posted 2021-08-20 LANGZI7758521

var flag: boolean = true;
var num: number = 123;
var str: string = '123'

var arr: number[] = [11, 22, 33];
var arr2: Array<number> = [11, 22, 33];
var arr3: any[] = [11, 22, '33'];
var arr4: [number, string] = [123, '123'];

enum Flag {
    success = 1,
    error,
    'null'
}

let s: Flag = Flag.success;
let n: Flag = Flag.null;  // 默认加1

var any: any = 123;

var und: undefined;
var unde: number | undefined;

function run(): void {
    console.log('run');
}

run();

function run2(): number {
    return 123;
}

run2();

//never类型：是其他类型（包括null和undefind）的子类型，代表从不会出现的值
//这意味着声明never的变量只能被never类型所赋值
var a: undefined;
a = undefined;
var b: null;
b = null;
var c: never
//a = 123; // 错误
// c = (() => {
//     throw new Error('错误');
// })()

// ts中定义类
class person {
    public name: string;
    constructor(name: string) {
        this.name = name;
    }
    run(): void {
        alert(this.name);
    }
}

var p = new person('张三');
// p.run();

//2. ts中实现继承 extends super
class TsExtends {
    name: string;
    constructor(name: string) {
        this.name = name
    }
    run(): string {
        return `${this.name}在运动`;
    }
}

class Web extends TsExtends {
    constructor(name: string) {
        super(name); // 将this指向父亲
    }
    work(): string {
        return `${this.name}在工作`;
    }
}
var w = new Web('李四');
console.log(w.run()); // 李四在运动
var t = new TsExtends('张三')
console.log(t.name);//类外调用
console.log(w.work());//在子类调用
console.log(t.run());//在类中调用

//4. 静态属性，静态方法
class StaticPer {
    public name: string;//实例属性
    static sex: string = "男";//静态属性
    constructor(name: string) {
        this.name = name
    }
    run(): string { //实例方法
        return `${this.name}在运动`
    }

    static print() { //静态方法
        // console.log(this.name) //无法调用实例属性
        console.log('静态方法' + StaticPer.sex)
    }
}
//静态方法可以直接用类名调用
StaticPer.print()
//实例方法必须要实例化后才能调用
var S = new StaticPer('李四')
console.log(S.run())
console.log(StaticPer.sex) //外部调用静态属性

//5.多态：父类定义一个方法不去实现，让继承他的子类去实现 每一个子类有不同的表现
// 多态属于继承
//相当于将父类的方法重写，父类可以不定义
class Animal {
    name: string;
    constructor(name: string) {
        this.name = name
    }
    eat() {
        console.log('吃的方法')
    }
}
class Cat extends Animal {
    constructor(name: string) {
        super(name)
    }
    eat(): string { //具体实现方法
        return this.name + '吃鱼'
    }
}
var C = new Cat('小猫')
console.log(C.eat())

//5 抽象类
//typescript中的抽象类
// 他是提供其他类继承的基类，不能直接被实例化。
// 用abstract关键字定义抽象类和抽象方法，抽象类中的抽象方法不包含具体实现且必须在子类中实现
// abstract抽象方法只能放在抽象类中
// 抽象类和抽象方用来定义标准，标准的Animals这个类要求他的子类必须包含eat方法
abstract class Animals {
    name: string;
    constructor(name: any) {
        this.name = name
    }
    abstract eat(): any;//在子类必须实现，


}
// var a = new Animals()//错误写法，无法直接实例化
class Dog extends Animals {
    constructor(name: any) {
        super(name)
    }
    //抽象类的子类必须实现抽象类里面的抽象方法
    eat() {

    }
}

const { ccclass, property } = cc._decorator;

@ccclass
export default class NewClass extends cc.Component {

    onLoad() {

    }

}

参考：https://blog.csdn.net/marendu/article/details/102736517