itertools php

ITERTOOLS - PHP -Iteration -Tools, um Ihre Schleifen aufzusetzen

Inspiriert von Python - für PHP geprägt.

Merkmale

Itrertools macht Sie zu einem Iterations -Superstar, indem Sie zwei Arten von Tools bereitstellen:

• Tools zur Iteration von Schleifen
• Stream -Iteration -Tools

Beispiele für Schleifen Iteration Tools

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

Beispiel für Stream -Iteration -Tools

 $ 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

Alle Funktionen funktionieren auf iterable Sammlungen:

• array (Typ)
• Generator (Typ)
• Iterator (Schnittstelle)
• Traversable (Schnittstelle)

Readme -Dokumente in anderen Sprachen übersetzt:

• Русский

Schnelle Referenz

Tools zur Iteration von Schleifen

Multi -Iteration

Iterator	Beschreibung	Code -Snippet
chain	Mehrere iterables zusammenketten	Multi::chain($list1, $list2)
zip	Wiederholen Sie mehrere Sammlungen gleichzeitig, bis der kürzeste Iterator abgeschlossen ist	Multi::zip($list1, $list2)
zipEqual	Wiederholen Sie mehrere Sammlungen gleicher Länge gleichzeitig, Fehler, wenn die Längen nicht gleich sind	Multi::zipEqual($list1, $list2)
zipFilled	Wiederholen Sie mehrere Sammlungen, indem Sie einen Füllstoffwert verwenden, wenn die Längen nicht gleich sind	Multi::zipFilled($default, $list1, $list2)
zipLongest	Wiederholen Sie mehrere Sammlungen gleichzeitig, bis der längste Iterator abgeschlossen ist	Multi::zipLongest($list1, $list2)

Einzelne Iteration

Iterator	Beschreibung	Code -Snippet
chunkwise	Durch Stücke wiederholen	Single::chunkwise($data, $chunkSize)
chunkwiseOverlap	Durch überlappte Stücke wiederholen	Single::chunkwiseOverlap($data, $chunkSize, $overlapSize)
compress	Filtern Sie nicht ausgewählte Elemente heraus	Single::compress($data, $selectors)
compressAssociative	Filtern Sie Elemente nach nicht ausgewählten Schlüssel heraus	Single::compressAssociative($data, $selectorKeys)
dropWhile	Tropfenelemente, während Prädikat wahr ist	Single::dropWhile($data, $predicate)
filter	Filter für Elemente, bei denen Prädikat wahr ist	Single::filterTrue($data, $predicate)
filterTrue	Filter für wahrheitliche Elemente	Single::filterTrue($data)
filterFalse	Filter für falsy -Elemente	Single::filterFalse($data)
filterKeys	Filter für Schlüssel, bei denen das Prädikat wahr ist	Single::filterKeys($data, $predicate)
flatMap	Kartenfunktion auf Elementen und Flachergebnis	Single::flaMap($data, $mapper)
flatten	Multidimensionale iterable abflachen	Single::flatten($data, [$dimensions])
groupBy	Gruppendaten nach einem gemeinsamen Element	Single::groupBy($data, $groupKeyFunction, [$itemKeyFunc])
limit	Bis zu einer Grenze wiederholen	Single::limit($data, $limit)
map	Kartenfunktion auf jedem Element	Single::map($data, $function)
pairwise	Iterte aufeinanderfolgende überlappende Paare	Single::pairwise($data)
reindex	Reindedextasten des Schlüsselwerts iterabler	Single::reindex($data, $reindexer)
repeat	Wiederholen Sie mehrmals einen Artikel	Single::repeat($item, $repetitions)
reverse	Elemente in umgekehrter Reihenfolge wiederholen	Single::reverse($data)
skip	Nach dem Überspringen von Elementen iterieren	Single::skip($data, $count, [$offset])
slice	Extrahieren Sie eine Scheibe des iterablen	Single::slice($data, [$start], [$count], [$step])
string	Iterieren Sie die Zeichen einer Zeichenfolge	Single::string($string)
takeWhile	Iterate Elemente, während Prädikat wahr ist	Single::takeWhile($data, $predicate)

Unendliche Iteration

Iterator	Beschreibung	Code -Snippet
count	Nacheinander für immer zählen	Infinite::count($start, $step)
cycle	Durch eine Sammlung fahren	Infinite::cycle($collection)
repeat	Wiederholen Sie einen Artikel für immer	Infinite::repeat($item)

Zufällige Iteration

Iterator	Beschreibung	Code -Snippet
choice	Zufällige Auswahl aus der Liste	Random::choice($list, $repetitions)
coinFlip	Zufällige Münzflips (0 oder 1)	Random::coinFlip($repetitions)
number	Zufallszahlen	Random::number($min, $max, $repetitions)
percentage	Zufälliger Prozentsatz zwischen 0 und 1	Random::percentage($repetitions)
rockPaperScissors	Zufällige Hände für Steinpapierabschüsse	Random::rockPaperScissors($repetitions)

Mathematik -Iteration

Iterator	Beschreibung	Code -Snippet
frequencies	Frequenzverteilung von Daten	Math::frequencies($data, [$strict])
relativeFrequencies	Relative Frequenzverteilung von Daten	Math::relativeFrequencies($data, [$strict])
runningAverage	Durchschnittlich durchschnittliche Akkumulation	Math::runningAverage($numbers, $initialValue)
runningDifference	Auslaufdifferenzakkumulation	Math::runningDifference($numbers, $initialValue)
runningMax	Maximale Akkumulation ausführen	Math::runningMax($numbers, $initialValue)
runningMin	Mindestakkumulation ausführen	Math::runningMin($numbers, $initialValue)
runningProduct	Produktakkumulation ausführen	Math::runningProduct($numbers, $initialValue)
runningTotal	Totalakkumulation ausführen	Math::runningTotal($numbers, $initialValue)

Set- und Multiset -Iteration

Iterator	Beschreibung	Code -Snippet
distinct	Nur unterschiedliche Gegenstände iterieren	Set::distinct($data)
distinctBy	Iterieren Sie nur unterschiedliche Elemente mit dem benutzerdefinierten Komparator	Set::distinct($data, $compareBy)
intersection	Schnittpunkt iterierbar	Set::intersection(...$iterables)
intersectionCoercive	Schnittpunkt mit Typ -Zwang	Set::intersectionCoercive(...$iterables)
partialIntersection	Teilweise Schnittpunkt der ITerables	Set::partialIntersection($minCount, ...$iterables)
partialIntersectionCoercive	Partielle Schnittstelle mit Typ -Zwang	Set::partialIntersectionCoercive($minCount, ...$iterables)
symmetricDifference	Symmetrische Unterschiede der iTerables	Set::symmetricDifference(...$iterables)
symmetricDifferenceCoercive	Symmetrischer Unterschied mit dem Typ -Zwang	Set::symmetricDifferenceCoercive(...$iterables)
union	Vereinigung von iTerables	Set::union(...$iterables)
unionCoercive	Gewerkschaft mit Typ Zwang	Set::unionCoercive(...$iterables)

Iteration sortieren

Iterator	Beschreibung	Code -Snippet
asort	Iterieren Sie eine sortierte Sammlung, die Schlüsseln unterhält	Sort::asort($data, [$comparator])
sort	Eine sortierte Sammlung wiederholen	Sort::sort($data, [$comparator])

Datei -Iteration

Iterator	Beschreibung	Code -Snippet
readCsv	Kreuzung Eine CSV -Dateizeile für Zeile	File::readCsv($fileHandle)
readLines	Eine Dateizeile nach Zeile wiederholen	File::readLines($fileHandle)

Iteration transformieren

Iterator	Beschreibung	Code -Snippet
tee	Itere doppelte Iteratoren	Transform::tee($data, $count)
toArray	Iterbar in ein Array transformieren	Transform::toArray($data)
toAssociativeArray	Iterbar in ein assoziatives Array transformieren	Transform::toAssociativeArray($data, [$keyFunc], [$valueFunc])
toIterator	Iterbar in einen Iterator transformieren	Transform::toIterator($data)

