La classe Set

(PECL ds >= 1.0.0)

Introduction

Un Set est une séquence de valeurs uniques. Cette implémentation utilise la même table de hachage que Ds\Map, où les valeurs sont utilisées comme clés et la valeur mappée est ignorée.

Force

  • 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é.
  • Libère automatiquement la mémoire allouée lorsque sa taille devient suffisamment faible.
  • add(), remove() et contains() sont tous de complexité O(1).

Faiblesses

  • Ne supporte pas: push(), pop(), insert(), shift(), ou unshift().
  • get() est de complexité O(n) s'il y a des valeurs supprimées dans le tampon avant l'index accédé, O(1) sinon.

Synopsis de la classe

class Ds\Set implements Ds\Collection, ArrayAccess {
/* Constantes */
const int MIN_CAPACITY = 16;
/* Méthodes */
public add(mixed ...$values): void
public allocate(int $capacity): void
public capacity(): int
public clear(): void
public contains(mixed ...$values): bool
public copy(): Ds\Set
public diff(Ds\Set $set): Ds\Set
public filter(callable $callback = ?): Ds\Set
public first(): mixed
public get(int $index): mixed
public intersect(Ds\Set $set): Ds\Set
public isEmpty(): bool
public join(string $glue = ?): string
public last(): mixed
public map(callable $callback): Ds\Set
public merge(mixed $values): Ds\Set
public reduce(callable $callback, mixed $initial = ?): mixed
public remove(mixed ...$values): void
public reverse(): void
public reversed(): Ds\Set
public slice(int $index, int $length = ?): Ds\Set
public sort(callable $comparator = ?): void
public sorted(callable $comparator = ?): Ds\Set
public sum(): int|float
public toArray(): array
public union(Ds\Set $set): Ds\Set
public xor(Ds\Set $set): Ds\Set
}

Constantes pré-définies

Ds\Set::MIN_CAPACITY

Historique

Version Description
PECL ds 1.3.0 Cette classe implémente maintenant ArrayAccess.
PECL ds 1.2.7 Ajout de la méthode Ds\Set::map().

Sommaire

  • Ds\Set::add — Ajoute des valeurs à la séquence
  • Ds\Set::allocate — Alloue suffisamment de mémoire pour une capacité requise
  • Ds\Set::capacity — Renvoie la capacité actuelle
  • Ds\Set::clear — Supprime toutes les valeurs
  • Ds\Set::__construct — Crée une nouvelle instance
  • Ds\Set::contains — Détermine si l'ensemble contient toutes les valeurs
  • Ds\Set::copy — Renvoie une copie superficielle de la séquence
  • Ds\Set::count — Renvoie le nombre de valeurs dans la séquence
  • Ds\Set::diff — Créer un nouvel ensemble en utilisant des valeurs qui ne sont pas dans une autre séquence
  • Ds\Set::filter — Créer un nouvel ensemble en utilisant un callable pour déterminer quelles valeurs inclure
  • Ds\Set::first — Renvoie la première valeur de la séquence
  • Ds\Set::get — Renvoie la valeur à un index donné
  • Ds\Set::intersect — Créer un nouvel ensemble en utilisant des valeurs communes avec une autre séquence
  • Ds\Set::isEmpty — Renvoie si l'ensemble est vide
  • Ds\Set::join — Rassemble toutes les valeurs en une chaîne
  • Ds\Set::jsonSerialize — Renvoie une représentation qui peut être convertie en JSON
  • Ds\Set::last — Renvoie la dernière valeur de la séquence
  • Ds\Set::map — Renvoie le résultat de l'application d'une fonction de rappel à chaque valeur
  • Ds\Set::merge — Renvoie le résultat de l'ajout de toutes les valeurs de la séquence
  • Ds\Set::reduce — Reduit l'ensemble à une seule valeur en utilisant une fonction de rappel
  • Ds\Set::remove — Supprime toutes les valeurs données de la séquence
  • Ds\Set::reverse — Renverse l'ensemble en place
  • Ds\Set::reversed — Renvoie une copie renversée
  • Ds\Set::slice — Renvoie un sous-ensemble d'une plage donnée
  • Ds\Set::sort — Trie l'ensemble en place
  • Ds\Set::sorted — Renvoie une copie triée
  • Ds\Set::sum — Renvoie la somme de toutes les valeurs de la séquence
  • Ds\Set::toArray — Convertit l'ensemble en un tableau
  • Ds\Set::union — Créer un nouvel ensemble en utilisant les valeurs de l'instance actuelle et d'un autre ensemble
  • Ds\Set::xor — Créer un nouvel ensemble en utilisant les valeurs de l'instance actuelle ou d'un autre ensemble, mais pas des deux