itertools php

ITerTools - Herramientas de iteración de PHP para encender sus bucles

Inspirado por Python, diseñado para PHP.

Características

IterTools te convierte en una superestrella de iteración al proporcionar dos tipos de herramientas:

• Herramientas de iteración de bucle
• Herramientas de iteración de transmisión

Ejemplo de herramientas de iteración de bucle

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

Ejemplo de herramientas de iteración de transmisión

 $ 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

Todas las funciones funcionan en colecciones iterable :

• array (tipo)
• Generator (tipo)
• Iterator (interfaz)
• Traversable (interfaz)

ReadMe Docs traducidos en otros idiomas:

• Русий

Referencia rápida

Herramientas de iteración de bucle

Múltiples iteraciones

Iterador	Descripción	Fragmento de código
chain	Cadena múltiples iterables juntos	Multi::chain($list1, $list2)
zip	Iterar múltiples colecciones simultáneamente hasta que se complete el iterador más corto	Multi::zip($list1, $list2)
zipEqual	Iterar colecciones múltiples de igual longitud simultáneamente, error si las longitudes no son iguales	Multi::zipEqual($list1, $list2)
zipFilled	Iterar colecciones múltiples, utilizando un valor de relleno si las longitudes no son iguales	Multi::zipFilled($default, $list1, $list2)
zipLongest	Iterar múltiples colecciones simultáneamente hasta que se complete el iterador más largo	Multi::zipLongest($list1, $list2)

Iteración única

Iterador	Descripción	Fragmento de código
chunkwise	Iterar por trozos	Single::chunkwise($data, $chunkSize)
chunkwiseOverlap	Iterar por trozos superpuestos	Single::chunkwiseOverlap($data, $chunkSize, $overlapSize)
compress	Filtrar elementos no seleccionados	Single::compress($data, $selectors)
compressAssociative	Filtrar elementos por teclas no seleccionadas	Single::compressAssociative($data, $selectorKeys)
dropWhile	Elementos de caída mientras el predicado es verdadero	Single::dropWhile($data, $predicate)
filter	Filtrar para elementos donde el predicado es verdadero	Single::filterTrue($data, $predicate)
filterTrue	Filtrar para elementos de verdad	Single::filterTrue($data)
filterFalse	Filtrar para elementos falsos	Single::filterFalse($data)
filterKeys	Filtrar para las teclas donde el predicado es verdadero	Single::filterKeys($data, $predicate)
flatMap	Mapa de la función en elementos y aplanado el resultado	Single::flaMap($data, $mapper)
flatten	Aplanado multidimensional iterable	Single::flatten($data, [$dimensions])
groupBy	Datos de grupo por un elemento común	Single::groupBy($data, $groupKeyFunction, [$itemKeyFunc])
limit	Iterar hasta un límite	Single::limit($data, $limit)
map	Mapa de la función en cada elemento	Single::map($data, $function)
pairwise	Iterar pares superpuestos sucesivos	Single::pairwise($data)
reindex	Reindex Keys of Key-Value ITerable	Single::reindex($data, $reindexer)
repeat	Repita un elemento varias veces	Single::repeat($item, $repetitions)
reverse	Iterar elementos en orden inverso	Single::reverse($data)
skip	Iterar después de omitir elementos	Single::skip($data, $count, [$offset])
slice	Extraer una porción de la iterable	Single::slice($data, [$start], [$count], [$step])
string	Iterar los caracteres de una cadena	Single::string($string)
takeWhile	Iterar elementos mientras el predicado es verdadero	Single::takeWhile($data, $predicate)

Iteración infinita

Iterador	Descripción	Fragmento de código
count	Contar secuencialmente para siempre	Infinite::count($start, $step)
cycle	Piclo a través de una colección	Infinite::cycle($collection)
repeat	Repita un artículo para siempre	Infinite::repeat($item)

Iteración aleatoria

Iterador	Descripción	Fragmento de código
choice	Selecciones aleatorias de la lista	Random::choice($list, $repetitions)
coinFlip	Flips de monedas aleatorios (0 o 1)	Random::coinFlip($repetitions)
number	Números aleatorios	Random::number($min, $max, $repetitions)
percentage	Porcentaje aleatorio entre 0 y 1	Random::percentage($repetitions)
rockPaperScissors	Manos al azar de rock-papel-Pisorsors	Random::rockPaperScissors($repetitions)

Iteración matemática

Iterador	Descripción	Fragmento de código
frequencies	Distribución de datos de frecuencia	Math::frequencies($data, [$strict])
relativeFrequencies	Distribución relativa de la frecuencia de los datos	Math::relativeFrequencies($data, [$strict])
runningAverage	Ejecución de acumulación promedio	Math::runningAverage($numbers, $initialValue)
runningDifference	Acumulación de diferencia de ejecución	Math::runningDifference($numbers, $initialValue)
runningMax	Ejecutando la máxima acumulación	Math::runningMax($numbers, $initialValue)
runningMin	Ejecución de acumulación mínima	Math::runningMin($numbers, $initialValue)
runningProduct	Ejecución de acumulación de productos	Math::runningProduct($numbers, $initialValue)
runningTotal	Acumulación total de ejecución	Math::runningTotal($numbers, $initialValue)

Establecer y iteración multiset

Iterador	Descripción	Fragmento de código
distinct	Iterar solo elementos distintos	Set::distinct($data)
distinctBy	Iterar solo elementos distintos usando un comparador personalizado	Set::distinct($data, $compareBy)
intersection	Intersección de iterables	Set::intersection(...$iterables)
intersectionCoercive	Intersección con coerción de tipo	Set::intersectionCoercive(...$iterables)
partialIntersection	Intersección parcial de iterables	Set::partialIntersection($minCount, ...$iterables)
partialIntersectionCoercive	Intersección parcial con coerción de tipo	Set::partialIntersectionCoercive($minCount, ...$iterables)
symmetricDifference	Diferencia simétrica de iterables	Set::symmetricDifference(...$iterables)
symmetricDifferenceCoercive	Diferencia simétrica con coerción de tipo	Set::symmetricDifferenceCoercive(...$iterables)
union	Unión de Iterables	Set::union(...$iterables)
unionCoercive	Unión con coerción de tipo	Set::unionCoercive(...$iterables)

Ordenar iteración

Iterador	Descripción	Fragmento de código
asort	Iterar una colección ordenada que mantiene claves	Sort::asort($data, [$comparator])
sort	Iterar una colección ordenada	Sort::sort($data, [$comparator])

Iteración de archivo

Iterador	Descripción	Fragmento de código
readCsv	Intersección un archivo csv línea por línea	File::readCsv($fileHandle)
readLines	Iterar un archivo línea por línea	File::readLines($fileHandle)

Transformar la iteración

