itertools php

Itertools - outils d'itération PHP pour alimenter vos boucles

Inspiré par Python - conçu pour PHP.

Caractéristiques

Itertools fait de vous une superstar d'itération en fournissant deux types d'outils:

• Outils d'itération en boucle
• Outils d'itération de flux

Exemple d'outils d'itération de boucle

 foreach (Multi:: zip ([ ' a ' , ' b ' ], [ 1 , 2 ]) as [ $ letter , $ number ]) {
    print ( $ letter . $ number );  // a1, b2
}

Exemple d'outils d'itération de flux

 $ result = Stream:: of ([ 1 , 1 , 2 , 2 , 3 , 4 , 5 ])
    -> distinct ()                 // [1, 2, 3, 4, 5]
    -> map ( fn ( $ x ) => $ x ** 2 )      // [1, 4, 9, 16, 25]
    -> filter ( fn ( $ x ) => $ x < 10 ) // [1, 4, 9]
    -> toSum ();                   // 14

Toutes les fonctions fonctionnent sur des collections iterable :

• array (type)
• Generator (type)
• Iterator (interface)
• Traversable (interface)

Readme Docs traduit dans d'autres langues:

• Русский

Référence rapide

Outils d'itération en boucle

Multi-itération

Itérateur	Description	Extrait de code
chain	Chaîner plusieurs itérables ensemble	Multi::chain($list1, $list2)
zip	Itérer plusieurs collections simultanément jusqu'à ce que l'itérateur le plus court termine	Multi::zip($list1, $list2)
zipEqual	Itérer plusieurs collections de longueur égale simultanément, erreur si les longueurs ne sont pas égales	Multi::zipEqual($list1, $list2)
zipFilled	Itérer plusieurs collections, en utilisant une valeur de remplissage si les longueurs ne sont pas égales	Multi::zipFilled($default, $list1, $list2)
zipLongest	Itérer plusieurs collections simultanément jusqu'à ce que l'itérateur le plus long termine	Multi::zipLongest($list1, $list2)

Itération unique

Itérateur	Description	Extrait de code
chunkwise	Itérer par des morceaux	Single::chunkwise($data, $chunkSize)
chunkwiseOverlap	Itérer par des morceaux chevauchés	Single::chunkwiseOverlap($data, $chunkSize, $overlapSize)
compress	Filtrer les éléments non sélectionnés	Single::compress($data, $selectors)
compressAssociative	Filtrez des éléments par clés non sélectionnées	Single::compressAssociative($data, $selectorKeys)
dropWhile	Déposez les éléments tandis que le prédicat est vrai	Single::dropWhile($data, $predicate)
filter	Filtre pour les éléments où le prédicat est vrai	Single::filterTrue($data, $predicate)
filterTrue	Filtre pour les éléments de vérité	Single::filterTrue($data)
filterFalse	Filtre pour les éléments fausses	Single::filterFalse($data)
filterKeys	Filtre pour les clés où le prédicat est vrai	Single::filterKeys($data, $predicate)
flatMap	Carte la fonction sur les éléments et aplatir le résultat	Single::flaMap($data, $mapper)
flatten	Aplatir itérable multidimensionnel	Single::flatten($data, [$dimensions])
groupBy	Données de groupe par un élément commun	Single::groupBy($data, $groupKeyFunction, [$itemKeyFunc])
limit	Itérer jusqu'à une limite	Single::limit($data, $limit)
map	Carte la fonction sur chaque élément	Single::map($data, $function)
pairwise	Itérer les paires qui se chevauchent successives	Single::pairwise($data)
reindex	Reindex Clés de la valeur clé itérable	Single::reindex($data, $reindexer)
repeat	Répétez un élément plusieurs fois	Single::repeat($item, $repetitions)
reverse	Itérer les éléments dans l'ordre inverse	Single::reverse($data)
skip	Itérer après avoir sauté des éléments	Single::skip($data, $count, [$offset])
slice	Extraire une tranche de l'itérable	Single::slice($data, [$start], [$count], [$step])
string	Itérer les caractères d'une chaîne	Single::string($string)
takeWhile	Itérer les éléments tandis que le prédicat est vrai	Single::takeWhile($data, $predicate)

Itération infinie

Itérateur	Description	Extrait de code
count	Compter séquentiellement pour toujours	Infinite::count($start, $step)
cycle	Faire du vélo dans une collection	Infinite::cycle($collection)
repeat	Répétez un article pour toujours	Infinite::repeat($item)

Itération aléatoire

Itérateur	Description	Extrait de code
choice	Sélections aléatoires de la liste	Random::choice($list, $repetitions)
coinFlip	Flips de pièces aléatoires (0 ou 1)	Random::coinFlip($repetitions)
number	Nombres aléatoires	Random::number($min, $max, $repetitions)
percentage	Pourcentage aléatoire entre 0 et 1	Random::percentage($repetitions)
rockPaperScissors	Hands de scisseurs de papier rocheux aléatoires	Random::rockPaperScissors($repetitions)

Itération mathématique

Itérateur	Description	Extrait de code
frequencies	Distribution de fréquence des données	Math::frequencies($data, [$strict])
relativeFrequencies	Distribution relative de fréquence des données	Math::relativeFrequencies($data, [$strict])
runningAverage	Accumulation moyenne de course	Math::runningAverage($numbers, $initialValue)
runningDifference	Accumulation de différence de course	Math::runningDifference($numbers, $initialValue)
runningMax	Exécution d'une accumulation maximale	Math::runningMax($numbers, $initialValue)
runningMin	Exécuter une accumulation minimale	Math::runningMin($numbers, $initialValue)
runningProduct	Exécution d'accumulation de produits	Math::runningProduct($numbers, $initialValue)
runningTotal	Exécution d'accumulation totale	Math::runningTotal($numbers, $initialValue)

Définir et itération multiset

Itérateur	Description	Extrait de code
distinct	Ilétez uniquement les éléments distincts	Set::distinct($data)
distinctBy	Itérer uniquement des éléments distincts utilisant un comparateur personnalisé	Set::distinct($data, $compareBy)
intersection	Intersection des itérables	Set::intersection(...$iterables)
intersectionCoercive	Intersection avec la coercition de type	Set::intersectionCoercive(...$iterables)
partialIntersection	Intersection partielle des itérables	Set::partialIntersection($minCount, ...$iterables)
partialIntersectionCoercive	Intersection partielle avec coercition de type	Set::partialIntersectionCoercive($minCount, ...$iterables)
symmetricDifference	Différence symétrique des iterables	Set::symmetricDifference(...$iterables)
symmetricDifferenceCoercive	Différence symétrique avec la coercition de type	Set::symmetricDifferenceCoercive(...$iterables)
union	Union des iterables	Set::union(...$iterables)
unionCoercive	Union avec la coercition de type	Set::unionCoercive(...$iterables)

Trier itération

Itérateur	Description	Extrait de code
asort	Itérer une collection triée en maintenant les clés	Sort::asort($data, [$comparator])
sort	Itérer une collection triée	Sort::sort($data, [$comparator])

Itération de dossier

Itérateur	Description	Extrait de code
readCsv	Intersection un fichier CSV ligne par ligne	File::readCsv($fileHandle)
readLines	Itérer un fichier ligne par ligne	File::readLines($fileHandle)

Transformation

Itérateur	Description	Extrait de code
tee	Itérer les itérateurs en double	Transform::tee($data, $count)
toArray	Transformez itérable en un tableau	Transform::toArray($data)
toAssociativeArray	Transformez itérable en un tableau associatif	Transform::toAssociativeArray($data, [$keyFunc], [$valueFunc])
toIterator	Transformez iTable en un itérateur	Transform::toIterator($data)

Résumé

Résumé	Description	Extrait de code
allMatch	Vrai si tous les éléments sont vrais selon le prédicat	Summary::allMatch($data, $predicate)
allUnique	Vrai si tous les articles sont uniques	Summary::allUnique($data, [$strict])
anyMatch	Vrai si un élément est vrai selon le prédicat	Summary::anyMatch($data, $predicate)
arePermutations	Vrai si itérables sont des permutations les uns des autres	Summary::arePermutations(...$iterables)
arePermutationsCoercive	Vrai si itérables sont des permutations les uns des autres avec la coercition de type	Summary::arePermutationsCoercive(...$iterables)
exactlyN	Vrai si exactement n éléments sont vrais selon le prédicat	Summary::exactlyN($data, $n, $predicate)
isEmpty	Vrai si itérable n'a pas d'articles	Summary::isEmpty($data)
isPartitioned	Vrai si partitionné avec des éléments vrai selon le prédicat devant les autres	Summary::isPartitioned($data, $predicate)
isSorted	Vrai si itérable trié	Summary::isSorted($data)
isReversed	Vrai si itérable inversé trié	Summary::isReversed($data)
noneMatch	Vrai si aucun des éléments est vrai selon le prédicat	Summary::noneMatch($data, $predicate)
same	Vrai si itérables sont les mêmes	Summary::same(...$iterables)
sameCount	Vrai si les iterables ont les mêmes longueurs	Summary::sameCount(...$iterables)

Réduire

Réducteur	Description	Extrait de code
toAverage	Moyenne moyenne des éléments	Reduce::toAverage($numbers)
toCount	Réduire la longueur de la direction	Reduce::toCount($data)
toFirst	Réduire à sa première valeur	Reduce::toFirst($data)
toFirstAndLast	Réduire à ses premières et dernières valeurs	Reduce::toFirstAndLast($data)
toLast	Réduire à sa dernière valeur	Reduce::toLast()
toMax	Réduire à son plus grand élément	Reduce::toMax($numbers, [$compareBy])
toMin	Réduire à son plus petit élément	Reduce::toMin($numbers, [$compareBy])
toMinMax	Réduire à la table des limites supérieures et inférieures	Reduce::toMinMax($numbers, [$compareBy])
toNth	Réduisez à la valeur en position nème	Reduce::toNth($data, $position)
toProduct	Réduire le produit de ses éléments	Reduce::toProduct($numbers)
toRandomValue	Réduire à la valeur aléatoire de itérable	Reduce::toRandomValue($data)
toRange	Réduire la différence des valeurs max et min	Reduce::toRange($numbers)
toString	Réduisez à la chaîne jointe	Reduce::toString($data, [$separator], [$prefix], [$suffix])
toSum	Réduire à la somme de ses éléments	Reduce::toSum($numbers)
toValue	Réduire à la valeur en utilisant un réducteur appelant	Reduce::toValue($data, $reducer, $initialValue)

Outils d'itération de flux

Stream Sources

Source	Description	Extrait de code
of	Créer un flux à partir d'un itérable	Stream::of($iterable)
ofCoinFlips	Créer un flux de flips de pièces aléatoires	Stream::ofCoinFlips($repetitions)
ofCsvFile	Créer un flux à partir d'un fichier CSV	Stream::ofCsvFile($fileHandle)
ofEmpty	Créer un flux vide	Stream::ofEmpty()
ofFileLines	Créer un flux à partir des lignes d'un fichier	Stream::ofFileLines($fileHandle)
ofRandomChoice	Créer un flux de sélections aléatoires	Stream::ofRandomChoice($items, $repetitions)
ofRandomNumbers	Créer un flux de nombres aléatoires (entiers)	Stream::ofRandomNumbers($min, $max, $repetitions)
ofRandomPercentage	Créer un flux de pourcentages aléatoires entre 0 et 1	Stream::ofRandomPercentage($repetitions)
ofRange	Créer un flux d'une gamme de nombres	Stream::ofRange($start, $end, $step)
ofRockPaperScissors	Créer un flux de mains-scisseurs de papier rocheux	Stream::ofRockPaperScissors($repetitions)

Opérations de flux

Opération	Description	Extrait de code
asort	Trie la source itérable en maintenant les clés	$stream->asort([$comparator])
chainWith	Chaîne itérable source avec des itérables en une seule itération	$stream->chainWith(...$iterables)
compress	Compress Source en filtrant les données non sélectionnées	$stream->compress($selectors)
compressAssociative	Source de compression en filtrant les touches non sélectionnées	$stream->compressAssociative($selectorKeys)
chunkwise	Itérer par des morceaux	$stream->chunkwise($chunkSize)
chunkwiseOverlap	Itérer par des morceaux chevauchés	$stream->chunkwiseOverlap($chunkSize, $overlap)
distinct	Filtrez des éléments: itérez uniquement les articles uniques	$stream->distinct([$strict])
distinctBy	Filtrez des éléments: Ilétez uniquement les éléments uniques à l'aide d'un comparateur personnalisé	$stream->distinct($compareBy)
dropWhile	Déposez les éléments de la source itérable tandis que la fonction de prédicat est vraie	$stream->dropWhile($predicate)
filter	Filtrez uniquement les éléments où la fonction de prédicat est vraie	$stream->filterTrue($predicate)
filterTrue	Filtre pour uniquement des éléments de vérité	$stream->filterTrue()
filterFalse	Filtre pour uniquement des éléments fausses	$stream->filterFalse()
filterKeys	Filtre pour les touches où la fonction de prédicat est vraie	$stream->filterKeys($predicate)
flatMap	Fonction de cartographie sur les éléments et aplatir le résultat	$stream->flatMap($function)
flatten	Aplatir le flux multidimensionnel	$stream->flatten($dimensions)
frequencies	Distribution de fréquence	$stream->frequencies([$strict])
groupBy	Groupe itérable source par un élément de données commun	$stream->groupBy($groupKeyFunction, [$itemKeyFunc])
infiniteCycle	Parcourir les éléments de la source itérable séquentiellement pour toujours	$stream->infiniteCycle()
intersectionWith	Se croiser la source itérable et recevoir des itérables	$stream->intersectionWith(...$iterables)
intersection CoerciveWith	Se croiser la source itérable et recevoir des itérables avec la coercition de type	$stream->intersectionCoerciveWith(...$iterables)
limit	Limitez l'itération du flux	$stream->limit($limit)
map	Fonction de carte sur les éléments	$stream->map($function)
pairwise	Retour des paires d'éléments de la source itérable	$stream->pairwise()
partialIntersectionWith	Se croiser partiellement itérable et recevoir des itérables	$stream->partialIntersectionWith( $minIntersectionCount, ...$iterables)
partialIntersection CoerciveWith	Se croiser partiellement itérable et recevoir des itérables avec la coercition de type	$stream->partialIntersectionCoerciveWith( $minIntersectionCount, ...$iterables)
reindex	Clés Reindex du flux de valeurs clés	$stream->reindex($reindexer)
relativeFrequencies	Distribution de fréquence relative	$stream->relativeFrequencies([$strict])
reverse	Éléments inversés du ruisseau	$stream->reverse()
runningAverage	Accumuler la moyenne de course (moyenne) sur la source itérable	$stream->runningAverage($initialValue)
runningDifference	Accumuler la différence de fonctionnement par rapport à la source itérable	$stream->runningDifference($initialValue)
runningMax	Accumuler le maximum en cours d'exécution sur la source itérable	$stream->runningMax($initialValue)
runningMin	Accumuler le Min en cours d'exécution sur la source itérable	$stream->runningMin($initialValue)
runningProduct	Accumuler le produit en cours d'exécution sur une source itérable	$stream->runningProduct($initialValue)
runningTotal	Accumuler le total de course sur la source itérable	$stream->runningTotal($initialValue)
skip	Sauter quelques éléments du ruisseau	$stream->skip($count, [$offset])
slice	Extraire une tranche du ruisseau	$stream->slice([$start], [$count], [$step])
sort	Trie le flux	$stream->sort([$comparator])
symmetricDifferenceWith	Différence symétrique de source itérable et donnée itérables	$this->symmetricDifferenceWith(...$iterables)
symmetricDifference CoerciveWith	Différence symétrique de la source itérable et donnée itérables avec coercition de type	$this->symmetricDifferenceCoerciveWith( ...$iterables)
takeWhile	Les éléments de retour de la source itérable tant que le prédicat est vrai	$stream->takeWhile($predicate)
unionWith	Union of Stream with Iterables	$stream->unionWith(...$iterables)
unionCoerciveWith	Union de flux avec itérables avec coercition de type	$stream->unionCoerciveWith(...$iterables)
zipWith	Itérer la source itérable avec une autre collection itérable simultanément	$stream->zipWith(...$iterables)
zipEqualWith	Itérer la source itérable avec une autre collection itérable de longueurs égales simultanément	$stream->zipEqualWith(...$iterables)
zipFilledWith	Itérer la source itérable avec une autre collection itérable en utilisant le remplissage par défaut	$stream->zipFilledWith($default, ...$iterables)
zipLongestWith	Itérer la source itérable avec une autre collection itérable simultanément	$stream->zipLongestWith(...$iterables)

