Typescript基础语法

枚举

• enum

enum State {
    idle,
    run,
    death,
    attack
}

• 表示idle=0，run=1，death=2，attack=3
• 类型验证：typeof x

运算符

• 算数运算符 + - * / %
• 自增 i++ 自剪i--
• i++ +“” 输出的值并没有+1 ，是先使用在自增自减
• ++i 是先自增再使用
• 比较运算符 >、<、>=、<=、！=、！==、==（一个等号是赋值。两个等号是比较，类型可以不同，只判断结果不判断类型。三个等号是比较，类型必须相同，既判断结果也判断类型）,返回值是布尔
• 逻辑运算符 &&逻辑与 并且、｜｜逻辑或 或者、！true、！false逻辑非 取反
• 赋值运算符 = 把右边的值赋值给左边、+=、-=、*=、/=、%=

选择结果语句

enum State{
    idle,
    run,
    attack,
    die
}
let state:State = State.idle;

switch(state){
    case State.idle:
        document.write("站立");
        break;//到此结束
    case State.run:
        document.write("跑步");
        break;
    case State.attack:
        document.write("攻击");
        break;
    default:
        document.write("其他状态")
}

循环控制语句

let names:string[] = ["a","b","c"];
for (let i = 0;j < 3; j++){
    document.write(names[j]);
}
或者
for(let tmpName of names){
    document.write(temName);
}
或者
for(let index in names){
    document.write(index)
}//in 是把索引赋值给index

继承

• extends
• 当附类的新方法与类的方法名称一样，附类的方法就会覆盖类的方法，可以super.附类方法名（）会先调用类的方法，再调用附类的方法

抽象类

• abstract
• 抽象类本身不能被实例化为对象，但是可以被继承，被继承时，必须调用实现抽象类里的方法

接口

• 多继承

class Person{
    name:string;
}

interface IWolf{//interface 变成一个接口
    attack();//不能写方法
}

class WolfMan extends Person implements IWolf{//同时有人和狼的特性
    attack(){

    }
}

属性

//属性寄存器
class Person{
    _hp:number = 100;//加_不希望用户直接调用_hp,作个区分

    //取值
    get hp(){//创建一个叫hp的属性
        return this._hp;
    }
    //赋值
    set hp(value){
        if (value < 0){
            this._ho = 0;
        }else {
            this._hp = value;
        }
    }
}

let a = new Person();
a.hp -= 180;
document.write(a.h + "")

• 因为生命值0-100，没有负值

名称空间

• namespace
• 名称空间就是解决命名重复问题··
• 如果希望名称空间在外部可以调用，必须加上export

namespace aa{
    export class Person{
        name:string;
    }
}

namespace bb {
    class Person{
        //...
    }
}

let person = new aa.Person();

泛型

• 泛型的意思就是我们类型定义为某类型，好比数学中定义x，我们不知道传递进来的是哪个类型
• 比如以下，可以传递进来任何类型的值，但是如果是数字，就自增，如果是其他类型的值，就原样返回

function add(num:any):any{
    if(typeof num == "number){
        num++;
        return num;
    }
    return num;
}
document.write(add(3) + "");

或者

function add<T>(num:T):T{//用尖括号表示我们的类型
     if(typeof num == "number){
        num++;
        return num;
    }
    return num;
}
document.write(add<number>(3) + "")

• 第一种方法any有可能导致我们传进来的类型是number但是传出去的类型是string，因为我们类型不限定
• 第二种方法在调用时需要用尖括号把类型说明一下
• 不推荐第一种方法

在数组后面追加元素

• array.push();

在数组前面追加元素

• array.unshift();

数组删除最后面的元素

• array.pop();

数组删除最前面的元素

• array.shift();

数组从第几位开始删

• array.splice();

合并两个数组

• array1 = array1.concat(array2);

数组查找元素位置

• let index = array.indexof(3)；

数组排序

• array.sort(); 正序
• array.reverse();逆序

字典