Zusammenfassung

Zusammenfassung	Beschreibung	Code -Snippet
allMatch	Wahr, wenn alle Elemente nach Prädikat wahr sind	Summary::allMatch($data, $predicate)
allUnique	Wahr, wenn alle Elemente einzigartig sind	Summary::allUnique($data, [$strict])
anyMatch	Wahr, wenn ein Element entsprechend dem Prädikat wahr ist	Summary::anyMatch($data, $predicate)
arePermutations	Wahr, wenn iterables Permutationen voneinander sind	Summary::arePermutations(...$iterables)
arePermutationsCoercive	Wahr, wenn iterables Permutationen voneinander mit Typ -Zwang sind	Summary::arePermutationsCoercive(...$iterables)
exactlyN	Richtig, wenn genau N -Elemente entsprechend dem Prädikat wahr sind	Summary::exactlyN($data, $n, $predicate)
isEmpty	Wahr, wenn iterable keine Gegenstände hat	Summary::isEmpty($data)
isPartitioned	Wahr, wenn sie mit Elementen partitioniert werden.	Summary::isPartitioned($data, $predicate)
isSorted	Wahr, wenn iterable sortiert	Summary::isSorted($data)
isReversed	Wahr, wenn iterable umgekehrt sortiert	Summary::isReversed($data)
noneMatch	Wahr, wenn keiner der Elemente nach Prädikat wahr ist	Summary::noneMatch($data, $predicate)
same	Wahr, wenn iterables die gleichen sind	Summary::same(...$iterables)
sameCount	Wahr, wenn iterables die gleichen Längen haben	Summary::sameCount(...$iterables)

Reduzieren

Reduzierer	Beschreibung	Code -Snippet
toAverage	Durchschnittlicher Durchschnitt der Elemente	Reduce::toAverage($numbers)
toCount	Reduzieren auf die Länge der iterablen	Reduce::toCount($data)
toFirst	Auf seinen ersten Wert reduzieren	Reduce::toFirst($data)
toFirstAndLast	Auf seine ersten und letzten Werte reduzieren	Reduce::toFirstAndLast($data)
toLast	Auf seinen letzten Wert reduzieren	Reduce::toLast()
toMax	Auf sein größtes Element reduzieren	Reduce::toMax($numbers, [$compareBy])
toMin	Auf sein kleinstes Element reduzieren	Reduce::toMin($numbers, [$compareBy])
toMinMax	Auf eine Reihe von oberen und unteren Grenzen reduzieren	Reduce::toMinMax($numbers, [$compareBy])
toNth	Auf n. Position auf Wert reduzieren	Reduce::toNth($data, $position)
toProduct	Auf das Produkt seiner Elemente reduzieren	Reduce::toProduct($numbers)
toRandomValue	Reduzieren den zufälligen Wert von iterable	Reduce::toRandomValue($data)
toRange	Reduzieren Sie die Differenz von Max- und MIN -Werten	Reduce::toRange($numbers)
toString	Reduzieren Sie die angeschlossene String	Reduce::toString($data, [$separator], [$prefix], [$suffix])
toSum	Reduzieren Sie die Summe seiner Elemente	Reduce::toSum($numbers)
toValue	Reduzieren Sie den Wert mit Callable Reducer auf den Wert	Reduce::toValue($data, $reducer, $initialValue)

Stream -Iteration -Tools

Stream -Quellen

Quelle	Beschreibung	Code -Snippet
of	Erstellen Sie einen Stream aus einem iterablen	Stream::of($iterable)
ofCoinFlips	Erstellen Sie einen Strom von zufälligen Münzflips	Stream::ofCoinFlips($repetitions)
ofCsvFile	Erstellen Sie einen Stream aus einer CSV -Datei	Stream::ofCsvFile($fileHandle)
ofEmpty	Erstellen Sie einen leeren Stream	Stream::ofEmpty()
ofFileLines	Erstellen Sie einen Stream aus Zeilen einer Datei	Stream::ofFileLines($fileHandle)
ofRandomChoice	Erstellen Sie einen Strom von zufälligen Auswahlen	Stream::ofRandomChoice($items, $repetitions)
ofRandomNumbers	Erstellen Sie einen Strom von Zufallszahlen (Ganzzahlen)	Stream::ofRandomNumbers($min, $max, $repetitions)
ofRandomPercentage	Erstellen Sie einen Strom von zufälligen Prozentsätzen zwischen 0 und 1	Stream::ofRandomPercentage($repetitions)
ofRange	Erstellen Sie einen Strom einer Reihe von Zahlen	Stream::ofRange($start, $end, $step)
ofRockPaperScissors	Erstellen Sie einen Strom von Händen von Gesteins-Papier-Scheren	Stream::ofRockPaperScissors($repetitions)

Streamoperationen

Betrieb	Beschreibung	Code -Snippet
asort	Sortiert die iterable Quelle, bei der Schlüssel beibehalten wird	$stream->asort([$comparator])
chainWith	Ketten iterable Quelle mit den angegebenen iterablen zusammen in eine einzelne Iteration zusammen	$stream->chainWith(...$iterables)
compress	Komprimierende Quelle durch Filterung von nicht ausgewählten Daten komprimieren	$stream->compress($selectors)
compressAssociative	Komprimierende Quelle durch Filtern von Tasten, die nicht ausgewählt sind	$stream->compressAssociative($selectorKeys)
chunkwise	Durch Stücke wiederholen	$stream->chunkwise($chunkSize)
chunkwiseOverlap	Durch überlappte Stücke wiederholen	$stream->chunkwiseOverlap($chunkSize, $overlap)
distinct	Filtern Sie Elemente heraus: Nur einzigartige Gegenstände iterieren	$stream->distinct([$strict])
distinctBy	Filtern Sie Elemente heraus: Nur eindeutige Elemente mit benutzerdefiniertem Komparator iterieren	$stream->distinct($compareBy)
dropWhile	Lassen Sie Elemente aus der iterbaren Quelle fallen, während die Prädikatfunktion wahr ist	$stream->dropWhile($predicate)
filter	Filter für nur Elemente, bei denen die Prädikatfunktion wahr ist	$stream->filterTrue($predicate)
filterTrue	Filter für nur wahrheitsgemäße Elemente	$stream->filterTrue()
filterFalse	Filter für nur falsy -Elemente	$stream->filterFalse()
filterKeys	Filter für Schlüssel, bei denen die Prädikatfunktion wahr ist	$stream->filterKeys($predicate)
flatMap	Kartenfunktion auf Elementen und Flachergebnis	$stream->flatMap($function)
flatten	Mehrdimensionaler Strom flach	$stream->flatten($dimensions)
frequencies	Frequenzverteilung	$stream->frequencies([$strict])
groupBy	Gruppener iterable Quelle durch ein gemeinsames Datenelement	$stream->groupBy($groupKeyFunction, [$itemKeyFunc])
infiniteCycle	Fahren Sie durch die Elemente der iterbaren Quelle nacheinander für immer durch	$stream->infiniteCycle()
intersectionWith	Überschneidende iterable Quelle und verabreichte iterable	$stream->intersectionWith(...$iterables)
intersection CoerciveWith	Überschneiden Sie iterable Quelle und verabreicht iterables mit dem Typ -Zwang	$stream->intersectionCoerciveWith(...$iterables)
limit	Begrenzen Sie die Iteration des Streams	$stream->limit($limit)
map	Kartenfunktion auf Elementen	$stream->map($function)
pairwise	Returnpaare von Elementen aus der iterbaren Quelle zurück	$stream->pairwise()
partialIntersectionWith	Sich teilweise iterable Quelle überschneiden und iterable verabreicht werden	$stream->partialIntersectionWith( $minIntersectionCount, ...$iterables)
partialIntersection CoerciveWith	Überschneiden	$stream->partialIntersectionCoerciveWith( $minIntersectionCount, ...$iterables)
reindex	Reindedextasten des Schlüsselwertsstroms	$stream->reindex($reindexer)
relativeFrequencies	Relative Frequenzverteilung	$stream->relativeFrequencies([$strict])
reverse	Umgekehrte Elemente des Streams	$stream->reverse()
runningAverage	Akkumulieren Sie den laufenden Durchschnitt (Mittelwert) über iterable Quelle	$stream->runningAverage($initialValue)
runningDifference	Akkumulieren Sie den laufenden Unterschied über iterable Quelle	$stream->runningDifference($initialValue)
runningMax	Akkumulieren Sie die laufende Maximum über iterable Quelle	$stream->runningMax($initialValue)
runningMin	Akkumulieren Sie die laufende min über iterable Quelle	$stream->runningMin($initialValue)
runningProduct	Akkumulieren Sie das laufende Produkt über iterable Quelle	$stream->runningProduct($initialValue)
runningTotal	Akkumulieren Sie die laufende Gesamtsumme über iterable Quelle	$stream->runningTotal($initialValue)
skip	Überspringen Sie einige Elemente des Streams	$stream->skip($count, [$offset])
slice	Extrahieren Sie eine Scheibe des Stroms	$stream->slice([$start], [$count], [$step])
sort	Sortiert den Strom	$stream->sort([$comparator])
symmetricDifferenceWith	Symmetrischer Unterschied iterierbarer Quelle und gegebene iterable	$this->symmetricDifferenceWith(...$iterables)
symmetricDifference CoerciveWith	Symmetrischer Unterschied iterierbarer Quelle und verabreichte iterbare Gäste mit Typ -Zwang	$this->symmetricDifferenceCoerciveWith( ...$iterables)
takeWhile	Returnelemente aus der iterbaren Quelle, solange das Prädikat wahr ist	$stream->takeWhile($predicate)
unionWith	Vereinigung des Streams mit iTerables	$stream->unionWith(...$iterables)
unionCoerciveWith	Vereinigung des Streams mit iTerables mit Typ Zwang	$stream->unionCoerciveWith(...$iterables)
zipWith	Iterbare Quelle mit einer anderen iterbaren Sammlung gleichzeitig iterieren	$stream->zipWith(...$iterables)
zipEqualWith	Iterable Quelle mit einer weiteren iterbaren Sammlung gleicher Längen gleichzeitig	$stream->zipEqualWith(...$iterables)
zipFilledWith	Iterbare Quelle mit einer anderen iterbaren Sammlung mit dem Standardfüller iterierbar	$stream->zipFilledWith($default, ...$iterables)
zipLongestWith	Iterbare Quelle mit einer anderen iterbaren Sammlung gleichzeitig iterieren	$stream->zipLongestWith(...$iterables)

