collections - biblioteca - chicago public library hours

¿Hay una clase/biblioteca de List<> y/o Map<>?

Question

¿Añadieron una clase de tipo List <> y / o Map <> de tiempo de ejecución a typepad 1.0? Y si no, ¿hay una biblioteca sólida por ahí que alguien escribió que proporciona esta funcionalidad?

Y en el caso de List <>, ¿hay una lista vinculada donde los elementos de la lista tienen la propiedad next / prev? Necesitamos una lista donde, desde un elemento objeto (es decir, no desde un iterador), podamos obtener los elementos siguientes y anteriores en la lista (o null si es el primero / el último).

Answer 1

¿Agregaron una lista de tipos de lista de ejecución <> y / o mapa <> a typepad 1.0?

No, proporcionar un tiempo de ejecución no es el objetivo del equipo de TypeScript.

¿Hay una biblioteca sólida por ahí alguien escribió que proporciona esta funcionalidad?

Escribí (en realidad, solo se transfirió a cubos a texto mecanografiado): https://github.com/basarat/typescript-collections

Answer 2

Es muy fácil escribirlo usted mismo, y de esa manera tiene más control sobre las cosas. Como dicen las otras respuestas, TypeScript no apunta a agregar tipos o funcionalidades de tiempo de ejecución.

Mapa:

class Map<T> {
    private items: { [key: string]: T };

    constructor() {
        this.items = {};
    }

    add(key: string, value: T): void {
        this.items[key] = value;
    }

    has(key: string): boolean {
        return key in this.items;
    }

    get(key: string): T {
        return this.items[key];
    }
}

Lista:

class List<T> {
    private items: Array<T>;

    constructor() {
        this.items = [];
    }

    size(): number {
        return this.items.length;
    }

    add(value: T): void {
        this.items.push(value);
    }

    get(index: number): T {
        return this.items[index];
    }
}

No he probado (ni intentado compilar) este código, pero debería darle un punto de partida. Por supuesto, puede cambiar lo que quiera y agregar la funcionalidad que USTED necesita ...

En cuanto a sus "necesidades especiales" de la Lista, no veo ninguna razón para implementar una lista vinculada, ya que la matriz de JavaScript le permite agregar y eliminar elementos.
Aquí hay una versión modificada de la lista para manejar el get prev / next del elemento en sí:

class ListItem<T> {
    private list: List<T>;
    private index: number;

    public value: T;

    constructor(list: List<T>, value: T, index: number) {
        this.list = list;
        this.index = index;
        this.value = value;
    }

    prev(): ListItem<T> {
        return this.list.get(this.index - 1);
    }

    next(): ListItem<T> {
        return this.list.get(this.index + 1);   
    }
}

class List<T> {
    private items: Array<ListItem<T>>;

    constructor() {
        this.items = [];
    }

    size(): number {
        return this.items.length;
    }

    add(value: T): void {
        this.items.push(new ListItem<T>(this, value, this.size()));
    }

    get(index: number): ListItem<T> {
        return this.items[index];
    }
}

Aquí también está buscando código no probado ...

Espero que esto ayude.

Editar - como esta respuesta todavía recibe algo de atención

Javascript tiene un objeto Map nativo, por lo que no es necesario crear uno propio:

let map = new Map();
map.set("key1", "value1");
console.log(map.get("key1")); // value1