Opérations de terminaux de cours d'eau

Opérations de terminal sommaire

Opération de terminal	Description	Extrait de code
allMatch	Renvoie True si tous les éléments de Stream correspondent au prédicat	$stream->allMatch($predicate)
allUnique	Renvoie vrai si tous les éléments du flux sont uniques	$stream->allUnique([$strict]])
anyMatch	Renvoie True si un élément dans le flux correspond au prédicat	$stream->anyMatch($predicate)
arePermutationsWith	Renvoie True si toutes les permutations itérables du flux	$stream->arePermutationsWith(...$iterables)
arePermutationsCoerciveWith	Renvoie True si toutes les permutations itérables du flux avec la coercition de type	$stream->arePermutationsCoerciveWith(...$iterables)
exactlyN	Renvoie vrai si exactement n éléments sont vrais selon le prédicat	$stream->exactlyN($n, $predicate)
isEmpty	Renvoie True si Stream n'a pas d'éléments	$stream::isEmpty()
isPartitioned	Renvoie vrai si partitionné avec des éléments vrai selon le prédicat devant les autres	$stream::isPartitioned($predicate)
isSorted	Renvoie True si Stream est trié par ordre croissant	$stream->isSorted()
isReversed	Renvoie True si Stream est trié dans l'ordre descendant inverse	$stream->isReversed()
noneMatch	Renvoie True si aucun des éléments du prédicat ne correspond	$stream->noneMatch($predicate)
sameWith	Renvoie True si Stream et toutes les collections données sont les mêmes	$stream->sameWith(...$iterables)
sameCountWith	Renvoie True si Stream et toutes les collections données ont les mêmes longueurs	$stream->sameCountWith(...$iterables)

Opérations de terminal de réduction

Opération de terminal	Description	Extrait de code
toAverage	Réduit le flux vers la moyenne moyenne de ses articles	$stream->toAverage()
toCount	Réduit le flux sur sa longueur	$stream->toCount()
toFirst	Réduit le flux vers sa première valeur	$stream->toFirst()
toFirstAndLast	Réduit le flux vers ses premières et dernières valeurs	$stream->toFirstAndLast()
toLast	Réduit le flux vers sa dernière valeur	$stream->toLast()
toMax	Réduit le flux vers sa valeur maximale	$stream->toMax([$compareBy])
toMin	Réduit le flux vers sa valeur min	$stream->toMin([$compareBy])
toMinMax	Réduit le ruisseau à la table des limites supérieures et inférieures	$stream->toMinMax([$compareBy])
toNth	Réduit le flux à la valeur en position nème	$stream->toNth($position)
toProduct	Réduit le flux vers le produit de ses articles	$stream->toProduct()
toString	Réduit le flux vers la chaîne jointe	$stream->toString([$separator], [$prefix], [$suffix])
toSum	Réduit le flux à la somme de ses éléments	$stream->toSum()
toRandomValue	Réduit le flux à la valeur aléatoire	$stream->toRandomValue()
toRange	Réduit le flux à la différence des valeurs max et min	$stream->toRange()
toValue	Réduit le flux comme la fonction array_reduce ()	$stream->toValue($reducer, $initialValue)

Opérations de terminal de transformation

Opération de terminal	Description	Extrait de code
toArray	Renvoie une table d'éléments de flux	$stream->toArray()
toAssociativeArray	Renvoie la carte des valeurs clés des éléments de flux	$stream->toAssociativeArray($keyFunc, $valueFunc)
tee	Renvoie la gamme de multiples flux identiques	$stream->tee($count)

Opérations terminales à effet secondaire

Opération de terminal	Description	Extrait de code
callForEach	Effectuez l'action via la fonction sur chaque élément	$stream->callForEach($function)
print	print chaque élément dans le flux	$stream->print([$separator], [$prefix], [$suffix])
printLn	print chaque article sur une nouvelle ligne	$stream->printLn()
toCsvFile	Écrivez le contenu du flux sur un fichier CSV	$stream->toCsvFile($fileHandle, [$headers])
toFile	Écrivez le contenu du flux sur un fichier	$stream->toFile($fileHandle)

Opérations de débogage de diffusion

Opération de débogage	Description	Extrait de code
peek	Jetez un coup d'œil à chaque élément entre les opérations du flux	$stream->peek($peekFunc)
peekStream	Jetez un coup d'œil à l'ensemble du flux entre les opérations	$stream->peekStream($peekFunc)
peekPrint	Jetez un coup d'œil à chaque élément en imprimant entre les opérations	$stream->peekPrint()
peekPrintR	Jetez un coup d'œil à chaque élément en effectuant l'impression entre les opérations	$stream->peekPrintR()
printR	print_r chaque élément	$stream->printR()
varDump	var_dump à chaque élément	$stream->varDump()

Installation

Ajoutez la bibliothèque à votre fichier composer.json dans votre projet:

{
  "require" : {
      "markrogoyski/itertools-php" : " 1.* "
  }
}

Utilisez le compositeur pour installer la bibliothèque:

$ php composer.phar install

Composer installera Itertools à l'intérieur de votre dossier de fournisseur. Ensuite, vous pouvez ajouter ce qui suit à vos fichiers .php pour utiliser la bibliothèque avec automatiquement.

 require_once __DIR__ . ' /vendor/autoload.php ' ;

Alternativement, utilisez le compositeur sur la ligne de commande pour exiger et installer itertools:

 $ php composer.phar require markrogoyski/itertools-php:1.*

Exigences minimales

• PHP 7.4

Usage

Toutes les fonctions fonctionnent sur des collections iterable :

• array (type)
• Generator (type)
• Iterator (interface)
• Traversable (interface)

Multi-itération

Chaîne

Chaînon plusieurs itérables ensemble en une seule séquence continue.

Multi::chain(iterable ...$iterables)

 use IterTools  Multi ;

$ prequels  = [ ' Phantom Menace ' , ' Attack of the Clones ' , ' Revenge of the Sith ' ];
$ originals = [ ' A New Hope ' , ' Empire Strikes Back ' , ' Return of the Jedi ' ];

foreach (Multi:: chain ( $ prequels , $ originals ) as $ movie ) {
    print ( $ movie );
}
// 'Phantom Menace', 'Attack of the Clones', 'Revenge of the Sith', 'A New Hope', 'Empire Strikes Back', 'Return of the Jedi'

Fermeture éclair

Itérer simultanément plusieurs collections itérables.

Multi::zip(iterable ...$iterables)

 use IterTools  Multi ;

$ languages = [ ' PHP ' , ' Python ' , ' Java ' , ' Go ' ];
$ mascots   = [ ' elephant ' , ' snake ' , ' bean ' , ' gopher ' ];

foreach (Multi:: zip ( $ languages , $ mascots ) as [ $ language , $ mascot ]) {
    print ( " The { $ language } language mascot is an { $ mascot } . " );
}
// The PHP language mascot is an elephant.
// ...

Zip fonctionne avec plusieurs entrées itérables - pas limité à seulement deux.

 $ names          = [ ' Ryu ' , ' Ken ' , ' Chun Li ' , ' Guile ' ];
$ countries      = [ ' Japan ' , ' USA ' , ' China ' , ' USA ' ];
$ signatureMoves = [ ' hadouken ' , ' shoryuken ' , ' spinning bird kick ' , ' sonic boom ' ];

foreach (Multi:: zip ( $ names , $ countries , $ signatureMoves ) as [ $ name , $ country , $ signatureMove ]) {
    $ streetFighter = new StreetFighter ( $ name , $ country , $ signatureMove );
}

Remarque: Pour les longueurs inégales, l'itération s'arrête lorsque l'itérable le plus court est épuisé.

À zipe

Itérer simultanément plusieurs collections itérables avec des longueurs égales.

Jette LengthException si les longueurs ne sont pas égales, ce qui signifie qu'au moins un itérateur se termine devant les autres.

Multi::zipEqual(iterable ...$iterables)

 use IterTools  Multi ;

$ letters = [ ' A ' , ' B ' , ' C ' ];
$ numbers = [ 1 , 2 , 3 ];

foreach (Multi:: zipEqual ( $ letters , $ numbers ) as [ $ letter , $ number ]) {
    // ['A', 1], ['B', 2], ['C', 3]
}

Zippé

Itérer simultanément les collections itéables, en utilisant une valeur de remplissage par défaut si les longueurs ne sont pas égales.

Multi::zipFilled(mixed $filler, iterable ...$iterables)

 use IterTools  Multi ;

$ default = ' ? ' ;
$ letters = [ ' A ' , ' B ' ];
$ numbers = [ 1 , 2 , 3 ];

foreach (Multi:: zipFilled ( $ default , $ letters , $ numbers ) as [ $ letter , $ number ]) {
    // ['A', 1], ['B', 2], ['?', 3]
}

Le plus ziplé

Itérer simultanément plusieurs collections itérables.

Multi::zipLongest(iterable ...$iterables)

Pour les longueurs inégales, les itérables épuisés produiront null pour les itérations restantes.

 use IterTools  Multi ;

$ letters = [ ' A ' , ' B ' , ' C ' ];
$ numbers = [ 1 , 2 ];

foreach (Multi:: zipLongest ( $ letters , $ numbers ) as [ $ letter , $ number ]) {
    // ['A', 1], ['B', 2], ['C', null]
}

Itération unique

Chunkwise

Éléments de retour en morceaux d'une certaine taille.

Single::chunkwise(iterable $data, int $chunkSize)

La taille du morceau doit être d'au moins 1.

 use IterTools  Single ;

$ movies = [
    ' Phantom Menace ' , ' Attack of the Clones ' , ' Revenge of the Sith ' ,
    ' A New Hope ' , ' Empire Strikes Back ' , ' Return of the Jedi ' ,
    ' The Force Awakens ' , ' The Last Jedi ' , ' The Rise of Skywalker '
];

foreach (Single:: chunkwise ( $ movies , 3 ) as $ trilogy ) {
    $ trilogies [] = $ trilogy ;
}
// [
//     ['Phantom Menace', 'Attack of the Clones', 'Revenge of the Sith'],
//     ['A New Hope', 'Empire Strikes Back', 'Return of the Jedi'],
//     ['The Force Awakens', 'The Last Jedi', 'The Rise of Skywalker]'
// ]

Chevauchement

Le retour se chevauche des morceaux d'éléments.

Single::chunkwiseOverlap(iterable $data, int $chunkSize, int $overlapSize, bool $includeIncompleteTail = true)

• La taille du morceau doit être d'au moins 1.
• La taille du chevauchement doit être inférieure à la taille du morceau.

 use IterTools  Single ;

$ numbers = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ];

foreach (Single:: chunkwiseOverlap ( $ numbers , 3 , 1 ) as $ chunk ) {
    // [1, 2, 3], [3, 4, 5], [5, 6, 7], [7, 8, 9], [9, 10]
}

Compresse

Comprimez un itérable en filtrant les données qui ne sont pas sélectionnées.

Single::compress(string $data, $selectors)

 use IterTools  Single ;

$ movies = [
    ' Phantom Menace ' , ' Attack of the Clones ' , ' Revenge of the Sith ' ,
    ' A New Hope ' , ' Empire Strikes Back ' , ' Return of the Jedi ' ,
    ' The Force Awakens ' , ' The Last Jedi ' , ' The Rise of Skywalker '
];
$ goodMovies = [ 0 , 0 , 0 , 1 , 1 , 1 , 1 , 0 , 0 ];

foreach (Single:: compress ( $ movies , $ goodMovies ) as $ goodMovie ) {
    print ( $ goodMovie );
}
// 'A New Hope', 'Empire Strikes Back', 'Return of the Jedi', 'The Force Awakens'

Compression associative

Compressez un itérable en filtrant les clés qui ne sont pas sélectionnées.

Single::compressAssociative(string $data, array $selectorKeys)

• Clés standard PHP Array / Iterator uniquement (chaîne, entier).

 use IterTools  Single ;

$ starWarsEpisodes = [
    ' I '    => ' The Phantom Menace ' ,
    ' II '   => ' Attack of the Clones ' ,
    ' III '  => ' Revenge of the Sith ' ,
    ' IV '   => ' A New Hope ' ,
    ' V '    => ' The Empire Strikes Back ' ,
    ' VI '   => ' Return of the Jedi ' ,
    ' VII '  => ' The Force Awakens ' ,
    ' VIII ' => ' The Last Jedi ' ,
    ' IX '   => ' The Rise of Skywalker ' ,
];
$ originalTrilogyNumbers = [ ' IV ' , ' V ' , ' VI ' ];

foreach (Single:: compressAssociative ( $ starWarsEpisodes , $ originalTrilogyNumbers ) as $ episode => $ title ) {
    print ( " $ episode : $ title " .  PHP_EOL );
}
// IV: A New Hope
// V: The Empire Strikes Back
// VI: Return of the Jedi

Tomber pendant que

Déposez les éléments de l'itérable tandis que la fonction de prédicat est vraie.

Une fois que la fonction de prédicat renvoie false une fois, tous les éléments restants sont retournés.

Single::dropWhile(iterable $data, callable $predicate)

 use IterTools  Single ;

$ scores    = [ 50 , 60 , 70 , 85 , 65 , 90 ];
$ predicate = fn ( $ x ) => $ x < 70 ;

foreach (Single:: dropWhile ( $ scores , $ predicate ) as $ score ) {
    print ( $ score );
}
// 70, 85, 65, 90

Filtre

Filtrez les éléments de l'itément uniquement des éléments de retour où la fonction de prédicat est vraie.

Single::filter(iterable $data, callable $predicate)

 use IterTools  Single ;

$ starWarsEpisodes   = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ];
$ goodMoviePredicate = fn ( $ episode ) => $ episode > 3 && $ episode < 8 ;

foreach (Single:: filter ( $ starWarsEpisodes , $ goodMoviePredicate ) as $ goodMovie ) {
    print ( $ goodMovie );
}
// 4, 5, 6, 7

Filtre vrai

Filtrez les éléments des éléments de retour uniquement de retour uniquement.

Single::filterTrue(iterable $data)

 use IterTools  Single ;

$ reportCardGrades = [ 100 , 0 , 95 , 85 , 0 , 94 , 0 ];

foreach (Single:: filterTrue ( $ reportCardGrades ) as $ goodGrade ) {
    print ( $ goodGrade );
}
// 100, 95, 85, 94

Filtre faux

Filtrez les éléments de l'itément uniquement des éléments de retour où la fonction de prédicat est fausse.

Si aucun prédicat n'est fourni, la valeur booléenne des données est utilisée.

Single::filterFalse(iterable $data, callable $predicate)

 use IterTools  Single ;

$ alerts = [ 0 , 1 , 1 , 0 , 1 , 0 , 0 , 1 , 1 ];

foreach (Single:: filterFalse ( $ alerts ) as $ noAlert ) {
    print ( $ noAlert );
}
// 0, 0, 0, 0

Clés de filtre

Filtrez les éléments de l'itément des éléments de retour uniquement pour lesquels les clés La fonction de prédicat est vraie.

Single::filterKeys(iterable $data, callable $predicate)

 use IterTools  Single ;

$ olympics = [
    2000 => ' Sydney ' ,
    2002 => ' Salt Lake City ' ,
    2004 => ' Athens ' ,
    2006 => ' Turin ' ,
    2008 => ' Beijing ' ,
    2010 => ' Vancouver ' ,
    2012 => ' London ' ,
    2014 => ' Sochi ' ,
    2016 => ' Rio de Janeiro ' ,
    2018 => ' Pyeongchang ' ,
    2020 => ' Tokyo ' ,
    2022 => ' Beijing ' ,
];

$ summerFilter = fn ( $ year ) => $ year % 4 === 0 ;

foreach (Single:: filterKeys ( $ olympics , $ summerFilter ) as $ year => $ hostCity ) {
    print ( " $ year : $ hostCity " .  PHP_EOL );
}
// 2000: Sydney
// 2004: Athens
// 2008: Beijing
// 2012: London
// 2016: Rio de Janeiro
// 2020: Tokyo

Carte plate

Maptez une fonction uniquement les éléments de l'itérable, puis aplatissez les résultats.

Single::flatMap(iterable $data, callable $mapper)

 use IterTools  Single ;

$ data   = [ 1 , 2 , 3 , 4 , 5 ];
$ mapper = fn ( $ item ) => [ $ item , - $ item ];