Stream -Terminaloperationen

Zusammenfassende Terminaloperationen

Terminalbetrieb	Beschreibung	Code -Snippet
allMatch	Gibt true zurück, wenn alle Elemente im Stream -Prädikat übereinstimmen	$stream->allMatch($predicate)
allUnique	Gibt true zurück, wenn alle Elemente im Stream einzigartig sind	$stream->allUnique([$strict]])
anyMatch	Gibt true zurück, wenn ein Element in Stream Predicate übereinstimmt	$stream->anyMatch($predicate)
arePermutationsWith	Gibt true zurück, wenn alle iterierenden Permutationen des Streams	$stream->arePermutationsWith(...$iterables)
arePermutationsCoerciveWith	Gibt true zurück, wenn alle iterierenden Permutationen des Streams mit Typ -Zwang	$stream->arePermutationsCoerciveWith(...$iterables)
exactlyN	Gibt true zurück, wenn genau N -Elemente entsprechend dem Prädikat wahr sind	$stream->exactlyN($n, $predicate)
isEmpty	Gibt true zurück, wenn Stream keine Elemente hat	$stream::isEmpty()
isPartitioned	Gibt true zurück, wenn sie mit Elementen partitioniert sind	$stream::isPartitioned($predicate)
isSorted	Gibt true zurück, wenn Stream in aufsteigender Reihenfolge sortiert ist	$stream->isSorted()
isReversed	Gibt true zurück, wenn Stream in umgekehrter absteigender Reihenfolge sortiert ist	$stream->isReversed()
noneMatch	Gibt true zurück, wenn keiner der Elemente im Stream -Prädikat übereinstimmen	$stream->noneMatch($predicate)
sameWith	Gibt true zurück, wenn Stream und alle angegebenen Sammlungen gleich sind	$stream->sameWith(...$iterables)
sameCountWith	Gibt true zurück, wenn Stream und alle angegebenen Kollektionen die gleichen Längen haben	$stream->sameCountWith(...$iterables)

Reduktionsanschlussoperationen

Terminalbetrieb	Beschreibung	Code -Snippet
toAverage	Reduziert den Strom auf den durchschnittlichen Durchschnitt seiner Artikel	$stream->toAverage()
toCount	Reduziert den Strom auf seine Länge	$stream->toCount()
toFirst	Reduziert den Strom auf seinen ersten Wert	$stream->toFirst()
toFirstAndLast	Reduziert den Strom auf seine ersten und letzten Werte	$stream->toFirstAndLast()
toLast	Reduziert den Strom auf seinen letzten Wert	$stream->toLast()
toMax	Reduziert den Strom auf seinen maximalen Wert	$stream->toMax([$compareBy])
toMin	Reduziert den Strom auf seinen min -Wert	$stream->toMin([$compareBy])
toMinMax	Reduziert den Strom auf eine Reihe von oberen und unteren Grenzen	$stream->toMinMax([$compareBy])
toNth	Reduziert den Strom auf Wert an n. Position auf Wert	$stream->toNth($position)
toProduct	Reduziert den Strom auf das Produkt seiner Artikel	$stream->toProduct()
toString	Reduziert den Stream auf verbundene String	$stream->toString([$separator], [$prefix], [$suffix])
toSum	Reduziert den Strom auf die Summe seiner Artikel	$stream->toSum()
toRandomValue	Reduziert den Stream auf zufälligen Wert darin	$stream->toRandomValue()
toRange	Reduziert den Strom auf Differenz von max und min -Werten	$stream->toRange()
toValue	Reduziert den Strom wie Array_Reduce () Funktion	$stream->toValue($reducer, $initialValue)

Transformationsterminalvorgänge

Terminalbetrieb	Beschreibung	Code -Snippet
toArray	Gibt eine Reihe von Streamelementen zurück	$stream->toArray()
toAssociativeArray	Gibt die Schlüsselwertkarte von Stream-Elementen zurück	$stream->toAssociativeArray($keyFunc, $valueFunc)
tee	Gibt Array mehrerer identischer Ströme zurück	$stream->tee($count)

Nebeneffekt -Terminaloperationen

Terminalbetrieb	Beschreibung	Code -Snippet
callForEach	Führen Sie die Aktion über die Funktion auf jedem Element durch	$stream->callForEach($function)
print	print jeden Element im Stream aus	$stream->print([$separator], [$prefix], [$suffix])
printLn	print jeden Artikel auf einer neuen Zeile aus	$stream->printLn()
toCsvFile	Schreiben Sie den Inhalt des Streams in eine CSV -Datei	$stream->toCsvFile($fileHandle, [$headers])
toFile	Schreiben Sie den Inhalt des Streams in eine Datei	$stream->toFile($fileHandle)

Stream -Debug -Operationen