Iterador	Descripción	Fragmento de código
tee	Iteradores duplicados iteradores	Transform::tee($data, $count)
toArray	Transformar ITerable en una matriz	Transform::toArray($data)
toAssociativeArray	Transformar ITerable en una matriz asociativa	Transform::toAssociativeArray($data, [$keyFunc], [$valueFunc])
toIterator	Transformar ITerable a un iterador	Transform::toIterator($data)

Resumen

Resumen	Descripción	Fragmento de código
allMatch	Cierto si todos los elementos son ciertos según el predicado	Summary::allMatch($data, $predicate)
allUnique	Cierto si todos los artículos son únicos	Summary::allUnique($data, [$strict])
anyMatch	Verdadero si algún elemento es cierto según el predicado	Summary::anyMatch($data, $predicate)
arePermutations	Verdadero si iterables son permutaciones entre sí	Summary::arePermutations(...$iterables)
arePermutationsCoercive	Verdadero si iterables son permutaciones entre sí con coerción de tipo	Summary::arePermutationsCoercive(...$iterables)
exactlyN	Cierto si exactamente n elementos son verdaderos según el predicado	Summary::exactlyN($data, $n, $predicate)
isEmpty	Cierto si iterable no tiene elementos	Summary::isEmpty($data)
isPartitioned	Cierto si se divide con elementos verdaderos según el predicado antes que otros	Summary::isPartitioned($data, $predicate)
isSorted	Verdadero si iterable ordenado	Summary::isSorted($data)
isReversed	Verdadero si iterable se clasifica en reverso	Summary::isReversed($data)
noneMatch	Cierto si ninguno de los elementos es cierto según el predicado	Summary::noneMatch($data, $predicate)
same	Verdadero si iterables son los mismos	Summary::same(...$iterables)
sameCount	Verdadero si iterable tiene las mismas longitudes	Summary::sameCount(...$iterables)

Reducir

Reductor	Descripción	Fragmento de código
toAverage	Promedio medio de elementos	Reduce::toAverage($numbers)
toCount	Reducir a la longitud de iterable	Reduce::toCount($data)
toFirst	Reducir a su primer valor	Reduce::toFirst($data)
toFirstAndLast	Reducir a sus primeros valores y últimos valores	Reduce::toFirstAndLast($data)
toLast	Reducir a su último valor	Reduce::toLast()
toMax	Reducir a su elemento más grande	Reduce::toMax($numbers, [$compareBy])
toMin	Reducir a su elemento más pequeño	Reduce::toMin($numbers, [$compareBy])
toMinMax	Reducir a la matriz de límites superiores e inferiores	Reduce::toMinMax($numbers, [$compareBy])
toNth	Reducir al valor en enésima posición	Reduce::toNth($data, $position)
toProduct	Reducir al producto de sus elementos	Reduce::toProduct($numbers)
toRandomValue	Reducir al valor aleatorio de itererable	Reduce::toRandomValue($data)
toRange	Reducir a la diferencia de valores máximos y min	Reduce::toRange($numbers)
toString	Reducir a una cadena unida	Reduce::toString($data, [$separator], [$prefix], [$suffix])
toSum	Reducir a la suma de sus elementos	Reduce::toSum($numbers)
toValue	Reducir al valor utilizando un reductor de llamada	Reduce::toValue($data, $reducer, $initialValue)

Herramientas de iteración de transmisión

Fuentes de transmisión

Fuente	Descripción	Fragmento de código
of	Crear una transmisión a partir de un iterable	Stream::of($iterable)
ofCoinFlips	Crea una corriente de volteretas de monedas aleatorias	Stream::ofCoinFlips($repetitions)
ofCsvFile	Crear una transmisión a partir de un archivo CSV	Stream::ofCsvFile($fileHandle)
ofEmpty	Crear una transmisión vacía	Stream::ofEmpty()
ofFileLines	Crear una transmisión a partir de líneas de un archivo	Stream::ofFileLines($fileHandle)
ofRandomChoice	Crear un flujo de selecciones aleatorias	Stream::ofRandomChoice($items, $repetitions)
ofRandomNumbers	Crear un flujo de números aleatorios (enteros)	Stream::ofRandomNumbers($min, $max, $repetitions)
ofRandomPercentage	Cree un flujo de porcentajes aleatorios entre 0 y 1	Stream::ofRandomPercentage($repetitions)
ofRange	Crear un flujo de una variedad de números	Stream::ofRange($start, $end, $step)
ofRockPaperScissors	Crea una corriente de manos de puestos de papel de roca	Stream::ofRockPaperScissors($repetitions)

Operaciones de transmisión