foreach (Single:: flatMap ( $ data , $ mapper ) as $ number ) {
    print ( $ number . ' ' );
}
// 1 -1 2 -2 3 -3 4 -4 5 -5

Aplatir

Aplatir un itérable multidimensionnel.

Single::flatten(iterable $data, int $dimensions = 1)

 use IterTools  Single ;

$ multidimensional = [ 1 , [ 2 , 3 ], [ 4 , 5 ]];

$ flattened = [];
foreach (Single:: flatten ( $ multidimensional ) as $ number ) {
    $ flattened [] = $ number ;
}
// [1, 2, 3, 4, 5]

Se regrouper

Données de groupe par un élément de données commun.

Single::groupBy(iterable $data, callable $groupKeyFunction, callable $itemKeyFunction = null)

• Le $groupKeyFunction détermine la clé des éléments de groupe par.
• La Fonctionnelle $itemKeyFunction permet des index personnalisés au sein de chaque membre du groupe.

 use IterTools  Single ;

$ cartoonCharacters = [
    [ ' Garfield ' , ' cat ' ],
    [ ' Tom ' , ' cat ' ],
    [ ' Felix ' , ' cat ' ],
    [ ' Heathcliff ' , ' cat ' ],
    [ ' Snoopy ' , ' dog ' ],
    [ ' Scooby-Doo ' , ' dog ' ],
    [ ' Odie ' , ' dog ' ],
    [ ' Donald ' , ' duck ' ],
    [ ' Daffy ' , ' duck ' ],
];

$ charactersGroupedByAnimal = [];
foreach (Single:: groupBy ( $ cartoonCharacters , fn ( $ x ) => $ x [ 1 ]) as $ animal => $ characters ) {
    $ charactersGroupedByAnimal [ $ animal ] = $ characters ;
}
/*
'cat' => [
    ['Garfield', 'cat'],
    ['Tom', 'cat'],
    ['Felix', 'cat'],
    ['Heathcliff', 'cat'],
],
'dog' => [
    ['Snoopy', 'dog'],
    ['Scooby-Doo', 'dog'],
    ['Odie', 'dog'],
],
'duck' => [
    ['Donald', 'duck'],
    ['Daffy', 'duck'],
*/

Limite

Itérer jusqu'à une limite.

S'arrête même si plus de données disponibles si la limite atteint.

Single::limit(iterable $data, int $limit)

 use IterTools  Single ;

$ matrixMovies = [ ' The Matrix ' , ' The Matrix Reloaded ' , ' The Matrix Revolutions ' , ' The Matrix Resurrections ' ];
$ limit        = 1 ;

foreach (Single:: limit ( $ matrixMovies , $ limit ) as $ goodMovie ) {
    print ( $ goodMovie );
}
// 'The Matrix' (and nothing else)

Carte

Maptez une fonction sur chaque élément.

Single::map(iterable $data, callable $function)

 use IterTools  Single ;

$ grades               = [ 100 , 99 , 95 , 98 , 100 ];
$ strictParentsOpinion = fn ( $ g ) => $ g === 100 ? ' A ' : ' F ' ;

foreach (Single:: map ( $ grades , $ strictParentsOpinion ) as $ actualGrade ) {
    print ( $ actualGrade );
}
// A, F, F, F, A

Par paire

Renvoie des paires qui se chevauchent successives.

Renvoie un générateur vide si la collection donnée contient moins de 2 éléments.

Single::pairwise(iterable $data)

 use IterTools  Single ;

$ friends = [ ' Ross ' , ' Rachel ' , ' Chandler ' , ' Monica ' , ' Joey ' , ' Phoebe ' ];

foreach (Single:: pairwise ( $ friends ) as [ $ leftFriend , $ rightFriend ]) {
    print ( "{ $ leftFriend } and { $ rightFriend }" );
}
// Ross and Rachel, Rachel and Chandler, Chandler and Monica, ...

Répéter

Répéter un élément.

Single::repeat(mixed $item, int $repetitions)

 use IterTools  Single ;

$ data        = ' Beetlejuice ' ;
$ repetitions = 3 ;

foreach (Single:: repeat ( $ data , $ repetitions ) as $ repeated ) {
    print ( $ repeated );
}
// 'Beetlejuice', 'Beetlejuice', 'Beetlejuice'

Réindex

Reindex touches de la valeur clé itérable à l'aide de la fonction d'indexer.

Single::reindex(string $data, callable $indexer)

 use IterTools  Single ;

$ data = [
    [
        ' title '   => ' Star Wars: Episode IV – A New Hope ' ,
        ' episode ' => ' IV ' ,
        ' year '    => 1977 ,
    ],
    [
        ' title '   => ' Star Wars: Episode V – The Empire Strikes Back ' ,
        ' episode ' => ' V ' ,
        ' year '    => 1980 ,
    ],
    [
        ' title ' => ' Star Wars: Episode VI – Return of the Jedi ' ,
        ' episode ' => ' VI ' ,
        ' year ' => 1983 ,
    ],
];
$ reindexFunc = fn ( array $ swFilm ) => $ swFilm [ ' episode ' ];

$ reindexedData = [];
foreach (Single:: reindex ( $ data , $ reindexFunc ) as $ key => $ filmData ) {
    $ reindexedData [ $ key ] = $ filmData ;
}
// [
//     'IV' => [
//         'title'   => 'Star Wars: Episode IV – A New Hope',
//         'episode' => 'IV',
//         'year'    => 1977,
//     ],
//     'V' => [
//         'title'   => 'Star Wars: Episode V – The Empire Strikes Back',
//         'episode' => 'V',
//         'year'    => 1980,
//     ],
//     'VI' => [
//         'title' => 'Star Wars: Episode VI – Return of the Jedi',
//         'episode' => 'VI',
//         'year' => 1983,
//     ],
// ]

Inverse

Inverser les éléments d'un itérable.

Single::reverse(iterable $data)

 use IterTools  Single ;

$ words = [ ' Alice ' , ' answers ' , ' your ' , ' questions ' , ' Bob ' ];

foreach (Single:: reverse ( $ words ) as $ word ) {
    print ( $ word . ' ' );
}
// Bob questions your answers Alice

Sauter

Évitez les éléments n dans l'itérable après le décalage du décalage facultatif.

Single::skip(iterable $data, int $count, int $offset = 0)

 use IterTools  Single ;

$ movies = [
    ' The Phantom Menace ' , ' Attack of the Clones ' , ' Revenge of the Sith ' ,
    ' A New Hope ' , ' The Empire Strikes Back ' , ' Return of the Jedi ' ,
    ' The Force Awakens ' , ' The Last Jedi ' , ' The Rise of Skywalker '
];

$ prequelsRemoved = [];
foreach (Single:: skip ( $ movies , 3 ) as $ nonPrequel ) {
    $ prequelsRemoved [] = $ nonPrequel ;
} // Episodes IV - IX

$ onlyTheBest = [];
foreach (Single:: skip ( $ prequelsRemoved , 3 , 3 ) as $ nonSequel ) {
    $ onlyTheBest [] = $ nonSequel ;
}
// 'A New Hope', 'The Empire Strikes Back', 'Return of the Jedi'

Tranche

Extraire une tranche de l'itérable.

Single::slice(iterable $data, int $start = 0, int $count = null, int $step = 1)

 use IterTools  Single ;

$ olympics = [ 1992 , 1994 , 1996 , 1998 , 2000 , 2002 , 2004 , 2006 , 2008 , 2010 , 2012 , 2014 , 2016 , 2018 , 2020 , 2022 ];
$ winterOlympics = [];

foreach (Single:: slice ( $ olympics , 1 , 8 , 2 ) as $ winterYear ) {
    $ winterOlympics [] = $ winterYear ;
}
// [1994, 1998, 2002, 2006, 2010, 2014, 2018, 2022]

Chaîne

Itérer les caractères individuels d'une chaîne.

Single::string(string $string)

 use IterTools  Single ;

$ string = ' MickeyMouse ' ;

$ listOfCharacters = [];
foreach (Single:: string ( $ string ) as $ character ) {
    $ listOfCharacters [] = $ character ;
}
// ['M', 'i', 'c', 'k', 'e', 'y', 'M', 'o', 'u', 's', 'e']

Prendre

Retour des éléments de l'ITERAY tant que le prédicat est vrai.

Arrête l'itération dès que le prédicat revient faux, même si d'autres éléments plus tard reviendraient finalement (différent de filtertrue).

Single::takeWhile(iterable $data, callable $predicate)

 use IterTools  Single ;

$ prices = [ 0 , 0 , 5 , 10 , 0 , 0 , 9 ];
$ isFree = fn ( $ price ) => $ price == 0 ;

foreach (Single:: takeWhile ( $ prices , $ isFree ) as $ freePrice ) {
    print ( $ freePrice );
}
// 0, 0 

Itération infinie

Compter

Comptez séquentiellement pour toujours.

Infinite::count(int $start = 1, int $step = 1)

 use IterTools  Infinite ;

$ start = 1 ;
$ step  = 1 ;

foreach (Infinite:: count ( $ start , $ step ) as $ i ) {
    print ( $ i );
}
// 1, 2, 3, 4, 5 ...

Faire du vélo

Cycle à travers les éléments d'une collection séquentiellement pour toujours.

Infinite::cycle(iterable $iterable)

 use IterTools  Infinite ;

$ hands = [ ' rock ' , ' paper ' , ' scissors ' ];

foreach (Infinite:: cycle ( $ hands ) as $ hand ) {
    RockPaperScissors:: playHand ( $ hand );
}
// rock, paper, scissors, rock, paper, scissors, ...

Répéter (infini)

Répétez un élément pour toujours.

Infinite::repeat(mixed $item)

 use IterTools  Infinite ;

$ dialogue = ' Are we there yet? ' ;

foreach (Infinite:: repeat ( $ dialogue ) as $ repeated ) {
    print ( $ repeated );
}
// 'Are we there yet?', 'Are we there yet?', 'Are we there yet?', ... 

Itération aléatoire

Choix

Générez des sélections aléatoires à partir d'un tableau de valeurs.

Random::choice(array $items, int $repetitions)

 use IterTools  Random ;

$ cards       = [ ' Ace ' , ' King ' , ' Queen ' , ' Jack ' , ' Joker ' ];
$ repetitions = 10 ;

foreach (Random:: choice ( $ cards , $ repetitions ) as $ card ) {
    print ( $ card );
}
// 'King', 'Jack', 'King', 'Ace', ... [random]

Coïnal

Générez des flips de pièces aléatoires (0 ou 1).

Random::coinFlip(int $repetitions)

 use IterTools  Random ;

$ repetitions = 10 ;

foreach (Random:: coinFlip ( $ repetitions ) as $ coinFlip ) {
    print ( $ coinFlip );
}
// 1, 0, 1, 1, 0, ... [random]

Nombre

Générer des nombres aléatoires (entiers).

Random::number(int $min, int $max, int $repetitions)

 use IterTools  Random ;

$ min         = 1 ;
$ max         = 4 ;
$ repetitions = 10 ;

foreach (Random:: number ( $ min , $ max , $ repetitions ) as $ number ) {
    print ( $ number );
}
// 3, 2, 5, 5, 1, 2, ... [random]

Pourcentage

Générez un pourcentage aléatoire entre 0 et 1.

Random::percentage(int $repetitions)

 use IterTools  Random ;

$ repetitions = 10 ;

foreach (Random:: percentage ( $ repetitions ) as $ percentage ) {
    print ( $ percentage );
}
// 0.30205562629132, 0.59648594775233, ... [random]

Vitesses de roche

Générez les mains de caisseurs de papier rocheux aléatoires.

Random::rockPaperScissors(int $repetitions)

 use IterTools  Random ;

$ repetitions = 10 ;

foreach (Random:: rockPaperScissors ( $ repetitions ) as $ rpsHand ) {
    print ( $ rpsHand );
}
// 'paper', 'rock', 'rock', 'scissors', ... [random] 

Itération mathématique

Fréquences

Renvoie une distribution de fréquence des données.

Math::frequencies(iterable $data, bool $strict = true): Generator

Par défaut, des comparaisons de type stricte. Définissez Strict sur False pour les comparaisons de coercition de type.

 use IterTools  Math ;

$ grades = [ ' A ' , ' A ' , ' B ' , ' B ' , ' B ' , ' C ' ];

foreach (Math:: frequencies ( $ grades ) as $ grade => $ frequency ) {
    print ( " $ grade : $ frequency " .  PHP_EOL );
}
// A: 2, B: 3, C: 1

Fréquences relatives

Renvoie une distribution de fréquence relative des données.

Math::relativeFrequencies(iterable $data, bool $strict = true): Generator

Par défaut, des comparaisons de type stricte. Définissez Strict sur False pour les comparaisons de coercition de type.

 use IterTools  Math ;

$ grades = [ ' A ' , ' A ' , ' B ' , ' B ' , ' B ' , ' C ' ];

foreach (Math:: relativeFrequencies ( $ grades ) as $ grade => $ frequency ) {
    print ( " $ grade : $ frequency " .  PHP_EOL );
}
// A: 0.33, B: 0.5, C: 0.166

Moyenne de course

Accumuler la moyenne de course sur une liste de nombres.

Math::runningAverage(iterable $numbers, int|float $initialValue = null)

 use IterTools  Math ;

$ grades = [ 100 , 80 , 80 , 90 , 85 ];

foreach (Math:: runningAverage ( $ grades ) as $ runningAverage ) {
    print ( $ runningAverage );
}
// 100, 90, 86.667, 87.5, 87

Différence de course

Accumuler la différence de fonctionnement par rapport à une liste de nombres.

Math::runningDifference(iterable $numbers, int|float $initialValue = null)

 use IterTools  Math ;

$ credits = [ 1 , 2 , 3 , 4 , 5 ];

foreach (Math:: runningDifference ( $ credits ) as $ runningDifference ) {
    print ( $ runningDifference );
}
// -1, -3, -6, -10, -15

Fournissez une valeur initiale facultative pour mener la différence de course.

 use IterTools  Math ;

$ dartsScores   = [ 50 , 50 , 25 , 50 ];
$ startingScore = 501 ;

foreach (Math:: runningDifference ( $ dartsScores , $ startingScore ) as $ runningScore ) {
    print ( $ runningScore );
}
// 501, 451, 401, 376, 326

Running Max

Accumuler le maximum en cours d'exécution sur une liste de nombres.

Math::runningMax(iterable $numbers, int|float $initialValue = null)

 use IterTools  Math ;

$ numbers = [ 1 , 2 , 1 , 3 , 5 ];

foreach (Math:: runningMax ( $ numbers ) as $ runningMax ) {
    print ( $ runningMax );
}
// 1, 2, 2, 3, 5

Running Min

Accumuler le minimum en cours d'exécution sur une liste de nombres.

Math::runningMin(iterable $numbers, int|float $initialValue = null)

 use IterTools  Math ;

$ numbers = [ 3 , 4 , 2 , 5 , 1 ];

foreach (Math:: runningMin ( $ numbers ) as $ runningMin ) {
    print ( $ runningMin );
}
// 3, 3, 2, 2, 1

Produit en cours d'exécution

Accumuler le produit en cours d'exécution sur une liste de nombres.

Math::runningProduct(iterable $numbers, int|float $initialValue = null)

 use IterTools  Math ;

$ numbers = [ 1 , 2 , 3 , 4 , 5 ];

foreach (Math:: runningProduct ( $ numbers ) as $ runningProduct ) {
    print ( $ runningProduct );
}
// 1, 2, 6, 24, 120

Fournissez une valeur initiale facultative pour mener le produit en cours d'exécution.

 use IterTools  Math ;

$ numbers      = [ 1 , 2 , 3 , 4 , 5 ];
$ initialValue = 5 ;

foreach (Math:: runningProduct ( $ numbers , $ initialValue ) as $ runningProduct ) {
    print ( $ runningProduct );
}
// 5, 5, 10, 30, 120, 600

Total de course

Accumuler le total de course sur une liste de nombres.

Math::runningTotal(iterable $numbers, int|float $initialValue = null)

 use IterTools  Math ;

$ prices = [ 1 , 2 , 3 , 4 , 5 ];

foreach (Math:: runningTotal ( $ prices ) as $ runningTotal ) {
    print ( $ runningTotal );
}
// 1, 3, 6, 10, 15

Fournissez une valeur initiale facultative pour mener le total en cours d'exécution.

 use IterTools  Math ;

$ prices       = [ 1 , 2 , 3 , 4 , 5 ];
$ initialValue = 5 ;

foreach (Math:: runningTotal ( $ prices , $ initialValue ) as $ runningTotal ) {
    print ( $ runningTotal );
}
// 5, 6, 8, 11, 15, 20 

