itertools php

IterTools - Alat iterasi PHP untuk meningkatkan loop Anda

Terinspirasi oleh Python - dirancang untuk PHP.

Fitur

IterTools membuat Anda menjadi superstar iterasi dengan menyediakan dua jenis alat:

• Alat Iterasi Loop
• Alat Iterasi Stream

Contoh Alat Iterasi Loop

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

Contoh Alat Iterasi Streaming

 $ 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

Semua fungsi bekerja pada koleksi iterable :

• array (jenis)
• Generator (jenis)
• Iterator (antarmuka)
• Traversable (antarmuka)

Dokumen ReadMe diterjemahkan dalam bahasa lain:

• Рсский

Referensi cepat

Alat Iterasi Loop

Multi iterasi

Iterator	Keterangan	Cuplikan kode
chain	Rantai ganda iterable bersama	Multi::chain($list1, $list2)
zip	Mengulangi beberapa koleksi secara bersamaan sampai iterator terpendek selesai	Multi::zip($list1, $list2)
zipEqual	Mengulangi beberapa koleksi dengan panjang yang sama secara bersamaan, kesalahan jika panjangnya tidak sama	Multi::zipEqual($list1, $list2)
zipFilled	Iterasi beberapa koleksi, menggunakan nilai pengisi jika panjangnya tidak sama	Multi::zipFilled($default, $list1, $list2)
zipLongest	Mengulangi beberapa koleksi secara bersamaan sampai iterator terpanjang selesai	Multi::zipLongest($list1, $list2)

Iterasi tunggal

Iterator	Keterangan	Cuplikan kode
chunkwise	ITerate oleh Chunks	Single::chunkwise($data, $chunkSize)
chunkwiseOverlap	ITerate dengan potongan yang tumpang tindih	Single::chunkwiseOverlap($data, $chunkSize, $overlapSize)
compress	Saring elemen yang tidak dipilih	Single::compress($data, $selectors)
compressAssociative	Saring elemen dengan tombol yang tidak dipilih	Single::compressAssociative($data, $selectorKeys)
dropWhile	Jatuhkan elemen sementara predikat benar	Single::dropWhile($data, $predicate)
filter	Filter untuk elemen di mana predikat benar	Single::filterTrue($data, $predicate)
filterTrue	Filter untuk elemen kebenaran	Single::filterTrue($data)
filterFalse	Filter untuk elemen palsu	Single::filterFalse($data)
filterKeys	Filter untuk kunci di mana predikat benar	Single::filterKeys($data, $predicate)
flatMap	Fungsi peta ke item dan hasil ratakan	Single::flaMap($data, $mapper)
flatten	Ratakan multidimensi yang dapat diulang	Single::flatten($data, [$dimensions])
groupBy	Data grup dengan elemen umum	Single::groupBy($data, $groupKeyFunction, [$itemKeyFunc])
limit	Iterasi hingga batas	Single::limit($data, $limit)
map	Fungsi peta ke setiap item	Single::map($data, $function)
pairwise	ITerate Pasangan yang tumpang tindih berturut -turut	Single::pairwise($data)
reindex	Kunci reindex dari nilai kunci iterable	Single::reindex($data, $reindexer)
repeat	Ulangi item beberapa kali	Single::repeat($item, $repetitions)
reverse	Mengulangi elemen dalam urutan terbalik	Single::reverse($data)
skip	ITerate setelah melewatkan elemen	Single::skip($data, $count, [$offset])
slice	Ekstrak sepotong iterable	Single::slice($data, [$start], [$count], [$step])
string	Mengulangi karakter string	Single::string($string)
takeWhile	Mengulangi elemen sementara predikat benar	Single::takeWhile($data, $predicate)

Iterasi yang tak terbatas

Iterator	Keterangan	Cuplikan kode
count	Hitung secara berurutan selamanya	Infinite::count($start, $step)
cycle	Bersepeda melalui koleksi	Infinite::cycle($collection)
repeat	Ulangi item selamanya	Infinite::repeat($item)

Iterasi acak

Iterator	Keterangan	Cuplikan kode
choice	Pilihan acak dari daftar	Random::choice($list, $repetitions)
coinFlip	Flips koin acak (0 atau 1)	Random::coinFlip($repetitions)
number	Angka acak	Random::number($min, $max, $repetitions)
percentage	Persentase acak antara 0 dan 1	Random::percentage($repetitions)
rockPaperScissors	Tangan Rock-Paper-Scissors Acak	Random::rockPaperScissors($repetitions)

Iterasi matematika

Iterator	Keterangan	Cuplikan kode
frequencies	Distribusi frekuensi data	Math::frequencies($data, [$strict])
relativeFrequencies	Distribusi frekuensi relatif data	Math::relativeFrequencies($data, [$strict])
runningAverage	Menjalankan akumulasi rata -rata	Math::runningAverage($numbers, $initialValue)
runningDifference	Menjalankan akumulasi perbedaan	Math::runningDifference($numbers, $initialValue)
runningMax	Menjalankan akumulasi maksimum	Math::runningMax($numbers, $initialValue)
runningMin	Menjalankan akumulasi minimum	Math::runningMin($numbers, $initialValue)
runningProduct	Menjalankan akumulasi produk	Math::runningProduct($numbers, $initialValue)
runningTotal	Menjalankan akumulasi total	Math::runningTotal($numbers, $initialValue)

Set dan iterasi multiset

Iterator	Keterangan	Cuplikan kode
distinct	Mengulangi hanya item yang berbeda	Set::distinct($data)
distinctBy	Mengulangi hanya item berbeda menggunakan pembanding khusus	Set::distinct($data, $compareBy)
intersection	Persimpangan iterables	Set::intersection(...$iterables)
intersectionCoercive	Persimpangan dengan paksaan tipe	Set::intersectionCoercive(...$iterables)
partialIntersection	Persimpangan parsial dari iterable	Set::partialIntersection($minCount, ...$iterables)
partialIntersectionCoercive	Persimpangan parsial dengan paksaan tipe	Set::partialIntersectionCoercive($minCount, ...$iterables)
symmetricDifference	Perbedaan simetris dari iterable	Set::symmetricDifference(...$iterables)
symmetricDifferenceCoercive	Perbedaan simetris dengan paksaan tipe	Set::symmetricDifferenceCoercive(...$iterables)
union	Persatuan iterables	Set::union(...$iterables)
unionCoercive	Persatuan dengan pemaksaan tipe	Set::unionCoercive(...$iterables)

Urutkan iterasi

Iterator	Keterangan	Cuplikan kode
asort	Mengulangi koleksi yang diurutkan.	Sort::asort($data, [$comparator])
sort	Mengulangi koleksi yang diurutkan	Sort::sort($data, [$comparator])

File iterasi

Iterator	Keterangan	Cuplikan kode
readCsv	Persimpangan baris file csv demi baris	File::readCsv($fileHandle)
readLines	Izin baris file demi baris	File::readLines($fileHandle)

Mengubah iterasi