Operación	Descripción	Fragmento de código
asort	Clasifica la fuente iterable de mantenimiento de las teclas	$stream->asort([$comparator])
chainWith	Cadena iterable de fuente con iterables en una sola iteración	$stream->chainWith(...$iterables)
compress	Fuente de comprimir filtrando datos no seleccionados	$stream->compress($selectors)
compressAssociative	Fuente de comprimir filtrando teclas no seleccionadas	$stream->compressAssociative($selectorKeys)
chunkwise	Iterar por trozos	$stream->chunkwise($chunkSize)
chunkwiseOverlap	Iterar por trozos superpuestos	$stream->chunkwiseOverlap($chunkSize, $overlap)
distinct	Filtrar elementos de salida: iterar solo elementos únicos	$stream->distinct([$strict])
distinctBy	Filtrar elementos de salida: iterar solo elementos únicos usando un comparador personalizado	$stream->distinct($compareBy)
dropWhile	Deje caer elementos de la fuente iterable mientras que la función de predicado es verdadera	$stream->dropWhile($predicate)
filter	Filtrar solo para elementos donde la función de predicado es verdadera	$stream->filterTrue($predicate)
filterTrue	Filtrar solo para elementos verdaderos	$stream->filterTrue()
filterFalse	Filtrar solo para elementos falsos	$stream->filterFalse()
filterKeys	Filtrar para teclas donde la función de predicado es verdadera	$stream->filterKeys($predicate)
flatMap	Mapa de la función en elementos y aplanado el resultado	$stream->flatMap($function)
flatten	Aplanar la corriente multidimensional	$stream->flatten($dimensions)
frequencies	Distribución de frecuencia	$stream->frequencies([$strict])
groupBy	Grupo Iterable Fuente por un elemento de datos común	$stream->groupBy($groupKeyFunction, [$itemKeyFunc])
infiniteCycle	Ciclo a través de los elementos de la fuente Iterable secuencialmente para siempre	$stream->infiniteCycle()
intersectionWith	Intersectar la fuente iterable y dada iterable	$stream->intersectionWith(...$iterables)
intersection CoerciveWith	Intersectar la fuente iterable y dada iterable con coerción de tipo	$stream->intersectionCoerciveWith(...$iterables)
limit	Limitar la iteración de la corriente	$stream->limit($limit)
map	Mapa de la función en elementos	$stream->map($function)
pairwise	Devuelve pares de elementos de la fuente Iterable	$stream->pairwise()
partialIntersectionWith	Intersectar parcialmente la fuente iterable y dada iterable	$stream->partialIntersectionWith( $minIntersectionCount, ...$iterables)
partialIntersection CoerciveWith	Intersectar parcialmente la fuente iterable y dada iterable con coerción de tipo	$stream->partialIntersectionCoerciveWith( $minIntersectionCount, ...$iterables)
reindex	Reindex Keys of Key-Value Stream	$stream->reindex($reindexer)
relativeFrequencies	Distribución de frecuencia relativa	$stream->relativeFrequencies([$strict])
reverse	Elementos inverso de la transmisión	$stream->reverse()
runningAverage	Acumular el promedio de ejecución (media) sobre la fuente iterable	$stream->runningAverage($initialValue)
runningDifference	Acumular la diferencia de ejecución sobre la fuente iterable	$stream->runningDifference($initialValue)
runningMax	Acumular el máximo de ejecución sobre la fuente iterable	$stream->runningMax($initialValue)
runningMin	Acumular el minuto de carrera sobre la fuente iterable	$stream->runningMin($initialValue)
runningProduct	Acumular el producto en ejecución sobre la fuente iterable	$stream->runningProduct($initialValue)
runningTotal	Acumular el total de la carrera sobre la fuente iterable	$stream->runningTotal($initialValue)
skip	Omita algunos elementos de la corriente	$stream->skip($count, [$offset])
slice	Extraer una porción de la corriente	$stream->slice([$start], [$count], [$step])
sort	Clasifica la transmisión	$stream->sort([$comparator])
symmetricDifferenceWith	Diferencia simétrica de fuente iterable y dada iterable	$this->symmetricDifferenceWith(...$iterables)
symmetricDifference CoerciveWith	Diferencia simétrica de fuente iterable y dada iterable con coerción de tipo	$this->symmetricDifferenceCoerciveWith( ...$iterables)
takeWhile	Elementos de retorno de la fuente Iterable siempre que el predicado sea verdadero	$stream->takeWhile($predicate)
unionWith	Unión de Stream con iterables	$stream->unionWith(...$iterables)
unionCoerciveWith	Unión de transmisión con iterables con coerción de tipo	$stream->unionCoerciveWith(...$iterables)
zipWith	Iterer iterable fuente con otra colección iterable simultáneamente	$stream->zipWith(...$iterables)
zipEqualWith	Iterer iterable fuente con otra colección iterable de igual longitudes simultáneamente	$stream->zipEqualWith(...$iterables)
zipFilledWith	Iterer iterable Fuente con otra colección Iterable usando un relleno predeterminado	$stream->zipFilledWith($default, ...$iterables)
zipLongestWith	Iterer iterable fuente con otra colección iterable simultáneamente	$stream->zipLongestWith(...$iterables)

Operaciones de terminales de flujo

Operaciones terminales resumidas

Operación terminal	Descripción	Fragmento de código
allMatch	Devuelve verdadero si todos los elementos en la transmisión coinciden con predicado	$stream->allMatch($predicate)
allUnique	Devuelve verdadero si todos los elementos en la transmisión son únicos	$stream->allUnique([$strict]])
anyMatch	Devuelve verdadero si algún elemento en el flujo coincide con predicado	$stream->anyMatch($predicate)
arePermutationsWith	Devuelve verdadero si todas las permutaciones iterables de la transmisión	$stream->arePermutationsWith(...$iterables)
arePermutationsCoerciveWith	Devuelve verdadero si todas las permutaciones iterables de la transmisión con coerción de tipo	$stream->arePermutationsCoerciveWith(...$iterables)
exactlyN	Devuelve verdadero si exactamente n elementos son verdaderos según el predicado	$stream->exactlyN($n, $predicate)
isEmpty	Devuelve verdadero si la transmisión no tiene elementos	$stream::isEmpty()
isPartitioned	Devuelve verdadero si se divide con elementos verdaderos según el predicado antes de los demás	$stream::isPartitioned($predicate)
isSorted	Devuelve verdadero si la transmisión se clasifica en orden ascendente	$stream->isSorted()
isReversed	Devuelve verdadero si la transmisión se clasifica en orden descendente inversa	$stream->isReversed()
noneMatch	Devuelve verdadero si ninguno de los elementos en el predicado de coincidencia de flujo	$stream->noneMatch($predicate)
sameWith	Devuelve verdadero si la transmisión y todas las colecciones dadas son las mismas	$stream->sameWith(...$iterables)
sameCountWith	Devuelve verdadero si la transmisión y todas las colecciones dadas tienen las mismas longitudes	$stream->sameCountWith(...$iterables)

Operaciones terminales de reducción

Operación terminal	Descripción	Fragmento de código
toAverage	Reduce la corriente al promedio medio de sus elementos	$stream->toAverage()
toCount	Reduce la corriente	$stream->toCount()
toFirst	Reduce la corriente a su primer valor	$stream->toFirst()
toFirstAndLast	Reduce la corriente a sus primeros y últimos valores	$stream->toFirstAndLast()
toLast	Reduce la corriente a su último valor	$stream->toLast()
toMax	Reduce la corriente a su valor máximo	$stream->toMax([$compareBy])
toMin	Reduce la corriente a su valor mínimo	$stream->toMin([$compareBy])
toMinMax	Reduce la corriente a la matriz de los límites superior e inferior	$stream->toMinMax([$compareBy])
toNth	Reduce la corriente al valor en la décima posición	$stream->toNth($position)
toProduct	Reduce la corriente al producto de sus artículos	$stream->toProduct()
toString	Reduce la corriente a la cadena unida	$stream->toString([$separator], [$prefix], [$suffix])
toSum	Reduce la corriente a la suma de sus artículos	$stream->toSum()
toRandomValue	Reduce la corriente al valor aleatorio dentro de él	$stream->toRandomValue()
toRange	Reduce la corriente a la diferencia de valores máximos y min	$stream->toRange()
toValue	Reduce la función como array_reduce ()	$stream->toValue($reducer, $initialValue)

Operaciones de terminal de transformación

Operación terminal	Descripción	Fragmento de código
toArray	Devuelve la matriz de elementos de transmisión	$stream->toArray()
toAssociativeArray	Devuelve el mapa de valor clave de los elementos de transmisión	$stream->toAssociativeArray($keyFunc, $valueFunc)
tee	Devuelve la matriz de múltiples corrientes idénticas	$stream->tee($count)

Operaciones terminales de efectos secundarios