Set et multiset

Distinct

Filtrez les éléments de l'Iitable ne renvoyant que des éléments distincts.

Set::distinct(iterable $data, bool $strict = true)

Par défaut, des comparaisons de type stricte. Définissez Strict sur False pour les comparaisons de coercition de type.

 use IterTools  Set ;

$ chessSet = [ ' rook ' , ' rook ' , ' knight ' , ' knight ' , ' bishop ' , ' bishop ' , ' king ' , ' queen ' , ' pawn ' , ' pawn ' , ... ];

foreach (Set:: distinct ( $ chessSet ) as $ chessPiece ) {
    print ( $ chessPiece );
}
// rook, knight, bishop, king, queen, pawn

$ mixedTypes = [ 1 , ' 1 ' , 2 , ' 2 ' , 3 ];

foreach (Set:: distinct ( $ mixedTypes , false ) as $ datum ) {
    print ( $ datum );
}
// 1, 2, 3

Distinct par

Filtrez les éléments de l'itérable ne renvoyant que des éléments distincts selon une fonction de comparateur personnalisée.

Set::distinctBy(iterable $data, callable $compareBy)

 use IterTools  Set ;

$ streetFighterConsoleReleases = [
    [ ' id ' => ' 112233 ' , ' name ' => ' Street Fighter 3 3rd Strike ' , ' console ' => ' Dreamcast ' ],
    [ ' id ' => ' 223344 ' , ' name ' => ' Street Fighter 3 3rd Strike ' , ' console ' => ' PS4 ' ],
    [ ' id ' => ' 334455 ' , ' name ' => ' Street Fighter 3 3rd Strike ' , ' console ' => ' PS5 ' ],
    [ ' id ' => ' 445566 ' , ' name ' => ' Street Fighter VI ' , ' console ' => ' PS4 ' ],
    [ ' id ' => ' 556677 ' , ' name ' => ' Street Fighter VI ' , ' console ' => ' PS5 ' ],
    [ ' id ' => ' 667788 ' , ' name ' => ' Street Fighter VI ' , ' console ' => ' PC ' ],
];
$ compareBy = fn ( $ sfTitle ) => $ sfTitle [ ' name ' ];

$ uniqueTitles = [];
foreach (Set:: distinctBy ( $ streetFighterConsoleReleases , $ compareBy ) as $ sfTitle ) {
    $ uniqueTitles [] = $ sfTitle ;
}

// Contains one SF3 3rd Strike entry and one SFVI entry.

Intersection

Iterates intersection des itérables.

Set::intersection(iterable ...$iterables)

Si les itérables d'entrée produisent des éléments en double, les règles d'intersection multiset s'appliquent.

 use IterTools  Set ;

$ chessPieces = [ ' rook ' , ' knight ' , ' bishop ' , ' queen ' , ' king ' , ' pawn ' ];
$ shogiPieces = [ ' rook ' , ' knight ' , ' bishop ' 'king', ' pawn ' , ' lance ' , ' gold general ' , ' silver general ' ];

foreach (Set:: intersection ( $ chessPieces , $ shogiPieces ) as $ commonPiece ) {
    print ( $ commonPiece );
}
// rook, knight, bishop, king, pawn

Intersection coercitive

Iterate intersection des itérables en utilisant la coercition de type.

Set::intersectionCoercive(iterable ...$iterables)

Si les itérables d'entrée produisent des éléments en double, les règles d'intersection multiset s'appliquent.

 use IterTools  Set ;

$ numbers  = [ 1 , 2 , 3 , 4 , 5 ];
$ numerics = [ ' 1 ' , ' 2 ' , 3 ];

foreach (Set:: intersectionCoercive ( $ numbers , $ numerics ) as $ commonNumber ) {
    print ( $ commonNumber );
}
// 1, 2, 3

Intersection partielle

Iterate l'intersection m-sartiale des itérables.

Set::partialIntersection(int $minIntersectionCount, iterable ...$iterables)

• Si les itérables d'entrée produisent des éléments en double, les règles d'intersection multiset s'appliquent.

 use IterTools  Set ;

$ staticallyTyped    = [ ' c++ ' , ' java ' , ' c# ' , ' go ' , ' haskell ' ];
$ dynamicallyTyped   = [ ' php ' , ' python ' , ' javascript ' , ' typescript ' ];
$ supportsInterfaces = [ ' php ' , ' java ' , ' c# ' , ' typescript ' ];

foreach (Set:: partialIntersection ( 2 , $ staticallyTyped , $ dynamicallyTyped , $ supportsInterfaces ) as $ language ) {
    print ( $ language );
}
// c++, java, c#, go, php

Intersection partielle coercitive

Iterate l'intersection m-sartiale des itérables en utilisant la coercition de type.

Set::partialIntersectionCoercive(int $minIntersectionCount, iterable ...$iterables)

• Si les itérables d'entrée produisent des éléments en double, les règles d'intersection multiset s'appliquent.

 use IterTools  Set ;

$ set1 = [ 1 , 2 , 3 ],
$ set2 = [ ' 2 ' , ' 3 ' , 4 , 5 ],
$ set3 = [ 1 , ' 2 ' ],

foreach (Set:: partialIntersectionCoercive ( 2 , $ set1 , $ set2 , $ set3 ) as $ partiallyCommonNumber ) {
    print ( $ partiallyCommonNumber );
}
// 1, 2, 3

Différence symétrique

Itera la différence symétrique des itérables.

Set::symmetricDifference(iterable ...$iterables)

Si les itérables d'entrée produisent des éléments en double, les règles de différence multiset s'appliquent.

 use IterTools  Set ;

$ a = [ 1 , 2 , 3 , 4 , 7 ];
$ b = [ ' 1 ' , 2 , 3 , 5 , 8 ];
$ c = [ 1 , 2 , 3 , 6 , 9 ];

foreach (Set:: symmetricDifference ( $ a , $ b , $ c ) as $ item ) {
    print ( $ item );
}
// 1, 4, 5, 6, 7, 8, 9

Différence symétrique coercitive

Itera la différence symétrique des itérables avec la coercition de type.

Set::symmetricDifferenceCoercive(iterable ...$iterables)

Si les itérables d'entrée produisent des éléments en double, les règles de différence multiset s'appliquent.

 use IterTools  Set ;

$ a = [ 1 , 2 , 3 , 4 , 7 ];
$ b = [ ' 1 ' , 2 , 3 , 5 , 8 ];
$ c = [ 1 , 2 , 3 , 6 , 9 ];

foreach (Set:: symmetricDifferenceCoercive ( $ a , $ b , $ c ) as $ item ) {
    print ( $ item );
}
// 4, 5, 6, 7, 8, 9

Union

Itera l'union des itérables.

Set::union(iterable ...$iterables)

Si les itérables d'entrée produisent des éléments en double, les règles de l'Union multiset s'appliquent.

 use IterTools  Set ;

$ a = [ 1 , 2 , 3 ];
$ b = [ 3 , 4 ];
$ c = [ 1 , 2 , 3 , 6 , 7 ];

foreach (Set:: union ( $ a , $ b , $ c ) as $ item ) {
    print ( $ item );
}
//1, 2, 3, 4, 6, 7

Union coercitive

Itère l'union des itérables avec la coercition de type.

Set::unionCoercive(iterable ...$iterables)

Si les itérables d'entrée produisent des éléments en double, les règles de l'Union multiset s'appliquent.

 use IterTools  Set ;

$ a = [ ' 1 ' , 2 , 3 ];
$ b = [ 3 , 4 ];
$ c = [ 1 , 2 , 3 , 6 , 7 ];

foreach (Set:: unionCoercive ( $ a , $ b , $ c ) as $ item ) {
    print ( $ item );
}
//1, 2, 3, 4, 6, 7 

Trier itération

Asorter

Itérer la collection triée tout en maintenant les relations associatives de l'indice des clés.

Sort::sort(iterable $data, callable $comparator = null)

Utilise le tri par défaut si la fonction de comparateur facultative non fournie.

 use IterTools  Single ;

$ worldPopulations = [
    ' China '     => 1_439_323_776 ,
    ' India '     => 1_380_004_385 ,
    ' Indonesia ' => 273_523_615 ,
    ' Pakistan '  => 220_892_340 ,
    ' USA '       => 331_002_651 ,
];

foreach (Sort:: sort ( $ worldPopulations ) as $ country => $ population ) {
    print ( " $ country : $ population " .  PHP_EOL );
}
// Pakistan: 220,892,340
// Indonesia: 273,523,615
// USA: 331,002,651
// India: 1,380,004,385
// China: 1,439,323,776

Trier

Itérer la collection triée.

Sort::sort(iterable $data, callable $comparator = null)

Utilise le tri par défaut si la fonction de comparateur facultative non fournie.

 use IterTools  Single ;

$ data = [ 3 , 4 , 5 , 9 , 8 , 7 , 1 , 6 , 2 ];

foreach (Sort:: sort ( $ data ) as $ datum ) {
    print ( $ datum );
}
// 1, 2, 3, 4, 5, 6, 7, 8, 9 

Déposer

Lire CSV

Itérer les lignes d'un fichier CSV.

