Ds\Map::put

(PECL ds >= 1.0.0)

Ds\Map::put — Associe une clé à une valeur

Description

public Ds\Map::put(mixed $key, mixed $value): void

Associe une clé à une valeur, en écrasant une association précédente si elle existe.

Note:
Les clés de type object sont supportées. Si un objet implémente Ds\Hashable, l'égalité sera déterminée par la fonction equals de l'objet. Si un objet n'implémente pas Ds\Hashable, les objets doivent être des références à la même instance pour être considérés comme égaux.

Note:
Il est également possible d'utiliser la syntaxe de tableau pour associer des valeurs par clé, par exemple $map["clé"] = $valeur.

Attention

Attention à l'utilisation de la syntaxe de tableau. Les clés scalaires seront coercées en entiers par le moteur. Par exemple, $map["1"] tentera d'accéder à int(1), tandis que $map->get("1") recherchera correctement la clé de chaîne.

Voir tableaux.

Liste de paramètres

key: La clé à associer à la valeur.
value: La valeur à associer à la clé.

Valeurs de retour

Aucune valeur n'est retournée.

Exemples

Exemple #1 Exemple de Ds\Map::put()

<?php
$map = new \Ds\Map();

$map->put("a", 1);
$map->put("b", 2);
$map->put("c", 3);

print_r($map);
?>

Résultat de l'exemple ci-dessus est similaire à :

Ds\Map Object
(
    [0] => Ds\Pair Object
        (
            [key] => a
            [value] => 1
        )

    [1] => Ds\Pair Object
        (
            [key] => b
            [value] => 2
        )

    [2] => Ds\Pair Object
        (
            [key] => c
            [value] => 3
        )

)

Exemple #2 Exemple de Ds\Map::put() utilisant des objets en tant que clé

<?php
class HashableObject implements \Ds\Hashable
{
    /**
     * Une valeur arbitraire à utiliser comme valeur de hachage. Ne définit pas l'égalité.
     */
    private $value;

    public function __construct($value)
    {
        $this->value = $value;
    }

    public function hash()
    {
        return $this->value;
    }

    public function equals($obj): bool
    {
        return $this->value === $obj->value;
    }
}

$map = new \Ds\Map();

$obj = new \ArrayIterator([]);

// Utiliser la même instance plusieurs fois écrasera la valeur précédente.
$map->put($obj, 1);
$map->put($obj, 2);

// Utiliser plusieurs instances du même objet créera de nouvelles associations.
$map->put(new \stdClass(), 3);
$map->put(new \stdClass(), 4);

// Utiliser plusieurs instances d'objets égaux écrasera les valeurs précédentes.
$map->put(new \HashableObject(1), 5);
$map->put(new \HashableObject(1), 6);
$map->put(new \HashableObject(2), 7);
$map->put(new \HashableObject(2), 8);

var_dump($map);
?>

Résultat de l'exemple ci-dessus est similaire à :

object(Ds\Map)#1 (5) {
  [0]=>
  object(Ds\Pair)#7 (2) {
    ["key"]=>
    object(ArrayIterator)#2 (1) {
      ["storage":"ArrayIterator":private]=>
      array(0) {
      }
    }
    ["value"]=>
    int(2)
  }
  [1]=>
  object(Ds\Pair)#8 (2) {
    ["key"]=>
    object(stdClass)#3 (0) {
    }
    ["value"]=>
    int(3)
  }
  [2]=>
  object(Ds\Pair)#9 (2) {
    ["key"]=>
    object(stdClass)#4 (0) {
    }
    ["value"]=>
    int(4)
  }
  [3]=>
  object(Ds\Pair)#10 (2) {
    ["key"]=>
    object(HashableObject)#5 (1) {
      ["value":"HashableObject":private]=>
      int(1)
    }
    ["value"]=>
    int(6)
  }
  [4]=>
  object(Ds\Pair)#11 (2) {
    ["key"]=>
    object(HashableObject)#6 (1) {
      ["value":"HashableObject":private]=>
      int(2)
    }
    ["value"]=>
    int(8)
  }
}