Operación terminal	Descripción	Fragmento de código
callForEach	Realizar acción a través de la función en cada elemento	$stream->callForEach($function)
print	print cada artículo en la transmisión	$stream->print([$separator], [$prefix], [$suffix])
printLn	print cada artículo en una nueva línea	$stream->printLn()
toCsvFile	Escriba el contenido de la transmisión a un archivo CSV	$stream->toCsvFile($fileHandle, [$headers])
toFile	Escriba el contenido de la transmisión en un archivo	$stream->toFile($fileHandle)

Transmisión de operaciones de depuración

Operación de depuración	Descripción	Fragmento de código
peek	Echa un vistazo a cada elemento entre las operaciones de transmisión	$stream->peek($peekFunc)
peekStream	Echa un vistazo a toda la transmisión entre operaciones	$stream->peekStream($peekFunc)
peekPrint	Echa un vistazo a cada elemento imprimiendo entre operaciones	$stream->peekPrint()
peekPrintR	Echa un vistazo a cada elemento realizando impresiones entre operaciones	$stream->peekPrintR()
printR	print_r cada elemento	$stream->printR()
varDump	var_dump cada elemento	$stream->varDump()

Configuración

Agregue la biblioteca a su archivo composer.json en su proyecto:

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

Use el compositor para instalar la biblioteca:

$ php composer.phar install

El compositor instalará ITerTools dentro de su carpeta de proveedores. Luego, puede agregar lo siguiente a sus archivos .php para usar la biblioteca con autolaading.

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

Alternativamente, use el compositor en la línea de comando para requerir e instalar iTerTools:

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

Requisitos mínimos

• PHP 7.4

Uso

Todas las funciones funcionan en colecciones iterable :

• array (tipo)
• Generator (tipo)
• Iterator (interfaz)
• Traversable (interfaz)

Múltiples iteraciones

Cadena

Cadena múltiples iterables juntos en una sola secuencia continua.

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'

Cremallera

Iterar múltiples colecciones iterables simultáneamente.

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 funciona con múltiples entradas iterables, no limitadas a solo dos.

 $ 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 );
}

Nota: Para longitudes desiguales, la iteración se detiene cuando el iterable más corto está agotado.

Zipequal

Itera múltiples colecciones iterables con igual longitudes simultáneamente.

Lanza LengthException si las longitudes no son iguales, lo que significa que al menos un iterador termina antes que los demás.

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]
}

Con descarado

Iterar múltiples colecciones iterables simultáneamente, utilizando un valor de relleno predeterminado si las longitudes no son iguales.

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]
}

El más exagerado

Iterar múltiples colecciones iterables simultáneamente.

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

Para longitudes desiguales, los iterables agotados producirán null para las iteraciones 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]
}

Iteración única

Fragmento

Elementos de retorno en trozos de cierto tamaño.

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

El tamaño del trozo debe ser al menos 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]'
// ]

Superposición de fragmento

Devuelve trozos de elementos superpuestos.

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

• El tamaño del trozo debe ser al menos 1.
• El tamaño de superposición debe ser menos que el tamaño del trozo.

 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]
}

Comprimir

Comprimir un iterable filtrando datos que no están seleccionados.

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'

Comprimido asociativo

Comprimir una iterable filtrando teclas que no se seleccionan.

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

• Llaves estándar de matriz PHP/iterador (String, entero).

 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

Dejar caer mientras

Deje caer elementos del itererable mientras que la función de predicado es verdadero.

Una vez que la función de predicado devuelve falso una vez, se devuelven todos los elementos restantes.

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

Filtrar

Filtre los elementos de los elementos iciables solo de regreso donde la función de predicado es verdadera.

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

Filtrar verdadero

Filtre elementos de los elementos iterables que son de regreso que son verdaderos.

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

Filtro falso

Filtre los elementos de los elementos iterables de regreso solo donde la función de predicado es falso.

Si no se proporciona ningún predicado, se utiliza el valor booleano de los datos.

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

Teclas de filtro

Filtre los elementos de los elementos iterables de regreso solo para los que las teclas la función de predicado es verdadero.

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

Mapa plana

Mapee una función solo los elementos de lo iterable y luego aplane los resultados.

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

Aplanar

Aplanar un iterable multidimensional.

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]

Agrupar

Datos de grupo por un elemento de datos común.

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

• El $groupKeyFunction determina la clave para los elementos grupales por.
• El $itemKeyFunction opcional permite índices personalizados dentro de cada miembro del grupo.

 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'],
*/

Límite

Iterar hasta un límite.

Se detiene incluso si se alcanza más datos disponibles si se alcanza el límite.

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)

Mapa

Mapee una función en cada elemento.

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

A pareja

Devuelve pares superpuestos sucesivos.

Devuelve el generador vacío si la colección dada contiene menos de 2 elementos.

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, ...

Repetir

Repita un elemento.

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'

Reindex

Reindex Keys of Key-Value ITerable utilizando la función indexador.

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,
//     ],
// ]

Contrarrestar

Invierta los elementos de un itererable.

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

Saltar

Omita los elementos N en el iterable después de la compensación opcional de desplazamiento.

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'

Rebanada

Extraiga una porción de la iterable.

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]

Cadena

Iterar los caracteres individuales de una cadena.

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']

Tomar mientras

Elementos de retorno del ITerable siempre que el predicado sea verdadero.

Detiene la iteración tan pronto como el predicado regrese falso, incluso si otros elementos más adelante eventualmente devolverían verdadero (diferente 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 

Iteración infinita

Contar

Cuente secuencialmente para siempre.

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 ...

Ciclo

Ciclo a través de los elementos de una colección secuencialmente para siempre.

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, ...

Repetir (infinito)

Repita un elemento para siempre.

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?', ... 

Iteración aleatoria

Elección

Genere selecciones aleatorias a partir de una matriz de valores.

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]

Coinflip

Genere volteos de monedas aleatorios (0 o 1).

Random::coinFlip(int $repetitions)

 use IterTools  Random ;

$ repetitions = 10 ;

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

Número

Genere números aleatorios (enteros).

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]

Porcentaje

Genere un porcentaje aleatorio entre 0 y 1.

Random::percentage(int $repetitions)

 use IterTools  Random ;

$ repetitions = 10 ;

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

Rockpaperscissors

Genere las manos aleatorias de puestos de papel de roca.

Random::rockPaperScissors(int $repetitions)

 use IterTools  Random ;

$ repetitions = 10 ;

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

Iteración matemática

Frecuencias

Devuelve una distribución de frecuencia de los datos.

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

El valor predeterminado se aplica a comparaciones de tipo estricto. Establezca estricto a falso para las comparaciones de coerción de tipo.

 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

Frecuencias relativas

Devuelve una distribución de frecuencia relativa de los datos.

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