Debug -Operation	Beschreibung	Code -Snippet
peek	Blick auf jedes Element zwischen Stream -Operationen	$stream->peek($peekFunc)
peekStream	Blick auf den gesamten Strom zwischen Operationen	$stream->peekStream($peekFunc)
peekPrint	Schauen Sie sich jedes Element durch Drucken zwischen Operationen an	$stream->peekPrint()
peekPrintR	Schauen Sie sich jedes Element an, indem Sie zwischen den Operationen gedruckt werden	$stream->peekPrintR()
printR	print_r in jedem Artikel	$stream->printR()
varDump	var_dump jedes Element	$stream->varDump()

Aufstellen

Fügen Sie die Bibliothek Ihrer Datei composer.json in Ihrem Projekt hinzu:

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

Verwenden Sie den Komponisten, um die Bibliothek zu installieren:

$ php composer.phar install

Der Komponist installiert ITertools in Ihrem Anbieterordner. Anschließend können Sie Ihren .php -Dateien Folgendes hinzufügen, um die Bibliothek mit autoladieren zu verwenden.

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

Verwenden Sie alternativ den Komponisten in der Befehlszeile, um ITertools zu fordern und zu installieren:

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

Mindestanforderungen

• Php 7.4

Verwendung

Alle Funktionen funktionieren auf iterable Sammlungen:

• array (Typ)
• Generator (Typ)
• Iterator (Schnittstelle)
• Traversable (Schnittstelle)

Multi -Iteration

Kette

Ketten Sie mehrere iterable in eine einzelne kontinuierliche Sequenz zusammen.

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'

Reißverschluss

Iterieren Sie mehrere iterable Sammlungen gleichzeitig.

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 funktioniert mit mehreren iterbaren Eingängen-nicht nur auf zwei.

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

HINWEIS: Bei ungleichmäßigen Längen stoppt die Iteration, wenn die kürzeste Iterable erschöpft ist.

Zipequal

Iterieren Sie mehrere iterable Sammlungen mit gleichzeitigen Längen gleichzeitig.

Wirft LengthException wenn die Längen nicht gleich sind, was bedeutet, dass mindestens ein Iterator vor den anderen endet.

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

Zipfilliert

Iterieren Sie mehrere iterable Sammlungen gleichzeitig und verwenden Sie einen Standardfüllerwert, wenn die Längen nicht gleich sind.

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

Klangestest

Iterieren Sie mehrere iterable Sammlungen gleichzeitig.

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

Bei ungleichmäßigen Längen erzeugen die erschöpften Iterables für die verbleibenden Iterationen null .

 use IterTools  Multi ;

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

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

Einzelne Iteration

Chunkwise

Returnelemente in Stücken einer bestimmten Größe zurückgeben.

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

Die Chunk -Größe muss mindestens 1 betragen.

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

Chunkgewise -Überlappung

Return überlappte Elementbrocken.

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

• Die Chunk -Größe muss mindestens 1 betragen.
• Die Überlappungsgröße muss geringer sein als die Größe.

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

Kompresse

Komprimieren Sie eine Iterable, indem Daten herausgefiltert werden, die nicht ausgewählt sind.

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'

Kompress assoziativ

Komprimieren Sie eine Iterable, indem Sie nicht ausgewählte Schlüssel herausfiltern.

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

• Nur Standard -PHP -Array/Iterator -Schlüssel (String, Integer).

 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

Drop während

Lassen Sie Elemente aus dem iterablen, während die Prädikatfunktion wahr ist.

Sobald die Prädikatfunktion einmal falsch zurückgibt, werden alle verbleibenden Elemente zurückgegeben.

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

Filter

Filtern Sie Elemente aus dem iterablen, nur zurückgegebenen Elemente heraus, bei denen die Prädikatfunktion wahr ist.

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

Filter true

Filtern Sie Elemente aus den iterablen, die nur zurückgegebene Elemente herausfiltern, die wahr sind.

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

Filter falsch

Filtern Sie Elemente aus dem iterablen, nur zurückgegebenen Elemente heraus, bei denen die Prädikatfunktion falsch ist.

Wenn kein Prädikat bereitgestellt wird, wird der Boolesche Wert der Daten verwendet.

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

Filterschlüssel

Filtern Sie Elemente aus dem iterablen, nur zurückgegebenen Elemente heraus, für die die Tasten die Prädikatfunktion wahr sind.

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

Flache Karte

Kartieren Sie eine Funktion nur die Elemente des iterablen und fassen Sie dann die Ergebnisse ab.

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

Flach

Eine mehrdimensionale iterable abflachen.

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]

Gruppe von

Gruppendaten nach einem gemeinsamen Datenelement.

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

• Die $groupKeyFunction bestimmt den Schlüssel zu Gruppenelementen nach.
• Die optionale $itemKeyFunction ermöglicht benutzerdefinierte Indizes in jedem Gruppenelement.

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

Limit

Bis zu einer Grenze iterieren.

Stoppt auch wenn mehr Daten verfügbar sind, wenn die Grenze erreicht ist.

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)

Karte

Kartieren Sie eine Funktion auf jedes Element.

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

Paarweise

Gibt aufeinanderfolgende überlappende Paare zurück.

Gibt den leeren Generator zurück, wenn die gegebene Sammlung weniger als 2 Elemente enthält.

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

Wiederholen

Wiederholen Sie einen Gegenstand.

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'

Reindedex

ReinIdex-Tasten von Schlüsselwert iterable mit der Indexer-Funktion.

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

Umkehren

Die Elemente eines iterablen umkehren.

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

Überspringen

Überspringen Sie N -Elemente im iterablen nach optionalem Offset -Offset.

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'

Scheibe

Extrahieren Sie eine Scheibe des iterablen.

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]

Saite

Iterieren Sie die einzelnen Zeichen einer Zeichenfolge.

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

Währenddessen

Returnelemente aus dem iterablen, solange das Prädikat wahr ist.

Stoppt die Iteration, sobald das Prädikat falsch zurückgibt, auch wenn später andere Elemente irgendwann zurückkehren würden (anders als 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 

Unendliche Iteration

Zählen

Nacheinander für immer zählen.

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

Zyklus

Fahren Sie durch die Elemente einer Sammlung nacheinander für immer.

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

Wiederholen (unendlich)

Wiederholen Sie einen Gegenstand für immer.

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

Zufällige Iteration

Auswahl

Generieren Sie zufällige Auswahlen aus einem Array von Werten.

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]

Münzflip

Erzeugen Sie zufällige Münzflips (0 oder 1).

Random::coinFlip(int $repetitions)

 use IterTools  Random ;

$ repetitions = 10 ;

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

Nummer

Generieren Sie Zufallszahlen (Ganzzahlen).

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]

Prozentsatz

Generieren Sie einen zufälligen Prozentsatz zwischen 0 und 1.

Random::percentage(int $repetitions)

 use IterTools  Random ;

$ repetitions = 10 ;

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

Rockpaperszweiß

Erzeugen Sie zufällige Hände von Rock-Paper-Scissors.

Random::rockPaperScissors(int $repetitions)

 use IterTools  Random ;

$ repetitions = 10 ;

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

Mathematik -Iteration

Frequenzen

Gibt eine Frequenzverteilung der Daten zurück.

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

Standardeinstellungen zu strengen Typvergleichen. Setzen Sie für den Typ -Zwangsvergleich streng auf False.

 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

Relative Frequenzen

Gibt eine relative Frequenzverteilung der Daten zurück.

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

Standardeinstellungen zu strengen Typvergleichen. Setzen Sie für den Typ -Zwangsvergleich streng auf False.

 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

Laufen durchschnittlich

Akkumulieren Sie den Laufdurchschnitt über eine Liste von Zahlen.

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

Laufunterschied

Akkumulieren Sie den laufenden Unterschied über eine Liste von Zahlen.

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

Geben Sie einen optionalen Anfangswert an, um den laufenden Differenz zu leiten.

 use IterTools  Math ;

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

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

Maximal laufen

Akkumulieren Sie das laufende Maximum über eine Liste von Zahlen.

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

Laufen min