File::readCsv(resource $fileHandle, string $separator = ',', string $enclosure = '"', string $escape = '\')

 use IterTools  File ;

$ fileHandle = fopen ( ' path/to/file.csv ' , ' r ' );

foreach (File:: readCsv ( $ fileHandle ) as $ row ) {
    print_r ( $ row );
}
// Each column field is an element of the array

LIRE LIGNES

Itérer les lignes d'un fichier.

File::readLines(resource $fileHandle)

 use IterTools  File ;

$ fileHandle = fopen ( ' path/to/file.txt ' , ' r ' );

foreach (File:: readLines ( $ fileHandle ) as $ line ) {
    print ( $ line );
}

Transformer

Tee

Renvoyez plusieurs itérateurs indépendants (dupliqués) d'un seul itérable.

Transform::tee(iterable $data, int $count): array

 use IterTools  Transform ;

$ daysOfWeek = [ ' Mon ' , ' Tues ' , ' Wed ' , ' Thurs ' , ' Fri ' , ' Sat ' , ' Sun ' ];
$ count = 3 ;

[ $ week1 , $ week2 , $ week3 ] = Transform:: tee ( $ data , $ count );
// Each $week contains iterator containing ['Mon', 'Tues', 'Wed', 'Thurs', 'Fri', 'Sat', 'Sun']

À la table

Transforme tout itérable en un tableau.

Transform::toArray(iterable $data): array

 use IterTools  Transform ;

$ iterator = new  ArrayIterator ([ 1 , 2 , 3 , 4 , 5 ]);

$ array = Transform:: toArray ( $ iterator );

À un tableau associatif

Transforme tout itérable en un tableau associatif.

Transform::toAssociativeArray(iterable $data, callable $keyFunc = null, callable $valueFunc = null): array

 use IterTools  Transform ;

$ messages = [ ' message 1 ' , ' message 2 ' , ' message 3 ' ];

$ keyFunc   = fn ( $ msg ) => md5 ( $ msg );
$ valueFunc = fn ( $ msg ) => strtoupper ( $ msg );

$ associativeArray = Transform:: toAssociativeArray ( $ messages , $ keyFunc , $ valueFunc );
// [
//     '1db65a6a0a818fd39655b95e33ada11d' => 'MESSAGE 1',
//     '83b2330607fe8f817ce6d24249dea373' => 'MESSAGE 2',
//     '037805d3ad7b10c5b8425427b516b5ce' => 'MESSAGE 3',
// ]

À itérateur

Transforme tout itérable en un itérateur.

Transform::toArray(iterable $data): array

 use IterTools  Transform ;

$ array = [ 1 , 2 , 3 , 4 , 5 ];

$ iterator = Transform:: toIterator ( $ array );

Résumé

Tout match

Renvoie True si tous les éléments correspondent à la fonction de prédicat.

Summary::allMatch(iterable $data, callable $predicate): bool

 use IterTools  Summary ;

$ finalFantasyNumbers = [ 4 , 5 , 6 ];
$ isOnSuperNintendo   = fn ( $ ff ) => $ ff >= 4 && $ ff <= 6 ;

$ boolean = Summary:: allMatch ( $ finalFantasyNumbers , $ isOnSuperNintendo );
// true

$ isOnPlaystation = fn ( $ ff ) => $ ff >= 7 && $ ff <= 9 ;

$ boolean = Summary:: allMatch ( $ finalFantasyNumbers , $ isOnPlaystation );
// false

Tous uniques

Renvoie vrai si tous les éléments sont uniques.

Summary::allUnique(iterable $data, bool $strict = true): bool

Par défaut, des comparaisons de type stricte. Définissez Strict sur False pour les comparaisons de coercition de type.

 use IterTools  Summary ;

$ items = [ ' fingerprints ' , ' snowflakes ' , ' eyes ' , ' DNA ' ]

$ boolean = Summary:: allUnique ( $ items );
// true

Toute match

Renvoie True si un élément correspond à la fonction de prédicat.

Summary::anyMatch(iterable $data, callable $predicate): bool

 use IterTools  Summary ;

$ answers          = [ ' fish ' , ' towel ' , 42 , " don't panic " ];
$ isUltimateAnswer = fn ( $ a ) => a == 42 ;

$ boolean = Summary:: anyMatch ( $ answers , $ isUltimateAnswer );
// true

Sont des permutations

Renvoie True si toutes les iterables sont des permutations les uns des autres.

Summary::arePermutations(iterable ...$iterables): bool

 use IterTools  Summary ;

$ iter = [ ' i ' , ' t ' , ' e ' , ' r ' ];
$ rite = [ ' r ' , ' i ' , ' t ' , ' e ' ];
$ reit = [ ' r ' , ' e ' , ' i ' , ' t ' ];
$ tier = [ ' t ' , ' i ' , ' e ' , ' r ' ];
$ tire = [ ' t ' , ' i ' , ' r ' , ' e ' ];
$ trie = [ ' t ' , ' r ' , ' i ' , ' e ' ];

$ boolean = Summary:: arePermutations ( $ iter , $ rite , $ reit , $ tier , $ tire , $ trie );
// true

Les permutations sont-elles coercitives

Renvoie True si toutes les itérables sont des permutations les unes des autres avec la coercition de type.

Summary::arePermutationsCoercive(iterable ...$iterables): bool

 use IterTools  Summary ;

$ set1 = [ 1 , 2.0 , ' 3 ' ];
$ set2 = [ 2.0 , ' 1 ' , 3 ];
$ set3 = [ 3 , 2 , 1 ];

$ boolean = Summary:: arePermutationsCoercive ( $ set1 , $ set2 , $ set3 );
// true

Exactement n

Renvoie True si exactement n éléments sont vrais selon une fonction de prédicat.

• Le prédicat est facultatif.
• Le prédicat par défaut est la valeur booléenne de chaque élément.

Summary::exactlyN(iterable $data, int $n, callable $predicate): bool

 use IterTools  Summary ;

$ twoTruthsAndALie = [ true , true , false ];
$ n                = 2 ;

$ boolean = Summary:: exactlyN ( $ twoTruthsAndALie , $ n );
// true

$ ages      = [ 18 , 21 , 24 , 54 ];
$ n         = 4 ;
$ predicate = fn ( $ age ) => $ age >= 21 ;

$ boolean = Summary:: exactlyN ( $ ages , $ n , $ predicate );
// false

Est vide

Renvoie True si l'itérable est vide n'ayant pas d'articles.

Summary::isEmpty(iterable $data): bool

 use IterTools  Summary ;

$ data = []

$ boolean = Summary:: isEmpty ( $ data );
// true

Est partitionné

Renvoie True si tous les éléments de la collection donnée qui satisfont le prédicat apparaissent devant tous les éléments qui ne le font pas.

• Renvoie True pour la collection vide ou pour la collection avec un seul élément.
• Le prédicat par défaut s'il n'est pas fourni est la valeur booléenne de chaque élément de données.

Summary::isPartitioned(iterable $data, callable $predicate = null): bool

 use IterTools  Summary ;

$ numbers          = [ 0 , 2 , 4 , 1 , 3 , 5 ];
$ evensBeforeOdds = fn ( $ item ) => $ item % 2 === 0 ;

$ boolean = Summary:: isPartitioned ( $ numbers , $ evensBeforeOdds );

Est trié

Renvoie True si les éléments sont triés, sinon faux.

• Les éléments doivent être comparables.
• Renvoie True si vide ou n'a qu'un seul élément.

Summary::isSorted(iterable $data): bool

 use IterTools  Summary ;

$ numbers = [ 1 , 2 , 3 , 4 , 5 ];

$ boolean = Summary:: isSorted ( $ numbers );
// true

$ numbers = [ 3 , 2 , 3 , 4 , 5 ];

$ boolean = Summary:: isSorted ( $ numbers );
// false

Est inversé

Renvoie True si les éléments sont triés inversés, sinon faux.

• Les éléments doivent être comparables.
• Renvoie True si vide ou n'a qu'un seul élément.

Summary::isReversed(iterable $data): bool

 use IterTools  Summary ;

$ numbers = [ 5 , 4 , 3 , 2 , 1 ];

$ boolean = Summary:: isReversed ( $ numbers );
// true

$ numbers = [ 1 , 4 , 3 , 2 , 1 ];

$ boolean = Summary:: isReversed ( $ numbers );
// false

Aucun ne correspond

Renvoie True si aucun élément correspond à la fonction de prédicat.

Summary::noneMatch(iterable $data, callable $predicate): bool

 use IterTools  Summary ;

$ grades         = [ 45 , 50 , 61 , 0 ];
$ isPassingGrade = fn ( $ grade ) => $ grade >= 70 ;

$ boolean = Summary:: noneMatch ( $ grades , $ isPassingGrade );
// true

Même

Renvoie True si toutes les collections données sont les mêmes.

Pour la liste des itérables itérable ou vide unique renvoie true.

Summary::same(iterable ...$iterables): bool

 use IterTools  Summary ;

$ cocaColaIngredients = [ ' carbonated water ' , ' sugar ' , ' caramel color ' , ' phosphoric acid ' ];
$ pepsiIngredients    = [ ' carbonated water ' , ' sugar ' , ' caramel color ' , ' phosphoric acid ' ];

$ boolean = Summary:: same ( $ cocaColaIngredients , $ pepsiIngredients );
// true

$ cocaColaIngredients = [ ' carbonated water ' , ' sugar ' , ' caramel color ' , ' phosphoric acid ' ];
$ spriteIngredients   = [ ' carbonated water ' , ' sugar ' , ' citric acid ' , ' lemon lime flavorings ' ];

$ boolean = Summary:: same ( $ cocaColaIngredients , $ spriteIngredients );
// false

Même décompte

Renvoie True si toutes les collections données ont les mêmes longueurs.

Pour la liste des itérables itérable ou vide unique renvoie true.

Summary::sameCount(iterable ...$iterables): bool

 use IterTools  Summary ;

$ prequels  = [ ' Phantom Menace ' , ' Attack of the Clones ' , ' Revenge of the Sith ' ];
$ originals = [ ' A New Hope ' , ' Empire Strikes Back ' , ' Return of the Jedi ' ];
$ sequels   = [ ' The Force Awakens ' , ' The Last Jedi ' , ' The Rise of Skywalker ' ];

$ boolean = Summary:: sameCount ( $ prequels , $ originals , $ sequels );
// true

$ batmanMovies = [ ' Batman Begins ' , ' The Dark Knight ' , ' The Dark Knight Rises ' ];
$ matrixMovies = [ ' The Matrix ' , ' The Matrix Reloaded ' , ' The Matrix Revolutions ' , ' The Matrix Resurrections ' ];

$ result = Summary:: sameCount ( $ batmanMovies , $ matrixMovies );
// false 

Réduire

À la moyenne

Réduit à la moyenne moyenne.

Renvoie null si la collection est vide.

Reduce::toAverage(iterable $data): float

 use IterTools  Reduce ;

$ grades = [ 100 , 90 , 95 , 85 , 94 ];

$ finalGrade = Reduce:: toAverage ( $ numbers );
// 92.8

Compter

Réduit itérable à sa longueur.

Reduce::toCount(iterable $data): int

 use IterTools  Reduce ;

$ someIterable = ImportantThing:: getCollectionAsIterable ();

$ length = Reduce:: toCount ( $ someIterable );
// 3

Pour d'abord

Réduit itérable à son premier élément.

Reduce::toFirst(iterable $data): mixed

Lance LengthException si la collection est vide.

 use IterTools  Reduce ;

$ medals = [ ' gold ' , ' silver ' , ' bronze ' ];

$ first = Reduce:: toFirst ( $ medals );
// gold

Au premier et au dernier

Réduit itérable à ses premiers et derniers éléments.

Reduce::toFirstAndLast(iterable $data): array{mixed, mixed}

Lance LengthException si la collection est vide.

 use IterTools  Reduce ;

$ weekdays = [ ' Monday ' , ' Tuesday ' , ' Wednesday ' , ' Thursday ' , ' Friday ' ];

$ firstAndLast = Reduce:: toFirstAndLast ( $ weekdays );
// [Monday, Friday]

Pour durer

Réduit itérable à son dernier élément.

Reduce::toLast(iterable $data): mixed

Lance LengthException si la collection est vide.

 use IterTools  Reduce ;

$ gnomesThreePhasePlan = [ ' Collect underpants ' , ' ? ' , ' Profit ' ];

$ lastPhase = Reduce:: toLast ( $ gnomesThreePhasePlan );
// Profit

À max

Réduit à la valeur maximale.

Reduce::toMax(iterable $data, callable $compareBy = null): mixed|null

• PARAM CALLable Facultatif $compareBy doit renvoyer une valeur comparable.
• Si $compareBy n'est pas fourni, les éléments de la collection donnés doivent être comparables.
• Renvoie null si la collection est vide.

 use IterTools  Reduce ;

$ numbers = [ 5 , 3 , 1 , 2 , 4 ];

$ result = Reduce:: toMax ( $ numbers );
// 5

$ movieRatings = [
    [
        ' title ' => ' Star Wars: Episode IV - A New Hope ' ,
        ' rating ' => 4.6
    ],
    [
        ' title ' => ' Star Wars: Episode V - The Empire Strikes Back ' ,
        ' rating ' => 4.8
    ],
    [
        ' title ' => ' Star Wars: Episode VI - Return of the Jedi ' ,
        ' rating ' => 4.6
    ],
];
$ compareBy = fn ( $ movie ) => $ movie [ ' rating ' ];

$ highestRatedMovie = Reduce:: toMax ( $ movieRatings , $ compareBy );
// [
//     'title' => 'Star Wars: Episode V - The Empire Strikes Back',
//     'rating' => 4.8
// ];

À min

Réduit la valeur min.

Reduce::toMin(iterable $data, callable $compareBy = null): mixed|null

• PARAM CALLable Facultatif $compareBy doit renvoyer une valeur comparable.
• Si $compareBy n'est pas fourni, les éléments de la collection donnés doivent être comparables.
• Renvoie null si la collection est vide.

 use IterTools  Reduce ;

$ numbers = [ 5 , 3 , 1 , 2 , 4 ];

$ result = Reduce:: toMin ( $ numbers );
// 1


$ movieRatings = [
    [
        ' title ' => ' The Matrix ' ,
        ' rating ' => 4.7
    ],
    [
        ' title ' => ' The Matrix Reloaded ' ,
        ' rating ' => 4.3
    ],
    [
        ' title ' => ' The Matrix Revolutions ' ,
        ' rating ' => 3.9
    ],
    [
        ' title ' => ' The Matrix Resurrections ' ,
        ' rating ' => 2.5
    ],
];
$ compareBy = fn ( $ movie ) => $ movie [ ' rating ' ];

$ lowestRatedMovie = Reduce:: toMin ( $ movieRatings , $ compareBy );
// [
//     'title' => 'The Matrix Resurrections',
//     'rating' => 2.5
// ]

À min max

Réduit à la table de ses limites supérieure et inférieure (max et min).

Reduce::toMinMax(iterable $numbers, callable $compareBy = null): array

• PARAM CALLable Facultatif $compareBy doit renvoyer une valeur comparable.
• Si $compareBy n'est pas fourni, les éléments de la collection donnés doivent être comparables.
• Renvoie [null, null] Si la collection donnée est vide.

 use IterTools  Reduce ;

$ numbers = [ 1 , 2 , 7 , - 1 , - 2 , - 3 ];

[ $ min , $ max ] = Reduce:: toMinMax ( $ numbers );
// [-3, 7]

$ reportCard = [
    [
        ' subject ' => ' history ' ,
        ' grade ' => 90
    ],
    [
        ' subject ' => ' math ' ,
        ' grade ' => 98
    ],
    [
        ' subject ' => ' science ' ,
        ' grade ' => 92
    ],
    [
        ' subject ' => ' english ' ,
        ' grade ' => 85
    ],
    [
        ' subject ' => ' programming ' ,
        ' grade ' => 100
    ],
];
$ compareBy = fn ( $ class ) => $ class [ ' grade ' ];

$ bestAndWorstSubject = Reduce:: toMinMax ( $ reportCard , $ compareBy );
// [
//     [
//         'subject' => 'english',
//         'grade' => 85
//     ],
//     [
//         'subject' => 'programming',
//         'grade' => 100
//     ],
// ]

À la norme

Réduit la valeur en première position.

Reduce::toNth(iterable $data, int $position): mixed

 use IterTools  Reduce ;

$ lotrMovies = [ ' The Fellowship of the Ring ' , ' The Two Towers ' , ' The Return of the King ' ];

$ rotk = Reduce:: toNth ( $ lotrMovies , 2 );
// 20

Au produit

Réduit le produit de ses éléments.

Renvoie null si la collection est vide.

Reduce::toProduct(iterable $data): number|null

 use IterTools  Reduce ;

$ primeFactors = [ 5 , 2 , 2 ];

$ number = Reduce:: toProduct ( $ primeFactors );
// 20

À une valeur aléatoire

Réduit la collecte donnée à une valeur aléatoire en lui.

Reduce::toRandomValue(iterable $data): mixed

 use IterTools  Reduce ;

$ sfWakeupOptions = [ ' mid ' , ' low ' , ' overhead ' , ' throw ' , ' meaty ' ];

$ wakeupOption = Reduce:: toRandomValue ( $ sfWakeupOptions );
// e.g., throw

Pour aller

Réduit la collection donnée à sa gamme (différence entre max et min).

Reduce::toRange(iterable $numbers): int|float

Renvoie 0 si la source itérable est vide.

 use IterTools  Reduce ;

$ grades = [ 100 , 90 , 80 , 85 , 95 ];

$ range = Reduce:: toRange ( $ numbers );
// 20

À la chaîne

Réduit à une chaîne qui joint tous les éléments.

• Séparateur facultatif à insérer entre les éléments.
• Préfixe facultatif pour représenter la chaîne.
• Suffixe facultatif pour ajouter à la chaîne.

Reduce::toString(iterable $data, string $separator = '', string $prefix = '', string $suffix = ''): string

 use IterTools  Reduce ;

$ words = [ ' IterTools ' , ' PHP ' , ' v1.0 ' ];

$ string = Reduce:: toString ( $ words );
// IterToolsPHPv1.0
$ string = Reduce:: toString ( $ words , ' - ' );
// IterTools-PHP-v1.0
$ string = Reduce:: toString ( $ words , ' - ' , ' Library: ' );
// Library: IterTools-PHP-v1.0
$ string = Reduce:: toString ( $ words , ' - ' , ' Library: ' , ' ! ' );
// Library: IterTools-PHP-v1.0!

Pour résumer

Réduit la somme de ses éléments.

Reduce::toSum(iterable $data): number

 use IterTools  Reduce ;

$ parts = [ 10 , 20 , 30 ];

$ sum = Reduce:: toSum ( $ parts );
// 60

Pour évaluer

Réduisez les éléments en une seule valeur à l'aide de la fonction réductrice.

Reduce::toValue(iterable $data, callable $reducer, mixed $initialValue): mixed

 use IterTools  Reduce ;

$ input = [ 1 , 2 , 3 , 4 , 5 ];
$ sum   = fn ( $ carry , $ item ) => $ carry + $ item ;

$ result = Reduce:: toValue ( $ input , $ sum , 0 );
// 15 

Flux

Les flux fournissent une interface fluide pour transformer les tableaux et les itérables via un pipeline d'opérations.

Les flux sont composés de:

1. Une méthode d'usine de source de flux pour créer le flux.
2. Zéro ou plus d'opérateurs de flux qui transforment le flux en un nouveau flux.
3. Fonctionnement du terminal de soit:
   • Fonctionnement du terminal de flux pour transformer le flux en valeur ou structure de données.

    $ result = Stream:: of ([ 1 , 1 , 2 , 2 , 3 , 4 , 5 ])
      -> distinct ()                  // [1, 2, 3, 4, 5]
      -> map ( fn ( $ x ) => $ x ** 2 )       // [1, 4, 9, 16, 25]
      -> filter ( fn ( $ x ) => $ x < 10 )  // [1, 4, 9]
      -> toSum ();                    // 14

   • Le flux est itéré via une boucle foreach .

    $ result = Stream:: of ([ 1 , 1 , 2 , 2 , 3 , 4 , 5 ])
      -> distinct ()                  // [1, 2, 3, 4, 5]
      -> map ( fn ( $ x ) => $ x ** 2 )       // [1, 4, 9, 16, 25]
      -> filter ( fn ( $ x ) => $ x < 10 ); // [1, 4, 9]
   
   foreach ( $ result as $ item ) {
       // 1, 4, 9
   }

Stream Sources

De

Crée du flux à partir d'un itérable.

Stream::of(iterable $iterable): Stream

 use IterTools  Stream ;

$ iterable = [ 1 , 2 , 3 ];

$ result = Stream:: of ( $ iterable )
    -> chainWith ([ 4 , 5 , 6 ], [ 7 , 8 , 9 ])
    -> zipEqualWith ([ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ])
    -> toValue ( fn ( $ carry , $ item ) => $ carry + array_sum ( $ item ));
// 90 

De flips de monnaie

Crée un flux de n flips de pièces aléatoires.

Stream::ofCoinFlips(int $repetitions): Stream

 use IterTools  Stream ;

$ result = Stream:: ofCoinFlips ( 10 )
    -> filterTrue ()
    -> toCount ();
// 5 (random) 

Du fichier csv

Crée un flux de lignes d'un fichier CSV.

Stream::ofCsvFile(resource $fileHandle, string $separator = ',', string $enclosure = '"', string = $escape = '\'): Stream

 use IterTools  Stream ;

$ fileHandle = fopen ( ' path/to/file.csv ' , ' r ' );

$ result = Stream:: of ( $ fileHandle )
    -> toArray ();

De vide

Crée un flux de rien.

Stream::ofEmpty(): Stream

 use IterTools  Stream ;

$ result = Stream:: ofEmpty ()
    -> chainWith ([ 1 , 2 , 3 ])
    -> toArray ();
// 1, 2, 3 

Des lignes de fichiers

Crée un flux de lignes d'un fichier.

Stream::ofFileLines(resource $fileHandle): Stream

 use IterTools  Stream ;

$ fileHandle = fopen ( ' path/to/file.txt ' , ' r ' );

$ result = Stream:: of ( $ fileHandle )
    -> map ( ' strtoupper ' );
    -> toArray ();

De choix aléatoire

Crée un flux de sélections aléatoires à partir d'un tableau de valeurs.

Stream::ofRandomChoice(array $items, int $repetitions): Stream

 use IterTools  Stream ;

$ languages = [ ' PHP ' , ' Go ' , ' Python ' ];

$ languages = Stream:: ofRandomChoice ( $ languages , 5 )
    -> toArray ();
// 'Go', 'PHP', 'Python', 'PHP', 'PHP' (random) 

De nombres aléatoires

Crée un flux de nombres aléatoires (entiers).

Stream::ofRandomNumbers(int $min, int $max, int $repetitions): Stream

 use IterTools  Stream ;

$ min  = 1 ;
$ max  = 3 ;
$ reps = 7 ;

$ result = Stream:: ofRandomNumbers ( $ min , $ max , $ reps )
    -> toArray ();
// 1, 2, 2, 1, 3, 2, 1 (random) 

De pourcentage aléatoire

Crée un flux de pourcentages aléatoires entre 0 et 1.

Stream::ofRandomPercentage(int $repetitions): Stream

 use IterTools  Stream ;

$ stream = Stream:: ofRandomPercentage ( 3 )
    -> toArray ();
// 0.8012566976245, 0.81237281724151, 0.61676896329459 [random] 

De portée

Crée un flux d'une gamme de nombres.

Stream::ofRange(int|float $start, int|float $end, int|float $step = 1): Stream

 use IterTools  Stream ;

$ numbers = Stream:: ofRange ( 0 , 5 )
    -> toArray ();
// 0, 1, 2, 3, 4, 5 

De ciseaux en papier rocheux

Crée un flux de mains-scisseurs de papier rocheux.

Stream::ofRockPaperScissors(int $repetitions): Stream

 use IterTools  Stream ;

$ rps = Stream:: ofRockPaperScissors ( 5 )
    -> toArray ();
// 'paper', 'rock', 'rock', 'scissors', 'paper' [random]

Opérations de flux

Asorter

Trie le flux, en maintenant les clés.

$stream->asort(callable $comparator = null)

Si le comparateur n'est pas fourni, les éléments de la source itérable doivent être comparables.

 use IterTools  Stream ;

$ worldPopulations = [
    ' China '     => 1_439_323_776 ,
    ' India '     => 1_380_004_385 ,
    ' Indonesia ' => 273_523_615 ,
    ' USA '       => 331_002_651 ,
];

$ result = Stream:: of ( $ worldPopulations )
    -> filter ( fn ( $ pop ) => $ pop > 300_000_000 )
    -> asort ()
    -> toAssociativeArray ();
// USA   => 331_002_651,
// India => 1_380_004_385,
// China => 1_439_323_776, 

Chaîne

Renvoyez un flux en train de chaîner des sources supplémentaires dans un seul flux consécutif.

$stream->chainWith(iterable ...$iterables): Stream

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

$ result = Stream:: of ( $ input )
    -> chainWith ([ 4 , 5 , 6 ])
    -> chainWith ([ 7 , 8 , 9 ])
    -> toArray ();
// 1, 2, 3, 4, 5, 6, 7, 8, 9 

Compresse

Compression vers un nouveau flux en filtrant des données qui ne sont pas sélectionnées.

$stream->compress(iterable $selectors): Stream

Les sélecteurs indiquent quelles données. Vrai Value Sélectionne l'élément. False Value filtre les données.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

$ result = Stream:: of ( $ input )
    -> compress ([ 0 , 1 , 1 ])
    -> toArray ();
// 2, 3 

Compression associative

Comprimez vers un nouveau flux en filtrant les touches qui ne sont pas sélectionnées.

$stream->compressAssociative(array $keys): Stream

• Clés standard PHP Array / Iterator uniquement (chaîne, entier).

 use IterTools  Stream ;

$ starWarsEpisodes = [
    ' I '    => ' The Phantom Menace ' ,
    ' II '   => ' Attack of the Clones ' ,
    ' III '  => ' Revenge of the Sith ' ,
    ' IV '   => ' A New Hope ' ,
    ' V '    => ' The Empire Strikes Back ' ,
    ' VI '   => ' Return of the Jedi ' ,
    ' VII '  => ' The Force Awakens ' ,
    ' VIII ' => ' The Last Jedi ' ,
    ' IX '   => ' The Rise of Skywalker ' ,
];
$ sequelTrilogyNumbers = [ ' VII ' , ' VIII ' , ' IX ' ];

$ sequelTrilogy = Stream:: of ( $ starWarsEpisodes )
    -> compressAssociative ( $ sequelTrilogyNumbers )
    -> toAssociativeArray ();
// 'VII'  => 'The Force Awakens',
// 'VIII' => 'The Last Jedi',
// 'IX'   => 'The Rise of Skywalker', 

Chunkwise

Renvoyez un flux composé de morceaux d'éléments du flux.

$stream->chunkwise(int $chunkSize): Stream

La taille du morceau doit être d'au moins 1.

 use IterTools  Stream ;

$ friends = [ ' Ross ' , ' Rachel ' , ' Chandler ' , ' Monica ' , ' Joey ' ];

$ result = Stream:: of ( $ friends )
    -> chunkwise ( 2 )
    -> toArray ();
// ['Ross', 'Rachel'], ['Chandler', 'Monica'], ['Joey'] 

Chevauchement

Renvoyez un flux composé de morceaux d'éléments qui se chevauchent du flux.

$stream->chunkwiseOverlap(int $chunkSize, int $overlapSize, bool $includeIncompleteTail = true): Stream

• La taille du morceau doit être d'au moins 1.
• La taille du chevauchement doit être inférieure à la taille du morceau.

 use IterTools  Stream ;

$ numbers = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ];

$ result = Stream:: of ( $ friends )
    -> chunkwiseOverlap ( 3 , 1 )
    -> toArray ()
// [1, 2, 3], [3, 4, 5], [5, 6, 7], [7, 8, 9] 

Distinct

Renvoyez un flux filtrant les éléments du flux ne renvoyant que des éléments distincts.

$stream->distinct(bool $strict = true): Stream

Par défaut, des comparaisons de type stricte. Définissez Strict sur False pour les comparaisons de coercition de type.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 1 , 2 , 3 , 3 , ' 1 ' , ' 1 ' , ' 2 ' , ' 3 ' ];
$ stream = Stream:: of ( $ input )
    -> distinct ()
    -> toArray ();