• 比如["a","b","c"] 对应的key value是 0:"a",1:"b",2:"c",我们希望索引0，1，2也由自己定义

let dic :{[key:string]:string} = {
    "name":"小明"
    "name2":"小红"
}
dic["name3"]="小兰"

正则表达式

• 正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串，在很多文本编辑器里，正则表达式通常用来检索、替换那些符合某个模式的文本
• 原义文本字符：正常的文本字符
• 元字符：具有特殊意义的专用字符，是代替正常文本字符的字符
• 限定符：限定匹配的数量或特殊条件

• 元字符
• .匹配除换行符以外的任意字符
• \w匹配字母或数组或下划线或汉字
• \s匹配任意的空白符
• \d匹配数字
• \b匹配单词的开始或结束
• ^匹配字符串的开始
• $匹配字符串的结束

• [a-z]匹配小写a-小写z
• [a-zA-Z]匹配小写a-小写z同时也匹配大写A-大写Z
• 想匹配什么范围自己往后添

• 常用限定符
• {n}重复n次
• {n,}重复大于等于n次
• {n,m}重复n次到m次
• *重复大于等于0次
• +重复大于等于1次
• ?重复0次或1次

怎样在代码里使用正则表达式

let reg = /\d{4}-\d{7}/g;//正则表达式就是双斜杠，在斜杠后面添加一个g
let str = "0345-1234567";//普通字符串检测正则表达式
let res = reg.exec(str);//开始匹配
document.writ(res.length + "");//检测是否匹配到
res.forEach(function(value,index){
    documen.write(value + "" +index);//匹配到的内容。value是匹配到的内容，index是从哪一位开始匹配到
})

访问修饰符

• 一个类class，不希望外界访问到内部的属性和方法，
• public 公开的，可以正常访问内部的属性和方法
• protected 子类可以调用属性和方法，外界调用不了
• private 完全私有 只有类内部可以访问，子类和外界都访问不了

单例模式

• 让一个类只产生一个对象

class SoundMAnager{
    static Instance = new SoundManager();
    private constructor(){};
}
SoundManager.Instance//这里的instance是属性，单例所对应的对象在一开始就产生了

或

class SoundMAnager{
    private static instance:SoundManager;
    private constructor(){};

    static Instance(){
        //当前单例是否产生
        //懒加载
        if(!SoundManager.instance){
                SoundManager.instance = new SoundManager;
        }
        return SoundManager.instance;
    }
}
SoundManager.Instance//这里的instance是方法，单例锁对应的对象什么时候用到什么时候产生对象,省内存

代理模式

• 自己不做让别人做就是代理

interface ICalc{
    calc(num1,num2):number;
}

class Npc1 implements ICalc{
    calc(num1,num2){
        return num1 + num2;
    }
}

class Npc2 implements ICalc{
    calc(num1,num2){
        return num1 + num2;
    }
}

class Person{
    //用哪个代理
    delegate:ICalc;//只要你遵循了我的协议，你就能做我的代理
    //让代理计算数字
    GetNum(num1,num2){
        //拿到num1和2计算后的结果
        let num = this.delegate.calc(num1,num2);
        document.write(num + "");
    }
}

let person = new Person();
//设定一个代理
person.delegate = new Npc1();
person.GetNum(3,4);

观察者模式

interface IObserver{
    nameChanged(newName);
}

class Person {
    private  _name:string;
    //所有的观察者
    observers:Array<IObserver> = new Array<IObserver>();

    set name(value){
        this._name = value;
        //发生变化
        //遍历观察者数组，给所有的观察者发消息
        for (let observer of this.observer){
            observer.nameChanged(this.name);
        }
    }

    get name(){
        return this._name;
    }
}

class Test implements IObserver{
    nameChanged(newName){
        document.write("监听到变化，名次变为' + newName);
    }
}

let person = new Person();
let test = new Test();

//设置为监听对象
person.observer.push(test);
person.name="哈哈哈"