Akkumulieren Sie das laufende Minimum über eine Liste von Zahlen.

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

Auslaufprodukt

Akkumulieren Sie das laufende Produkt über eine Liste von Zahlen.

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

Geben Sie einen optionalen Anfangswert an, um das laufende Produkt auszuleiten.

 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

Gesamtlauf

Akkumulieren Sie die laufende Gesamtsumme über eine Liste von Zahlen.

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

Geben Sie einen optionalen Anfangswert an, um die laufende Gesamtsumme auszuleiten.

 use IterTools  Math ;

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

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

Set und Multiset

Unterscheidbar

Filtern Sie Elemente aus dem iterablen heraus, der nur verschiedene Elemente zurückgibt.

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

Standardeinstellungen zu strengen Typvergleichen. Setzen Sie für den Typ -Zwangsvergleich streng auf False.

 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

Unterschiedlich durch

Filtern Sie Elemente aus dem iterablen heraus, der nur bestimmte Elemente gemäß einer benutzerdefinierten Komparatorfunktion zurückgibt.

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.

Überschneidung

Iteriert die Schnittstelle von iTerables.

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

Wenn Eingabe iterable doppelte Elemente erzeugen, gelten Multiset -Kreuzungsregeln.

 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

Kreuzung Zwang

Iteriert die Schnittstelle iterierbar unter Verwendung von Typ -Zwang.

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

Wenn Eingabe iterable doppelte Elemente erzeugen, gelten Multiset -Kreuzungsregeln.

 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

Teilweise Kreuzung

Iterates m-partialer Schnittpunkt von iTerables.

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

• Wenn Eingabe iterable doppelte Elemente erzeugen, gelten Multiset -Kreuzungsregeln.

 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

Partieller Schnittpunkt Zwang

Iterates m-partialer Schnittpunkt iterierbar unter Verwendung von Typ-Zwang.

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

• Wenn Eingabe iterable doppelte Elemente erzeugen, gelten Multiset -Kreuzungsregeln.

 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

Symmetrischer Unterschied

Iteriert den symmetrischen Unterschied von iterbaren.

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

Wenn Eingabe iterable doppelte Elemente erzeugen, gelten Multiset -Differenzregeln.

 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

Symmetrischer Unterschied zwanghaft

Iteriert den symmetrischen Unterschied von iterierbaren Funktionen mit dem Typ -Zwang.

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

Wenn Eingabe iterable doppelte Elemente erzeugen, gelten Multiset -Differenzregeln.

 use IterTools  Set ;

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

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

Union

Iteriert die Vereinigung von iTerables.

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

Wenn Eingabe iterable doppelte Elemente erzeugen, gelten Multiset Union -Regeln.

 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

Gewerkschaftszwang

Iteriert die Vereinigung von iTerables mit Typ -Zwang.

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

Wenn Eingabe iterable doppelte Elemente erzeugen, gelten Multiset Union -Regeln.

 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 

Iteration sortieren

Asort

Iterieren Sie die Sammlung, die sortiert ist, während die assoziativen Schlüsselindexbeziehungen aufrechterhalten werden.

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

Verwendet die Standardsortierung, wenn die optionale Komparatorfunktion nicht bereitgestellt wird.

 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

Sortieren

Iterieren Sie die Sammlung sortiert.

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

Verwendet die Standardsortierung, wenn die optionale Komparatorfunktion nicht bereitgestellt wird.

 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 

Datei

Lesen Sie CSV

Iterieren Sie die Zeilen einer CSV -Datei.

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

Zeilen lesen

Iterieren Sie die Zeilen einer Datei.

File::readLines(resource $fileHandle)

 use IterTools  File ;

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

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

Verwandeln

Tee

Geben Sie mehrere unabhängige (duplizierte) Iteratoren aus einem einzigen iterablen zurück.

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

Zu Array

Verwandelt alle iterablen in ein Array.

Transform::toArray(iterable $data): array

 use IterTools  Transform ;

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

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

Zu assoziativem Array

Verwandelt alle iterablen in ein assoziatives Array.

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

Iterator

Verwandelt alle iterbaren in einen Iterator.

Transform::toArray(iterable $data): array

 use IterTools  Transform ;

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

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

Zusammenfassung

Alles Match

Gibt true zurück, wenn alle Elemente mit der Prädikatfunktion übereinstimmen.

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

Alles einzigartig

Gibt wahr, wenn alle Elemente einzigartig sind.

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

Standardeinstellungen zu strengen Typvergleichen. Setzen Sie für den Typ -Zwangsvergleich streng auf False.

 use IterTools  Summary ;

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

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

Jedes Match

Gibt true zurück, wenn ein Element mit der Prädikatfunktion übereinstimmt.

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

Sind Permutationen

Gibt true zurück, wenn alle iTerables Permutationen voneinander sind.

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

Sind Permutationen erzwungen

Gibt true zurück, wenn alle iterbaren Permutationen voneinander mit Typ -Zwang sind.

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

Genau n

Gibt true zurück, wenn genau N -Elemente gemäß einer Prädikatfunktion wahr sind.

• Prädikat ist optional.
• Das Standardprädikat ist der Boolesche Wert jedes Elements.

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

Ist leer

Gibt true zurück, wenn das iterable leer ist und keine Gegenstände hat.

Summary::isEmpty(iterable $data): bool

 use IterTools  Summary ;

$ data = []

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

Ist verteilt

Gibt true zurück, wenn alle Elemente der bestimmten Sammlung, die das Prädikat erfüllen, vor allen Elementen erscheinen, die dies nicht tun.

• Gibt true für leere Sammlung oder für die Sammlung mit einzelnen Elementen zurück.
• Standardmäßiges Prädikat ist der Boolesche Wert jedes Datenelements.

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

Ist sortiert

Gibt true zurück, wenn Elemente sortiert sind, ansonsten falsch.

• Elemente müssen vergleichbar sein.
• Gibt true zurück, wenn es leer ist oder nur ein Element hat.

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

Ist umgekehrt

Gibt true zurück, wenn Elemente umgekehrt sortiert sind, ansonsten falsch.

• Elemente müssen vergleichbar sein.
• Gibt true zurück, wenn es leer ist oder nur ein Element hat.

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

Keine Übereinstimmung

Gibt true zurück, wenn kein Element mit der Prädikatfunktion übereinstimmt.

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

Dasselbe

Gibt true zurück, wenn alle angegebenen Sammlungen gleich sind.

Für einzelne iterable oder leere iterable Liste gibt die Liste der truen zurück.

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

Gleiche Anzahl

Gibt true zurück, wenn alle angegebenen Sammlungen die gleichen Längen haben.

Für einzelne iterable oder leere iterable Liste gibt die Liste der truen zurück.

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 

Reduzieren

Zum Durchschnitt

Reduziert sich auf den durchschnittlichen Durchschnitt.

Gibt NULL zurück, wenn die Sammlung leer ist.

Reduce::toAverage(iterable $data): float

 use IterTools  Reduce ;

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

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

Zählen

Reduziert iterable auf seine Länge.

Reduce::toCount(iterable $data): int

 use IterTools  Reduce ;

$ someIterable = ImportantThing:: getCollectionAsIterable ();

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

Zuerst

Reduziert iterable auf sein erstes Element.

Reduce::toFirst(iterable $data): mixed

Wirft LengthException wenn die Sammlung leer ist.

 use IterTools  Reduce ;

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

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

Zuerst und zuletzt

Reduziert iterable auf seine ersten und letzten Elemente.

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

Wirft LengthException wenn die Sammlung leer ist.

 use IterTools  Reduce ;

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

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

Zu dauern

Reduziert iterable auf sein letztes Element.

Reduce::toLast(iterable $data): mixed

Wirft LengthException wenn die Sammlung leer ist.

 use IterTools  Reduce ;

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

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

Nach max

Reduziert sich auf den maximalen Wert.

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