// 1, 2, 3, '1', '2', '3'

$ stream = Stream:: of ( $ input )
    -> distinct ( false )
    -> toArray ();
// 1, 2, 3 

Distinct par

Renvoie un flux filtrant les éléments du flux uniquement des éléments distincts en fonction d'une fonction de comparaison personnalisée.

$stream->distinctBy(callable $compareBy): Stream

 use IterTools  Stream ;

$ streetFighterConsoleReleases = [
    [ ' id ' => ' 112233 ' , ' name ' => ' Street Fighter 3 3rd Strike ' , ' console ' => ' Dreamcast ' ],
    [ ' id ' => ' 223344 ' , ' name ' => ' Street Fighter 3 3rd Strike ' , ' console ' => ' PS4 ' ],
    [ ' id ' => ' 334455 ' , ' name ' => ' Street Fighter 3 3rd Strike ' , ' console ' => ' PS5 ' ],
    [ ' id ' => ' 445566 ' , ' name ' => ' Street Fighter VI ' , ' console ' => ' PS4 ' ],
    [ ' id ' => ' 556677 ' , ' name ' => ' Street Fighter VI ' , ' console ' => ' PS5 ' ],
    [ ' id ' => ' 667799 ' , ' name ' => ' Street Fighter VI ' , ' console ' => ' PC ' ],
];
$ stream = Stream:: of ( $ streetFighterConsoleReleases )
    -> distinctBy ( fn ( $ sfTitle ) => $ sfTitle [ ' name ' ])
    -> toArray ();
// Contains one SF3 3rd Strike entry and one SFVI entry 

Tomber pendant que

Déposez les éléments du flux tandis que la fonction de prédicat est vraie.

$stream->dropWhile(callable $predicate): Stream

Une fois que la fonction de prédicat renvoie false une fois, tous les éléments restants sont retournés.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 , 4 , 5 ]

$ result = Stream:: of ( $ input )
    -> dropWhile ( fn ( $ value ) => $ value < 3 )
    -> toArray ();
// 3, 4, 5 

Filtre

Filtrez les éléments du flux en conservant les éléments où la fonction de prédicat est vraie.

$stream->filter(callable $predicate): Stream

 use IterTools  Stream ;

$ input = [ 1 , - 1 , 2 , - 2 , 3 , - 3 ];

$ result = Stream:: of ( $ input )
    -> filter ( fn ( $ value ) => $ value > 0 )
    -> toArray ();
// 1, 2, 3 

Filtre vrai

Filtrez les éléments du flux en gardant uniquement des éléments qui sont à la vérité.

$stream->filterTrue(): Stream

 use IterTools  Stream ;

$ input = [ 0 , 1 , 2 , 3 , 0 , 4 ];

$ result = Stream:: of ( $ input )
    -> filterTrue ()
    -> toArray ();
// 1, 2, 3, 4 

Filtre faux

Filtrez les éléments du flux uniquement en gardant les éléments qui sont fausses.

$stream->filterFalse(): Stream

 use IterTools  Stream ;

$ input = [ 0 , 1 , 2 , 3 , 0 , 4 ];

$ result = Stream:: of ( $ input )
    -> filterFalse ()
    -> toArray ();
// 0, 0 

Clés de filtre

Filtrez les éléments du flux en gardant uniquement les éléments où la fonction de prédicat sur les touches est vraie.

$stream->filterKeys(callable $filter): Stream

 $ olympics = [
    2000 => ' Sydney ' ,
    2002 => ' Salt Lake City ' ,
    2004 => ' Athens ' ,
    2006 => ' Turin ' ,
    2008 => ' Beijing ' ,
    2010 => ' Vancouver ' ,
    2012 => ' London ' ,
    2014 => ' Sochi ' ,
    2016 => ' Rio de Janeiro ' ,
    2018 => ' Pyeongchang ' ,
    2020 => ' Tokyo ' ,
    2022 => ' Beijing ' ,
];

$ winterFilter = fn ( $ year ) => $ year % 4 === 2 ;

$ result = Stream:: of ( $ olympics )
    -> filterKeys ( $ winterFilter )
    -> toAssociativeArray ();
}
// 2002 => Salt Lake City
// 2006 => Turin
// 2010 => Vancouver
// 2014 => Sochi
// 2018 => Pyeongchang
// 2022 => Beijing 

Carte plate

Cartez une fonction sur les éléments du flux et aplaties les résultats.

$stream->flatMap(callable $mapper): Stream

 $ data    = [ 1 , 2 , 3 , 4 , 5 ];
$ mapper  fn ( $ item ) => ( $ item % 2 === 0 ) ? [ $ item , $ item ] : $ item ;

$ result = Stream:: of ( $ data )
    -> flatMap ( $ mapper )
    -> toArray ();
// [1, 2, 2, 3, 4, 4, 5] 

Aplatir

Aplatir un flux multidimensionnel.

$stream->flatten(int $dimensions = 1): Stream

 $ data = [ 1 , [ 2 , 3 ], [ 4 , 5 ]];

$ result = Stream:: of ( $ data )
    -> flatten ( $ mapper )
    -> toArray ();
// [1, 2, 3, 4, 5] 

Fréquences

Distribution de fréquence des éléments de flux.

$stream->frequencies(bool $strict = true): Stream

 use IterTools  Stream ;

$ grades = [ ' A ' , ' A ' , ' B ' , ' B ' , ' B ' , ' C ' ];

$ result = Stream:: of ( $ grades )
    -> frequencies ()
    -> toAssociativeArray ();

// ['A' => 2, 'B' => 3, 'C' => 1] 

Se regrouper

Renvoie un groupe de flux par un élément de données commun.

$stream->groupBy(callable $groupKeyFunction, callable $itemKeyFunction = null): Stream

• Le $groupKeyFunction détermine la clé des éléments de groupe par.
• La Fonctionnelle $itemKeyFunction permet des index personnalisés au sein de chaque membre du groupe.

 use IterTools  Stream ;

$ input = [ 1 , - 1 , 2 , - 2 , 3 , - 3 ];

$ groups = Stream:: of ( $ input )
    -> groupBy ( fn ( $ item ) => $ item > 0 ? ' positive ' : ' negative ' );

foreach ( $ groups as $ group => $ item ) {
    // 'positive' => [1, 2, 3], 'negative' => [-1, -2, -3]
}

Cycle infini

Renvoyez un flux à traverser les éléments du flux séquentiellement pour toujours.

$stream->infiniteCycle(): Stream

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

$ result = Stream:: of ( $ input )
    -> infiniteCycle ()
    -> print ();
// 1, 2, 3, 1, 2, 3, ... 

Intersection avec

Renvoie un flux croisant le flux avec les itérables d'entrée.

$stream->intersectionWith(iterable ...$iterables): Stream

 use IterTools  Stream ;

$ numbers    = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ];
$ numerics   = [ ' 1 ' , ' 2 ' , 3 , 4 , 5 , 6 , 7 , ' 8 ' , ' 9 ' ];
$ oddNumbers = [ 1 , 3 , 5 , 7 , 9 , 11 ];

$ stream = Stream:: of ( $ numbers )
    -> intersectionWith ( $ numerics , $ oddNumbers )
    -> toArray ();
// 3, 5, 7 

Intersection coercitive avec

Renvoie un flux croisant le flux avec les itérables des entrées en utilisant la coercition de type.

$stream->intersectionCoerciveWith(iterable ...$iterables): Stream

 use IterTools  Stream ;

$ languages          = [ ' php ' , ' python ' , ' c++ ' , ' java ' , ' c# ' , ' javascript ' , ' typescript ' ];
$ scriptLanguages    = [ ' php ' , ' python ' , ' javascript ' , ' typescript ' ];
$ supportsInterfaces = [ ' php ' , ' java ' , ' c# ' , ' typescript ' ];

$ stream = Stream:: of ( $ languages )
    -> intersectionCoerciveWith ( $ scriptLanguages , $ supportsInterfaces )
    -> toArray ();
// 'php', 'typescript' 

Limite

Renvoyez un flux jusqu'à une limite.

S'arrête même si plus de données disponibles si la limite atteint.

$stream->limit(int $limit): Stream

 Use IterTools  Single ;

$ matrixMovies = [ ' The Matrix ' , ' The Matrix Reloaded ' , ' The Matrix Revolutions ' , ' The Matrix Resurrections ' ];
$ limit        = 1 ;

$ goodMovies = Stream:: of ( $ matrixMovies )
    -> limit ( $ limit )
    -> toArray ();
// 'The Matrix' (and nothing else) 

Carte

Renvoie un flux contenant le résultat de la cartographie d'une fonction sur chaque élément du flux.

$stream->map(callable $function): Stream

 use IterTools  Stream ;

$ grades = [ 100 , 95 , 98 , 89 , 100 ];

$ result = Stream:: of ( $ grades )
    -> map ( fn ( $ grade ) => $ grade === 100 ? ' A ' : ' F ' )
    -> toArray ();
// A, F, F, F, A 

Par paire

Retournez un flux composé de paires d'éléments du flux.

$stream->pairwise(): Stream

Renvoie un flux vide si la collection contienne moins de 2 éléments.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 , 4 , 5 ];

$ stream = Stream:: of ( $ input )
    -> pairwise ()
    -> toArray ();
// [1, 2], [2, 3], [3, 4], [4, 5] 

Intersection partielle avec

Renvoie un flux qui entre en partie le flux avec les itérables d'entrée.

$stream->partialIntersectionWith(int $minIntersectionCount, iterable ...$iterables): Stream

 use IterTools  Stream ;

$ numbers    = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ];
$ numerics   = [ ' 1 ' , ' 2 ' , 3 , 4 , 5 , 6 , 7 , ' 8 ' , ' 9 ' ];
$ oddNumbers = [ 1 , 3 , 5 , 7 , 9 , 11 ];

$ stream = Stream:: of ( $ numbers )
    -> partialIntersectionWith ( $ numerics , $ oddNumbers )
    -> toArray ();
// 1, 3, 4, 5, 6, 7, 9 

Intersection partielle coercitive avec

Renvoie un flux en partie qui se croit partiellement le flux avec les itérables d'entrée en utilisant la coercition de type.

$stream->partialIntersectionCoerciveWith(int $minIntersectionCount, iterable ...$iterables): Stream

 use IterTools  Stream ;

$ languages          = [ ' php ' , ' python ' , ' c++ ' , ' java ' , ' c# ' , ' javascript ' , ' typescript ' ];
$ scriptLanguages    = [ ' php ' , ' python ' , ' javascript ' , ' typescript ' ];
$ supportsInterfaces = [ ' php ' , ' java ' , ' c# ' , ' typescript ' ];

$ stream = Stream:: of ( $ languages )
    -> partialIntersectionCoerciveWith ( 2 , $ scriptLanguages , $ supportsInterfaces )
    -> toArray ();
// 'php', 'python', 'java', 'typescript', 'c#', 'javascript' 

Réindex

Renvoie un nouveau flux d'éléments de valeur clé réindexés par la fonction d'indexeur de clé.

$stream->reindex(callable $indexer): Stream

 use IterTools  Stream ;

$ data = [
    [
        ' title '   => ' Star Wars: Episode IV – A New Hope ' ,
        ' episode ' => ' IV ' ,
        ' year '    => 1977 ,
    ],
    [
        ' title '   => ' Star Wars: Episode V – The Empire Strikes Back ' ,
        ' episode ' => ' V ' ,
        ' year '    => 1980 ,
    ],
    [
        ' title ' => ' Star Wars: Episode VI – Return of the Jedi ' ,
        ' episode ' => ' VI ' ,
        ' year ' => 1983 ,
    ],
];
$ reindexFunc = fn ( array $ swFilm ) => $ swFilm [ ' episode ' ];

$ reindexResult = Stream:: of ( $ data )
    -> reindex ( $ reindexFunc )
    -> toAssociativeArray ();