Iterator	Keterangan	Cuplikan kode
tee	Iterasi Iterator Duplikat	Transform::tee($data, $count)
toArray	Mengubah iterable menjadi array	Transform::toArray($data)
toAssociativeArray	Mengubah iterable menjadi array asosiatif	Transform::toAssociativeArray($data, [$keyFunc], [$valueFunc])
toIterator	Mengubah iterable menjadi iterator	Transform::toIterator($data)

Ringkasan

Ringkasan	Keterangan	Cuplikan kode
allMatch	Benar jika semua item benar menurut predikat	Summary::allMatch($data, $predicate)
allUnique	Benar jika semua item unik	Summary::allUnique($data, [$strict])
anyMatch	Benar jika ada item yang benar menurut predikat	Summary::anyMatch($data, $predicate)
arePermutations	Benar jika Iterable adalah permutasi satu sama lain	Summary::arePermutations(...$iterables)
arePermutationsCoercive	Benar jika Iterable adalah permutasi satu sama lain dengan paksaan tipe	Summary::arePermutationsCoercive(...$iterables)
exactlyN	Benar jika tepatnya n item benar menurut predikat	Summary::exactlyN($data, $n, $predicate)
isEmpty	Benar jika Iterable tidak memiliki item	Summary::isEmpty($data)
isPartitioned	Benar jika dipartisi dengan item yang benar menurut predikat sebelum orang lain	Summary::isPartitioned($data, $predicate)
isSorted	Benar jika Iterable disortir	Summary::isSorted($data)
isReversed	Benar jika Iterable Reverse Diurutkan	Summary::isReversed($data)
noneMatch	Benar jika tidak ada item yang benar menurut predikat	Summary::noneMatch($data, $predicate)
same	Benar jika iterable sama	Summary::same(...$iterables)
sameCount	Benar jika Iterable memiliki panjang yang sama	Summary::sameCount(...$iterables)

Mengurangi

Peredam	Keterangan	Cuplikan kode
toAverage	Rata -rata rata -rata elemen	Reduce::toAverage($numbers)
toCount	Mengurangi panjangnya	Reduce::toCount($data)
toFirst	Mengurangi nilai pertamanya	Reduce::toFirst($data)
toFirstAndLast	Mengurangi nilai pertama dan terakhir	Reduce::toFirstAndLast($data)
toLast	Mengurangi nilai terakhirnya	Reduce::toLast()
toMax	Mengurangi ke elemen terbesarnya	Reduce::toMax($numbers, [$compareBy])
toMin	Mengurangi elemen terkecil	Reduce::toMin($numbers, [$compareBy])
toMinMax	Kurangi ke array batas atas dan bawah	Reduce::toMinMax($numbers, [$compareBy])
toNth	Mengurangi nilai pada posisi ke -n	Reduce::toNth($data, $position)
toProduct	Mengurangi produk elemennya	Reduce::toProduct($numbers)
toRandomValue	Mengurangi nilai acak dari iterable	Reduce::toRandomValue($data)
toRange	Mengurangi perbedaan nilai maks dan min	Reduce::toRange($numbers)
toString	Kurangi untuk bergabung dengan string	Reduce::toString($data, [$separator], [$prefix], [$suffix])
toSum	Mengurangi jumlah elemennya	Reduce::toSum($numbers)
toValue	Mengurangi nilai menggunakan peredam yang dapat dipanggil	Reduce::toValue($data, $reducer, $initialValue)

Alat Iterasi Stream

Sumber aliran

Sumber	Keterangan	Cuplikan kode
of	Buat aliran dari iterable	Stream::of($iterable)
ofCoinFlips	Buat aliran flip koin acak	Stream::ofCoinFlips($repetitions)
ofCsvFile	Buat aliran dari file CSV	Stream::ofCsvFile($fileHandle)
ofEmpty	Buat aliran kosong	Stream::ofEmpty()
ofFileLines	Buat aliran dari baris file	Stream::ofFileLines($fileHandle)
ofRandomChoice	Buat aliran pilihan acak	Stream::ofRandomChoice($items, $repetitions)
ofRandomNumbers	Buat aliran angka acak (bilangan bulat)	Stream::ofRandomNumbers($min, $max, $repetitions)
ofRandomPercentage	Buat aliran persentase acak antara 0 dan 1	Stream::ofRandomPercentage($repetitions)
ofRange	Buat aliran berbagai angka	Stream::ofRange($start, $end, $step)
ofRockPaperScissors	Buat aliran tangan paper-kertas batu	Stream::ofRockPaperScissors($repetitions)

Operasi stream