• Optional Callable Param $compareBy muss einen vergleichbaren Wert zurückgeben.
• Wenn $compareBy nicht bereitgestellt wird, müssen Elemente der gegebenen Sammlung vergleichbar sein.
• Gibt NULL zurück, wenn die Sammlung leer ist.

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

Zu min

Reduziert sich auf den min -Wert.

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

• Optional Callable Param $compareBy muss einen vergleichbaren Wert zurückgeben.
• Wenn $compareBy nicht bereitgestellt wird, müssen Elemente der gegebenen Sammlung vergleichbar sein.
• Gibt NULL zurück, wenn die Sammlung leer ist.

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

Nach max

Reduziert sich auf eine Reihe seiner oberen und unteren Grenzen (max und min).

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

• Optional Callable Param $compareBy muss einen vergleichbaren Wert zurückgeben.
• Wenn $compareBy nicht bereitgestellt wird, müssen Elemente der gegebenen Sammlung vergleichbar sein.
• Gibt [null, null] zurück, wenn die gegebene Sammlung leer ist.

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

Zu n -ten

Reduziert sich auf die nte Position auf Wert.

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

Produkt

Reduziert sich auf das Produkt seiner Elemente.

Gibt NULL zurück, wenn die Sammlung leer ist.

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

 use IterTools  Reduce ;

$ primeFactors = [ 5 , 2 , 2 ];

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

Zum zufälligen Wert

Reduziert die gegebene Sammlung auf einen zufälligen Wert darin.

Reduce::toRandomValue(iterable $data): mixed

 use IterTools  Reduce ;

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

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

Reichweite

Reduziert die Ansammlung der Sammlung auf seinen Bereich (Unterschied zwischen max und min).

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

Gibt 0 zurück, wenn iterable Quelle leer ist.

 use IterTools  Reduce ;

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

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

Zu String

Reduziert sich auf eine Zeichenfolge, die alle Elemente verbindet.

• Optionales Trennzeichen zwischen Elementen.
• Optionales Präfix zur Vorbereitung auf die Zeichenfolge.
• Optionales Suffix zum Anhängen an die Zeichenfolge.

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!

Zu summieren

Reduziert sich auf die Summe seiner Elemente.

Reduce::toSum(iterable $data): number

 use IterTools  Reduce ;

$ parts = [ 10 , 20 , 30 ];

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

Zu schätzen

Reduzieren Sie die Elemente mithilfe der Reduzierfunktion auf einen einzelnen Wert.

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 

Strom

Streams bieten eine fließende Schnittstelle zur Transformation von Arrays und iterablen über eine Operationspipeline.

Streams bestehen aus:

1. Eine Stream -Quellfabrik -Methode zum Erstellen des Streams.
2. Null oder mehr Stream -Operatoren, die den Stream in einen neuen Stream umwandeln.
3. Terminalbetrieb von beiden:
   • Stream -Anschlussbetrieb, um den Stream in einen Wert oder eine Datenstruktur zu verwandeln.

    $ 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

   • Der Stream wird über eine foreach -Schleife iteriert.

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

Stream -Quellen

Von

Erstellt Stream von einem iterablen.

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 

Von Münzflips

Erstellt Strom von n zufälligen Münzflips.

Stream::ofCoinFlips(int $repetitions): Stream

 use IterTools  Stream ;

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

Von CSV -Datei

Erstellt einen Strom von Zeilen einer CSV -Datei.

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

Von leer

Erstellt Strom von nichts.

Stream::ofEmpty(): Stream

 use IterTools  Stream ;

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

Von Dateizeilen

Erstellt einen Strom von Zeilen einer Datei.

Stream::ofFileLines(resource $fileHandle): Stream

 use IterTools  Stream ;

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

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

Von zufälliger Wahl

Erstellt Strom zufälliger Auswahlen aus einem Array von Werten.

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) 

Von Zufallszahlen

Erstellt Stream von Zufallszahlen (Ganzzahlen).

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) 

Von zufälligem Prozentsatz

Erstellt einen Strom von zufälligen Prozentsätzen zwischen 0 und 1.

Stream::ofRandomPercentage(int $repetitions): Stream

 use IterTools  Stream ;

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

Von Reichweite

Erstellt Strom einer Reihe von Zahlen.

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 

Von Steinpapierscheren

Erstellt Strom von Händen von Gesteins-Papier-Scheren.

Stream::ofRockPaperScissors(int $repetitions): Stream

 use IterTools  Stream ;

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

Streamoperationen

Asort

Sortiert den Stream und pflegen Sie Schlüssel.

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

Wenn kein Komparator bereitgestellt wird, müssen die Elemente der iterbaren Quelle vergleichbar sein.

 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, 

Kette mit

Gibt einen Stream zurück, der zusätzliche Quellen zusammen in einen einzigen aufeinanderfolgenden Stream verkettet.

$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 

Kompresse

Komprimieren Sie einen neuen Stream, indem Sie Daten herausfiltern, die nicht ausgewählt sind.

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

Selektoren geben an, welche Daten. True Value wählt Element aus. Falsche Wert filtert Daten aus.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

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

Kompress assoziativ

Komprimieren Sie einen neuen Strom, indem Sie nicht ausgewählte Schlüssel herausfiltern.

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

• Nur Standard -PHP -Array/Iterator -Schlüssel (String, Integer).

 use IterTools  Stream ;

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

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

Chunkwise

Gibt einen Stream zurück, der aus Elementen aus dem Strom besteht.

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

Die Chunk -Größe muss mindestens 1 betragen.

 use IterTools  Stream ;

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

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

Chunkgewise -Überlappung

Geben Sie einen Stream zurück, der aus überlappenden Elementenbrocken aus dem Strom besteht.

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

• Die Chunk -Größe muss mindestens 1 betragen.
• Die Überlappungsgröße muss geringer sein als die Größe.

 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] 

Unterscheidbar

Gibt einen Stream zurück, der Elemente aus dem Stream herausfiltert, der nur bestimmte Elemente zurückgibt.

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

Standardeinstellungen zu strengen Typvergleichen. Setzen Sie für den Typ -Zwangsvergleich streng auf False.

 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 

Unterschiedlich durch

Geben Sie ein Stream zurück, das Elemente aus dem Stream herausgefiltert wird, der nur bestimmte Elemente gemäß einer benutzerdefinierten Komparatorfunktion zurückgibt.

$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 

Drop während

Dropelemente aus dem Stream, während die Prädikatfunktion wahr ist.

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

Sobald die Prädikatfunktion einmal falsch zurückgibt, werden alle verbleibenden Elemente zurückgegeben.

 use IterTools  Stream ;

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

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

Filter

Filtern Sie Elemente aus dem Stream heraus, bei dem nur Elemente beibehalten, bei denen die Prädikatfunktion wahr ist.

$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 

Filter true

Filtern Sie Elemente aus dem Strom heraus, um nur Elemente zu halten, die wahr sind.

$stream->filterTrue(): Stream

 use IterTools  Stream ;

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

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

Filter falsch

Filtern Sie Elemente aus dem Strom heraus, um nur Elemente zu behalten, die falsy sind.

$stream->filterFalse(): Stream

 use IterTools  Stream ;

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

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

Filterschlüssel

Filtern Sie Elemente aus dem Stream heraus, bei dem nur Elemente beibehalten werden, bei denen die Prädikatfunktion auf den Tasten wahr ist.

$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 

Flache Karte

Zeichnen Sie eine Funktion auf die Elemente des Streams und füllen Sie die Ergebnisse ab.

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

Flach

Einen mehrdimensionalen Strom flachen.

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

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

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

Frequenzen

Frequenzverteilung der Streamelemente.

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

Gruppe von

Gibt eine Stream -Gruppierung durch ein gemeinsames Datenelement zurück.

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

• Die $groupKeyFunction bestimmt den Schlüssel zu Gruppenelementen nach.
• Die optionale $itemKeyFunction ermöglicht benutzerdefinierte Indizes in jedem Gruppenelement.

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

