ts高仿C#的List、Dictionary

/**
 * 高仿C#List
 */
export default class List<T> extends Array<T> {
    public constructor() {
        super();
    }

    add:Function = function(value:T):void{
        this.push(value);
    }

    insert:Function = function(index:number, value:T):void{
        this.splice(index, 0, value);
    }

    remove:Function = function(value:T):void{
        var index:number = this.indexOf(value);
        this.removeAt(index);
    }

    removeAt:Function = function(index:number):void{
        this.splice(index, 1);
    }

    contains:Function = function(value:T):boolean{
        return this.indexOf(value)>=0;
    }

    count:Function = function():number{
        return this.length;
    }

    clear:Function = function():void{
        this.splice(0);
    }

    foreach:Function = function(callback:Function):void {
        this._breaking = false;
        var sum = this.length;
        for(var i=0;i<sum;i++){
            if(this._breaking){
                break;
            }
            callback(this[i]);
        }
    }

    _breaking:boolean = false;
    break:Function = function():void {
        this._breaking = true;
    }

    toArray:Function = function():T[]{
        var array:T[] = [];
        this.forEach(element => {
            array.push(element);
        });
        return array;
    }

    append:Function = function(value:T[]):void{
        value.forEach(element => {
            this.push(element);
        });
    }
}

/**
 * 高仿C#Dictionary
 * 效率稍差
 */
export default class Dictionary<K,V> extends Object {

    _keys: K[] = [];
    _values: V[] = [];

    public constructor(){
        super();
    }

    add:Function = function(key: K, value: V):void {
        if(this.containsKey(key)){
            this._values[this._keys.indexOf(key)] = value;
        }else{
            this._keys.push(key);
            this._values.push(value);
        }
    }

    remove:Function = function(key: K):void {
        var index = this._keys.indexOf(key, 0);
        this._keys.splice(index, 1);
        this._values.splice(index, 1);
    }

    get:Function = function(key:K):V{
        if(this.containsKey(key)){
            return this._values[this._keys.indexOf(key)];
        }else{
            return null;
        }
    }

    set:Function = function(key: K, value: V):void {
        if(this.containsKey(key)){
            this._values[this._keys.indexOf(key)] = value;
        }else{
            this._keys.push(key);
            this._values.push(value);
        }
    }

    keys:Function = function(): K[] {
        return this._keys;
    }

    values:Function = function(): V[] {
        return this._values;
    }

    containsKey:Function = function(key:K):boolean {
        return this._keys.indexOf(key) != -1;
    }

    containsValue:Function = function(value:V):boolean{
        return this._values.indexOf(value) != -1;
    }

    count:Function = function():number{
        return this._keys.length;
    }

    clear:Function = function():void{
        this._keys.splice(0);
        this._values.splice(0);
    }

    forEach:Function = function(callback:Function):void {
        this.foreach(callback);
    }

    foreach:Function = function(callback:Function):void {
        this._breaking = false;
        var sum = this._keys.length;
        for(var i=0;i<sum;i++){
            if(this._breaking){
                break;
            }
            callback(this._keys[i], this._values[i]);
        }
    }

    _breaking:boolean = false;
    break:Function = function():void {
        this._breaking = true;
    }

    toObject:Function = function():Object{
        var obj:Object = new Object();
        this.forEach((k,v) => {
            obj[k] = v;
        });
        return obj;
    }
}

变相支持break方法，但要注意foreach是小写。

额外附送一个Map的封装，本质还是Object，方法字典化便于调用，效率比字典要好

export default class Map extends Object {

    public constructor(){
        super();
    }

    add:Function = function(key: string, value: Object):void {
        this[key] = value;
    }

    remove:Function = function(key: string):void {
        if(this.containsKey(key)){
            delete this[key];
        }
    }

    get:Function = function(key:string):Object{
        if(this.containsKey(key)){
            return this[key];
        }
        return null;
    }

    set:Function = function(key: string, value: Object):void {
        this[key] = value;
    }

    keys:Function = function(): string[] {
        var _keys:string[] = [];
        for (var key in this) {
            if (this.hasOwnProperty(key)) {
                _keys.push(key);
            }
        }
        return _keys;
    }

    values:Function = function(): Object[] {
        var _values:Object[] = [];
        for (var key in this) {
            if (this.hasOwnProperty(key)) {
                _values.push(this[key]);
            }
        }
        return _values;
    }

    containsKey:Function = function(key:string):boolean {
        return this.hasOwnProperty(key);
    }

    containsValue:Function = function(value:Object):boolean{
        for (var key in this) {
            if (this.hasOwnProperty(key)) {
                if (this[key] == value) {
                   return true;
                }
            }
        }
        return false;
    }

    count:Function = function():number{
        var num:number = 0;
        for (var key in this) {
            if (this.hasOwnProperty(key)) {
                num++;
            }
        }
        return num;
    }

    clear:Function = function():void{
        for (var key in this) {
            if (this.hasOwnProperty(key)) {
                delete this[key];
            }
        }
    }

    forEach:Function = function(callback:Function):void{
        this.foreach(callback);
    }

    foreach:Function = function(callback:Function):void{
        this._breaking = false;
        for (var key in this) {
            if(this._breaking){
                break;
            }
            if (this.hasOwnProperty(key)) {
                var type: string = typeof (this[key]);
                if(type != "function" && key != "_breaking"){
                    callback(key, this[key]);
                }
            }
        }
    }

    _breaking:boolean = false;
    break:Function = function():void {
        this._breaking = true;
    }
}

以上就是一些常用的简单封装，你也可以结合自身需要抽象类似IList、IDictionary的接口 ^ ^