Operasi	Keterangan	Cuplikan kode
asort	Mengurutkan sumber yang dapat diulangi	$stream->asort([$comparator])
chainWith	Rantai sumber yang dapat diulang dengan iterable bersama menjadi satu iterasi tunggal	$stream->chainWith(...$iterables)
compress	Sumber kompres dengan memfilter data yang tidak dipilih	$stream->compress($selectors)
compressAssociative	Sumber kompres dengan memfilter tombol yang tidak dipilih	$stream->compressAssociative($selectorKeys)
chunkwise	ITerate oleh Chunks	$stream->chunkwise($chunkSize)
chunkwiseOverlap	ITerate dengan potongan yang tumpang tindih	$stream->chunkwiseOverlap($chunkSize, $overlap)
distinct	Filter keluar elemen: iterate saja item unik	$stream->distinct([$strict])
distinctBy	Filter keluar elemen: iterate saja item unik menggunakan pembanding khusus	$stream->distinct($compareBy)
dropWhile	Jatuhkan elemen dari sumber iterable sedangkan fungsi predikat benar	$stream->dropWhile($predicate)
filter	Filter hanya untuk elemen di mana fungsi predikat benar	$stream->filterTrue($predicate)
filterTrue	Memfilter hanya untuk elemen kebenaran	$stream->filterTrue()
filterFalse	Filter hanya untuk elemen palsu	$stream->filterFalse()
filterKeys	Filter untuk kunci di mana fungsi predikat benar	$stream->filterKeys($predicate)
flatMap	Fungsi peta ke elemen dan ratakan hasil	$stream->flatMap($function)
flatten	Ratakan aliran multidimensi	$stream->flatten($dimensions)
frequencies	Distribusi frekuensi	$stream->frequencies([$strict])
groupBy	Sumber iterable grup dengan elemen data umum	$stream->groupBy($groupKeyFunction, [$itemKeyFunc])
infiniteCycle	Bersepeda melalui elemen -elemen sumber iterable secara berurutan selamanya	$stream->infiniteCycle()
intersectionWith	Berpotongan sumber yang dapat diulang dan diberikan iterable	$stream->intersectionWith(...$iterables)
intersection CoerciveWith	Sumber yang dapat diselingi dan diberikan iterable dengan paksaan tipe	$stream->intersectionCoerciveWith(...$iterables)
limit	Batasi iterasi aliran	$stream->limit($limit)
map	Fungsi peta ke elemen	$stream->map($function)
pairwise	Mengembalikan pasangan elemen dari sumber yang dapat diulang	$stream->pairwise()
partialIntersectionWith	Sumber yang dapat diselingi sebagian dan diberikan iterable	$stream->partialIntersectionWith( $minIntersectionCount, ...$iterables)
partialIntersection CoerciveWith	Sumber yang dapat diselingi sebagian dan diberikan iterable dengan tipe paksaan	$stream->partialIntersectionCoerciveWith( $minIntersectionCount, ...$iterables)
reindex	Tombol reindex dari aliran value kunci	$stream->reindex($reindexer)
relativeFrequencies	Distribusi frekuensi relatif	$stream->relativeFrequencies([$strict])
reverse	Elemen terbalik dari aliran	$stream->reverse()
runningAverage	Mengumpulkan rata -rata berjalan (rata -rata) di atas sumber yang dapat diulang	$stream->runningAverage($initialValue)
runningDifference	Mengakumulasikan perbedaan yang berjalan di atas sumber yang dapat diulang	$stream->runningDifference($initialValue)
runningMax	Menumpuk maks yang berjalan di atas sumber yang dapat diulang	$stream->runningMax($initialValue)
runningMin	Menumpuk min running di atas sumber yang dapat diulang	$stream->runningMin($initialValue)
runningProduct	Mengakumulasi produk yang berjalan di atas sumber yang dapat diulang	$stream->runningProduct($initialValue)
runningTotal	Mengakumulasi total yang berjalan di atas sumber yang dapat diulang	$stream->runningTotal($initialValue)
skip	Lewati beberapa elemen aliran	$stream->skip($count, [$offset])
slice	Ekstrak sepotong aliran	$stream->slice([$start], [$count], [$step])
sort	Mengurutkan aliran	$stream->sort([$comparator])
symmetricDifferenceWith	Perbedaan simetris dari sumber yang dapat diulang dan diberikan iterable	$this->symmetricDifferenceWith(...$iterables)
symmetricDifference CoerciveWith	Perbedaan Simetris dari Sumber Iterable dan Diberikan Iterable Dengan Paksaan Jenis	$this->symmetricDifferenceCoerciveWith( ...$iterables)
takeWhile	Elemen pengembalian dari sumber iterable selama predikat itu benar	$stream->takeWhile($predicate)
unionWith	Persatuan aliran dengan iterable	$stream->unionWith(...$iterables)
unionCoerciveWith	Union of Stream dengan iterables dengan paksaan tipe	$stream->unionCoerciveWith(...$iterables)
zipWith	Mengulangi sumber yang dapat diulang dengan koleksi lain yang dapat diulang secara bersamaan	$stream->zipWith(...$iterables)
zipEqualWith	Mengulangi sumber yang dapat diulang dengan kumpulan panjang yang sama dengan panjang yang sama secara bersamaan	$stream->zipEqualWith(...$iterables)
zipFilledWith	ITerate iterable Source dengan koleksi iterable lain menggunakan pengisi default	$stream->zipFilledWith($default, ...$iterables)
zipLongestWith	Mengulangi sumber yang dapat diulang dengan koleksi lain yang dapat diulang secara bersamaan	$stream->zipLongestWith(...$iterables)

Operasi Terminal Stream

Ringkasan Operasi Terminal

Operasi Terminal	Keterangan	Cuplikan kode
allMatch	Mengembalikan true jika semua item dalam stream mencocokkan predikat	$stream->allMatch($predicate)
allUnique	Mengembalikan true jika semua item dalam aliran itu unik	$stream->allUnique([$strict]])
anyMatch	Mengembalikan true jika ada item dalam stream yang cocok dengan predikat	$stream->anyMatch($predicate)
arePermutationsWith	Mengembalikan true jika semua permutasi aliran yang dapat diulang	$stream->arePermutationsWith(...$iterables)
arePermutationsCoerciveWith	Mengembalikan true jika semua permutasi aliran yang dapat diulang dengan paksaan tipe	$stream->arePermutationsCoerciveWith(...$iterables)
exactlyN	Mengembalikan true jika tepatnya n item benar menurut predikat	$stream->exactlyN($n, $predicate)
isEmpty	Mengembalikan true jika stream tidak memiliki item	$stream::isEmpty()
isPartitioned	Mengembalikan true jika dipartisi dengan item yang benar menurut predikat sebelum orang lain	$stream::isPartitioned($predicate)
isSorted	Mengembalikan true jika stream diurutkan dalam urutan naik	$stream->isSorted()
isReversed	Mengembalikan true jika stream diurutkan dalam urutan turun terbalik	$stream->isReversed()
noneMatch	Mengembalikan true jika tidak ada item dalam stream yang cocok dengan predikat	$stream->noneMatch($predicate)
sameWith	Mengembalikan true jika stream dan semua koleksi yang diberikan adalah sama	$stream->sameWith(...$iterables)
sameCountWith	Mengembalikan true jika stream dan semua koleksi yang diberikan memiliki panjang yang sama	$stream->sameCountWith(...$iterables)

Operasi Terminal Pengurangan

Operasi Terminal	Keterangan	Cuplikan kode
toAverage	Mengurangi aliran ke rata -rata rata -rata itemnya	$stream->toAverage()
toCount	Mengurangi aliran hingga panjangnya	$stream->toCount()
toFirst	Mengurangi aliran ke nilai pertamanya	$stream->toFirst()
toFirstAndLast	Mengurangi aliran ke nilai pertama dan terakhir	$stream->toFirstAndLast()
toLast	Mengurangi aliran ke nilai terakhirnya	$stream->toLast()
toMax	Mengurangi aliran ke nilai maksimal	$stream->toMax([$compareBy])
toMin	Mengurangi aliran ke nilai min	$stream->toMin([$compareBy])
toMinMax	Mengurangi aliran ke array batas atas dan bawah	$stream->toMinMax([$compareBy])
toNth	Mengurangi aliran ke nilai pada posisi ke -n	$stream->toNth($position)
toProduct	Mengurangi aliran ke produk itemnya	$stream->toProduct()
toString	Mengurangi aliran ke string yang bergabung	$stream->toString([$separator], [$prefix], [$suffix])
toSum	Mengurangi aliran ke jumlah itemnya	$stream->toSum()
toRandomValue	Mengurangi aliran ke nilai acak di dalamnya	$stream->toRandomValue()
toRange	Mengurangi aliran menjadi perbedaan nilai maks dan min	$stream->toRange()
toValue	Mengurangi Fungsi Stream Like Array_Reduce ()	$stream->toValue($reducer, $initialValue)

Operasi Terminal Transformasi

Operasi Terminal	Keterangan	Cuplikan kode
toArray	Mengembalikan array elemen aliran	$stream->toArray()
toAssociativeArray	Mengembalikan peta nilai kunci elemen aliran	$stream->toAssociativeArray($keyFunc, $valueFunc)
tee	Mengembalikan array beberapa aliran identik	$stream->tee($count)

Operasi Terminal Efek Samping

Operasi Terminal	Keterangan	Cuplikan kode
callForEach	Lakukan tindakan melalui fungsi pada setiap item	$stream->callForEach($function)
print	print setiap item di aliran	$stream->print([$separator], [$prefix], [$suffix])
printLn	print setiap item pada baris baru	$stream->printLn()
toCsvFile	Tulis konten aliran ke file CSV	$stream->toCsvFile($fileHandle, [$headers])
toFile	Tulis konten aliran ke file	$stream->toFile($fileHandle)