Unendlicher Zyklus

Gibt einen Stream -Radfahren durch die Elemente des Streams nacheinander für immer zurück.

$stream->infiniteCycle(): Stream

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

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

Kreuzung mit

Geben Sie einen Stream zurück, der den Stream mit den Eingabe iterables überschneidet.

$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 

Kreuzung Zwang mit

Geben Sie einen Stream zurück, der den Stream mit den Eingabe -iterables mit dem Typ -Zwang überschneidet.

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

Limit

Geben Sie einen Stream bis zu einem Grenzwert zurück.

Stoppt auch wenn mehr Daten verfügbar sind, wenn die Grenze erreicht ist.

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

Karte

Geben Sie einen Stream zurück, der das Ergebnis der Zuordnung einer Funktion auf jedes Element des Streams enthält.

$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 

Paarweise

Gibt einen Stream zurück, der aus Elementpaaren aus dem Stream besteht.

$stream->pairwise(): Stream

Gibt einen leeren Stream zurück, wenn die angegebene Sammlung weniger als 2 Elemente enthält.

 use IterTools  Stream ;

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

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

Partielle Schnittpunkt mit

Geben Sie einen Stream zurück, der den Stream mit den Eingabe -iterablen teilweise überschneidet.

$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 

Partieller Schnittpunkt erzwungen mit

Geben Sie einen Stream zurück, der den Stream mit den Eingabe iterables mit dem Typ -Zwang überschneidet.

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

Reindedex

Geben Sie einen neuen Strom von Schlüsselwertelementen zurück, die von der wichtigsten Indexer-Funktion wieder integriert wurden.

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

Relative Frequenzen

Relative Frequenzverteilung der Streamelemente.

$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 

Umkehren

Die Elemente eines Streams umkehren.

$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 

Laufen durchschnittlich

Gibt einen Stream zurück, der den laufenden Durchschnitt (Mittelwert) über den Stream sammelt.

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

 use IterTools  Stream ;

$ input = [ 1 , 3 , 5 ];

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

Laufunterschied

Gibt einen Stream zurück, der den laufenden Unterschied über den Stream sammelt.

$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 

Maximal laufen

Geben Sie einen Stream zurück, der den laufenden Maximal über dem Stream sammelt.

$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 

Laufen min

Geben Sie einen Strom zurück, der den laufenden Min über dem Strom sammelt.

$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 

Auslaufprodukt

Gibt einen Stream zurück, der das laufende Produkt über den Stream sammelt.

$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 

Gesamtlauf

Geben Sie einen Stream zurück, der die laufende Gesamtsumme über dem Stream sammelt.

$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 

Überspringen

Überspringen Sie einige Elemente des Streams.

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

Scheibe

Extrahieren Sie eine Scheibe des Stroms.

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

Sortieren

Sortiert den Strom.

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

Wenn kein Komparator bereitgestellt wird, müssen die Elemente der iterbaren Quelle vergleichbar sein.

 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 

Symmetrischer Unterschied mit

Geben Sie einen Strom der symmetrischen Differenz des Streams und der angegebenen Iterables zurück.

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

HINWEIS: Wenn Eingabe iterable doppelte Elemente erzeugen, gelten Multiset -Kreuzungsregeln.

 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 

Symmetrischer Unterschied erzwungen mit

Geben Sie einen Strom der symmetrischen Differenz des Streams und der angegebenen Iterables mit dem Typ -Zwang zurück.

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

HINWEIS: Wenn Eingabe iterable doppelte Elemente erzeugen, gelten Multiset -Kreuzungsregeln.

 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 

Währenddessen

Halten Sie Elemente vom Strom aus, solange das Prädikat wahr ist.

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

Wenn kein Prädikat bereitgestellt wird, wird der Boolesche Wert der Daten verwendet.

 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 

Vereinigung mit

Geben Sie einen Stream zurück, der aus der Vereinigung des Streams und den Eingabe iterables besteht.

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

HINWEIS: Wenn Eingabe iterable doppelte Elemente erzeugen, gelten Multiset Union -Regeln.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

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

Gewerkschaftszwang mit

Geben Sie einen Stream zurück, der aus der Vereinigung des Streams und den Eingangs -iterables mit dem Typ -Zwang besteht.

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

HINWEIS: Wenn Eingabe iterable doppelte Elemente erzeugen, gelten Multiset Union -Regeln.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

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

Reißverschluss mit

Gibt einen Stream zurück, der aus mehreren iterbaren Sammlungen besteht, die gleichzeitig gestreamt werden.

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

Bei ungleichmäßigen Längen stoppt die Iterationen, wenn die kürzeste Iterable erschöpft ist.

 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] 

Reißverschluss mit

Geben Sie einen Stream zurück, der aus mehreren iterbaren Sammlungen besteht, wobei ein Standardfüllerwert verwendet wird, wenn die Länge nicht gleich ist.

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

Geben Sie einen Stream zurück, der aus mehreren iterbaren Sammlungen gleicher Längen besteht, die gleichzeitig gestreamt werden.

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

Funktioniert wie Stream::zipWith() Methode, wirft aber länger aufgenommen, wenn die Längen nicht gleich sind, dh mindestens ein Iterator endet vor den anderen.

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

Reißverschluss am längsten mit

Gibt einen Stream zurück, der aus mehreren iterbaren Sammlungen besteht, die gleichzeitig gestreamt werden.

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

• Die Iteration wird fortgesetzt, bis die am längsten iterable erschöpft ist.
• Bei ungleichmäßigen Längen erzeugen die erschöpften Iterables für die verbleibenden Iterationen Null.

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

Stream -Terminaloperationen

Stream Summary Terminal Operations

Alles Match

Gibt true zurück, wenn alle Elemente mit der Prädikatfunktion übereinstimmen.

$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 

Alles einzigartig

Gibt wahr, wenn alle Elemente einzigartig sind.

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

Standardeinstellungen zu strengen Typvergleichen. Setzen Sie für den Typ -Zwangsvergleich streng auf False.

 use IterTools  Summary ;

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

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

Jedes Match

Gibt true zurück, wenn ein Element mit der Prädikatfunktion übereinstimmt.

$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 

Sind Permutationen mit

Gibt true zurück, wenn alle iTerables Permutationen mit Stream sind.

$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 

Sind Permutationen erzwungen mit

Gibt true zurück, wenn alle iterables Permutationen mit Stream mit Typ -Zwang sind.

$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 

Genau n

Gibt true zurück, wenn genau N -Elemente gemäß einer Prädikatfunktion wahr sind.

• Prädikat ist optional.
• Das Standardprädikat ist der Boolesche Wert jedes Elements.

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

 use IterTools  Summary ;

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

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

Ist leer

Gibt true zurück, wenn der Stream leer ist und keine Elemente hat.

$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 

Ist verteilt

Gibt true zurück, wenn alle Elemente der bestimmten Sammlung, die das Prädikat erfüllen, vor allen Elementen erscheinen, die dies nicht tun.

• Gibt true für leere Sammlung oder für die Sammlung mit einzelnen Elementen zurück.
• Standardmäßiges Prädikat ist der Boolesche Wert jedes Datenelements.

$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 

Ist sortiert

Gibt true zurück, wenn eine iterable Quelle in aufsteigender Reihenfolge sortiert ist. sonst falsch.

$stream->isSorted(): bool

Elemente iterierbarer Quelle müssen vergleichbar sein.

Gibt true zurück, wenn die iterable Quelle leer ist oder nur ein Element hat.

 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 

Ist umgekehrt

Gibt true zurück, wenn die iterable Quelle in umgekehrter absteigender Reihenfolge sortiert wird. sonst falsch.

$stream->isReversed(): bool

Elemente iterierbarer Quelle müssen vergleichbar sein.