// [
//     'IV' => [
//         'title'   => 'Star Wars: Episode IV – A New Hope',
//         'episode' => 'IV',
//         'year'    => 1977,
//     ],
//     'V' => [
//         'title'   => 'Star Wars: Episode V – The Empire Strikes Back',
//         'episode' => 'V',
//         'year'    => 1980,
//     ],
//     'VI' => [
//         'title' => 'Star Wars: Episode VI – Return of the Jedi',
//         'episode' => 'VI',
//         'year' => 1983,
//     ],
// ] 

Fréquences relatives

Distribution de fréquence relative des éléments de flux.

$stream->relativeFrequencies(bool $strict = true): Stream

 use IterTools  Stream ;

$ grades = [ ' A ' , ' A ' , ' B ' , ' B ' , ' B ' , ' C ' ];

$ result = Stream:: of ( $ grades )
    -> relativeFrequencies ()
    -> toAssociativeArray ();

// A => 0.33, B => 0.5, C => 0.166 

Inverse

Inverser les éléments d'un flux.

$stream->reverse(): Stream

 use IterTools  Stream ;

$ words = [ ' are ' , ' you ' , ' as ' , ' bored ' , ' as ' , ' I ' , ' am ' ];

$ reversed = Stream:: of ( $ words )
    -> reverse ()
    -> toString ( ' ' );
// am I as bored as you are 

Moyenne de course

Renvoyez un flux accumulant la moyenne (moyenne) en cours d'exécution sur le flux.

$stream->runningAverage(int|float|null $initialValue = null): Stream

 use IterTools  Stream ;

$ input = [ 1 , 3 , 5 ];

$ result = Stream:: of ( $ input )
    -> runningAverage ()
    -> toArray ();
// 1, 2, 3 

Différence de course

Renvoie un flux accumulant la différence de course sur le flux.

$stream->runningDifference(int|float|null $initialValue = null): Stream

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 , 4 , 5 ];

$ result = Stream:: of ( $ input )
    -> runningDifference ()
    -> toArray ();
// -1, -3, -6, -10, -15 

Running Max

Renvoie un flux accumulant le maximum en cours d'exécution sur le flux.

$stream->runningMax(int|float|null $initialValue = null): Stream

 use IterTools  Stream ;

$ input = [ 1 , - 1 , 2 , - 2 , 3 , - 3 ];

$ result = Stream:: of ( $ input )
    -> runningMax ()
    -> toArray ();
// 1, 1, 2, 2, 3, 3 

Running Min

Renvoyez un flux accumulant le Min en cours d'exécution sur le flux.

$stream->runningMin(int|float|null $initialValue = null): Stream

 use IterTools  Stream ;

$ input = [ 1 , - 1 , 2 , - 2 , 3 , - 3 ];

$ result = Stream:: of ( $ input )
    -> runningMin ()
    -> toArray ();
// 1, -1, -1, -2, -2, -3 

Produit en cours d'exécution

Renvoyez un flux en accumulant le produit en cours d'exécution sur le flux.

$stream->runningProduct(int|float|null $initialValue = null): Stream

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 , 4 , 5 ];

$ result = Stream:: of ( $ input )
    -> runningProduct ()
    -> toArray ();
// 1, 2, 6, 24, 120 

Total de course

Renvoyez un flux accumulant le total de course sur le flux.

$stream->runningTotal(int|float|null $initialValue = null): Stream

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 , 4 , 5 ];

$ result = Stream:: of ( $ input )
    -> runningTotal ()
    -> toArray ();
// 1, 3, 6, 10, 15 

Sauter

Sautez quelques éléments du ruisseau.

$stream->skip(int $count, int $offset = 0): Stream

 use IterTools  Stream ;

$ movies = [
    ' The Phantom Menace ' , ' Attack of the Clones ' , ' Revenge of the Sith ' ,
    ' A New Hope ' , ' The Empire Strikes Back ' , ' Return of the Jedi ' ,
    ' The Force Awakens ' , ' The Last Jedi ' , ' The Rise of Skywalker '
];

$ onlyTheBest = Stream:: of ( $ movies )
    -> skip ( 3 )
    -> skip ( 3 , 3 )
    -> toArray ();
// 'A New Hope', 'The Empire Strikes Back', 'Return of the Jedi' 

Tranche

Extraire une tranche du ruisseau.

$stream->slice(int $start = 0, int $count = null, int $step = 1)

 use IterTools  Stream ;

$ olympics = [ 1992 , 1994 , 1996 , 1998 , 2000 , 2002 , 2004 , 2006 , 2008 , 2010 , 2012 , 2014 , 2016 , 2018 , 2020 , 2022 ];

$ summerOlympics = Stream:: of ( $ olympics )
    -> slice ( 0 , 8 , 2 )
    -> toArray ();
// [1992, 1996, 2000, 2004, 2008, 2012, 2016, 2020] 

Trier

Trie le flux.

$stream->sort(callable $comparator = null)

Si le comparateur n'est pas fourni, les éléments de la source itérable doivent être comparables.

 use IterTools  Stream ;

$ input = [ 3 , 4 , 5 , 9 , 8 , 7 , 1 , 6 , 2 ];

$ result = Stream:: of ( $ input )
    -> sort ()
    -> toArray ();
// 1, 2, 3, 4, 5, 6, 7, 8, 9 

Différence symétrique avec

Renvoyez un flux de la différence symétrique du flux et des itérables donnés.

$stream->symmetricDifferenceWith(iterable ...$iterables): Stream

Remarque: Si les itérables d'entrée produisent des éléments en double, les règles d'intersection multiset s'appliquent.

 use IterTools  Stream ;

$ a = [ 1 , 2 , 3 , 4 , 7 ];
$ b = [ ' 1 ' , 2 , 3 , 5 , 8 ];
$ c = [ 1 , 2 , 3 , 6 , 9 ];

$ stream = Stream:: of ( $ a )
    -> symmetricDifferenceWith ( $ b , $ c )
    -> toArray ();
// '1', 4, 5, 6, 7, 8, 9 

Différence symétrique coercitive avec

Renvoyez un flux de la différence symétrique du flux et des itérables donnés en utilisant la coercition de type.

$stream->symmetricDifferenceCoerciveWith(iterable ...$iterables): Stream

Remarque: Si les itérables d'entrée produisent des éléments en double, les règles d'intersection multiset s'appliquent.

 use IterTools  Stream ;

$ a = [ 1 , 2 , 3 , 4 , 7 ];
$ b = [ ' 1 ' , 2 , 3 , 5 , 8 ];
$ c = [ 1 , 2 , 3 , 6 , 9 ];

$ stream = Stream:: of ( $ a )
    -> symmetricDifferenceCoerciveWith ( $ b , $ c )
    -> toArray ();
// 4, 5, 6, 7, 8, 9 

Prendre

Gardez les éléments du flux tant que le prédicat est vrai.

$stream->takeWhile(callable $predicate): Stream

Si aucun prédicat n'est fourni, la valeur booléenne des données est utilisée.

 use IterTools  Stream ;

$ input = [ 1 , - 1 , 2 , - 2 , 3 , - 3 ];

$ result = Stream:: of ( $ input )
    -> takeWhile ( fn ( $ value ) => abs ( $ value ) < 3 )
    -> toArray ();
// 1, -1, 2, -2 

Se syndiquer avec

Renvoie un flux composé de l'union du flux et des itérables d'entrée.

$stream->unionWith(iterable ...$iterables): Stream

Remarque: Si les itérables d'entrée produisent des éléments en double, les règles de l'Union multiset s'appliquent.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

$ stream = Stream:: of ( $ input )
    -> unionWith ([ 3 , 4 , 5 , 6 ])
    -> toArray ();
// [1, 2, 3, 4, 5, 6] 

Union coercitive avec

Renvoie un flux composé de l'union du flux et des itérables d'entrée en utilisant la coercition de type.

$stream->unionCoerciveWith(iterable ...$iterables): Stream

Remarque: Si les itérables d'entrée produisent des éléments en double, les règles de l'Union multiset s'appliquent.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

$ stream = Stream:: of ( $ input )
    -> unionCoerciveWith ([ ' 3 ' , 4 , 5 , 6 ])
    -> toArray ();
// [1, 2, 3, 4, 5, 6] 

Zipter avec

Renvoyez un flux composé de plusieurs collections itéables diffusées simultanément.

$stream->zipWith(iterable ...$iterables): Stream

Pour les longueurs inégales, les itérations s'arrêtent lorsque l'itérable le plus court est épuisé.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

$ stream = Stream:: of ( $ input )
    -> zipWith ([ 4 , 5 , 6 ])
    -> zipWith ([ 7 , 8 , 9 ])
    -> toArray ();
// [1, 4, 7], [2, 5, 8], [3, 6, 9] 

Zip rempli de

Renvoie un flux composé de plusieurs collections itéables, en utilisant une valeur de remplissage par défaut si les longueurs ne sont pas égales.

$stream->zipFilledWith(mixed $default, iterable ...$iterables): Stream

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

$ stream = Stream:: of ( $ input )
    -> zipFilledWith ( ' ? ' , [ ' A ' , ' B ' ]);

foreach ( $ stream as $ zipped ) {
    // [1, A], [2, B], [3, ?]
}

Zip égal à

Renvoie un flux composé de plusieurs collections itérables de longueurs égales diffusées simultanément.

$stream->zipEqualWith(iterable ...$iterables): Stream

Fonctionne comme Stream::zipWith() Méthode mais lève LONGGEDException si les longueurs ne sont pas égales, c'est-à-dire, au moins un itérateur se termine devant les autres.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

$ stream = Stream:: of ( $ input )
    -> zipEqualWith ([ 4 , 5 , 6 ])
    -> zipEqualWith ([ 7 , 8 , 9 ]);

foreach ( $ stream as $ zipped ) {
    // [1, 4, 7], [2, 5, 8], [3, 6, 9]
}

Zip le plus long avec

Renvoyez un flux composé de plusieurs collections itéables diffusées simultanément.

$stream->zipLongestWith(iterable ...$iterables): Stream

• L'itération se poursuit jusqu'à ce que l'itérable le plus long soit épuisé.
• Pour les longueurs inégales, les itérables épuisés produiront null pour les itérations restantes.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 , 4 , 5 ];

$ stream = Stream:: of ( $ input )
    -> zipLongestWith ([ 4 , 5 , 6 ])
    -> zipLongestWith ([ 7 , 8 , 9 , 10 ]);

foreach ( $ stream as $ zipped ) {
    // [1, 4, 7], [2, 5, 8], [3, 6, 9], [4, null, 10], [null, null, 5]
}

Opérations de terminaux de cours d'eau

Opérations de terminal sommaire des cours d'eau

Tout match

Renvoie True si tous les éléments correspondent à la fonction de prédicat.

$stream->allMatch(callable $predicate): bool

 use IterTools  Summary ;

$ finalFantasyNumbers = [ 4 , 5 , 6 ];
$ isOnSuperNintendo   = fn ( $ ff ) => $ ff >= 4 && $ ff <= 6 ;

$ boolean = Stream:: of ( $ finalFantasyNumbers )
    -> allMatch ( $ isOnSuperNintendo );
// true 

Tous uniques

Renvoie vrai si tous les éléments sont uniques.

$stream->allUnique(bool $strict = true): bool

Par défaut, des comparaisons de type stricte. Définissez Strict sur False pour les comparaisons de coercition de type.

 use IterTools  Summary ;

$ items = [ ' fingerprints ' , ' snowflakes ' , ' eyes ' , ' DNA ' ]

$ boolean = Stream:: of ( $ items )
    -> allUnique ();
// true 

Toute match

Renvoie True si un élément correspond à la fonction de prédicat.

$stream->anyMatch(callable $predicate): bool

 use IterTools  Summary ;

$ answers          = [ ' fish ' , ' towel ' , 42 , " don't panic " ];
$ isUltimateAnswer = fn ( $ a ) => a == 42 ;

$ boolean = Stream:: of ( $ answers )
    -> anyMatch ( $ answers , $ isUltimateAnswer );
// true 

Sont des permutations avec

Renvoie True si toutes les iterables sont des permutations avec le flux.

$stream->arePermutationsWith(...$iterables): bool

 use IterTools  Summary ;

$ rite = [ ' r ' , ' i ' , ' t ' , ' e ' ];
$ reit = [ ' r ' , ' e ' , ' i ' , ' t ' ];
$ tier = [ ' t ' , ' i ' , ' e ' , ' r ' ];
$ tire = [ ' t ' , ' i ' , ' r ' , ' e ' ];
$ trie = [ ' t ' , ' r ' , ' i ' , ' e ' ];

$ boolean = Stream:: of ([ ' i ' , ' t ' , ' e ' , ' r ' ])
    -> arePermutationsWith ( $ rite , $ reit , $ tier , $ tire , $ trie );
// true 

Les permutations sont-elles coercitives avec

Renvoie True si toutes les iterables sont des permutations avec un flux avec la coercition de type.

$stream->arePermutationsCoerciveWith(...$iterables): bool

 use IterTools  Summary ;

$ set2 = [ 2.0 , ' 1 ' , 3 ];
$ set3 = [ 3 , 2 , 1 ];

$ boolean = Stream:: of ([ 1 , 2.0 , ' 3 ' ])
    -> arePermutationsCoerciveWith ( $ set2 , $ set3 );
// true 

Exactement n

Renvoie True si exactement n éléments sont vrais selon une fonction de prédicat.

• Le prédicat est facultatif.
• Le prédicat par défaut est la valeur booléenne de chaque élément.

$stream->exactlyN(int $n, callable $predicate = null): bool

 use IterTools  Summary ;

$ twoTruthsAndALie = [ true , true , false ];
$ n                = 2 ;

$ boolean = Stream:: of ( $ twoTruthsAndALie )-> exactlyN ( $ n );
// true 

Est vide

Renvoie True si le flux est vide n'ayant pas d'articles.

$stream->isEmpty(): bool

 use IterTools  Summary ;

$ numbers    = [ 0 , 1 , 2 , 3 , 4 , 5 ];
$ filterFunc = fn ( $ x ) => $ x > 10 ;

$ boolean = Stream::( $ numbers )
    -> filter ( $ filterFunc )
    -> isEmpty ();
// true 

Est partitionné

Renvoie True si tous les éléments de la collection donnée qui satisfont le prédicat apparaissent devant tous les éléments qui ne le font pas.

• Renvoie True pour la collection vide ou pour la collection avec un seul élément.
• Le prédicat par défaut s'il n'est pas fourni est la valeur booléenne de chaque élément de données.

$stream->isPartitioned(callable $predicate = null): bool

 use IterTools  Summary ;

$ numbers          = [ 0 , 2 , 4 , 1 , 3 , 5 ];
$ evensBeforeOdds = fn ( $ item ) => $ item % 2 === 0 ;

$ boolean = Stream::( $ numbers )
    -> isPartitioned ( $ evensBeforeOdds );
// true 

Est trié

Renvoie True si Itable Source est trié par ordre croissant; sinon faux.

$stream->isSorted(): bool

Les éléments de la source itérable doivent être comparables.

Renvoie True si Itable Source est vide ou n'a qu'un seul élément.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 , 4 , 5 ];

$ result = Stream:: of ( $ input )
    -> isSorted ();
// true

$ input = [ 1 , 2 , 3 , 2 , 1 ];

$ result = Stream:: of ( $ input )
    -> isSorted ();
// false 

Est inversé

Renvoie True si la source itérable est triée dans l'ordre descendant inverse; sinon faux.

$stream->isReversed(): bool

Les éléments de la source itérable doivent être comparables.

Renvoie True si Itable Source est vide ou n'a qu'un seul élément.

 use IterTools  Stream ;

$ input = [ 5 , 4 , 3 , 2 , 1 ];

$ result = Stream:: of ( $ input )
    -> isReversed ();
// true

$ input = [ 1 , 2 , 3 , 2 , 1 ];

$ result = Stream:: of ( $ input )
    -> isReversed ();
// false 

Aucun ne correspond

Renvoie True si aucun élément correspond à la fonction de prédicat.

$stream->noneMatch(callable $predicate): bool

 use IterTools  Summary ;

$ grades         = [ 45 , 50 , 61 , 0 ];
$ isPassingGrade = fn ( $ grade ) => $ grade >= 70 ;

$ boolean = Stream:: of ( $ grades )-> noneMatch ( $ isPassingGrade );
// true 

Identique à

Renvoie True If iTable Source et toutes les collections données sont les mêmes.

$stream->sameWith(iterable ...$iterables): bool