Stream Operasi Debug

Operasi debug	Keterangan	Cuplikan kode
peek	Mengintip setiap elemen di antara operasi aliran	$stream->peek($peekFunc)
peekStream	Mengintip seluruh aliran antar operasi	$stream->peekStream($peekFunc)
peekPrint	Mengintip setiap elemen dengan mencetak antar operasi	$stream->peekPrint()
peekPrintR	Mengintip setiap elemen dengan melakukan cetak-R antar operasi	$stream->peekPrintR()
printR	print_r setiap item	$stream->printR()
varDump	var_dump setiap item	$stream->varDump()

Pengaturan

Tambahkan pustaka ke file composer.json Anda di proyek Anda:

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

Gunakan komposer untuk menginstal perpustakaan:

$ php composer.phar install

Komposer akan menginstal iTertools di dalam folder vendor Anda. Kemudian Anda dapat menambahkan yang berikut ke file .php Anda untuk menggunakan pustaka dengan autoloading.

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

Atau, gunakan komposer pada baris perintah untuk meminta dan menginstal iterTools:

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

Persyaratan minimum

• PHP 7.4

Penggunaan

Semua fungsi bekerja pada koleksi iterable :

• array (jenis)
• Generator (jenis)
• Iterator (antarmuka)
• Traversable (antarmuka)

Multi iterasi

Rantai

Rantai ganda iterable bersama -sama menjadi satu urutan kontinu tunggal.

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'

Ritsleting

Iterasi beberapa koleksi iterable secara bersamaan.

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 berfungsi dengan beberapa input iterable-tidak terbatas hanya dua.

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

Catatan: Untuk panjang yang tidak rata, iterasi berhenti ketika iterable terpendek habis.

Zipequal

Iterasi beberapa koleksi iterable dengan panjang yang sama secara bersamaan.

Melempar LengthException Jika panjangnya tidak sama, artinya setidaknya satu iterator berakhir sebelum yang lain.

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

Zipfilled

Iterasi beberapa koleksi iterable secara bersamaan, menggunakan nilai pengisi default jika panjang tidak sama.

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

Ziplongest

Iterasi beberapa koleksi iterable secara bersamaan.

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

Untuk panjang yang tidak merata, iterables yang kelelahan akan menghasilkan null untuk iterasi yang tersisa.

 use IterTools  Multi ;

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

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

Iterasi tunggal

Chunkware

Elemen pengembalian dalam potongan dengan ukuran tertentu.

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

Ukuran chunk harus setidaknya 1.

 use IterTools  Single ;

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

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

Tumpang tindih chunkwise

Kembalikan potongan elemen yang tumpang tindih.

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

• Ukuran chunk harus setidaknya 1.
• Ukuran tumpang tindih harus kurang dari ukuran potongan.

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

Kompres

Kompres iterable dengan memfilter data yang tidak dipilih.

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'

Compress Associative

Kompres iterable dengan memfilter tombol yang tidak dipilih.

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

• Hanya kunci array php/iterator standar (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

Jatuh sementara

Jatuhkan elemen dari iterable sedangkan fungsi predikat benar.

Setelah fungsi predikat kembali salah satu kali, semua elemen yang tersisa dikembalikan.

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

Menyaring

Saring elemen dari elemen pengembalian yang dapat diulang di mana fungsi predikat benar.

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

Saring elemen dari unsur -unsur pengembalian yang dapat diulangi yang benar.

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

Memfitor false

Saring elemen dari elemen pengembalian yang dapat diulang di mana fungsi predikat salah.

Jika tidak ada predikat yang disediakan, nilai boolean dari data digunakan.

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

Tombol filter

Saring elemen dari elemen pengembalian yang hanya dapat diulangi yang kunci fungsi predikat benar.

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

Peta datar

Peta fungsi hanya elemen -elemen yang dapat diulang dan kemudian ratakan hasilnya.

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

Meratakan

Ratakan iterable multidimensi.

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]

Grup oleh

Data grup dengan elemen data umum.

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

• $groupKeyFunction menentukan kunci untuk elemen grup oleh.
• Opsional $itemKeyFunction memungkinkan indeks khusus dalam setiap anggota grup.

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

Membatasi

Iterasi hingga batas.

Berhenti bahkan jika lebih banyak data yang tersedia jika batas dicapai.

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)

Peta

Peta fungsi ke setiap elemen.

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

Berpasangan

Mengembalikan pasangan yang tumpang tindih berturut -turut.

Mengembalikan generator kosong jika koleksi yang diberikan berisi kurang dari 2 elemen.

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

Mengulang

Ulangi item.

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

 use IterTools  Single ;

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

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

Reindex

Kunci reindex dari nilai kunci yang dapat digunakan menggunakan fungsi pengindeks.

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

Balik

Membalikkan elemen -elemen dari iterable.

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

Melewati

Lewati elemen N dalam iterable setelah offset offset opsional.

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'

Mengiris

Ekstrak sepotong iterable.

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

 use IterTools  Single ;

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

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

Rangkaian

Izin karakter individu dari suatu string.

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

Ambillah sementara

Elemen pengembalian dari Iterable selama predikat itu benar.

Menghentikan iterasi segera setelah predikat mengembalikan false, bahkan jika elemen lain kemudian pada akhirnya akan mengembalikan true (berbeda dari 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 

Iterasi yang tak terbatas

Menghitung

Hitung secara berurutan selamanya.

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

Siklus

Siklus melalui elemen -elemen koleksi secara berurutan selamanya.

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

Ulangi (tak terbatas)

Ulangi item selamanya.

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

Iterasi acak

Pilihan

Menghasilkan pilihan acak dari array nilai.

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

 use IterTools  Random ;

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

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

Coinflip

Hasilkan flips koin acak (0 atau 1).

Random::coinFlip(int $repetitions)

 use IterTools  Random ;

$ repetitions = 10 ;

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

Nomor

Menghasilkan angka acak (bilangan bulat).

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]

Persentase

Menghasilkan persentase acak antara 0 dan 1.

Random::percentage(int $repetitions)

 use IterTools  Random ;

$ repetitions = 10 ;

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

Rockpaperscissors

Hasilkan tangan-tangan paper-paper acak.

Random::rockPaperScissors(int $repetitions)

 use IterTools  Random ;

$ repetitions = 10 ;

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

Iterasi matematika

Frekuensi

Mengembalikan distribusi frekuensi data.

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

Default ke perbandingan tipe yang ketat. Tetapkan ketat menjadi false untuk perbandingan paksaan tipe.

 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

Frekuensi relatif

Mengembalikan distribusi frekuensi relatif data.

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

Default ke perbandingan tipe yang ketat. Tetapkan ketat menjadi false untuk perbandingan paksaan tipe.

 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

Rata -rata berjalan

Akumulasi rata -rata berjalan di atas daftar angka.

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

Berlari perbedaan

Akumulasi perbedaan berjalan pada daftar angka.

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