El valor predeterminado se aplica a comparaciones de tipo estricto. Establezca estricto a falso para las comparaciones de coerción de tipo.

 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

Promedio de ejecución

Acumular el promedio de ejecución en una lista de números.

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

Diferencia de carrera

Acumular la diferencia de ejecución en una lista de números.

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

Proporcione un valor inicial opcional para liderar la diferencia de ejecución.

 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

Acumular el máximo de ejecución en una lista de números.

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

Correr min

Acumular el mínimo de ejecución en una lista de números.

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

Producto en funcionamiento

Acumular el producto en ejecución en una lista de números.

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

Proporcione un valor inicial opcional para liderar el producto en ejecución.

 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 carrera

Acumular el total de ejecución en una lista de números.

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

Proporcione un valor inicial opcional para liderar el total de ejecución.

 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 

Establecer y multiset

Distinto

Filtre los elementos de los elementos distintos que solo devuelven.

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

El valor predeterminado se aplica a comparaciones de tipo estricto. Establezca estricto a falso para las comparaciones de coerción de tipo.

 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

Distinto por

Filtre los elementos de los elementos distintos que solo devuelven de acuerdo con una función de comparación personalizada.

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.

Intersección

Iteria la intersección de iterables.

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

Si la entrada iterable produce elementos duplicados, entonces se aplican las reglas de intersección multiset.

 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

Intersección coercitiva

Iteria la intersección de iterables usando la coerción de tipo.

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

Si la entrada iterable produce elementos duplicados, entonces se aplican las reglas de intersección multiset.

 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

Intersección parcial

Itera la intersección M-partial de iterables.

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

• Si la entrada iterable produce elementos duplicados, entonces se aplican las reglas de intersección multiset.

 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

Coercitivo de intersección parcial

Itera la intersección M-partial de iterables utilizando la coerción de tipo.

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

• Si la entrada iterable produce elementos duplicados, entonces se aplican las reglas de intersección multiset.

 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

Diferencia simétrica

Itera la diferencia simétrica de iterables.

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

Si la entrada iterable produce elementos duplicados, entonces se aplican las reglas de diferencia multiset.

 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

Diferencia simétrica coercitiva

Itera la diferencia simétrica de iterables con coerción de tipo.

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

Si la entrada iterable produce elementos duplicados, entonces se aplican las reglas de diferencia multiset.

 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

Unión

Itera la Unión de Iterables.

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

Si la entrada iterable produce elementos duplicados, entonces se aplican las reglas de la Unión Multiset.

 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

Coercitivo sindical

Itera la unión de iterables con coerción de tipo.

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

Si la entrada iterable produce elementos duplicados, entonces se aplican las reglas de la Unión Multiset.

 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 

Ordenar iteración

Asor

Iterar la colección ordenada mientras mantiene las relaciones de índice de clave asociativa.

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

Utiliza la clasificación predeterminada si no se proporciona función de comparación opcional.

 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

Clasificar

Iterar la colección ordenada.

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

Utiliza la clasificación predeterminada si no se proporciona función de comparación opcional.

 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 

Archivo

Leer CSV

Iterar las líneas de un archivo 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

Leer líneas

Iterar las líneas de un archivo.

File::readLines(resource $fileHandle)

 use IterTools  File ;

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

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

Transformar

Tee

Devuelve varios iteradores independientes (duplicados) de un solo iterable.

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']

A la matriz

Transforma cualquier iterable en una matriz.

Transform::toArray(iterable $data): array

 use IterTools  Transform ;

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

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

A una matriz asociativa

Transforma cualquier iterable en una matriz asociativa.

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',
// ]

Al iterador

Transforma cualquier iterable a un iterador.

Transform::toArray(iterable $data): array

 use IterTools  Transform ;

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

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

Resumen

Todo partido

Devuelve verdadero si todos los elementos coinciden con la función de predicado.

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

Todo único

Devuelve verdadero si todos los elementos son únicos.

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

El valor predeterminado se aplica a comparaciones de tipo estricto. Establezca estricto a falso para las comparaciones de coerción de tipo.

 use IterTools  Summary ;

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

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

Cualquier partido

Devuelve verdadero si algún elemento coincide con la función de predicado.

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

Son permutaciones

Devuelve verdadero si todos los iterables son permutaciones entre sí.

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

Son permutaciones coercitivas

Devuelve verdadero si todos los iterables son permutaciones entre sí con coerción de tipo.

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

Exactamente n

Devuelve verdadero si exactamente n elementos son verdaderos según una función de predicado.

• El predicado es opcional.
• El predicado predeterminado es el valor booleano de cada elemento.

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

Esta vacío

Devuelve verdadero si el Iterable está vacío no tiene elementos.

Summary::isEmpty(iterable $data): bool

 use IterTools  Summary ;

$ data = []

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

Está dividido

Devuelve verdadero si todos los elementos de la colección dada que satisfacen el predicado aparecen antes de todos los elementos que no.

• Devuelve verdadero para la colección vacía o para la colección con un solo elemento.
• El predicado predeterminado si no se proporciona es el valor booleano de cada elemento de datos.

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á ordenado

Devuelve verdadero si los elementos están ordenados, de lo contrario falsos.

• Los elementos deben ser comparables.
• Devuelve verdadero si está vacío o solo tiene un elemento.

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á invertido

Devuelve verdadero si los elementos se clasifican inversamente, de lo contrario falso.

• Los elementos deben ser comparables.
• Devuelve verdadero si está vacío o solo tiene un elemento.

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

Ninguno de los partidos

Devuelve verdadero si ningún elemento coincide con la función de predicado.

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

Mismo

Devuelve verdadero si todas las colecciones dadas son las mismas.

Para una sola lista de iterables iterable o vacía devuelve verdadero.

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

Mismo recuento

Devuelve verdadero si todas las colecciones dadas tienen las mismas longitudes.

Para una sola lista de iterables iterable o vacía devuelve verdadero.

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 

Reducir

A promedio

Se reduce al promedio medio.

Devuelve nulo si la colección está vacía.

Reduce::toAverage(iterable $data): float

 use IterTools  Reduce ;

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

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

Para contar

Se reduce a su longitud.

Reduce::toCount(iterable $data): int

 use IterTools  Reduce ;

$ someIterable = ImportantThing:: getCollectionAsIterable ();

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

Al primero

Se reduce a su primer elemento.

Reduce::toFirst(iterable $data): mixed

Lanza LengthException si la colección está vacía.

 use IterTools  Reduce ;

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

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

Primero y durar

Se reduce a su primer y último elemento.

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

Lanza LengthException si la colección está vacía.

 use IterTools  Reduce ;

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

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

Para durar

Se reduce a su último elemento.

Reduce::toLast(iterable $data): mixed