Pour la liste des iterables vides renvoie true.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 , 4 , 5 ];

$ result = Stream:: of ( $ input )
    -> sameWith ([ 1 , 2 , 3 , 4 , 5 ]);
// true

$ result = Stream:: of ( $ input )
    -> sameWith ([ 5 , 4 , 3 , 2 , 1 ]);
// false 

Même compter avec

Renvoie True If iTable Source et toutes les collections données ont les mêmes longueurs.

$stream->sameCountWith(iterable ...$iterables): bool

Pour la liste des iterables vides renvoie true.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 , 4 , 5 ];

$ result = Stream:: of ( $ input )
    -> sameCountWith ([ 5 , 4 , 3 , 2 , 1 ]);
// true

$ result = Stream:: of ( $ input )
    -> sameCountWith ([ 1 , 2 , 3 ]);
// false 

Opérations de terminal de réduction de flux

À la moyenne

Réduit la source itérable à la moyenne moyenne de ses articles.

$stream->toAverage(): mixed

Renvoie NULL si la source itérable est vide.

 use IterTools  Stream ;

$ input = [ 2 , 4 , 6 , 8 ];

$ result = Stream:: of ( $ iterable )
    -> toAverage ();
// 5 

Compter

Réduit la source itérable à sa longueur.

$stream->toCount(): mixed

 use IterTools  Stream ;

$ input = [ 10 , 20 , 30 , 40 , 50 ];

$ result = Stream:: of ( $ iterable )
    -> toCount ();
// 5 

Pour d'abord

Réduit la source itérable à son premier élément.

$stream->toFirst(): mixed

Lance LengthException si la source itérable est vide.

 use IterTools  Stream ;

$ input = [ 10 , 20 , 30 ];

$ result = Stream:: of ( $ input )
    -> toFirst ();
// 10 

Au premier et au dernier

Réduit la source itérable à ses premiers et derniers éléments.

$stream->toFirstAndLast(): array{mixed, mixed}

Lance LengthException si la source itérable est vide.

 use IterTools  Stream ;

$ input = [ 10 , 20 , 30 ];

$ result = Stream:: of ( $ input )
    -> toFirstAndLast ();
// [10, 30] 

Pour durer

Réduit la source itérable à son dernier élément.

$stream->toLast(): mixed

Lance LengthException si la source itérable est vide.

 use IterTools  Stream ;

$ input = [ 10 , 20 , 30 ];

$ result = Stream:: of ( $ input )
    -> toLast ();
// 30 

À max

Réduit la source itérable à sa valeur maximale.

$stream->toMax(callable $compareBy = null): mixed

• PARAM CALLable Facultatif $compareBy doit renvoyer une valeur comparable.
• Si $compareBy n'est pas fourni, les éléments de la collection donnés doivent être comparables.
• Renvoie null si la collection est vide.

 use IterTools  Stream ;

$ input = [ 1 , - 1 , 2 , - 2 , 3 , - 3 ];

$ result = Stream:: of ( $ iterable )
    -> toMax ();
// 3 

À min

Réduit la source itérable à sa valeur min.

$stream->toMin(callable $compareBy = null): mixed

• PARAM CALLable Facultatif $compareBy doit renvoyer une valeur comparable.
• Si $compareBy n'est pas fourni, les éléments de la collection donnés doivent être comparables.
• Renvoie null si la collection est vide.

 use IterTools  Stream ;

$ input = [ 1 , - 1 , 2 , - 2 , 3 , - 3 ];

$ result = Stream:: of ( $ iterable )
    -> toMin ();
// -3 

À min max

Réduit le ruisseau à la table de ses limites supérieure et inférieure (max et min).

$stream->toMinMax(callable $compareBy = null): array

• PARAM CALLable Facultatif $compareBy doit renvoyer une valeur comparable.
• Si $compareBy n'est pas fourni, les éléments de la collection donnés doivent être comparables.
• Renvoie [null, null] Si la collection donnée est vide.

 use IterTools  Stream ;

$ numbers = [ 1 , 2 , 7 , - 1 , - 2 , - 3 ];

[ $ min , $ max ] = Stream:: of ( $ numbers )
    -> toMinMax ();
// [-3, 7] 

À la norme

Réduit le flux à la valeur en première position.

$stream->toNth(int $position): mixed

Renvoie NULL si la source itérable est vide.

 use IterTools  Stream ;

$ lotrMovies = [ ' The Fellowship of the Ring ' , ' The Two Towers ' , ' The Return of the King ' ];

$ result = Stream:: of ( $ lotrMovies )
    -> toNth ( 2 );
// The Return of the King 

Au produit

Réduit le flux vers le produit de ses articles.

$stream->toProduct(): mixed

Renvoie NULL si la source itérable est vide.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 , 4 , 5 ];

$ result = Stream:: of ( $ iterable )
    -> toProduct ();
// 120 

À une valeur aléatoire

Réduit le flux à une valeur aléatoire à l'intérieur.

$stream->toRandomValue(): mixed

 use IterTools  Stream ;

$ rpsHands = [ ' rock ' , ' paper ' , ' scissors ' ]

$ range = Stream:: of ( $ numbers )
    -> map ( ' strtoupper ' )
    -> toRandomValue ();
// e.g., rock 

Pour aller

Réduit le flux vers sa gamme (différence entre Max et Min).

$stream->toRange(): int|float

Renvoie 0 si la source itérable est vide.

 use IterTools  Stream ;

$ grades = [ 100 , 90 , 80 , 85 , 95 ];

$ range = Stream:: of ( $ numbers )
    -> toRange ();
// 20 

À la chaîne

Réduit à une chaîne qui joint tous les éléments.

• Séparateur facultatif à insérer entre les éléments.
• Préfixe facultatif pour représenter la chaîne.
• Suffixe facultatif pour ajouter à la chaîne.

$stream->toString(string $separator = '', string $prefix = '', string $suffix = ''): string

 use IterTools  Stream ;

$ words = [ ' IterTools ' , ' PHP ' , ' v1.0 ' ];

$ string = Stream:: of ( $ words )-> toString ( $ words );
// IterToolsPHPv1.0
$ string = Stream:: of ( $ words )-> toString ( $ words , ' - ' );
// IterTools-PHP-v1.0
$ string = Stream:: of ( $ words )-> toString ( $ words , ' - ' , ' Library: ' );
// Library: IterTools-PHP-v1.0
$ string = Stream:: of ( $ words )-> toString ( $ words , ' - ' , ' Library: ' , ' ! ' );
// Library: IterTools-PHP-v1.0! 

Pour résumer

Réduit la source itérable à la somme de ses éléments.

$stream->toSum(): mixed

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 , 4 , 5 ];

$ result = Stream:: of ( $ iterable )
    -> toSum ();
// 15 

Pour évaluer

Réduit la source itérable comme la fonction array_reduce ().

Mais contrairement à array_reduce() , il fonctionne avec tous les types iterable .

$stream->toValue(callable $reducer, mixed $initialValue): mixed

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 , 4 , 5 ];

$ result = Stream:: of ( $ iterable )
    -> toValue ( fn ( $ carry , $ item ) => $ carry + $ item );
// 15 

Opérations de terminal de transformation

À la table

Renvoie un tableau d'éléments de flux.

$stream->toArray(): array

 use IterTools  Stream ;

$ array = Stream:: of ([ 1 , 1 , 2 , 2 , 3 , 4 , 5 ])
    -> distinct ()
    -> map ( fn ( $ x ) => $ x ** 2 )
    -> toArray ();
// [1, 4, 9, 16, 25] 

À un tableau associatif

Renvoie une carte de valeur clé des éléments de flux.

$stream->toAssociativeArray(callable $keyFunc, callable $valueFunc): array

 use IterTools  Stream ;

$ keyFunc

$ array = Stream:: of ([ ' message 1 ' , ' message 2 ' , ' message 3 ' ])
    -> map ( ' strtoupper ' )
    -> toAssociativeArray (
        fn ( $ s ) => md5 ( $ s ),
        fn ( $ s ) => $ s
    );
// [3b3f2272b3b904d342b2d0df2bf31ed4 => MESSAGE 1, 43638d919cfb8ea31979880f1a2bb146 => MESSAGE 2, ... ] 

Tee

Renvoyez plusieurs flux indépendants (dupliqués).

$stream->tee(int $count): array

 use IterTools  Transform ;

$ daysOfWeek = [ ' Mon ' , ' Tues ' , ' Wed ' , ' Thurs ' , ' Fri ' , ' Sat ' , ' Sun ' ];
$ count = 3 ;

[ $ week1Stream , $ week2Stream , $ week3Stream ] = Stream:: of ( $ daysOfWeek )
    -> tee ( $ count );

// Each $weekStream contains ['Mon', 'Tues', 'Wed', 'Thurs', 'Fri', 'Sat', 'Sun'] 

Opérations terminales à effet secondaire

Appel pour chacun

Effectuez une action via un appelable sur chaque élément du flux.

$stream->callForEach(callable $function): void

 use IterTools  Stream ;

$ languages = [ ' PHP ' , ' Python ' , ' Java ' , ' Go ' ];
$ mascots   = [ ' elephant ' , ' snake ' , ' bean ' , ' gopher ' ];

$ zipPrinter = fn ( $ zipped ) => print ( "{ $ zipped [ 0 ]} 's mascot: { $ zipped [ 1 ]}" );

Stream:: of ( $ languages )
    -> zipWith ( $ mascots )
    -> callForEach ( $ zipPrinter );
// PHP's mascot: elephant
// Python's mascot: snake
// ... 

Imprimer

Imprime chaque élément du flux.

• Les articles doivent être imprimables.

$stream->print(string $separator = '', string $prefix = '', string $suffix = ''): void

 use IterTools  Stream ;

$ words = [ ' IterTools ' , ' PHP ' , ' v1.0 ' ];

Stream:: of ( $ words )-> print ();                       // IterToolsPHPv1.0
Stream:: of ( $ words )-> print ( ' - ' );                    // IterTools-PHP-v1.0
Stream:: of ( $ words )-> print ( ' - ' , ' Library: ' );       // Library: IterTools-PHP-v1.0
Stream:: of ( $ words )-> print ( ' - ' , ' Library: ' , ' ! ' );  // Library: IterTools-PHP-v1.0! 

Ligne imprimée

Imprime chaque élément du flux sur sa propre ligne.

• Les articles doivent être imprimables.

$stream->println(): void

 use IterTools  Stream ;

$ words = [ ' IterTools ' , ' PHP ' , ' v1.0 ' ];

Stream:: of ( $ words )-> printLn ();
// IterTools
// PHP
// v1.0 

Au fichier CSV

Écrivez le contenu du flux sur un fichier CSV.

$stream->toCsvFile(resource $fileHandle, array $header = null, string 'separator = ',', string $enclosure = '"', string $escape = '\'): void

 use IterTools  Stream ;

$ starWarsMovies = [
    [ ' Star Wars: Episode IV – A New Hope ' , ' IV ' , 1977 ],
    [ ' Star Wars: Episode V – The Empire Strikes Back ' , ' V ' , 1980 ],
    [ ' Star Wars: Episode VI – Return of the Jedi ' , ' VI ' , 1983 ],
];
$ header = [ ' title ' , ' episode ' , ' year ' ];

Stream:: of ( $ data )
    -> toCsvFile ( $ fh , $ header );
// title,episode,year
// "Star Wars: Episode IV – A New Hope",IV,1977
// "Star Wars: Episode V – The Empire Strikes Back",V,1980
// "Star Wars: Episode VI – Return of the Jedi",VI,1983 

Pour déposer

Écrivez le contenu du flux dans un fichier.

$stream->toFile(resource $fileHandle, string $newLineSeparator = PHP_EOL, string $header = null, string $footer = null): void

 use IterTools  Stream ;

$ data = [ ' item1 ' , ' item2 ' , ' item3 ' ];
$ header = ' <ul> ' ;
$ footer = ' </ul> ' ;

Stream:: of ( $ data )
    -> map ( fn ( $ item ) => "  <li> $ item </li> " )
    -> toFile ( $ fh ,  PHP_EOL , $ header , $ footer );

// <ul>
//   <li>item1</li>
//   <li>item2</li>
//   <li>item3</li>
// </ul>

Opérations de débogage de diffusion

Jeter un coup d'œil

Jetez un coup d'œil à chaque élément entre les autres opérations de flux pour effectuer une action sans modifier le flux.

$stream->peek(callable $callback): Stream

 use IterTools  Stream ;

$ logger = new SimpleLog  Logger ( ' /tmp/log.txt ' , ' iterTools ' );

Stream:: of ([ ' some ' , ' items ' ])
  -> map ( ' strtoupper ' )
  -> peek ( fn ( $ x ) => $ logger -> info ( $ x ))
  -> foreach ( $ someComplexCallable );

Jet de vue

Jetez un coup d'œil à l'ensemble du flux entre d'autres opérations de flux pour effectuer une action sans modifier le flux.

$stream->peekStream(callable $callback): Stream

 use IterTools  Stream ;

$ logger = new SimpleLog  Logger ( ' /tmp/log.txt ' , ' iterTools ' );

Stream:: of ([ ' some ' , ' items ' ])
  -> map ( ' strtoupper ' )
  -> peekStream ( fn ( $ stream ) => $ logger -> info ( $ stream ))
  -> foreach ( $ someComplexCallable );

Imprimé aperçu

Jetez un coup d'œil à chaque élément entre les autres opérations de flux pour imprimer chaque élément sans modifier le flux.

$stream->peekPrint(string $separator = '', string $prefix = '', string $suffix = ''): void

 use IterTools  Stream ;

Stream:: of ([ ' some ' , ' items ' ])
  -> map ( ' strtoupper ' )
  -> peekPrint ()
  -> foreach ( $ someComplexCallable );

Peek Printr

Jetez un coup d'œil à chaque élément entre les autres opérations de flux vers print_r chaque élément sans modifier le flux.

$stream->peekPrintR(callable $callback): void

 use IterTools  Stream ;

Stream:: of ([ ' some ' , ' items ' ])
  -> map ( ' strtoupper ' )
  -> peekPrintR ()
  -> foreach ( $ someComplexCallable );

Imprimer R

print_r chaque élément du flux.

$stream->printR(): void

 use IterTools  Stream ;

$ items = [ $ string , $ array , $ object ];

Stream:: of ( $ words )-> printR ();
// print_r output 

Camion var

var_dump chaque élément du flux.

$stream->varDump(): void

 use IterTools  Stream ;

$ items = [ $ string , $ array , $ object ];

Stream:: of ( $ words )-> varDump ();
// var_dump output 

Composition

Itertools peut être combiné pour créer de nouvelles compositions itérables.

Cordes à fermeture éclair

 use IterTools  Multi ;
use IterTools  Single ;

$ letters = ' ABCDEFGHI ' ;
$ numbers = ' 123456789 ' ;

foreach (Multi:: zip (Single:: string ( $ letters ), Single:: string ( $ numbers )) as [ $ letter , $ number ]) {
     $ battleshipMove = new BattleshipMove( $ letter , $ number )
}
// A1, B2, C3 

Cordes de chaîne

 use IterTools  Multi ;
use IterTools  Single ;

$ letters = ' abc ' ;
$ numbers = ' 123 ' ;

foreach (Multi:: chain (Single:: string ( $ letters ), Single:: string ( $ numbers )) as $ character ) {
    print ( $ character );
}
// a, b, c, 1, 2, 3 

Types stricts et coercitifs

Lorsqu'il y a une option, la valeur par défaut fera des comparaisons de type stricte:

• scalaires: se compare strictement par type
• Objets: traite toujours différentes instances comme pas égales les unes aux autres
• tableaux: compare sérialisé

Lorsque la coercition de type (types non stricts) est disponible et activé via un indicateur facultatif:

• Scalars: Compare par valeur via la jonglerie de type
• objets: compare sérialisé
• tableaux: compare sérialisé

Normes

Itertools PHP est conforme aux normes suivantes:

• PSR-1 - Norme de codage de base (http://www.php-fig.org/psr/psr-1/)
• PSR-4 - Autoloader (http://www.php-fig.org/psr/psr-4/)
• PSR-12 - Guide de style de codage étendu (http://www.php-fig.org/psr/psr-12/)

Licence

Itertools PHP est licencié sous la licence du MIT.

Bibliothèques similaires dans d'autres langues

La fonctionnalité Itertools n'est pas limitée à PHP et Python. Other languages have similar libraries. Familiar functionality is available when working in other languages.

• IterTools TypeScript/Javascript
• IterTools Python: The original!