diff --git a/reference/yac/book.xml b/reference/yac/book.xml index aa46d9f7cd..7d0a389390 100644 --- a/reference/yac/book.xml +++ b/reference/yac/book.xml @@ -1,7 +1,5 @@ - - - + @@ -10,10 +8,34 @@ &reftitle.intro; - - Yac (Yet Another cache), est un cache de données utilisateur - en mémoire partagée, sans verrou, pouvant être utilisé pour remplacer APC. - + + Yac (Yet Another Cache) est un cache de données utilisateur en mémoire + partagée, sans verrou, pouvant être utilisé pour remplacer APC ou un + memcached local. + + + Yac stocke les données en mémoire partagée, ce qui les rend visibles par + chaque worker PHP de la même machine sans aucune communication + inter-processus. Au lieu de verrous, Yac repose sur des mises à jour + atomiques de slots et quelques sondes de collision, ce qui signifie qu'un + défaut de cache ne bloque jamais une requête, et qu'une écriture + concurrente peut au pire provoquer un échec de stockage ou une lecture + ratée que l'appelant peut simplement réessayer. + + + Parce que Yac échange des garanties de cohérence contre vitesse et + débit, il convient mieux aux données coûteuses à produire mais faciles à + recréer : fragments de page, instantanés de configuration, petites + réponses de service et autres caches locaux. Il ne doit pas être utilisé + comme stockage faisant autorité pour des données irremplaçables. + + + + La mémoire partagée n'est visible qu'au sein d'une seule machine. Pour + partager un cache entre plusieurs serveurs, utiliser un cache réseau tel + que Memcached ou Redis. + + &reference.yac.setup; diff --git a/reference/yac/configure.xml b/reference/yac/configure.xml index 2af0efd123..fa6f78f1ce 100644 --- a/reference/yac/configure.xml +++ b/reference/yac/configure.xml @@ -1,7 +1,5 @@ - - - +
&reftitle.install; diff --git a/reference/yac/constants.xml b/reference/yac/constants.xml index 45a2df7bfb..9d1a9d1bd4 100644 --- a/reference/yac/constants.xml +++ b/reference/yac/constants.xml @@ -1,7 +1,5 @@ - - - + &reftitle.constants; diff --git a/reference/yac/ini.xml b/reference/yac/ini.xml index 8d762346fe..88fe1265bb 100644 --- a/reference/yac/ini.xml +++ b/reference/yac/ini.xml @@ -1,14 +1,12 @@ - - - +
&reftitle.runtime; &extension.runtime; - &ConfigureOptions; Yac + Yac &ConfigureOptions; @@ -76,9 +74,14 @@ int - - - + + Les valeurs sérialisées plus grandes que ce nombre d'octets sont + compressées avant d'être stockées (actuellement avec LZ4). Mettre à + -1 (la valeur par défaut) pour désactiver + entièrement la compression. Compresser les grandes valeurs économise + de la mémoire partagée au coût de quelques cycles CPU lors du + stockage et de la récupération. + @@ -87,9 +90,10 @@ int - - - + + Réservé au débogage. À partir de Yac 2.4.0, cette directive est + enregistrée mais n'a aucun effet. + @@ -98,9 +102,10 @@ int - - - + + Si Yac est activé. Si désactivé, créer une instance de + Yac lance une exception. + @@ -109,9 +114,12 @@ int - - - + + Si Yac est activé lors de l'exécution sous le SAPI + CLI. Désactivé par défaut car les scripts en + ligne de commande démarrent et s'arrêtent immédiatement, et le + segment de mémoire partagée serait créé inutilement. + @@ -120,9 +128,15 @@ string - - - + + Quantité de mémoire partagée utilisée pour la table de hachage qui + contient les clés et les informations de gestion. Chaque slot est une + structure de taille fixe, donc cette valeur détermine combien + d'éléments peuvent être suivis simultanément. La valeur par défaut + est 4M. Yac divise cette zone en segments ; la + taille de segment est de 4M, donc cette valeur doit être un multiple + de 4M. + @@ -131,9 +145,17 @@ string - - - + + Sérialisateur utilisé pour transformer les valeurs PHP arbitraires + en octets avant de les stocker. Les valeurs autorisées sont + php (la valeur par défaut), + json, igbinary et + msgpack. Les trois derniers nécessitent que + l'extension soit compilée avec le support correspondant. Les + sérialisateurs binaires tels que igbinary et + msgpack sont généralement plus rapides et + produisent des données plus compactes que php. + @@ -142,9 +164,14 @@ string - - - + + Quantité de mémoire partagée utilisée pour stocker les valeurs + réelles. La valeur par défaut est 64M. Yac alloue + cette zone en segments de 4M chacun, donc cette valeur doit être un + multiple de 4M. Lorsque la zone est pleine, les + entrées les moins récemment utilisées sont expulsées pour faire de la + place aux nouvelles. + diff --git a/reference/yac/setup.xml b/reference/yac/setup.xml index 817606f190..f40402ba08 100644 --- a/reference/yac/setup.xml +++ b/reference/yac/setup.xml @@ -1,31 +1,65 @@ - - - + &reftitle.setup;
&reftitle.required; - - - + + Aucune bibliothèque externe n'est requise. +
&reftitle.install; - + &pecl.moved; - - + + &pecl.info; &url.pecl.package;yac. - - + + &pecl.windows.download.avail; + + + Le code source est hébergé sur + GitHub. Pour compiler + l'extension depuis les sources : + + + + + Les options configure suivantes sont disponibles : + + + Les valeurs sont compressées avec LZ4 avant d'être stockées. Par défaut, + Yac utilise la copie de LZ4 fournie avec l'extension ; aucun indicateur + supplémentaire n'est nécessaire. Pour lier l'extension contre la + bibliothèque LZ4 système, utiliser le commutateur + , qui nécessite que + l'en-tête lz4.h et liblz4 soient + installés. + + + Des sérialisateurs alternatifs peuvent être compilés avec + , + ou + , qui enregistrent + l'extension correspondante comme dépendance optionnelle. Le sérialisateur + utilisé à l'exécution est sélectionné avec la directive ini + yac.serializer. +
@@ -35,9 +69,9 @@
&reftitle.resources; - - - + + Cette extension ne définit aucune ressource. +
diff --git a/reference/yac/versions.xml b/reference/yac/versions.xml new file mode 100644 index 0000000000..2581df47f0 --- /dev/null +++ b/reference/yac/versions.xml @@ -0,0 +1,52 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/reference/yac/yac.xml b/reference/yac/yac.xml index 71a99f168a..eb580d8114 100644 --- a/reference/yac/yac.xml +++ b/reference/yac/yac.xml @@ -1,7 +1,5 @@ - - - + diff --git a/reference/yac/yac/add.xml b/reference/yac/yac/add.xml index 13bfb1a1c8..2611f8b443 100644 --- a/reference/yac/yac/add.xml +++ b/reference/yac/yac/add.xml @@ -1,29 +1,30 @@ - - - + Yac::add - Stocke un élément dans le cache + Stocke une valeur sans écraser une valeur existante &reftitle.description; public boolYac::add - stringkeys + stringarraykeys mixedvalue intttl0 public boolYac::add - arraykey_vals + arrayvalues + intttl0 - - Ajoute un élément dans le cache. - + + Stocke une valeur dans le cache. Contrairement à + Yac::set, cette méthode n'écrase pas une entrée + existante encore valide ; le stockage est rejeté dans ce cas. + @@ -32,25 +33,30 @@ keys - - &string; ; la clé - + + Une clé string, ou un array de paires + clé => valeur à stocker en un seul appel. + value - - Tout type de valeur PHP peut être stocké, à l'exception d'une &resource;. - + + La valeur à stocker. Tout type PHP sauf resource peut + être stocké. Utilisé uniquement dans la forme à clé unique ; quand + keys est un tableau, cet argument est le + ttl optionnel. + ttl - - Délai d'expiration. - + + Durée de vie en secondes. 0 signifie que l'entrée + n'expire jamais dans le temps. + @@ -58,27 +64,65 @@ &reftitle.returnvalues; + + Retourne &true; en cas de succès, &false; en cas d'échec. Un stockage + est également rejeté (retournant &false;) quand la clé existe déjà et + n'a pas expiré. + + + + Yac stocke les entrées sans verrou. Sous forte contention, un stockage + peut échouer de façon transitoire ; si la valeur doit finalement être + stockée, réessayer : + +add("key", "value")) { + // réessayer en cas d'échec transitoire +} +?> +]]> + + + + + + + &reftitle.examples; + + Exemple avec <methodname>Yac::add</methodname> + +add("foo", "bar")); // bool(true) +var_dump($yac->add("foo", "baz")); // bool(false): "foo" existe déjà + +// ttl en secondes ; 0 (la valeur par défaut) signifie que l'entrée n'expire jamais +$yac->add("short-lived", "value", 5); +sleep(6); +var_dump($yac->get("short-lived")); // bool(false): expiré + +// stocker plusieurs paires clé => valeur en un appel, avec un ttl +$yac->add(array("a" => 1, "b" => 2), 60); +?> +]]> + + + + + + &reftitle.seealso; - &boolean;, &true; en cas de succès, &false; si une erreur survient. - - - La méthode Yac::add peut échouer si le verrou - ne peut être obtenu, aussi, pour que l'élément soit stocké - proprement, il est recommandé d'écrire le code comme ceci : - - Permet de s'assurer que l'élément est stocké - - set("key", "value")); - ]]> - - - - + + Yac::set + Yac::get + Yac::delete + - - - + @@ -15,11 +13,13 @@ public Yac::__construct stringprefix"" - - Le préfixe est utilisé pour préfixer les clés ; cela permet d'éviter les - conflits entre plusieurs applications. - - + + Crée une nouvelle instance de Yac. Le + prefix optionnel est ajouté au début de chaque + clé stockée par cette instance, ce qui permet à plusieurs applications + ou caches sur la même machine d'utiliser des noms de clés chevauchants + sans collision. + @@ -28,32 +28,49 @@ prefix - - &string; ; le préfixe - + + Un préfixe de clé, jusqu'à 48 octets (YAC_MAX_KEY_LEN). + - - &reftitle.errors; + + Lance une Exception si le cache est + désactivé (yac.enable=0), ou si + prefix est plus long que 48 octets. + + + + + &reftitle.examples; + + Exemple avec <methodname>Yac::__construct</methodname> + +set("foo", "bar"); + +$other = new Yac("app2_"); +var_dump($other->get("foo")); // bool(false): espace de noms différent +$other->set("foo", "baz"); // stocké sous "app2_foo" +?> +]]> + + + + + + &reftitle.seealso; - Lance une Exception si Yac n'est pas activé. - Lance une Exception si prefix - excède la longueur maximale de clé de 48 - (YAC_MAX_KEY_LEN) octets. + + Yac::set + Yac::get + diff --git a/reference/yac/yac/delete.xml b/reference/yac/yac/delete.xml index 9a504aa1d2..20775c1aff 100644 --- a/reference/yac/yac/delete.xml +++ b/reference/yac/yac/delete.xml @@ -1,12 +1,10 @@ - - - + Yac::delete - Supprime un ou plusieurs éléments du cache + Supprime des éléments du cache @@ -14,11 +12,11 @@ public boolYac::delete stringarraykeys - intttl + intdelay0 - + Supprime un ou plusieurs éléments du cache. - + @@ -27,18 +25,21 @@ keys - - La clé ou un tableau de plusieurs clés à supprimer - + + Une clé string, ou un array de clés à + supprimer. + - ttl + delay - - Si le délai est défini, l'opération de suppression va marquer les éléments - pour qu'ils soient invalides au bout de ttl secondes. - + + Nombre de secondes avant que l'élément devienne invalide. Quand omis + ou 0, l'élément est invalidé immédiatement. Une + valeur positive garde l'élément lisible pendant ce nombre de secondes + avant qu'il expire. + @@ -46,12 +47,48 @@ &reftitle.returnvalues; + + Retourne &true; en cas de succès, ou &false; si la clé n'était pas + présente dans le cache. + + + + + &reftitle.examples; + + Exemple avec <methodname>Yac::delete</methodname> + +set("foo", "bar"); + +var_dump($yac->delete("foo")); // bool(true) +var_dump($yac->delete("foo")); // bool(false): déjà supprimé + +// suppression différée : garder l'entrée lisible encore 60 secondes, +// elle disparaît seulement après ce délai +$yac->set("tmp", "value"); +var_dump($yac->delete("tmp", 60)); // bool(true) + +// supprimer plusieurs clés à la fois +var_dump($yac->delete(array("a", "b"))); +?> +]]> + + + + + + &reftitle.seealso; - + + Yac::set + Yac::flush + - + Yac::dump - Extrait les valeurs du cache + Vide les entrées du cache pour inspection &reftitle.description; - public mixedYac::dump - intnum + public arrayYac::dump + intlimit100 + intoffset0 - - Extrait les valeurs stockées dans le cache - + + Vide les métadonnées des entrées actuellement stockées dans le cache. + Les valeurs elles-mêmes ne sont pas retournées. + &reftitle.parameters; - num + limit + + + Nombre maximum d'entrées à retourner. + + + + + offset - - Nombre maximal d'éléments à retourner - + + Nombre d'entrées à sauter avant de collecter, qui peut être utilisé + pour paginer un cache contenant plus d'entrées que + limit. + @@ -34,12 +46,219 @@ &reftitle.returnvalues; + + Un array avec un élément par entrée vidée. Chaque élément + est lui-même un tableau décrivant l'entrée : + + + + index + + L'index de slot de l'entrée dans la table de hachage. + + + + hash + + Le hachage 64 bits de la clé, utilisé pour le sondage de slots. + + + + crc + + La somme de contrôle CRC32 de la valeur stockée, utilisée pour + détecter les lectures incomplètes. 0 pour les + entrées intégrées, qui n'ont pas de bloc de valeur. + + + + ttl + + L'horodatage d'expiration (heure Unix). 0 signifie + que l'entrée n'expire jamais dans le temps. Il est à noter que + Yac::delete marque seulement une entrée + comme expirée, donc les entrées supprimées peuvent encore apparaître + dans le vidage ; un ttl non nul dans le passé + indique une entrée expirée ou supprimée. + + + + k_len + + La longueur de la clé, en octets. + + + + v_len + + La longueur de la valeur, en octets. Pour les entrées compressées, + c'est la longueur de la valeur originale avant + compression (à partir de yac 2.4.0 ; les versions antérieures + rapportaient la longueur stockée, compressée). + + + + c_len + + Présent uniquement pour les entrées compressées (à partir de yac + 2.4.0) : la longueur du contenu compressé réellement stocké en + mémoire partagée, en octets. Comparer c_len avec + v_len montre combien la compression économise par + entrée. + + + + size + + La taille allouée du bloc de valeur en mémoire partagée, en octets. + 0 pour les entrées intégrées. + + + + atime + + Le dernier temps d'accès (heure Unix), mis à jour à chaque + Yac::get réussi. Quand le cache est plein, + l'entrée avec l'atime le plus ancien parmi les + slots candidats est expulsée en premier (à partir de yac 2.4.0). + + + + hits + + Un compteur de succès par entrée, incrémenté à chaque + Yac::get réussi, remis à zéro quand + l'entrée est écrasée, supprimée ou expire (à partir de yac 2.4.0). + + + + embedded + + Si la valeur est stockée directement à l'intérieur du slot plutôt que + dans un bloc de valeur séparé (à partir de yac 2.4.0). Les petites + valeurs — NULL, booléens, petits entiers, chaînes + jusqu'à 7 octets et tableaux vides — sont intégrées de cette façon et + n'allouent aucune mémoire de valeur ; pour elles, crc + et size sont rapportés à 0. + + + + key + + La clé de cache, sans aucun préfixe d'instance. + + + + + + + &reftitle.examples; + + Exemple avec <methodname>Yac::dump</methodname> + +set("foo", "bar"); +$yac->set("baz", "qux"); + +print_r($yac->dump()); +?> +]]> + + &example.outputs.similar; + + Array + ( + [index] => 12345 + [hash] => 14463105906481965911 + [crc] => 0 + [ttl] => 0 + [k_len] => 3 + [v_len] => 3 + [size] => 0 + [atime] => 1725955200 + [hits] => 0 + [embedded] => 1 + [key] => foo + ) + + [1] => Array + ( + [index] => 12987 + [hash] => 15132029420525657053 + [crc] => 0 + [ttl] => 0 + [k_len] => 3 + [v_len] => 3 + [size] => 0 + [atime] => 1725955200 + [hits] => 0 + [embedded] => 1 + [key] => baz + ) + +) +]]> + + + Les entrées sont listées dans l'ordre des slots, pas dans l'ordre où + elles ont été stockées. Les entrées intégrées (petits scalaires gardés + à l'intérieur du slot lui-même) ont crc et + size à zéro ; les entrées stockées dans un bloc de + valeur séparé portent leur somme de contrôle et taille de bloc, et les + entrées compressées portent additionnellement c_len. + + + + Pagination d'un grand cache + + limit limite le nombre d'entrées qu'un seul + appel retourne, et offset en saute autant avant + de collecter, donc les deux peuvent être combinés pour paginer un cache + contenant plus d'entrées qu'un appel peut en retourner. + + +dump($page_size, $page_size * ($page_num - 1)); + +var_dump(count($page)); +?> +]]> + + &example.outputs.similar; + + + + + Moins d'entrées que demandé sont retournées quand le cache en contient + moins que la page demandée ne couvre, et un tableau vide est retourné + quand l'offset pointe au-delà du dernier slot occupé. + + + + + + &reftitle.seealso; - Les éléments extraits. + + Yac::info + - - - + Yac::flush - Supprime toutes les valeurs mises en cache + Vide le cache @@ -15,9 +13,12 @@ public boolYac::flush - - Supprime toutes les valeurs mises en cache. - + + Supprime toutes les valeurs mises en cache. Comme le cache est partagé + par chaque processus de la même machine, cela vide le cache globalement ; + le préfixe de clé donné à Yac::__construct ne + limite pas ce qui est vidé. + @@ -27,12 +28,46 @@ &reftitle.returnvalues; + + Retourne &true;. + + + + + &reftitle.examples; + + Exemple avec <methodname>Yac::flush</methodname> + +set("foo", "bar"); + +$other = new Yac("app2_"); +$other->set("baz", "qux"); + +// flush vide tout le cache : les entrées de chaque instance, +// quel que soit le préfixe utilisé lors de leur stockage +$yac->flush(); + +var_dump($yac->get("foo")); // bool(false) +var_dump($other->get("baz")); // bool(false) +?> +]]> + + + + + + &reftitle.seealso; - Une valeur booléenne, toujours &true;. + + Yac::delete + Yac::info + - - - + Yac::get - Récupère un élément du cache + Récupère des valeurs du cache &reftitle.description; public mixedYac::get - stringarraykey - intcas&null; + stringarraykeys + mixeddefault&null; - - Récupère un élément du cache. - + + Récupère des valeurs du cache. + &reftitle.parameters; - key + keys - - &string; ; la clé, ou un &array; de plusieurs clés. - + + Une clé string, ou un array de clés. + - cas + default - - Si différent de &null;, ce devra être le cas de l'élément récupéré. - + + La valeur à retourner quand la clé (ou les clés) demandée n'est pas + présente dans le cache, disponible à partir de yac 2.4.0. Quand + omis, un défaut de cache retourne &false;. + + + + Avant yac 2.4.0, cet emplacement d'argument contenait un jeton + $cas par référence plutôt qu'une valeur par + défaut. Le code qui passait ou se reposait sur ce jeton doit être + mis à jour lors d'une montée en version vers 2.4.0. + + @@ -45,12 +53,61 @@ &reftitle.returnvalues; + + Pour une clé string, retourne la valeur mise en cache en + cas de succès, sinon la default (ou &false; si + aucune valeur par défaut n'a été donnée). + + + Pour un array de clés, retourne un tableau contenant les + valeurs trouvées indexées par leurs clés. Les clés absentes du cache + sont omises du résultat à partir de yac 2.4.0, ou remplies avec la + default quand une a été fournie ; avant 2.4.0, + un placeholder &false; était inséré pour chaque clé manquante. + + + + + &reftitle.examples; + + Exemple avec <methodname>Yac::get</methodname> + +set("foo", "bar"); +var_dump($yac->get("foo")); // string(3) "bar" +var_dump($yac->get("missing")); // bool(false): défaut de cache + +// un défaut de cache et un false stocké sont indiscernables sans valeur par défaut ; +// une valeur sentinelle (disponible à partir de yac 2.4.0) les distingue +$yac->set("flag", false); +var_dump($yac->get("flag")); // bool(false): la valeur stockée +var_dump($yac->get("missing", false)); // bool(false): un défaut de cache, même forme +var_dump($yac->get("flag", "__NONE__")); // bool(false): la valeur stockée +var_dump($yac->get("missing", "__NONE__")); // string(8) "__NONE__": un défaut de cache + +// avec un tableau de clés, seules les clés trouvées sont présentes dans le résultat +$yac->set("foo2", "bar2"); +var_dump($yac->get(array("foo", "foo2", "missing"))); +// array(2) { ["foo"]=> string(3) "bar" ["foo2"]=> string(4) "bar2" } +?> +]]> + + + + + + &reftitle.seealso; - Le ou les éléments, &false; si une erreur survient. + + Yac::set + Yac::__get + - - - + Yac::__get - Récupère un élément du cache + Récupère une valeur via la syntaxe propriété @@ -15,9 +13,11 @@ public mixedYac::__get stringkey - - Récupère un élément du cache. - + + Récupère une valeur du cache, invoqué lors de la lecture d'une propriété + d'une instance de Yac : $yac->foo + est équivalent à $yac->get("foo"). + @@ -26,9 +26,9 @@ key - - &string; ; la clé - + + Le nom de la propriété, utilisé comme clé de cache. + @@ -36,12 +36,47 @@ &reftitle.returnvalues; + + La valeur mise en cache en cas de succès, &null; quand la clé n'est pas + présente dans le cache. + + + + Contrairement à Yac::get, la syntaxe propriété + ne peut pas distinguer un &null; stocké d'une clé manquante, et ne + prend en charge que des clés uniques. + + + + + + &reftitle.examples; + + Exemple avec <methodname>Yac::__get</methodname> + +set("foo", "bar"); + +var_dump($yac->foo); // string(3) "bar" +var_dump($yac->missing); // NULL +?> +]]> + + + + + + &reftitle.seealso; - L'élément en cas de succès, &null; si une erreur survient. + + Yac::get + Yac::__set + - - - + Yac::info - Statut du cache + État du cache @@ -15,9 +13,9 @@ public arrayYac::info - - Récupère le statut du cache système. - + + Retourne l'état du système de cache. + @@ -27,14 +25,150 @@ &reftitle.returnvalues; + + Retourne un array avec les clés suivantes : + + + + memory_size + + Mémoire partagée totale utilisée, en octets : la table de slots plus + les blocs de valeurs. + + + + slots_memory_size + + Mémoire réservée pour la table de hachage de slots, en octets. + + + + values_memory_size + + Mémoire réservée pour les valeurs stockées, en octets. + + + + segment_size + + Taille d'un segment de mémoire de valeurs, en octets. + + + + segment_num + + Nombre de segments de mémoire de valeurs. + + + + miss + + Nombre de défauts de cache : recherches n'ayant rien trouvé ou + trouvant une entrée expirée. + + + + hits + + Nombre de succès de cache : recherches fructueuses. + + + + fails + + Nombre de stockages échoués : stockages n'ayant pas pu allouer un + bloc de valeur. + + + + kicks + + Nombre d'évictions : combien de fois une entrée existante a dû être + expulsée parce que le chemin de slot candidat était plein. + + + + recycles + + Nombre de fois où l'allocateur a atteint la fin d'un segment et est + revenu à son début. + + + + start_time + + L'horodatage Unix auquel le cache en mémoire partagée a été + initialisé. + + + + slots_size + + Nombre total de slots de hachage. + + + + slots_used + + Nombre de slots de hachage actuellement occupés. + + + + + + + &reftitle.examples; + + Exemple avec <methodname>Yac::info</methodname> + +set("foo", "bar"); + +print_r($yac->info()); +?> +]]> + + &example.outputs.similar; + + 46137344 + [slots_memory_size] => 4194304 + [values_memory_size] => 41943040 + [segment_size] => 4194304 + [segment_num] => 10 + [miss] => 0 + [hits] => 0 + [fails] => 0 + [kicks] => 0 + [recycles] => 0 + [start_time] => 1725955200 + [slots_size] => 32768 + [slots_used] => 1 +) +]]> + + + Le taux de succès peut être calculé comme + hits / (hits + miss) ; un compteur + kicks ou fails croissant indique + que le cache est sous pression mémoire. + + + + + + &reftitle.seealso; - Retourne un tableau contenant les éléments suivants : - "memory_size", "slots_memory_size", "values_memory_size", "segment_size", "segment_num", - "miss", "hits", "fails", "kicks", "recycles", "slots_size", "slots_used" + + Yac::dump + - - - + @@ -13,17 +11,19 @@ &reftitle.description; public boolYac::set - stringkeys + stringarraykeys mixedvalue intttl0 - public boolYac::add - arraykey_vals + public boolYac::set + arrayvalues + intttl0 - - Ajoute un élément dans le cache ; si la clé existe déjà, elle sera écrasée. - + + Stocke une valeur dans le cache. Si la clé existe déjà, l'entrée + existante est écrasée, qu'elle ait expiré ou non. + @@ -32,25 +32,30 @@ keys - - &string; ; la clé - + + Une clé string, ou un array de paires + clé => valeur à stocker en un seul appel. + value - - Tout type de valeur que PHP peut stocker, à l'exception d'une &resource;. - + + La valeur à stocker. Tout type PHP sauf resource peut + être stocké. Utilisé uniquement dans la forme à clé unique ; quand + keys est un tableau, cet argument est le + ttl optionnel. + ttl - - Durée d'expiration - + + Durée de vie en secondes. 0 signifie que l'entrée + n'expire jamais dans le temps. + @@ -58,8 +63,44 @@ &reftitle.returnvalues; + + Retourne &true; en cas de succès, &false; en cas d'échec. + + + + + &reftitle.examples; + + Exemple avec <methodname>Yac::set</methodname> + +set("foo", "bar"); // stocker une valeur unique +$yac->set("foo", "baz"); // écraser l'entrée existante + +// ttl en secondes : l'entrée expire après 5 secondes +$yac->set("short-lived", "value", 5); +sleep(6); +var_dump($yac->get("short-lived")); // bool(false): expiré + +// stocker plusieurs paires clé => valeur en un appel +$yac->set(array("a" => 1, "b" => 2)); +?> +]]> + + + + + + &reftitle.seealso; - La valeur stockée + + Yac::add + Yac::get + Yac::__set + diff --git a/reference/yac/yac/setter.xml b/reference/yac/yac/setter.xml index 26c0c0763d..0c3c389e7e 100644 --- a/reference/yac/yac/setter.xml +++ b/reference/yac/yac/setter.xml @@ -1,43 +1,45 @@ - - - + Yac::__set - Stocke un élément dans le cache + Stocke une valeur via la syntaxe propriété &reftitle.description; public mixedYac::__set - stringkeys + stringkey mixedvalue - - Stocke un élément dans le cache - + + Stocke une valeur dans le cache, invoqué lors de l'écriture d'une + propriété d'une instance de Yac : + $yac->foo = "bar" est équivalent à + $yac->set("foo", "bar"), sans ttl. + &reftitle.parameters; - keys + key - - &string; ; la clé - + + Le nom de la propriété, utilisé comme clé de cache. + value - - Tout type de valeur PHP peut être stockée, à l'exception d'une &resource; - + + La valeur à stocker. Tout type PHP sauf resource peut + être stocké. + @@ -45,8 +47,35 @@ &reftitle.returnvalues; + + Retourne la valeur stockée. + + + + + &reftitle.examples; + + Exemple avec <methodname>Yac::__set</methodname> + +foo = "bar"; // stocké sans ttl +var_dump($yac->get("foo")); // string(3) "bar" +?> +]]> + + + + + + &reftitle.seealso; - La valeur stockée + + Yac::set + Yac::__get +