Lanza LengthException si la colección está vacía.

 use IterTools  Reduce ;

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

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

A Max

Se reduce al valor máximo.

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

• Parámetro llamable opcional $compareBy debe devolver un valor comparable.
• Si no se proporciona $compareBy , los elementos de la colección dada deben ser comparables.
• Devuelve nulo si la colección está vacía.

 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
// ];

A min

Se reduce al valor min.

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

• Parámetro llamable opcional $compareBy debe devolver un valor comparable.
• Si no se proporciona $compareBy , los elementos de la colección dada deben ser comparables.
• Devuelve nulo si la colección está vacía.

 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
// ]

A min max

Se reduce a la matriz de sus límites superior e inferior (máx y min).

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

• Parámetro llamable opcional $compareBy debe devolver un valor comparable.
• Si no se proporciona $compareBy , los elementos de la colección dada deben ser comparables.
• Devuelve [null, null] si la colección dada está vacía.

 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
//     ],
// ]

A enésimo

Se reduce al valor en la enésima posición.

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

Al producto

Se reduce al producto de sus elementos.

Devuelve nulo si la colección está vacía.

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

 use IterTools  Reduce ;

$ primeFactors = [ 5 , 2 , 2 ];

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

Al valor aleatorio

Reduce la colección dada a un valor aleatorio dentro de él.

Reduce::toRandomValue(iterable $data): mixed

 use IterTools  Reduce ;

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

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

Para alcanzar

Reduce la colección dada a su rango (diferencia entre Max y Min).

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

Devuelve 0 si la fuente iterable está vacía.

 use IterTools  Reduce ;

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

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

A la cuerda

Se reduce a una cadena que une todos los elementos.

• Separador opcional para insertar entre elementos.
• Prefijo opcional para prevenir la cadena.
• Sufijo opcional para agregar a la cadena.

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!

A suma

Se reduce a la suma de sus elementos.

Reduce::toSum(iterable $data): number

 use IterTools  Reduce ;

$ parts = [ 10 , 20 , 30 ];

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

Para valorar

Reduzca elementos a un solo valor utilizando la función reductor.

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 

Arroyo

Las transmisiones proporcionan una interfaz fluida para transformar matrices y iterables a través de una tubería de operaciones.

Las transmisiones están formadas por:

1. Un método de fábrica de origen de flujo para crear la secuencia.
2. Cero o más operadores de transmisión que transforman la transmisión en una nueva transmisión.
3. Operación terminal de cualquiera de los dos:
   • Operación del terminal de flujo para transformar la secuencia en un valor o estructura de datos.

    $ 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

   • La transmisión se itera a través de un bucle 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
   }

Fuentes de transmisión

De

Crea la corriente de un iterable.

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 volteos de monedas

Crea flujo de n voltientes de monedas aleatorias.

Stream::ofCoinFlips(int $repetitions): Stream

 use IterTools  Stream ;

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

Del archivo CSV

Crea un flujo de filas de un archivo 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 vacío

Crea flujo de nada.

Stream::ofEmpty(): Stream

 use IterTools  Stream ;

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

De líneas de archivo

Crea un flujo de líneas de un archivo.

Stream::ofFileLines(resource $fileHandle): Stream

 use IterTools  Stream ;

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

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

De elección aleatoria

Crea flujo de selecciones aleatorias a partir de una matriz de valores.

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 números aleatorios

Crea flujo de números aleatorios (enteros).

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 porcentaje aleatorio

Crea un flujo de porcentajes aleatorios entre 0 y 1.

Stream::ofRandomPercentage(int $repetitions): Stream

 use IterTools  Stream ;

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

De rango

Crea flujo de una variedad de números.

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 tijeras de papel rock

Crea la corriente de manos de puestos de papel de roca.

Stream::ofRockPaperScissors(int $repetitions): Stream

 use IterTools  Stream ;

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

Operaciones de transmisión

Asor

Clasifica la transmisión, manteniendo las teclas.

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

Si no se proporciona un comparador, los elementos de la fuente iterable deben ser 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, 

Cadena con

Devuelva una corriente que encadene fuentes adicionales en una sola corriente consecutiva.

$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 

Comprimir

Complete a una nueva secuencia filtrando datos que no están seleccionados.

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

Los selectores indican qué datos. El valor verdadero selecciona el elemento. El valor falso filtra datos.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

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

Comprimido asociativo

Complete a una nueva transmisión filtrando teclas que no se seleccionan.

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

• Llaves estándar de matriz PHP/iterador (String, entero).

 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', 

Fragmento

Devuelve una transmisión que consiste en trozos de elementos de la transmisión.

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

El tamaño del trozo debe ser al menos 1.

 use IterTools  Stream ;

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

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

Superposición de fragmento

Devuelve una transmisión que consiste en trozos superpuestos de elementos de la transmisión.

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

• El tamaño del trozo debe ser al menos 1.
• El tamaño de superposición debe ser menos que el tamaño del trozo.

 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] 

Distinto

Devuelva una transmisión que filtrara elementos de la transmisión solo que devuelve elementos distintos.

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

El valor predeterminado se aplica a comparaciones de tipo estricto. Establezca estricto a falso para las comparaciones de coerción de tipo.

 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 

Distinto por

Devuelva una transmisión que filtrara elementos de la secuencia solo que devuelve elementos distintos de acuerdo con una función de comparación personalizada.

$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 

Dejar caer mientras

Deje caer elementos de la transmisión mientras la función de predicado es verdadero.

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

Una vez que la función de predicado devuelve falso una vez, se devuelven todos los elementos restantes.

 use IterTools  Stream ;

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

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

Filtrar

Filtre los elementos de la secuencia solo manteniendo elementos donde su función de predicado es verdadera.

$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 

Filtrar verdadero

Filtre los elementos de la transmisión solo manteniendo elementos que son verdaderos.

$stream->filterTrue(): Stream

 use IterTools  Stream ;

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

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

Filtro falso

Filtre los elementos de la secuencia solo manteniendo elementos que son falsos.

$stream->filterFalse(): Stream

 use IterTools  Stream ;

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

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

Teclas de filtro

Filtre los elementos de la transmisión solo manteniendo elementos donde la función de predicado en las teclas es verdadero.

$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 

Mapa plana

Mapee una función en los elementos de la transmisión y aplane los resultados.

$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] 

Aplanar

Aplanar una corriente multidimensional.

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

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

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

Frecuencias

Distribución de frecuencia de los elementos de la corriente.

$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] 

Agrupar

Devuelva una agrupación de flujo por un elemento de datos común.

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

• El $groupKeyFunction determina la clave para los elementos grupales por.
• El $itemKeyFunction opcional permite índices personalizados dentro de cada miembro del grupo.

 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]
}

Ciclo infinito