Gibt true zurück, wenn die iterable Quelle leer ist oder nur ein Element hat.

 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 

Keine Übereinstimmung

Gibt true zurück, wenn kein Element mit der Prädikatfunktion übereinstimmt.

$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 

Gleiches gleich mit

Gibt true zurück, wenn iterable Quelle und alle angegebenen Sammlungen gleich sind.

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

Für leere iterables List gibt die Liste wahr zurück.

 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 

Gleiche Zählung mit

Gibt true zurück, wenn iterable Quelle und alle angegebenen Sammlungen die gleichen Längen haben.

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

Für leere iterables List gibt die Liste wahr zurück.

 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 

Stream -Reduktionsanschlussoperationen

Zum Durchschnitt

Reduziert die iterable Quelle auf den Durchschnitt seiner Artikel.

$stream->toAverage(): mixed

Gibt NULL zurück, wenn iterable Quelle leer ist.

 use IterTools  Stream ;

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

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

Zählen

Reduziert die iterable Quelle auf ihre Länge.

$stream->toCount(): mixed

 use IterTools  Stream ;

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

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

Zuerst

Reduziert die iterable Quelle auf sein erstes Element.

$stream->toFirst(): mixed

Wirft LengthException aus, wenn iterable Quelle leer ist.

 use IterTools  Stream ;

$ input = [ 10 , 20 , 30 ];

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

Zuerst und zuletzt

Reduziert die iterable Quelle auf seine ersten und letzten Elemente.

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

Wirft LengthException aus, wenn iterable Quelle leer ist.

 use IterTools  Stream ;

$ input = [ 10 , 20 , 30 ];

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

Zu dauern

Reduziert die iterable Quelle auf sein letztes Element.

$stream->toLast(): mixed

Wirft LengthException aus, wenn iterable Quelle leer ist.

 use IterTools  Stream ;

$ input = [ 10 , 20 , 30 ];

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

Nach max

Reduziert die iterable Quelle auf ihren maximalen Wert.

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

• Optional Callable Param $compareBy muss einen vergleichbaren Wert zurückgeben.
• Wenn $compareBy nicht bereitgestellt wird, müssen Elemente der gegebenen Sammlung vergleichbar sein.
• Gibt NULL zurück, wenn die Sammlung leer ist.

 use IterTools  Stream ;

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

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

Zu min

Reduziert die iterable Quelle auf ihren min -Wert.

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

• Optional Callable Param $compareBy muss einen vergleichbaren Wert zurückgeben.
• Wenn $compareBy nicht bereitgestellt wird, müssen Elemente der gegebenen Sammlung vergleichbar sein.
• Gibt NULL zurück, wenn die Sammlung leer ist.

 use IterTools  Stream ;

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

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

Nach max

Reduziert den Strom auf eine Array der oberen und unteren Grenzen (max und min).

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

• Optional Callable Param $compareBy muss einen vergleichbaren Wert zurückgeben.
• Wenn $compareBy nicht bereitgestellt wird, müssen Elemente der gegebenen Sammlung vergleichbar sein.
• Gibt [null, null] zurück, wenn die gegebene Sammlung leer ist.

 use IterTools  Stream ;

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

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

Zu n -ten

Reduziert den Strom auf Wert an der n -ten Position.

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

Gibt NULL zurück, wenn iterable Quelle leer ist.

 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 

Produkt

Reduziert den Strom auf das Produkt seiner Artikel.

$stream->toProduct(): mixed

Gibt NULL zurück, wenn iterable Quelle leer ist.

 use IterTools  Stream ;

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

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

Zum zufälligen Wert

Reduziert den Strom auf einen zufälligen Wert darin.

$stream->toRandomValue(): mixed

 use IterTools  Stream ;

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

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

Reichweite

Reduziert den Strom auf seinen Bereich (Unterschied zwischen max und min).

$stream->toRange(): int|float

Gibt 0 zurück, wenn iterable Quelle leer ist.

 use IterTools  Stream ;

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

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

Zu String

Reduziert sich auf eine Zeichenfolge, die alle Elemente verbindet.

• Optionales Trennzeichen zwischen Elementen.
• Optionales Präfix zur Vorbereitung auf die Zeichenfolge.
• Optionales Suffix zum Anhängen an die Zeichenfolge.

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

Zu summieren

Reduziert die iterable Quelle auf die Summe seiner Elemente.

$stream->toSum(): mixed

 use IterTools  Stream ;

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

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

Zu schätzen

Reduziert die iterable Quelle wie Array_Reduce () Funktion.

Aber im Gegensatz zu array_reduce() funktioniert es mit allen iterable Typen.

$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 

Transformationsterminalvorgänge

Zu Array

Gibt eine Reihe von Stream -Elementen zurück.

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

Zu assoziativem Array

Gibt eine Schlüsselwertkarte von Stream-Elementen zurück.

$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

Gibt mehrere unabhängige (duplizierte) Streams zurück.

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

Nebeneffekt -Terminaloperationen

Rufen Sie für jeden an

Führen Sie eine Aktion über einen Anruf auf jedem Element im Stream aus.

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

Drucken

Druckt jeden Element im Stream.

• Artikel müssen druckbar sein.

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

Drucklinie

Druckt jeden Element im Stream in seiner eigenen Zeile.

• Artikel müssen druckbar sein.

$stream->println(): void

 use IterTools  Stream ;

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

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

Zu CSV -Datei

Schreiben Sie den Inhalt des Streams in eine CSV -Datei.

$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 

Zu leisten

Schreiben Sie den Inhalt des Streams in eine Datei.

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

Stream -Debug -Operationen

Spähen

Linken Sie jedes Element zwischen anderen Stream -Operationen, um eine Aktion auszuführen, ohne den Stream zu ändern.

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

Peek Stream

Schauen Sie sich den gesamten Stream zwischen anderen Stream -Operationen an, um eine Aktion durchzuführen, ohne den Stream zu ändern.

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

Peek -Druck

Linken Sie jedes Element zwischen anderen Stream -Operationen, um jedes Element zu drucken, ohne den Stream zu ändern.

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

 use IterTools  Stream ;

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

Peek Printr

Linken Sie jedes Element zwischen anderen Stream -Operationen zu print_r jedes Element, ohne den Stream zu ändern.

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

 use IterTools  Stream ;

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

Druck r

print_r jedes Element im Stream.

$stream->printR(): void

 use IterTools  Stream ;

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

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

Var Dump

var_dump jedes Element im Stream.

$stream->varDump(): void

 use IterTools  Stream ;

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

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

Zusammensetzung

Itertools können kombiniert werden, um neue iterbare Kompositionen zu erstellen.

Reißverschluss

 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 

Kettenschnüre

 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 

Strenge und Zwangsarten

Wenn es eine Option gibt, führt die Standardeinstellung strenge Typvergleiche durch:

• Skalare: Vergleiche streng nach Typ
• Objekte: behandelt immer unterschiedliche Instanzen als nicht gleich gleich zueinander
• Arrays: Vergleiche serialisiert

Wenn der Typ-Zwang (Nicht-Streng-Typen) verfügbar ist und über das optionale Flag aktiviert ist:

• Skalare: Vergleich nach Wert über Typ Jonglieren
• Objekte: Vergleiche serialisiert
• Arrays: Vergleiche serialisiert

Standards

ITertools PHP entspricht den folgenden Standards:

• PSR-1-Basic Coding Standard (http://www.php-fig.org/psr/psr-1/)
• PSR-4-Autoloader (http://www.php-fig.org/psr/psr-4/)
• PSR-22-Extended Coding Style Guide (http://www.php-fig.org/psr/psr-12/)

Lizenz

ITertools PHP ist unter der MIT -Lizenz lizenziert.

Ähnliche Bibliotheken in anderen Sprachen

Die Funktionalität von Itertools ist nicht auf PHP und Python beschränkt. Other languages have similar libraries. Familiar functionality is available when working in other languages.

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