Berikan nilai awal opsional untuk menyebabkan perbedaan berjalan.

 use IterTools  Math ;

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

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

Menjalankan maks

Akumulasi maksimum yang berjalan di atas daftar angka.

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

Menjalankan min

Mengumpulkan minimum yang berjalan di atas daftar angka.

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

Menjalankan produk

Akumulasi produk yang sedang berjalan melalui daftar angka.

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

Berikan nilai awal opsional untuk menyebabkan produk yang sedang berjalan.

 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

Berjalan total

Akumulasi total berjalan di atas daftar angka.

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

Berikan nilai awal opsional untuk menyebabkan total berjalan.

 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 dan multiset

Berbeda

Saring elemen dari iterable hanya mengembalikan elemen yang berbeda.

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

Default ke perbandingan tipe yang ketat. Tetapkan ketat menjadi false untuk perbandingan paksaan tipe.

 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

Berbeda oleh

Saring elemen dari iterable hanya mengembalikan elemen berbeda sesuai dengan fungsi pembanding khusus.

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.

Persimpangan

Mengulangi persimpangan iterables.

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

Jika input iterables menghasilkan item duplikat, maka aturan persimpangan multiset berlaku.

 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

Persimpangan paksaan

Iterasi persimpangan iterables menggunakan paksaan tipe.

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

Jika input iterables menghasilkan item duplikat, maka aturan persimpangan multiset berlaku.

 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

Persimpangan parsial

Iterasi persimpangan m-partsial dari iterables.

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

• Jika input iterables menghasilkan item duplikat, maka aturan persimpangan multiset berlaku.

 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

Paksaan persimpangan parsial

Iterasi persimpangan M-partal dari iterables menggunakan tipe paksaan.

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

• Jika input iterables menghasilkan item duplikat, maka aturan persimpangan multiset berlaku.

 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

Perbedaan simetris

Mengulangi perbedaan simetris dari iterables.

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

Jika input iterables menghasilkan item duplikat, maka aturan perbedaan multiset berlaku.

 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

Perbedaan simetris koersif

Iterasi perbedaan simetris dari iterables dengan paksaan tipe.

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

Jika input iterables menghasilkan item duplikat, maka aturan perbedaan multiset berlaku.

 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

Serikat

Mengulangi persatuan iterables.

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

Jika input iterables menghasilkan item duplikat, maka aturan Multiset Union berlaku.

 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

Paksaan Union

Iterasi penyatuan iterables dengan paksaan tipe.

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

Jika input iterables menghasilkan item duplikat, maka aturan Multiset Union berlaku.

 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 

Urutkan iterasi

Asort

Iterasi koleksi diurutkan sambil mempertahankan hubungan indeks kunci asosiatif.

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

Menggunakan penyortiran default jika fungsi pembanding opsional tidak disediakan.

 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

Menyortir

Iarir koleksi diurutkan.

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

Menggunakan penyortiran default jika fungsi pembanding opsional tidak disediakan.

 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 

Mengajukan

Baca CSV

Iterasi baris file CSV.

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

 use IterTools  File ;

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

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

Baca baris

Mengulangi baris file.

File::readLines(resource $fileHandle)

 use IterTools  File ;

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

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

Mengubah

Tee

Kembalikan beberapa iterator independen (digandakan) dari satu iterable.

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

 use IterTools  Transform ;

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

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

Untuk array

Mengubah apa pun yang dapat diulang ke array.

Transform::toArray(iterable $data): array

 use IterTools  Transform ;

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

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

Ke array asosiatif

Mengubah segala hal yang dapat diulang ke array asosiatif.

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

Ke Iterator

Mengubah iterable menjadi iterator.

Transform::toArray(iterable $data): array

 use IterTools  Transform ;

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

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

Ringkasan

Semua cocok

Mengembalikan true jika semua elemen cocok dengan fungsi predikat.

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

Semua unik

Mengembalikan true jika semua elemen unik.

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

Default ke perbandingan tipe yang ketat. Tetapkan ketat menjadi false untuk perbandingan paksaan tipe.

 use IterTools  Summary ;

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

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

Pertandingan apa pun

Mengembalikan true jika ada elemen yang cocok dengan fungsi predikat.

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

Adalah permutasi

Mengembalikan true jika semua iterable adalah permutasi satu sama lain.

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

Adalah permutasi paksaan

Mengembalikan true jika semua iterable adalah permutasi satu sama lain dengan jenis paksaan.

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

Tepatnya n

Mengembalikan true jika tepatnya N item benar menurut fungsi predikat.

• Predikat adalah opsional.
• Predikat default adalah nilai boolean dari setiap item.

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

Kosong

Mengembalikan true jika Iterable kosong tidak memiliki item.

Summary::isEmpty(iterable $data): bool

 use IterTools  Summary ;

$ data = []

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

Dipartisi

Mengembalikan true jika semua elemen koleksi yang diberikan yang memenuhi predikat muncul sebelum semua elemen yang tidak.

• Mengembalikan benar untuk koleksi kosong atau untuk koleksi dengan item tunggal.
• Predikat default jika tidak disediakan adalah nilai boolean dari setiap item data.

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

Diurutkan

Mengembalikan true jika elemen diurutkan, jika tidak salah.

• Elemen harus sebanding.
• Mengembalikan true jika kosong atau hanya memiliki satu elemen.

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

Terbalik

Mengembalikan true jika elemen diurutkan, jika tidak salah.

• Elemen harus sebanding.
• Mengembalikan true jika kosong atau hanya memiliki satu elemen.

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

Tidak ada yang cocok

Mengembalikan true jika tidak ada elemen yang cocok dengan fungsi predikat.

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

Sama

Mengembalikan true jika semua koleksi yang diberikan sama.

Untuk daftar iterable tunggal atau kosong yang dapat dikembalikan true.

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

 use IterTools  Summary ;

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

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

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

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

Hitungan yang sama

Mengembalikan true jika semua koleksi yang diberikan memiliki panjang yang sama.

Untuk daftar iterable tunggal atau kosong yang dapat dikembalikan true.

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

 use IterTools  Summary ;

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

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

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

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

Mengurangi

Rata -rata

Berkurang menjadi rata -rata rata -rata.

Kembali nol jika koleksi kosong.

Reduce::toAverage(iterable $data): float

 use IterTools  Reduce ;

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

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

Untuk menghitung

Mengurangi iterable hingga panjangnya.

Reduce::toCount(iterable $data): int

 use IterTools  Reduce ;

$ someIterable = ImportantThing:: getCollectionAsIterable ();

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

Untuk pertama

Mengurangi iterable ke elemen pertamanya.

Reduce::toFirst(iterable $data): mixed

Lempar LengthException Jika koleksi kosong.

 use IterTools  Reduce ;

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

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

Untuk yang pertama dan terakhir

Mengurangi iterable ke elemen pertama dan terakhir.

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

Lempar LengthException Jika koleksi kosong.

 use IterTools  Reduce ;

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

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

Untuk bertahan

Mengurangi iterable ke elemen terakhirnya.

Reduce::toLast(iterable $data): mixed