Devuelve un ciclismo de flujo a través de los elementos de la transmisión secuencialmente para siempre.

$stream->infiniteCycle(): Stream

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

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

Intersección con

Devuelve una secuencia que intersecte la secuencia con la entrada iterable.

$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 

Intersección coercitiva con

Devuelva una secuencia que intersecte la secuencia con la entrada iterable usando la coerción de tipo.

$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' 

Límite

Devolver una transmisión a un límite.

Se detiene incluso si se alcanza más datos disponibles si se alcanza el límite.

$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) 

Mapa

Devuelva una secuencia que contenga el resultado de mapear una función en cada elemento de la secuencia.

$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 

A pareja

Devuelve una transmisión que consiste en pares de elementos de la transmisión.

$stream->pairwise(): Stream

Devuelve la transmisión vacía si la colección dada contiene menos de 2 elementos.

 use IterTools  Stream ;

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

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

Intersección parcial con

Devuelva una transmisión parcialmente que intersecte la transmisión con la entrada iterable.

$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 

Intersección parcial coercitiva con

Devuelva una transmisión que intersecte parcialmente la secuencia con los iterables de entrada usando la coerción de tipo.

$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' 

Reindex

Devuelve una nueva secuencia de elementos de valor clave reindexado por la función de indexador clave.

$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,
//     ],
// ] 

Frecuencias relativas

Distribución de frecuencia relativa de los elementos de la corriente.

$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 

Contrarrestar

Invierta los elementos de una transmisión.

$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 

Promedio de ejecución

Devuelva una transmisión que acumule el promedio de ejecución (media) sobre la corriente.

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

 use IterTools  Stream ;

$ input = [ 1 , 3 , 5 ];

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

Diferencia de carrera

Devuelva una transmisión que acumule la diferencia de ejecución sobre la transmisión.

$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

Devuelva una transmisión que acumule el máximo de ejecución sobre la transmisión.

$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 

Correr min

Devuelva una transmisión que acumule el minuto de carrera sobre la transmisión.

$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 

Producto en funcionamiento

Devuelva una transmisión que acumule el producto en ejecución sobre la transmisión.

$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 carrera

Devuelva una transmisión que acumule el total de ejecución sobre la corriente.

$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 

Saltar

Omita algunos elementos de la corriente.

$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' 

Rebanada

Extraiga una porción de la corriente.

$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] 

Clasificar

Clasifica la transmisión.

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

Si no se proporciona un comparador, los elementos de la fuente iterable deben ser 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 

Diferencia simétrica con

Devuelva una secuencia de la diferencia simétrica de la transmisión y los iterables dados.

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

Nota: Si la entrada iterable produce elementos duplicados, entonces se aplican las reglas de intersección multisetín.

 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 

Diferencia simétrica coercitiva con

Devuelva una secuencia de la diferencia simétrica de la transmisión y los iterables dados usando la coerción de tipo.

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

Nota: Si la entrada iterable produce elementos duplicados, entonces se aplican las reglas de intersección multisetín.

 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 

Tomar mientras

Mantenga elementos de la corriente siempre que el predicado sea verdadero.

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

Si no se proporciona ningún predicado, se utiliza el valor booleano de los datos.

 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 

Sindicato con

Devuelve una transmisión que consiste en la unión de la transmisión y la entrada iterable.

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

Nota: Si la entrada iterable produce elementos duplicados, entonces se aplican las reglas de la Unión Multiset.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

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

Unión coercitiva con

Devuelve una secuencia que consiste en la unión de la transmisión y la entrada iterable usando la coerción de tipo.

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

Nota: Si la entrada iterable produce elementos duplicados, entonces se aplican las reglas de la Unión Multiset.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

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

Con cremallera con

Devuelve una transmisión que consta de múltiples colecciones iterables transmitidas simultáneamente.

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

Para longitudes desiguales, las iteraciones se detienen cuando el iterable más corto está agotado.

 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 lleno de

Devuelva una secuencia que consta de múltiples colecciones iterables, utilizando un valor de relleno predeterminado si longitudes no iguales.

$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 igual a

Devolver una transmisión que consta de múltiples colecciones iterables de igual longitudes transmitidas simultáneamente.

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

Funciona como el método Stream::zipWith() pero lanza longitudException si las longitudes no son iguales, es decir, al menos un iterador termina antes que los demás.

 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 más tiempo con

Devuelve una transmisión que consta de múltiples colecciones iterables transmitidas simultáneamente.

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

• La iteración continúa hasta que se agota el iterable más largo.
• Para longitudes desiguales, los iterables agotados producirán nulos para las iteraciones 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]
}

Operaciones de terminales de flujo

Operaciones terminales de resumen de flujo

Todo partido

Devuelve verdadero si todos los elementos coinciden con la función de predicado.

$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 

Todo único

Devuelve verdadero si todos los elementos son únicos.

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

El valor predeterminado se aplica a comparaciones de tipo estricto. Establezca estricto a falso para las comparaciones de coerción de tipo.

 use IterTools  Summary ;

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

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

Cualquier partido

Devuelve verdadero si algún elemento coincide con la función de predicado.

$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 

Son permutaciones con

Devuelve verdadero si todos los iterables son permutaciones con la transmisión.

$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 

¿Son las permutaciones coercitivas con

Devuelve verdadero si todos los iterables son permutaciones con flujo con coerción de tipo.

$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 

Exactamente n

Devuelve verdadero si exactamente n elementos son verdaderos según una función de predicado.

• El predicado es opcional.
• El predicado predeterminado es el valor booleano de cada elemento.

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

 use IterTools  Summary ;

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

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

Esta vacío

Devuelve verdadero si la transmisión está vacía sin artículos.

$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á dividido

Devuelve verdadero si todos los elementos de la colección dada que satisfacen el predicado aparecen antes de todos los elementos que no.

• Devuelve verdadero para la colección vacía o para la colección con un solo elemento.
• El predicado predeterminado si no se proporciona es el valor booleano de cada elemento de datos.

$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á ordenado

Devuelve verdadero si la fuente iterable se clasifica en orden ascendente; de lo contrario falso.

$stream->isSorted(): bool

Los elementos de la fuente iterable deben ser comparables.

Devuelve verdadero si la fuente iterable está vacía o solo tiene un elemento.

 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á invertido

Devuelve verdadero si la fuente iterable se clasifica en orden descendente inversa; de lo contrario falso.

$stream->isReversed(): bool

Los elementos de la fuente iterable deben ser comparables.

Devuelve verdadero si la fuente iterable está vacía o solo tiene un elemento.

 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 

Ninguno de los partidos

Devuelve verdadero si ningún elemento coincide con la función de predicado.

$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 

Lo mismo con

Devuelve verdadero si es una fuente iterable y todas las colecciones dadas son las mismas.

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

