La classe Map

    (PECL ds >= 1.0.0)

    Introduction

    Une Map est une collection séquentielle de paires clé-valeur, presque identique à un tableau utilisé dans un contexte similaire. Les clés peuvent être de n'importe quel type, mais doivent être uniques. Les valeurs sont remplacées si elles sont ajoutées à la map en utilisant la même clé.

    Force

    • Les clés et les valeurs peuvent être de n'importe quel type, y compris des objets.
    • Support de la syntaxe de tableau (crochets).
    • L'ordre d'insertion est préservé.
    • La performance et l'efficacité mémoire sont très similaires à un tableau.
    • Libère automatiquement la mémoire allouée lorsque sa taille devient suffisamment faible.

    Weaknesses

    • Ne peut pas être converti en un tableau lorsque des objets sont utilisés comme clés.

    Synopsis de la classe

    class Ds\Map implements Ds\Collection, ArrayAccess {
    /* Constantes */
    const int MIN_CAPACITY = 16;
    /* Méthodes */
    public allocate(int $capacity): void
    public apply(callable $callback): void
    public capacity(): int
    public clear(): void
    public copy(): Ds\Map
    public diff(Ds\Map $map): Ds\Map
    public filter(callable $callback = ?): Ds\Map
    public first(): Ds\Pair
    public get(mixed $key, mixed $default = ?): mixed
    public hasKey(mixed $key): bool
    public hasValue(mixed $value): bool
    public intersect(Ds\Map $map): Ds\Map
    public isEmpty(): bool
    public keys(): Ds\Set
    public ksort(callable $comparator = ?): void
    public ksorted(callable $comparator = ?): Ds\Map
    public last(): Ds\Pair
    public map(callable $callback): Ds\Map
    public merge(mixed $values): Ds\Map
    public pairs(): Ds\Sequence
    public put(mixed $key, mixed $value): void
    public putAll(mixed $pairs): void
    public reduce(callable $callback, mixed $initial = ?): mixed
    public remove(mixed $key, mixed $default = ?): mixed
    public reverse(): void
    public reversed(): Ds\Map
    public skip(int $position): Ds\Pair
    public slice(int $index, int $length = ?): Ds\Map
    public sort(callable $comparator = ?): void
    public sorted(callable $comparator = ?): Ds\Map
    public sum(): int|float
    public toArray(): array
    public union(Ds\Map $map): Ds\Map
    public values(): Ds\Sequence
    public xor(Ds\Map $map): Ds\Map
    }

    Constantes pré-définies

    Ds\Map::MIN_CAPACITY

    Historique

    Version Description
    PECL ds 1.3.0 La classe implémente maintenant ArrayAccess.

    Sommaire

    • Ds\Map::allocate — Alloue suffisamment de mémoire pour une capacité requise
    • Ds\Map::apply — Met à jour toutes les valeurs en appliquant une fonction de rappel à chaque valeur
    • Ds\Map::capacity — Renvoie la capacité actuelle
    • Ds\Map::clear — Enlève toutes les valeurs
    • Ds\Map::__construct — Créer une nouvelle instance
    • Ds\Map::copy — Renvoie une copie superficielle de la carte
    • Ds\Map::count — Renvoie le nombre de valeurs dans la carte
    • Ds\Map::diff — Créer une nouvelle map en utilisant des clés qui ne sont pas dans une autre map
    • Ds\Map::filter — Creer une nouvelle carte en utilisant un callable pour determiner quelles paires inclure
    • Ds\Map::first — Renvoie la première paire de la carte
    • Ds\Map::get — Renvoie la valeur pour une clé donnée
    • Ds\Map::hasKey — Détermine si la carte contient une clé donnée
    • Ds\Map::hasValue — Détermine si la carte contient une valeur donnée
    • Ds\Map::intersect — Créer une nouvelle carte en intersectant les clés avec une autre carte
    • Ds\Map::isEmpty — Renvoie si la carte est vide
    • Ds\Map::jsonSerialize — Renvoie une représentation qui peut être convertie en JSON
    • Ds\Map::keys — Renvoie un ensemble des clés de la carte
    • Ds\Map::ksort — Trie la carte en place par clé
    • Ds\Map::ksorted — Renvoie une copie, triée par clé
    • Ds\Map::last — Renvoie la dernière paire de la carte
    • Ds\Map::map — Renvoie le résultat de l'application d'une fonction de rappel à chaque valeur
    • Ds\Map::merge — Renvoie le résultat de l'ajout de toutes les associations données
    • Ds\Map::pairs — Renvoie une séquence contenant toutes les paires de la carte
    • Ds\Map::put — Associe une clé à une valeur
    • Ds\Map::putAll — Associe toutes les paires clé-valeur d'un objet traversable ou d'un tableau
    • Ds\Map::reduce — Réduit la carte à une seule valeur en utilisant une fonction de rappel
    • Ds\Map::remove — Enlève et renvoie une valeur par clé
    • Ds\Map::reverse — Renverse la carte en place
    • Ds\Map::reversed — Renvoie une copie inversée
    • Ds\Map::skip — Renvoie la paire à un index de position donné
    • Ds\Map::slice — Renvoie un sous-ensemble de la carte défini par un index de départ et une longueur
    • Ds\Map::sort — Trie la carte en place par valeur
    • Ds\Map::sorted — Renvoie une copie, triée par valeur
    • Ds\Map::sum — Renvoie la somme de toutes les valeurs de la carte
    • Ds\Map::toArray — Convertit la carte en un tableau
    • Ds\Map::union — Créer une nouvelle carte en utilisant les valeurs de l'instance actuelle et d'une autre carte
    • Ds\Map::values — Renvoie une séquence des valeurs de la carte
    • Ds\Map::xor — Créer une nouvelle carte en utilisant les clés de l'instance actuelle ou d'une autre carte, mais pas des deux

    Improve This Page

    Learn How To Improve This Page • Submit a Pull Request • Report a Bug
    ＋add a note

    User Contributed Notes

    There are no user contributed notes for this page.
    To Top