Lempar LengthException Jika koleksi kosong.

 use IterTools  Reduce ;

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

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

Untuk maks

Berkurang ke nilai maksimal.

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

• Param yang dapat dipanggil opsional $compareBy harus mengembalikan nilai yang sebanding.
• Jika $compareBy tidak disediakan maka item koleksi yang diberikan harus sebanding.
• Kembali nol jika koleksi kosong.

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

Untuk min

Berkurang ke nilai min.

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

• Param yang dapat dipanggil opsional $compareBy harus mengembalikan nilai yang sebanding.
• Jika $compareBy tidak disediakan maka item koleksi yang diberikan harus sebanding.
• Kembali nol jika koleksi kosong.

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

Untuk min max

Dikurangi menjadi array batas atas dan bawah (maks dan min).

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

• Param yang dapat dipanggil opsional $compareBy harus mengembalikan nilai yang sebanding.
• Jika $compareBy tidak disediakan maka item koleksi yang diberikan harus sebanding.
• Mengembalikan [null, null] Jika koleksi yang diberikan kosong.

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

Ke nth

Mengurangi nilai pada posisi ke -n.

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

 use IterTools  Reduce ;

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

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

Untuk produk

Mengurangi produk elemennya.

Kembali nol jika koleksi kosong.

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

 use IterTools  Reduce ;

$ primeFactors = [ 5 , 2 , 2 ];

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

Ke nilai acak

Mengurangi koleksi yang diberikan ke nilai acak di dalamnya.

Reduce::toRandomValue(iterable $data): mixed

 use IterTools  Reduce ;

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

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

Untuk jangkauan

Mengurangi koleksi yang diberikan ke jangkauannya (perbedaan antara max dan min).

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

Mengembalikan 0 jika sumber Iterable kosong.

 use IterTools  Reduce ;

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

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

Untuk string

Dikurangi menjadi string yang bergabung dengan semua elemen.

• Pemisah opsional untuk menyisipkan antar item.
• Awalan opsional untuk diatur ke string.
• Sufiks opsional untuk ditambahkan ke string.

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!

Lebih dari itu

Mengurangi jumlah elemennya.

Reduce::toSum(iterable $data): number

 use IterTools  Reduce ;

$ parts = [ 10 , 20 , 30 ];

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

Untuk menghargai

Kurangi elemen ke nilai tunggal menggunakan fungsi reducer.

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 

Sungai kecil

Streams menyediakan antarmuka yang lancar untuk mengubah array dan iterable melalui pipa operasi.

Stream terdiri dari:

1. Satu metode pabrik aliran pabrik untuk membuat aliran.
2. Nol atau lebih operator aliran yang mengubah aliran menjadi aliran baru.
3. Operasi terminal dari keduanya:
   • Operasi Terminal Stream untuk mengubah aliran ke nilai atau struktur data.

    $ 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

   • Aliran diulang melalui loop foreach .

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

Sumber aliran

Dari

Menciptakan aliran dari yang dapat diulang.

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 

Koin flips

Membuat aliran flops koin acak.

Stream::ofCoinFlips(int $repetitions): Stream

 use IterTools  Stream ;

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

File CSV

Membuat aliran baris file CSV.

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

 use IterTools  Stream ;

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

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

Kosong

Membuat aliran apa pun.

Stream::ofEmpty(): Stream

 use IterTools  Stream ;

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

Baris file

Membuat aliran baris file.

Stream::ofFileLines(resource $fileHandle): Stream

 use IterTools  Stream ;

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

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

Pilihan acak

Membuat aliran pilihan acak dari array nilai.

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) 

Angka acak

Membuat aliran angka acak (bilangan bulat).

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) 

Persentase acak

Membuat aliran persentase acak antara 0 dan 1.

Stream::ofRandomPercentage(int $repetitions): Stream

 use IterTools  Stream ;

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

Jangkauan

Menciptakan aliran berbagai angka.

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 

Gunting kertas batu

Membuat aliran tangan-scissors-scissors tangan.

Stream::ofRockPaperScissors(int $repetitions): Stream

 use IterTools  Stream ;

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

Operasi stream

Asort

Mengurutkan aliran, mempertahankan kunci.

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

Jika pembanding tidak disediakan, elemen -elemen dari sumber yang dapat diulang harus sebanding.

 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, 

Rantai dengan

Kembalikan aliran sumber tambahan bersama menjadi satu aliran berturut -turut.

$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 

Kompres

Kompres ke aliran baru dengan memfilter data yang tidak dipilih.

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

Pemilih menunjukkan data mana. Nilai Benar Memilih Item. Nilai False memfilter data.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

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

Compress Associative

Kompres ke aliran baru dengan memfilter tombol yang tidak dipilih.

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

• Hanya kunci array php/iterator standar (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', 

Chunkware

Kembalikan aliran yang terdiri dari potongan elemen dari aliran.

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

Ukuran chunk harus setidaknya 1.

 use IterTools  Stream ;

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

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

Tumpang tindih chunkwise

Kembalikan aliran yang terdiri dari potongan elemen yang tumpang tindih dari aliran.

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

• Ukuran chunk harus setidaknya 1.
• Ukuran tumpang tindih harus kurang dari ukuran potongan.

 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] 

Berbeda

Mengembalikan aliran yang memfilter elemen dari aliran hanya mengembalikan elemen yang berbeda.

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

Default ke perbandingan tipe yang ketat. Tetapkan ketat menjadi false untuk perbandingan paksaan tipe.

 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 

Berbeda oleh

Mengembalikan elemen yang memfilter aliran dari aliran hanya mengembalikan elemen yang berbeda sesuai dengan fungsi pembanding khusus.

$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 

Jatuh sementara

Jatuhkan elemen dari aliran sedangkan fungsi predikat benar.

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

Setelah fungsi predikat kembali salah satu kali, semua elemen yang tersisa dikembalikan.

 use IterTools  Stream ;

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

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

Menyaring

Saring elemen dari aliran hanya menjaga elemen di mana ada fungsi predikat yang benar.

$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

Saring elemen dari aliran hanya menjaga elemen yang benar.

$stream->filterTrue(): Stream

 use IterTools  Stream ;

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

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

Memfitor false

Saring elemen dari aliran hanya menjaga elemen yang salah.

$stream->filterFalse(): Stream

 use IterTools  Stream ;

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

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

Tombol filter

Saring elemen dari aliran hanya menjaga elemen di mana fungsi predikat pada tombol benar.

$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 

Peta datar

Peta fungsi ke elemen aliran dan ratakan hasilnya.

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

Meratakan

Ratakan aliran multidimensi.

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

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

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

Frekuensi

Distribusi frekuensi elemen aliran.

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

Grup oleh

Mengembalikan pengelompokan aliran dengan elemen data umum.

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

• $groupKeyFunction menentukan kunci untuk elemen grup oleh.
• Opsional $itemKeyFunction memungkinkan indeks khusus dalam setiap anggota grup.

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

Siklus tak terbatas

Kembalikan aliran yang bersepeda melalui elemen aliran secara berurutan selamanya.

$stream->infiniteCycle(): Stream

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

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

Persimpangan dengan