Para la lista de iterables vacías devuelve verdadero.

 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 

Mismo recuento con

Devuelve verdadero si es una fuente iterable y todas las colecciones dadas tienen las mismas longitudes.

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

Para la lista de iterables vacías devuelve verdadero.

 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 

Operaciones terminales de reducción de flujo

A promedio

Reduce la fuente iterable al promedio medio de sus elementos.

$stream->toAverage(): mixed

Devuelve nulo si la fuente iterable está vacía.

 use IterTools  Stream ;

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

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

Para contar

Reduce la fuente iterable a su longitud.

$stream->toCount(): mixed

 use IterTools  Stream ;

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

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

Al primero

Reduce la fuente iterable a su primer elemento.

$stream->toFirst(): mixed

Lanza LengthException si la fuente iterable está vacía.

 use IterTools  Stream ;

$ input = [ 10 , 20 , 30 ];

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

Primero y durar

Reduce la fuente iterable a su primer y último elemento.

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

Lanza LengthException si la fuente iterable está vacía.

 use IterTools  Stream ;

$ input = [ 10 , 20 , 30 ];

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

Para durar

Reduce la fuente iterable a su último elemento.

$stream->toLast(): mixed

Lanza LengthException si la fuente iterable está vacía.

 use IterTools  Stream ;

$ input = [ 10 , 20 , 30 ];

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

A Max

Reduce la fuente iterable a su valor máximo.

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

• Parámetro llamable opcional $compareBy debe devolver un valor comparable.
• Si no se proporciona $compareBy , los elementos de la colección dada deben ser comparables.
• Devuelve nulo si la colección está vacía.

 use IterTools  Stream ;

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

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

A min

Reduce la fuente iterable a su valor mínimo.

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

• Parámetro llamable opcional $compareBy debe devolver un valor comparable.
• Si no se proporciona $compareBy , los elementos de la colección dada deben ser comparables.
• Devuelve nulo si la colección está vacía.

 use IterTools  Stream ;

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

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

A min max

Reduce la corriente a la matriz de sus límites superior e inferior (máx y min).

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

• Parámetro llamable opcional $compareBy debe devolver un valor comparable.
• Si no se proporciona $compareBy , los elementos de la colección dada deben ser comparables.
• Devuelve [null, null] si la colección dada está vacía.

 use IterTools  Stream ;

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

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

A enésimo

Reduce la corriente al valor en la enésima posición.

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

Devuelve nulo si la fuente iterable está vacía.

 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 

Al producto

Reduce la corriente al producto de sus artículos.

$stream->toProduct(): mixed

Devuelve nulo si la fuente iterable está vacía.

 use IterTools  Stream ;

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

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

Al valor aleatorio

Reduce la corriente a un valor aleatorio dentro de él.

$stream->toRandomValue(): mixed

 use IterTools  Stream ;

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

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

Para alcanzar

Reduce la corriente a su rango (diferencia entre Max y Min).

$stream->toRange(): int|float

Devuelve 0 si la fuente iterable está vacía.

 use IterTools  Stream ;

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

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

A la cuerda

Se reduce a una cadena que une todos los elementos.

• Separador opcional para insertar entre elementos.
• Prefijo opcional para prevenir la cadena.
• Sufijo opcional para agregar a la cadena.

$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! 

A suma

Reduce la fuente iterable a la suma de sus elementos.

$stream->toSum(): mixed

 use IterTools  Stream ;

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

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

Para valorar

Reduce la fuente ITerable como la función Array_reduce ().

Pero a diferencia de array_reduce() , funciona con todos los tipos 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 

Operaciones de terminal de transformación

A la matriz

Devuelve una matriz de elementos de transmisión.

$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] 

A una matriz asociativa

Devuelve un mapa de valor clave de los elementos de transmisión.

$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

Devuelve varias transmisiones independientes (duplicadas).

$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'] 

Operaciones terminales de efectos secundarios

Llamar para cada

Realice una acción a través de una llamada en cada elemento en la transmisión.

$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
// ... 

Imprimir

Imprime cada artículo en la transmisión.

• Los artículos deben ser imprimibles.

$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! 

Línea de impresión

Imprime cada elemento en la transmisión en su propia línea.

• Los artículos deben ser imprimibles.

$stream->println(): void

 use IterTools  Stream ;

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

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

Al archivo CSV

Escriba el contenido de la transmisión a un archivo 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 

Para presentar

Escriba el contenido de la transmisión en un archivo.

$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>

Transmisión de operaciones de depuración

Ojeada

Mira cada elemento entre otras operaciones de transmisión para hacer alguna acción sin modificar la transmisión.

$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 );

Transmisión

Echa un vistazo a toda la transmisión entre otras operaciones de transmisión para hacer alguna acción sin modificar la transmisión.

$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 );

Impresión

Mira cada elemento entre otras operaciones de transmisión para imprimir cada elemento sin modificar la transmisión.

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

 use IterTools  Stream ;

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

Mirada printr

Mira cada elemento entre otras operaciones de transmisión para print_r cada elemento sin modificar la transmisión.

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

 use IterTools  Stream ;

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

Imprime r

print_r cada elemento en la transmisión.

$stream->printR(): void

 use IterTools  Stream ;

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

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

Volcado var

var_dump cada elemento en la transmisión.

$stream->varDump(): void

 use IterTools  Stream ;

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

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

Composición

Los iTerTools se pueden combinar para crear nuevas composiciones iterables.

Tiradas

 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 

Cadenas de cadena

 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 

Tipos estrictos y coercitivos

Cuando hay una opción, el valor predeterminado hará comparaciones de tipo estricto:

• Scalars: se compara estrictamente por tipo
• Objetos: siempre trata diferentes instancias como no iguales entre sí
• Matrices: compara serializado

Cuando el tipo de coerción (tipos no estrictos) está disponible y habilita a través de un indicador opcional:

• Scalars: se compara por valor a través de un malabarismo de tipo
• Objetos: compara serializado
• Matrices: compara serializado

Estándares

ITerTools PHP se ajusta a los siguientes estándares:

• PSR-1-Estándar de codificación básica (http://www.php-fig.org/psr/psr-1/)
• PSR-4-Autoloader (http://www.php-fig.org/psr/psr-4/)
• PSR-12-Guía de estilo de codificación extendida (http://www.php-fig.org/psr/psr-12/)

Licencia

ITerTools PHP tiene licencia bajo la licencia MIT.

Bibliotecas similares en otros idiomas

La funcionalidad de IterTools no se limita a PHP y Python. Otros idiomas tienen bibliotecas similares. La funcionalidad familiar está disponible cuando se trabaja en otros idiomas.

• ITerTools TypeScript/JavaScript
• ITERTOOLS PYTHON: ¡El original!