Kembalikan aliran yang memotong aliran dengan input iterables.

$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 

Persimpangan paksaan dengan

Kembalikan aliran yang memotong aliran dengan input iterables menggunakan tipe paksaan.

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

Membatasi

Kembalikan aliran hingga batas.

Berhenti bahkan jika lebih banyak data yang tersedia jika batas dicapai.

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

Peta

Kembalikan aliran yang berisi hasil pemetaan fungsi ke setiap elemen aliran.

$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 

Berpasangan

Kembalikan aliran yang terdiri dari pasangan elemen dari aliran.

$stream->pairwise(): Stream

Mengembalikan aliran kosong jika koleksi yang diberikan berisi kurang dari 2 elemen.

 use IterTools  Stream ;

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

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

Persimpangan parsial dengan

Kembalikan aliran sebagian memotong aliran dengan input iterables.

$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 

Paksaan persimpangan parsial dengan

Kembalikan aliran sebagian memotong aliran dengan input iterables menggunakan tipe paksaan.

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

 use IterTools  Stream ;

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

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

Reindex

Mengembalikan aliran baru elemen-elemen kunci yang diindeks ulang oleh fungsi pengindeks kunci.

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

Frekuensi relatif

Distribusi frekuensi relatif dari elemen aliran.

$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 

Balik

Membalikkan elemen aliran.

$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 

Rata -rata berjalan

Kembalikan aliran yang menumpuk rata -rata berjalan (rata -rata) di atas aliran.

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

 use IterTools  Stream ;

$ input = [ 1 , 3 , 5 ];

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

Berlari perbedaan

Kembalikan aliran yang mengakumulasi perbedaan berjalan di atas aliran.

$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 

Menjalankan maks

Kembalikan aliran yang menumpuk maks yang berjalan di atas aliran.

$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 

Menjalankan min

Kembalikan aliran yang menumpuk min running di atas aliran.

$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 

Menjalankan produk

Kembalikan aliran yang mengumpulkan produk yang sedang berjalan di atas aliran.

$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 

Berjalan total

Kembalikan aliran yang menumpuk total berjalan di atas aliran.

$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 

Melewati

Lewati beberapa elemen aliran.

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

Mengiris

Ekstrak sepotong aliran.

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

Menyortir

Mengurutkan aliran.

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

Jika pembanding tidak disediakan, elemen -elemen dari sumber yang dapat diulang harus sebanding.

 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 

Perbedaan simetris dengan

Kembalikan aliran perbedaan simetris aliran dan iterables yang diberikan.

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

Catatan: Jika input iterables menghasilkan item duplikat, maka aturan persimpangan multiset berlaku.

 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 

Perbedaan simetris koersif dengan

Kembalikan aliran perbedaan simetris aliran dan iterables yang diberikan menggunakan tipe paksaan.

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

Catatan: Jika input iterables menghasilkan item duplikat, maka aturan persimpangan multiset berlaku.

 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 

Ambillah sementara

Jauhkan elemen dari aliran selama predikat itu benar.

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

Jika tidak ada predikat yang disediakan, nilai boolean dari data digunakan.

 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 

Persatuan dengan

Kembalikan aliran yang terdiri dari penyatuan aliran dan input iterables.

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

Catatan: Jika input iterables menghasilkan item duplikat, maka aturan multiset Union berlaku.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

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

Serikat pekerja dengan

Kembalikan aliran yang terdiri dari penyatuan aliran dan input iterables menggunakan tipe paksaan.

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

Catatan: Jika input iterables menghasilkan item duplikat, maka aturan multiset Union berlaku.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

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

Zip dengan

Kembalikan aliran yang terdiri dari beberapa koleksi iterable yang dialirkan secara bersamaan.

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

Untuk panjang yang tidak merata, iterasi berhenti ketika iterable terpendek habis.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

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

Zip diisi dengan

Kembalikan aliran yang terdiri dari beberapa koleksi iterable, menggunakan nilai pengisi default jika panjangnya tidak sama.

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

Kembalikan aliran yang terdiri dari beberapa koleksi iterable dengan panjang yang sama dialirkan secara bersamaan.

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

Bekerja seperti Stream::zipWith() Metode tetapi melempar lengthException jika panjang tidak sama, yaitu, setidaknya satu iterator berakhir sebelum yang lain.

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

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

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

Zip terpanjang dengan

Kembalikan aliran yang terdiri dari beberapa koleksi iterable yang dialirkan secara bersamaan.

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

• Iterasi berlanjut sampai iterable terpanjang habis.
• Untuk panjang yang tidak merata, iterables yang kelelahan akan menghasilkan nol untuk iterasi yang tersisa.

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

Operasi Terminal Stream

Stream Ringkasan Terminal Operasi

Semua cocok

Mengembalikan true jika semua elemen cocok dengan fungsi predikat.

$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 

Semua unik

Mengembalikan true jika semua elemen unik.

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

Default ke perbandingan tipe yang ketat. Tetapkan ketat menjadi false untuk perbandingan paksaan tipe.

 use IterTools  Summary ;

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

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

Pertandingan apa pun

Mengembalikan true jika ada elemen yang cocok dengan fungsi predikat.

$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 

Adalah permutasi dengan

Mengembalikan true jika semua iterable adalah permutasi dengan aliran.

$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 

Adalah permutasi paksaan dengan

Mengembalikan true jika semua iterable adalah permutasi dengan aliran dengan tipe paksaan.

$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 

Tepatnya n

Mengembalikan true jika tepatnya N item benar menurut fungsi predikat.

• Predikat adalah opsional.
• Predikat default adalah nilai boolean dari setiap item.

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

 use IterTools  Summary ;

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

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

Kosong

Mengembalikan true jika aliran kosong tidak memiliki item.

$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 

Dipartisi

Mengembalikan true jika semua elemen koleksi yang diberikan yang memenuhi predikat muncul sebelum semua elemen yang tidak.

• Mengembalikan benar untuk koleksi kosong atau untuk koleksi dengan item tunggal.
• Predikat default jika tidak disediakan adalah nilai boolean dari setiap item data.

$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 

Diurutkan

Mengembalikan true jika sumber Iterable disortir dalam urutan naik; jika tidak salah.

$stream->isSorted(): bool

Item dari sumber yang dapat diulang harus sebanding.

Mengembalikan true jika sumber Iterable kosong atau hanya memiliki satu elemen.

 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 

Terbalik

Mengembalikan true jika sumber Iterable diurutkan dalam urutan turun terbalik; jika tidak salah.

$stream->isReversed(): bool

Item dari sumber yang dapat diulang harus sebanding.

Mengembalikan true jika sumber Iterable kosong atau hanya memiliki satu elemen.

 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 

Tidak ada yang cocok

Mengembalikan true jika tidak ada elemen yang cocok dengan fungsi predikat.

$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 

Sama dengan

Mengembalikan true jika sumber yang dapat diulang dan semua koleksi yang diberikan adalah sama.

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

Untuk daftar Iterable kosong, return true.

 use IterTools  Stream ;

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

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

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

Jumlah yang sama dengan

Mengembalikan true jika sumber yang dapat diulang dan semua koleksi yang diberikan memiliki panjang yang sama.

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

Untuk daftar Iterable kosong, return true.

 use IterTools  Stream ;

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

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

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

Operasi Terminal Pengurangan Aliran

Rata -rata

Mengurangi sumber Iterable ke rata -rata rata -rata itemnya.

$stream->toAverage(): mixed

Mengembalikan nol jika sumbernya yang dapat diulang kosong.

 use IterTools  Stream ;

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

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

Untuk menghitung

Mengurangi sumber Iterable dengan panjangnya.

$stream->toCount(): mixed

 use IterTools  Stream ;

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

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

Untuk pertama

Mengurangi sumber Iterable ke elemen pertamanya.

$stream->toFirst(): mixed

Melempar LengthException jika sumber Iterable kosong.

 use IterTools  Stream ;

$ input = [ 10 , 20 , 30 ];

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

Untuk yang pertama dan terakhir

Mengurangi sumber Iterable ke elemen pertama dan terakhir.

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

Melempar LengthException jika sumber Iterable kosong.

 use IterTools  Stream ;

$ input = [ 10 , 20 , 30 ];

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

Untuk bertahan

Mengurangi sumber Iterable ke elemen terakhirnya.

$stream->toLast(): mixed

Melempar LengthException jika sumber Iterable kosong.

 use IterTools  Stream ;

$ input = [ 10 , 20 , 30 ];

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

Untuk maks

Mengurangi sumber yang dapat diulang ke nilai maksimumnya.

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

• Param yang dapat dipanggil opsional $compareBy harus mengembalikan nilai yang sebanding.
• Jika $compareBy tidak disediakan maka item koleksi yang diberikan harus sebanding.
• Kembali nol jika koleksi kosong.

 use IterTools  Stream ;

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

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

Untuk min

Mengurangi sumber yang dapat diulang ke nilai min.

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

• Param yang dapat dipanggil opsional $compareBy harus mengembalikan nilai yang sebanding.
• Jika $compareBy tidak disediakan maka item koleksi yang diberikan harus sebanding.
• Kembali nol jika koleksi kosong.

 use IterTools  Stream ;

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

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

Untuk min max

Mengurangi aliran ke array batas atas dan bawahnya (maks dan min).

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

• Param yang dapat dipanggil opsional $compareBy harus mengembalikan nilai yang sebanding.
• Jika $compareBy tidak disediakan maka item koleksi yang diberikan harus sebanding.
• Mengembalikan [null, null] Jika koleksi yang diberikan kosong.

 use IterTools  Stream ;

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

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

Ke nth

Mengurangi aliran ke nilai pada posisi ke -n.

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

Mengembalikan nol jika sumbernya yang dapat diulang kosong.

 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 

Untuk produk

Mengurangi aliran ke produk itemnya.

$stream->toProduct(): mixed

Mengembalikan nol jika sumbernya yang dapat diulang kosong.

 use IterTools  Stream ;

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

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

Ke nilai acak

Mengurangi aliran ke nilai acak di dalamnya.

$stream->toRandomValue(): mixed

 use IterTools  Stream ;

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

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

Untuk jangkauan

Mengurangi aliran ke kisarannya (perbedaan antara max dan min).

$stream->toRange(): int|float

Mengembalikan 0 jika sumber Iterable kosong.

 use IterTools  Stream ;

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

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

Untuk string

Dikurangi menjadi string yang bergabung dengan semua elemen.

• Pemisah opsional untuk menyisipkan antar item.
• Awalan opsional untuk diatur ke string.
• Sufiks opsional untuk ditambahkan ke string.

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

Lebih dari itu

Mengurangi sumber yang dapat diulang dengan jumlah itemnya.

$stream->toSum(): mixed

 use IterTools  Stream ;

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

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

Untuk menghargai

Mengurangi sumbernya yang dapat berulang seperti fungsi array_reduce ().

Tetapi tidak seperti array_reduce() , ia bekerja dengan semua jenis iterable .

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

 use IterTools  Stream ;

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

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

Operasi Terminal Transformasi

Untuk array

Mengembalikan serangkaian elemen aliran.

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

Ke array asosiatif

Mengembalikan peta nilai kunci elemen aliran.

$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

Mengembalikan beberapa aliran independen (digandakan).

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

Operasi Terminal Efek Samping

Hubungi masing -masing

Lakukan tindakan melalui yang dapat dipanggil pada setiap item di aliran.

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

Mencetak

Mencetak setiap item dalam aliran.

• Item harus dapat dicetak.

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

Baris cetak

Mencetak setiap item dalam aliran di jalurnya sendiri.

• Item harus dapat dicetak.

$stream->println(): void

 use IterTools  Stream ;

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

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

Ke file CSV

Tulis konten aliran ke file CSV.

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

 use IterTools  Stream ;

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

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

Untuk mengajukan

Tulis konten aliran ke file.

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

Mengintip

Mengintip setiap elemen antara operasi aliran lain untuk melakukan beberapa tindakan tanpa memodifikasi aliran.

$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

Mengintip seluruh aliran antara operasi aliran lain untuk melakukan beberapa tindakan tanpa memodifikasi aliran.

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

Cetak mengintip

Mengintip setiap elemen antara operasi aliran lainnya untuk mencetak setiap item tanpa memodifikasi aliran.

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

 use IterTools  Stream ;

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

Peek Printtr

Mengintip setiap elemen antara operasi aliran lain untuk print_r setiap item tanpa memodifikasi aliran.

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

 use IterTools  Stream ;

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

Cetak r

print_r setiap item dalam aliran.

$stream->printR(): void

 use IterTools  Stream ;

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

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

Var dump

var_dump setiap item dalam aliran.

$stream->varDump(): void

 use IterTools  Stream ;

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

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

Komposisi

ITerTools dapat digabungkan untuk membuat komposisi iterable baru.

String zip

 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 

String rantai

 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 

Tipe ketat dan paksaan

Ketika ada opsi, default akan melakukan perbandingan tipe yang ketat:

• Scalars: membandingkan dengan tegas berdasarkan jenis
• Objek: Selalu memperlakukan contoh yang berbeda tidak sama satu sama lain
• Array: membandingkan serial

Saat tipe paksaan (tipe non-ketat) tersedia dan diaktifkan melalui bendera opsional:

• Scalars: dibandingkan dengan nilai melalui jenis juggling
• Objek: Membandingkan serial
• Array: membandingkan serial

Standar

IterTools PHP sesuai dengan standar berikut:

• PSR-1-Standar Pengodean Dasar (http://www.php-fig.org/psr/psr-1/)
• PSR-4-Autoloader (http://www.php-fig.org/psr/psr-4/)
• PSR-12-Panduan Gaya Pengodean Diperpanjang (http://www.php-fig.org/psr/psr-12/)

Lisensi

ITERTOOLS PHP dilisensikan di bawah lisensi MIT.

Perpustakaan serupa dalam bahasa lain

Fungsionalitas iTertools tidak terbatas pada PHP dan Python. Other languages have similar libraries. Familiar functionality is available when working in other languages.

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