ホーム>PHPソースコード>その他のカテゴリー
ダウンロード

itertoolslogoロゴ

itertools-ループを駆動するためのphpイテレーションツール

Pythonに触発されました - PHPのために設計されています。

特徴

Itertoolsは、2種類のツールを提供することにより、あなたに反復スーパースターになります。

  • ループ反復ツール
  • ストリーム反復ツール

ループイテレーションツールの例

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

ストリームイテレーションツールの例

 $ 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

すべての関数は、 iterableコレクションで機能します：

  • array （タイプ）
  • Generator （タイプ）
  • Iterator （インターフェイス）
  • Traversable （インターフェイス）

他の言語で翻訳されたreadmeドキュメント：

  • 陶芸

クイックリファレンス

ループ反復ツール

多反復

イテレーター説明コードスニペット
chain複数の反復剤を一緒にチェーンしますMulti::chain($list1, $list2)
zip最短のイテレーターが完了するまで、複数のコレクションを同時に反復しますMulti::zip($list1, $list2)
zipEqual同時に等しい長さの複数のコレクションを反復し、長さが等しくない場合はエラーMulti::zipEqual($list1, $list2)
zipFilled長さが等しくない場合、フィラー値を使用して複数のコレクションを反復しますMulti::zipFilled($default, $list1, $list2)
zipLongest最長のイテレーターが完了するまで、複数のコレクションを同時に反復しますMulti::zipLongest($list1, $list2)

単一の反復

イテレーター説明コードスニペット
chunkwiseチャンクによって反復しますSingle::chunkwise($data, $chunkSize)
chunkwiseOverlap重複したチャンクによって反復しますSingle::chunkwiseOverlap($data, $chunkSize, $overlapSize)
compress選択されていない要素を除外しますSingle::compress($data, $selectors)
compressAssociative選択されていないキーで要素を除外しますSingle::compressAssociative($data, $selectorKeys)
dropWhile述語が真実である間に要素をドロップしますSingle::dropWhile($data, $predicate)
filter述語が真である要素をフィルターしますSingle::filterTrue($data, $predicate)
filterTrue真実の要素をフィルタリングしますSingle::filterTrue($data)
filterFalse Falsy ElementsのフィルターSingle::filterFalse($data)
filterKeys述語が真であるキーをフィルターしますSingle::filterKeys($data, $predicate)
flatMapアイテムにマップ機能をマップし、結果の結果をフラットしますSingle::flaMap($data, $mapper)
flattenフラットン多次元反復可能Single::flatten($data, [$dimensions])
groupBy共通要素によるグループデータSingle::groupBy($data, $groupKeyFunction, [$itemKeyFunc])
limit制限まで反復しますSingle::limit($data, $limit)
map各アイテムにマップ機能Single::map($data, $function)
pairwise連続した重複ペアを反復しますSingle::pairwise($data)
reindexキー価値の繰り返しのリネックスキーSingle::reindex($data, $reindexer)
repeat何度もアイテムを繰り返しますSingle::repeat($item, $repetitions)
reverse逆順序で要素を反復しますSingle::reverse($data)
skip要素をスキップした後に反復しますSingle::skip($data, $count, [$offset])
slice反復可能なスライスを抽出しますSingle::slice($data, [$start], [$count], [$step])
string文字列の文字を反復しますSingle::string($string)
takeWhile予測が真である間に要素を反復しますSingle::takeWhile($data, $predicate)

無限の反復

イテレーター説明コードスニペット
count永遠に連続してカウントしますInfinite::count($start, $step)
cycleコレクションをサイクリングしますInfinite::cycle($collection)
repeatアイテムを永遠に繰り返しますInfinite::repeat($item)

ランダムイテレーション

イテレーター説明コードスニペット
choiceリストからのランダム選択Random::choice($list, $repetitions)
coinFlipランダムコインフリップ（0または1） Random::coinFlip($repetitions)
number乱数Random::number($min, $max, $repetitions)
percentage 0〜1のランダムな割合Random::percentage($repetitions)
rockPaperScissorsランダムなロックペーパーシザーの手Random::rockPaperScissors($repetitions)

数学の反復

イテレーター説明コードスニペット
frequenciesデータの頻度分布Math::frequencies($data, [$strict])
relativeFrequenciesデータの相対的な頻度分布Math::relativeFrequencies($data, [$strict])
runningAverage平均蓄積の実行Math::runningAverage($numbers, $initialValue)
runningDifferenceランニングの差の蓄積Math::runningDifference($numbers, $initialValue)
runningMax最大蓄積を実行しますMath::runningMax($numbers, $initialValue)
runningMin最小蓄積の実行Math::runningMin($numbers, $initialValue)
runningProductランニング製品の蓄積Math::runningProduct($numbers, $initialValue)
runningTotal総蓄積を実行しますMath::runningTotal($numbers, $initialValue)

セットとマルチセットの反復

イテレーター説明コードスニペット
distinct異なるアイテムのみを反復しますSet::distinct($data)
distinctByカスタムコンパレータを使用して異なるアイテムのみを反復しますSet::distinct($data, $compareBy)
intersection反復可能性の交差Set::intersection(...$iterables)
intersectionCoerciveタイプ強制との交差Set::intersectionCoercive(...$iterables)
partialIntersection反復可能性の部分的な交差点Set::partialIntersection($minCount, ...$iterables)
partialIntersectionCoerciveタイプ強制との部分的な交差Set::partialIntersectionCoercive($minCount, ...$iterables)
symmetricDifference反復可能性の対称差Set::symmetricDifference(...$iterables)
symmetricDifferenceCoerciveタイプ強制との対称的な違いSet::symmetricDifferenceCoercive(...$iterables)
union繰り返しの連合Set::union(...$iterables)
unionCoerciveタイプ強制との結合Set::unionCoercive(...$iterables)

イテレーションをソートします

イテレーター説明コードスニペット
asortキーを維持するソートコレクションを反復しますSort::asort($data, [$comparator])
sortソートされたコレクションを反復しますSort::sort($data, [$comparator])

ファイルの反復

イテレーター説明コードスニペット
readCsv交差CSVファイルラインFile::readCsv($fileHandle)
readLines行ごとにファイルを反復しますFile::readLines($fileHandle)

イテレーションを変換します

イテレーター説明コードスニペット
tee重複した反復器を反復しますTransform::tee($data, $count)
toArrayアレイに反復可能になりますTransform::toArray($data)
toAssociativeArray連想配列に繰り返しますTransform::toAssociativeArray($data, [$keyFunc], [$valueFunc])
toIteratorイテレーターにiterableを変換しますTransform::toIterator($data)

まとめ

まとめ説明コードスニペット
allMatchすべてのアイテムが述語に応じて真である場合はtrue Summary::allMatch($data, $predicate)
allUniqueすべてのアイテムが一意である場合はtrue Summary::allUnique($data, [$strict])
anyMatch PRESTICEに従って、項目が真である場合はTRUE Summary::anyMatch($data, $predicate)
arePermutations iterablesが互いの順列である場合はtrue Summary::arePermutations(...$iterables)
arePermutationsCoercive iterablesがタイプの強制で互いの順列である場合真実Summary::arePermutationsCoercive(...$iterables)
exactlyN正確にnアイテムが前のものに応じてtrueが真である場合はtrue Summary::exactlyN($data, $n, $predicate)
isEmpty iterableにアイテムがない場合はtrue Summary::isEmpty($data)
isPartitioned他の人の前に述語に応じて真のアイテムとパーティション化されている場合はtrue Summary::isPartitioned($data, $predicate)
isSorted iterableソートがある場合はtrue Summary::isSorted($data)
isReversed iterable reverseソートがある場合はtrue Summary::isReversed($data)
noneMatch PRESTICEによると、項目が真実でない場合はTRUE Summary::noneMatch($data, $predicate)
same iterablesが同じ場合はtrue Summary::same(...$iterables)
sameCount true iterablesの長さが同じ場合Summary::sameCount(...$iterables)

減らす

還元剤説明コードスニペット
toAverage要素の平均平均Reduce::toAverage($numbers)
toCount反復可能な長さまで減らしますReduce::toCount($data)
toFirst最初の値に減らしますReduce::toFirst($data)
toFirstAndLast最初と最後の値に減らしますReduce::toFirstAndLast($data)
toLast最後の値に減らしますReduce::toLast()
toMaxその最大の要素に減らしますReduce::toMax($numbers, [$compareBy])
toMin最小の要素に減らしますReduce::toMin($numbers, [$compareBy])
toMinMax上限と下限の配列に縮小しますReduce::toMinMax($numbers, [$compareBy])
toNth n番目の位置で値を減らしますReduce::toNth($data, $position)
toProductその要素の積に還元しますReduce::toProduct($numbers)
toRandomValue反復可能からランダムな値に減らしますReduce::toRandomValue($data)
toRange最大値と最小値の差を減らしますReduce::toRange($numbers)
toString結合された文字列に減らしますReduce::toString($data, [$separator], [$prefix], [$suffix])
toSumその要素の合計を減らしますReduce::toSum($numbers)
toValue呼び出し可能な還元剤を使用して値に減らしますReduce::toValue($data, $reducer, $initialValue)

ストリーム反復ツール

ストリームソース

ソース説明コードスニペット
of反復可能なストリームを作成しますStream::of($iterable)
ofCoinFlipsランダムコインフリップのストリームを作成しますStream::ofCoinFlips($repetitions)
ofCsvFile CSVファイルからストリームを作成しますStream::ofCsvFile($fileHandle)
ofEmpty空のストリームを作成しますStream::ofEmpty()
ofFileLinesファイルの行からストリームを作成しますStream::ofFileLines($fileHandle)
ofRandomChoiceランダム選択のストリームを作成しますStream::ofRandomChoice($items, $repetitions)
ofRandomNumbers乱数のストリーム（整数）を作成するStream::ofRandomNumbers($min, $max, $repetitions)
ofRandomPercentage 0から1の間のランダムな割合のストリームを作成しますStream::ofRandomPercentage($repetitions)
ofRangeさまざまな数字のストリームを作成しますStream::ofRange($start, $end, $step)
ofRockPaperScissorsロックペーパーシッサーの手の流れを作成しますStream::ofRockPaperScissors($repetitions)

ストリーム操作

手術説明コードスニペット
asortキーを維持する反復可能なソースをソートします$stream->asort([$comparator])
chainWith一回の反復に繰り返し与えられたチェーン反復ソース$stream->chainWith(...$iterables)
compress選択されていないデータをフィルタリングしてソースを圧縮します$stream->compress($selectors)
compressAssociative選択されていないキーを除外してソースを圧縮します$stream->compressAssociative($selectorKeys)
chunkwiseチャンクによって反復します$stream->chunkwise($chunkSize)
chunkwiseOverlap重複したチャンクによって反復します$stream->chunkwiseOverlap($chunkSize, $overlap)
distinct要素の除外：一意のアイテムのみを反復します$stream->distinct([$strict])
distinctByフィルターアウト要素：カスタムコンパレータを使用して一意のアイテムのみを反復$stream->distinct($compareBy)
dropWhile予測機能が真である間に、反復可能なソースから要素をドロップする$stream->dropWhile($predicate)
filter述語関数が真である要素のみをフィルタリングします$stream->filterTrue($predicate)
filterTrue真実の要素のみをフィルタリングします$stream->filterTrue()
filterFalse Falsy要素のみをフィルターします$stream->filterFalse()
filterKeys述語関数が真であるキーをフィルターします$stream->filterKeys($predicate)
flatMap要素にマップ機能をマップし、結果の結果をフラットします$stream->flatMap($function)
flatten多次元ストリームを平らにします$stream->flatten($dimensions)
frequencies頻度分布$stream->frequencies([$strict])
groupBy共通のデータ要素によるグループ反復ソース$stream->groupBy($groupKeyFunction, [$itemKeyFunc])
infiniteCycle反復可能なソースの要素を順番に順番に並べます$stream->infiniteCycle()
intersectionWith交差可能なソースと与えられた反復可能性$stream->intersectionWith(...$iterables)
intersection CoerciveWith交差可能なソースと、タイプの強制を伴う反復性が与えられます$stream->intersectionCoerciveWith(...$iterables)
limitストリームの反復を制限します$stream->limit($limit)
map要素へのマップ機能$stream->map($function)
pairwise反復可能なソースから要素のペアを返します$stream->pairwise()
partialIntersectionWith部分的に交差する反復ソースと繰り返しが与えられます$stream->partialIntersectionWith( $minIntersectionCount, ...$iterables)
partialIntersection CoerciveWith部分的に交差する反復ソースと、タイプの強制を伴う反復性が与えられます$stream->partialIntersectionCoerciveWith( $minIntersectionCount, ...$iterables)
reindexキー価値ストリームのリネックスキー$stream->reindex($reindexer)
relativeFrequencies相対頻度分布$stream->relativeFrequencies([$strict])
reverseストリームの逆要素$stream->reverse()
runningAverage反復可能なソースを介して実行平均（平均）を蓄積します$stream->runningAverage($initialValue)
runningDifference反復可能なソース上のランニングの違いを蓄積します$stream->runningDifference($initialValue)
runningMax繰り返し可能なソース上に実行されている最大値を蓄積します$stream->runningMax($initialValue)
runningMin反復可能なソースにランニング分を蓄積します$stream->runningMin($initialValue)
runningProduct繰り返し可能なソースに実行されている製品を蓄積します$stream->runningProduct($initialValue)
runningTotal繰り返し可能なソースを超えて実行される合計を蓄積します$stream->runningTotal($initialValue)
skipストリームのいくつかの要素をスキップします$stream->skip($count, [$offset])
sliceストリームのスライスを抽出します$stream->slice([$start], [$count], [$step])
sortストリームをソートします$stream->sort([$comparator])
symmetricDifferenceWith反復可能なソースの対称差と繰り返しの場合$this->symmetricDifferenceWith(...$iterables)
symmetricDifference CoerciveWith反復可能なソースの対称的な違いと、タイプの強制を伴う反復可能性$this->symmetricDifferenceCoerciveWith( ...$iterables)
takeWhile述語が真である限り、反復可能なソースから要素を返す$stream->takeWhile($predicate)
unionWith繰り返しのストリームの結合$stream->unionWith(...$iterables)
unionCoerciveWithタイプの強制との反復可能性との流れの結合$stream->unionCoerciveWith(...$iterables)
zipWith別の反復可能なコレクションを同時に繰り返し可能なソースを繰り返します$stream->zipWith(...$iterables)
zipEqualWith同時に等しい長さの別の反復可能なコレクションを繰り返し反復可能なソース$stream->zipEqualWith(...$iterables)
zipFilledWithデフォルトフィラーを使用した別の反復可能なコレクションを備えた反復可能なソース$stream->zipFilledWith($default, ...$iterables)
zipLongestWith別の反復可能なコレクションを同時に繰り返し可能なソースを繰り返します$stream->zipLongestWith(...$iterables)

ストリーム端子操作

概要端末操作
ターミナル操作説明コードスニペット
allMatchストリームのすべてのアイテムが述語を一致させる場合、trueを返します$stream->allMatch($predicate)
allUniqueストリーム内のすべてのアイテムが一意である場合、trueを返します$stream->allUnique([$strict]])
anyMatchストリームのアイテムが述語と一致する場合、trueを返します$stream->anyMatch($predicate)
arePermutationsWithストリームのすべてのiterablesの順列がある場合、trueを返します$stream->arePermutationsWith(...$iterables)
arePermutationsCoerciveWithタイプの強制を伴うストリームのすべての繰り返しの順列が真実である場合にtrueを返します$stream->arePermutationsCoerciveWith(...$iterables)
exactlyN PRESTICESに従って正確にnアイテムが真である場合にtrueを返します$stream->exactlyN($n, $predicate)
isEmptyストリームにアイテムがない場合、trueを返します$stream::isEmpty()
isPartitioned他の人の前に述語に応じて真のアイテムと分割された場合にtrueを返します$stream::isPartitioned($predicate)
isSortedストリームが昇順でソートされている場合、trueを返します$stream->isSorted()
isReversedストリームが逆の降順でソートされている場合、trueを返します$stream->isReversed()
noneMatchストリームのアイテムがいかなるものもない場合にtrueを返しますPredicate $stream->noneMatch($predicate)
sameWithストリームとすべての指定されたコレクションが同じ場合真実を返します$stream->sameWith(...$iterables)
sameCountWithストリームとすべての指定されたコレクションが同じ長さの場合、trueを返します$stream->sameCountWith(...$iterables)
削減端子操作
ターミナル操作説明コードスニペット
toAverageストリームをアイテムの平均平均に削減します$stream->toAverage()
toCountストリームをその長さに減らします$stream->toCount()
toFirstストリームを最初の値に減らします$stream->toFirst()
toFirstAndLastストリームを最初の値と最後の値に減らします$stream->toFirstAndLast()
toLastストリームを最後の値に減らします$stream->toLast()
toMaxストリームを最大値に減らします$stream->toMax([$compareBy])
toMinストリームを最小値に減らします$stream->toMin([$compareBy])
toMinMaxストリームを上限と下限の配列に減らします$stream->toMinMax([$compareBy])
toNth nth位置でストリームを値に減らします$stream->toNth($position)
toProductストリームをアイテムの製品に削減します$stream->toProduct()
toString Streamを結合した文字列に減らします$stream->toString([$separator], [$prefix], [$suffix])
toSumストリームをアイテムの合計に減らします$stream->toSum()
toRandomValueストリームを削減し、その中のランダム値になります$stream->toRandomValue()
toRangeストリームを最大値とMIN値の差に減らします$stream->toRange()
toValue Array_reduce（）関数のようなストリームを削減します$stream->toValue($reducer, $initialValue)
変換端子操作
ターミナル操作説明コードスニペット
toArrayストリーム要素の配列を返します$stream->toArray()
toAssociativeArrayストリーム要素のキー価値マップを返します$stream->toAssociativeArray($keyFunc, $valueFunc)
tee複数の同一のストリームの配列を返します$stream->tee($count)
副作用端子操作
ターミナル操作説明コードスニペット
callForEach各アイテムの関数を介してアクションを実行します$stream->callForEach($function)
printストリームに各アイテムprint $stream->print([$separator], [$prefix], [$suffix])
printLn各アイテムを新しい行にprint $stream->printLn()
toCsvFileストリームの内容をCSVファイルに書き込む$stream->toCsvFile($fileHandle, [$headers])
toFileストリームの内容をファイルに書き込みます$stream->toFile($fileHandle)

デバッグ操作をストリーミングします

デバッグ操作説明コードスニペット
peekストリーム操作間の各要素を覗きます$stream->peek($peekFunc)
peekStream操作間のストリーム全体を覗きます$stream->peekStream($peekFunc)
peekPrint操作間で印刷して各要素を覗きます$stream->peekPrint()
peekPrintR操作間でprint-rを実行することにより、各要素を覗きます$stream->peekPrintR()
printR各アイテムprint_r $stream->printR()
varDump var_dump各アイテム$stream->varDump()

設定

プロジェクトのcomposer.jsonファイルにライブラリを追加します。 

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

作曲家を使用してライブラリをインストールします。 

$ php composer.phar install

作曲家は、ベンダーフォルダー内にitertoolsをインストールします。次に、.phpファイルに以下を追加して、自動装置でライブラリを使用できます。 

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

または、コマンドラインで作曲家を使用して、itertoolsを要求およびインストールします。 

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

最小要件

  • PHP 7.4

使用法

すべての関数は、 iterableコレクションで機能します：

  • array （タイプ）
  • Generator （タイプ）
  • Iterator （インターフェイス）
  • Traversable （インターフェイス）

多反復

鎖

複数の反復性を単一の連続シーケンスに連れて行きます。

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'

ジップ

複数の反復コレクションを同時に反復します。

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は、複数の反復可能な入力で動作しますが、2つだけに制限されていません。 

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

注：不均一な長さの場合、最短の反復が使い果たされると反復が停止します。

Zipequal

同時に等しい長さの複数の反復コレクションを反復します。

長さが等しくない場合はLengthExceptionをスローします。つまり、少なくとも1つのイテレーターが他の繰り返しの前に終了します。

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

ジップフィルド

長さが等しくない場合は、デフォルトのフィラー値を使用して、複数の反復コレクションを同時に反復します。

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

複数の反復コレクションを同時に反復します。

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

不均一な長さの場合、排出された反復剤は、残りの反復に対してnull生成します。 

 use IterTools  Multi ;

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

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

単一の反復

チャンクワイズ

特定のサイズのチャンクで要素を返します。

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

チャンクサイズは少なくとも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]'
// ]

チャンクワイズオーバーラップ

重複した要素の塊を返します。

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

  • チャンクサイズは少なくとも1でなければなりません。
  • オーバーラップサイズは、チャンクサイズよりも少ない必要があります。 
 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]
}

圧縮

選択されていないデータをフィルタリングすることにより、反復可能を圧縮します。

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'

コンプレスの連想

選択されていないキーをフィルタリングすることにより、反復可能を圧縮します。

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

  • 標準のPHPアレイ/イテレーターキーのみ（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

whileを落とします

述語関数が真である間に、反復可能な要素をドロップします。

述語関数がfalseを一度返すと、残りの要素はすべて返されます。

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

フィルター

述語関数が真である場合に、反復可能な回復要素のみから要素を除外します。

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

Trueをフィルタリングします

真実である反復可能な返品要素からの要素を除外します。

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

Falseをフィルタリングします

述語関数がfalseである繰り返し可能な要素のみから要素を除外します。

述語が提供されていない場合、データのブール値が使用されます。

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

フィルターキー

述語関数が真であるキーを持つ反復可能な返品要素からの要素を除外します。

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

フラットマップ

関数をマップして、反復可能な要素のみをマップし、結果を平らにします。

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

平らに

多次元の反復可能をフラット化します。

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]

グループ

共通のデータ要素によるグループデータ。

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

  • $groupKeyFunctionは、グループ要素のキーを決定します。
  • オプションの$itemKeyFunction 、各グループメンバー内のカスタムインデックスを許可します。 
 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'],
*/

制限

制限まで反復します。

制限に達した場合、より多くのデータが利用可能であっても停止します。

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)

地図

関数を各要素にマップします。

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

ペアワイズ

連続した重複ペアを返します。

与えられたコレクションには2つ未満の要素が含まれている場合、空の発電機を返します。

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

繰り返す

アイテムを繰り返します。

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

インデクサー関数を使用してキー値の反復可能なリネックスキー。

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

逆行する

反復可能な要素を逆にします。

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

スキップ

オプションのオフセットオフセットの後、反復可能なn要素をスキップします。

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'

スライス

反復可能なスライスを抽出します。

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]

弦

文字列の個々の文字を反復します。

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

whereをしてください

述語が真である限り、反復可能な要素から要素を返します。

他の要素が最終的にtrue（filtertrueとは異なる）が最終的に戻ってくる場合でも、述語がfalseを返すとすぐに反復を停止します。

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

無限の反復

カウント

永遠に連続してカウントします。

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

サイクル

コレクションの要素を順番に永久に循環させます。

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

繰り返し（無限）

アイテムを永遠に繰り返します。

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

ランダムイテレーション

選択

一連の値からランダム選択を生成します。

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

ランダムコインフリップ（0または1）を生成します。

Random::coinFlip(int $repetitions) 

 use IterTools  Random ;

$ repetitions = 10 ;

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

番号

乱数（整数）を生成します。

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]

パーセンテージ

0〜1の間のランダムな割合を生成します。

Random::percentage(int $repetitions) 

 use IterTools  Random ;

$ repetitions = 10 ;

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

RockPaperscissors

ランダムなロックペーパーシッサーの手を生成します。

Random::rockPaperScissors(int $repetitions) 

 use IterTools  Random ;

$ repetitions = 10 ;

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

数学の反復

周波数

データの頻度分布を返します。

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

デフォルトは厳密なタイプの比較になります。タイプ強制比較に対して厳格にfalseに設定します。 

 use IterTools  Math ;

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

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

相対頻度

データの相対頻度分布を返します。

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

デフォルトは厳密なタイプの比較になります。タイプ強制比較に対して厳格にfalseに設定します。 

 use IterTools  Math ;

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

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

実行平均

数字のリストに及ぶ実行平均を蓄積します。

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

ランニングの違い

数字のリストに及ぼす違いを蓄積します。

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

オプションの初期値を提供して、ランニングの違いを導きます。 

 use IterTools  Math ;

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

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

最大ランニング

数字のリストに走る最大値を蓄積します。

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

ランニング分

数字のリストに並んで実行中の最小値を蓄積します。

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

ランニング製品

実行中の製品を数字のリストに蓄積します。

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

実行中の製品をリードするオプションの初期値を提供します。 

 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

合計の実行

数字のリストに合計を実行します。

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

オプションの初期値を提供して、実行中の合計をリードします。 

 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::distinct(iterable $data, bool $strict = true)

デフォルトは厳密なタイプの比較になります。タイプ強制比較に対して厳格にfalseに設定します。 

 use IterTools  Set ;

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

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

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

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

明確に

カスタムコンパレータ関数に従って、異なる要素を返す反復可能のみの要素を除外します。

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.

交差点

反復可能な交差点を反復します。

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

入力Iterablesが複製アイテムを生成する場合、マルチセット交差点ルールが適用されます。 

 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

交差点強制

タイプ強制を使用して、反復可能性の交差点を繰り返します。

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

入力Iterablesが複製アイテムを生成する場合、マルチセット交差点ルールが適用されます。 

 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

部分交差点

反復可能性のM-Partial交差点を反復します。

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

  • 入力Iterablesが複製アイテムを生成する場合、マルチセット交差点ルールが適用されます。 
 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

部分交差点強制

タイプ強制を使用して、反復可能性のM部分的な交差を反復します。

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

  • 入力Iterablesが複製アイテムを生成する場合、マルチセット交差点ルールが適用されます。 
 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

対称的な違い

反復可能性の対称的な違いを繰り返します。

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

入力Iterablesが複製アイテムを生成する場合、マルチセットの違いルールが適用されます。 

 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

対称差は強制的です

タイプの強制と反復可能性の対称差を繰り返します。

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

入力Iterablesが複製アイテムを生成する場合、マルチセットの違いルールが適用されます。 

 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

連合

反復液の結合を反復します。

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

入力Iterablesが複製アイテムを生成する場合、マルチセットユニオンルールが適用されます。 

 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

組合の強制

タイプの強制と反復液の結合を反復します。

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

入力Iterablesが複製アイテムを生成する場合、マルチセットユニオンルールが適用されます。 

 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

イテレーションをソートします

asort

連想キーインデックス関係を維持しながらソートされたコレクションを繰り返します。

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

オプションのコンパレータ機能が提供されていない場合、デフォルトのソートを使用します。 

 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

選別

ソートされたコレクションを反復します。

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

オプションのコンパレータ機能が提供されていない場合、デフォルトのソートを使用します。 

 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

ファイル

CSVを読んでください

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

行を読む

ファイルの行を反復します。

File::readLines(resource $fileHandle) 

 use IterTools  File ;

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

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

変身

ティー

単一の繰り返しからいくつかの独立した（重複した）反復器を返します。

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

配列に

アレイに繰り返し可能な任意の任意のものを変換します。

Transform::toArray(iterable $data): array 

 use IterTools  Transform ;

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

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

連想配列へ

連想配列に繰り返し可能な任意の任意のものを変換します。

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

イテレーターへ

イテレーターに反復可能なものを変換します。

Transform::toArray(iterable $data): array 

 use IterTools  Transform ;

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

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

まとめ

すべての一致

すべての要素が述語関数と一致する場合、trueを返します。

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

すべてユニーク

すべての要素が一意である場合、trueを返します。

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

デフォルトは厳密なタイプの比較になります。タイプ強制比較に対して厳格にfalseに設定します。 

 use IterTools  Summary ;

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

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

どんな試合も

いずれかの要素が述語関数と一致する場合、trueを返します。

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

順列です

すべての反復可能性が互いの順列である場合、真実を返します。

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

順列は強制的です

すべてのiterablesがタイプの強制を伴う互いの順列である場合、trueを返します。

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

正確にn

述語関数に従って正確にnアイテムが真である場合、trueを返します。

  • 述語はオプションです。
  • デフォルトの述語は、各アイテムのブール値です。

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

空です

繰り返し可能なアイテムがない場合はtrueを返します。

Summary::isEmpty(iterable $data): bool 

 use IterTools  Summary ;

$ data = []

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

分割されています

述語を満たす特定のコレクションのすべての要素が、そうでないすべての要素の前に表示される場合、trueを返します。

  • 空のコレクションまたは単一のアイテムを使用したコレクションにはtrueを返します。
  • 提供されていない場合のデフォルトの述語は、各データ項目のブール値です。

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

ソートされています

要素がソートされている場合、trueを返します。

  • 要素は同等でなければなりません。
  • 空の場合、または1つの要素のみがある場合にtrueを返します。

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

逆になります

要素が逆ソートされている場合はtrueを返し、それ以外の場合はfalse。

  • 要素は同等でなければなりません。
  • 空の場合、または1つの要素のみがある場合にtrueを返します。

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

一致しない

要素がない場合は、予定関数と一致する場合はtrueを返します。

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

同じ

与えられたすべてのコレクションが同じである場合、trueを返します。

単一の繰り返しまたは空のiterablesリストは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

同じカウント

与えられたすべてのコレクションの長さがすべて同じ場合、trueを返します。

単一の繰り返しまたは空のiterablesリストは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

減らす

平均する

平均平均に減少します。

コレクションが空の場合、nullを返します。

Reduce::toAverage(iterable $data): float 

 use IterTools  Reduce ;

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

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

数える

その長さを繰り返します。

Reduce::toCount(iterable $data): int 

 use IterTools  Reduce ;

$ someIterable = ImportantThing:: getCollectionAsIterable ();

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

最初に

最初の要素に反復可能になります。

Reduce::toFirst(iterable $data): mixed

コレクションが空の場合、 LengthExceptionをスローします。 

 use IterTools  Reduce ;

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

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

最初と最後まで

最初と最後の要素に反復可能になります。

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

コレクションが空の場合、 LengthExceptionをスローします。 

 use IterTools  Reduce ;

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

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

持続するために

最後の要素に反復可能になります。

Reduce::toLast(iterable $data): mixed

コレクションが空の場合、 LengthExceptionをスローします。 

 use IterTools  Reduce ;

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

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

マックスへ

最大値に減少します。

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

  • オプションの呼び出し可能なPARAM $compareBy 、同等の値を返す必要があります。
  • $compareByが提供されていない場合、指定されたコレクションの項目は同等でなければなりません。
  • コレクションが空の場合、nullを返します。 
 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
// ];

分から

最小値に減少します。

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

  • オプションの呼び出し可能なPARAM $compareBy 、同等の値を返す必要があります。
  • $compareByが提供されていない場合、指定されたコレクションの項目は同等でなければなりません。
  • コレクションが空の場合、nullを返します。 
 use IterTools  Reduce ;

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

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


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

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

最小マックスへ

上限と下限の配列（最大およびmin）に減少します。

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

  • オプションの呼び出し可能なPARAM $compareBy 、同等の値を返す必要があります。
  • $compareByが提供されていない場合、指定されたコレクションの項目は同等でなければなりません。
  • 与えられたコレクションが空である場合[null, null]を返します。 
 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
//     ],
// ]

nthに

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

製品に

その要素の積に縮小します。

コレクションが空の場合、nullを返します。

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

 use IterTools  Reduce ;

$ primeFactors = [ 5 , 2 , 2 ];

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

ランダム値に

指定されたコレクションは、その中のランダムな値に削減します。

Reduce::toRandomValue(iterable $data): mixed 

 use IterTools  Reduce ;

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

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

範囲に

指定されたコレクションをその範囲に減らします（最大と最小の差）。

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

iterableソースが空の場合は0返します。 

 use IterTools  Reduce ;

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

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

ひもに

すべての要素を結ぶ文字列に減らします。

  • アイテム間に挿入するオプションのセパレーター。
  • 文字列にプリデントするオプションのプレフィックス。
  • 文字列に追加するオプションのサフィックス。

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!

要約する

その要素の合計に減少します。

Reduce::toSum(iterable $data): number 

 use IterTools  Reduce ;

$ parts = [ 10 , 20 , 30 ];

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

価値に

還元剤関数を使用して要素を単一の値に減らします。

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

ストリーム

ストリームは、操作のパイプラインを通じて配列と反復性を変換するための流fluentインターフェイスを提供します。

ストリームは次のとおりです。

  1. ストリームを作成する1つのストリームソースファクトリーメソッド。
  2. ストリームを新しいストリームに変換するゼロ以上のストリーム演算子。
  3. どちらの端子操作：
    • ストリームターミナル操作は、ストリームを値またはデータ構造に変換します。 
     $ 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
    • ストリームは、 foreachループを介して繰り返されます。 
     $ result = Stream:: of ([ 1 , 1 , 2 , 2 , 3 , 4 , 5 ])
   -> distinct ()                  // [1, 2, 3, 4, 5]
   -> map ( fn ( $ x ) => $ x ** 2 )       // [1, 4, 9, 16, 25]
   -> filter ( fn ( $ x ) => $ x < 10 ); // [1, 4, 9]

foreach ( $ result as $ item ) {
    // 1, 4, 9
}

ストリームソース

の

反復可能なストリームを作成します。

Stream::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

コインフリップの

nランダムコインフリップのストリームを作成します。

Stream::ofCoinFlips(int $repetitions): Stream 

 use IterTools  Stream ;

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

CSVファイルの

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

空の

何もないストリームを作成します。

Stream::ofEmpty(): Stream 

 use IterTools  Stream ;

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

ファイル行の

ファイルの行のストリームを作成します。

Stream::ofFileLines(resource $fileHandle): Stream 

 use IterTools  Stream ;

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

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

ランダムな選択の

値の配列からランダム選択のストリームを作成します。

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)

乱数の

乱数（整数）のストリームを作成します。

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)

ランダムな割合の

0から1の間のランダムな割合のストリームを作成します。

Stream::ofRandomPercentage(int $repetitions): Stream 

 use IterTools  Stream ;

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

範囲の

さまざまな数字のストリームを作成します。

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

ロック紙はさみの

ロックペーパーシッサーの手の流れを作成します。

Stream::ofRockPaperScissors(int $repetitions): Stream 

 use IterTools  Stream ;

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

ストリーム操作

asort

キーを維持し、ストリームを並べ替えます。

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

コンパレータが提供されていない場合、反復可能なソースの要素は同等でなければなりません。 

 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,

チェーン

追加のソースを連鎖させてストリームを1つの連続したストリームに戻します。

$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

圧縮

選択されていないデータを除外して、新しいストリームに圧縮します。

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

セレクターは、どのデータを示します。真の値はアイテムを選択します。 false値はデータをフィルターアウトします。 

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

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

コンプレスの連想

選択されていないキーを除外して、新しいストリームに圧縮します。

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

  • 標準のPHPアレイ/イテレーターキーのみ（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',

チャンクワイズ

ストリームからの要素の塊で構成されるストリームを返します。

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

チャンクサイズは少なくとも1でなければなりません。 

 use IterTools  Stream ;

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

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

チャンクワイズオーバーラップ

ストリームからの要素の重複するチャンクで構成されるストリームを返します。

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

  • チャンクサイズは少なくとも1でなければなりません。
  • オーバーラップサイズは、チャンクサイズよりも少ない必要があります。 
 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]

明確な

ストリームのろ過を返すストリームから異なる要素のみを返すストリームから除外します。

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

デフォルトは厳密なタイプの比較になります。タイプ強制比較に対して厳格にfalseに設定します。 

 use IterTools  Stream ;

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

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

明確に

カスタムコンパレータ関数に従って異なる要素のみを返すストリームから要素を除外するストリームを返します。

$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

whileを落とします

予定関数が真である間に、ストリームから要素をドロップします。

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

述語関数がfalseを一度返すと、残りの要素はすべて返されます。 

 use IterTools  Stream ;

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

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

フィルター

予定関数が真である場合、要素のみを保持するストリームから要素を除外します。

$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

Trueをフィルタリングします

真実である要素のみを維持するストリームから要素を除外します。

$stream->filterTrue(): Stream 

 use IterTools  Stream ;

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

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

Falseをフィルタリングします

falsyの要素のみを保持するストリームから要素を除外します。

$stream->filterFalse(): Stream 

 use IterTools  Stream ;

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

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

フィルターキー

キー上の述語関数がtrueの場合、要素のみを維持するストリームから要素を除外します。

$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

フラットマップ

関数をストリームの要素にマップし、結果を平らにします。

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

平らに

多次元ストリームを平らにします。

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

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

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

周波数

ストリーム要素の頻度分布。

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

グループ

一般的なデータ要素によるストリームグループを返します。

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

  • $groupKeyFunctionは、グループ要素のキーを決定します。
  • オプションの$itemKeyFunction 、各グループメンバー内のカスタムインデックスを許可します。 
 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]
}

無限のサイクル

ストリームの要素を順番に永久に循環するストリームを返します。

$stream->infiniteCycle(): Stream 

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

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

との交差点

入力反復剤とストリームと交差するストリームを返します。

$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

交差点が強制的です

タイプ強制を使用して、入力反復可能なストリームと交差するストリームを返します。

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

制限

制限までストリームを返します。

制限に達した場合、より多くのデータが利用可能であっても停止します。

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

地図

関数をストリームの各要素にマッピングした結果を含むストリームを返します。

$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

ペアワイズ

ストリームからの要素のペアで構成されるストリームを返します。

$stream->pairwise(): Stream

与えられたコレクションに2つ未満の要素が含まれている場合、空のストリームを返します。 

 use IterTools  Stream ;

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

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

部分的な交差点

入力反復剤とストリームと部分的に交差するストリームを返します。

$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

部分的な交差点が強制的です

タイプ強制を使用して、ストリームを入力反復可能性と部分的に交差するストリームを返します。

$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

キーベリュー要素の新しいストリームを返します。キーインデクサー関数によって再インネックスされます。

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

相対頻度

ストリーム要素の相対的な頻度分布。

$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

逆行する

ストリームの要素を逆にします。

$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

実行平均

ストリーム（平均）を蓄積するストリームを返します。

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

 use IterTools  Stream ;

$ input = [ 1 , 3 , 5 ];

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

ランニングの違い

ストリームを返して、ストリーム上にランニングの違いを蓄積します。

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

 use IterTools  Stream ;

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

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

最大ランニング

runningランニングマックスをストリームに蓄積するストリームを返します。

$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

ランニング分

ストリームを蓄積するストリームを返します。

$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

ランニング製品

実行中の製品をストリームに蓄積するストリームを返します。

$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

合計の実行

ストリームを蓄積するストリームを返します。

$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

スキップ

ストリームのいくつかの要素をスキップします。

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

スライス

ストリームのスライスを抽出します。

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

選別

ストリームをソートします。

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

コンパレータが提供されていない場合、反復可能なソースの要素は同等でなければなりません。 

 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

対称的な違い

ストリームと指定された反復剤の対称差のストリームを返します。

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

注：入力Iterablesが複製アイテムを生成する場合、マルチセット交差点ルールが適用されます。 

 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

対称的な違いは強制的です

タイプ強制を使用して、ストリームと与えられた反復可能性の対称差のストリームを返します。

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

注：入力Iterablesが複製アイテムを生成する場合、マルチセット交差点ルールが適用されます。 

 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

whereをしてください

述語が真である限り、ストリームから要素を保持します。

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

述語が提供されていない場合、データのブール値が使用されます。 

 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

との結合

ストリームの結合と入力反復剤で構成されるストリームを返します。

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

注：入力iterablesが重複アイテムを生成する場合、マルチセットユニオンルールが適用されます。 

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

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

連合が強制的である

タイプ強制を使用して、ストリームの結合と入力反復剤からなるストリームを返します。

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

注：入力iterablesが重複アイテムを生成する場合、マルチセットユニオンルールが適用されます。 

 use IterTools  Stream ;

$ input = [ 1 , 2 , 3 ];

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

zip with

同時にストリーミングされた複数の反復コレクションで構成されるストリームを返します。

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

不均一な長さの場合、最短の反復が使い果たされると反復が停止します。 

 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]

で満たされたジップ

複数の反復可能なコレクションで構成されるストリームを返し、デフォルトのフィラー値を使用して長さが等しくない場合。

$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, ?]
}

等しいジップ

同時にストリーミングされた等しい長さの複数の反復コレクションで構成されるストリームを返します。

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

Stream::zipWith()メソッドのように動作しますが、長さが等しくない場合は lengthexceptionをスローします。 

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

最長のジップ

同時にストリーミングされた複数の反復コレクションで構成されるストリームを返します。

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

  • 最長の反復が使い果たされるまで、反復は継続されます。
  • 不均一な長さの場合、排出された反復剤は、残りの反復に対してヌルを生成します。 
 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]
}

ストリーム端子操作

ストリーム概要端末操作

すべての一致

すべての要素が述語関数と一致する場合、trueを返します。

$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
すべてユニーク

すべての要素が一意である場合、trueを返します。

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

デフォルトは厳密なタイプの比較になります。タイプ強制比較に対して厳格にfalseに設定します。 

 use IterTools  Summary ;

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

$ boolean = Stream:: of ( $ items )
    -> allUnique ();
// true
どんな試合も

いずれかの要素が述語関数と一致する場合、trueを返します。

$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
の順列です

すべてのiterablesがストリームの順列である場合、trueを返します。

$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
順列は強制的です

すべてのiterablesがタイプの強制を備えたストリームの順列である場合、trueを返します。

$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
正確にn

述語関数に従って正確にnアイテムが真である場合、trueを返します。

  • 述語はオプションです。
  • デフォルトの述語は、各アイテムのブール値です。

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

 use IterTools  Summary ;

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

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

ストリームが空になっている場合、アイテムがない場合はtrueを返します。

$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
分割されています

述語を満たす特定のコレクションのすべての要素が、そうでないすべての要素の前に表示される場合、trueを返します。

  • 空のコレクションまたは単一のアイテムを使用したコレクションにはtrueを返します。
  • 提供されていない場合のデフォルトの述語は、各データ項目のブール値です。

$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
ソートされています

反復可能なソースが昇順でソートされている場合、trueを返します。それ以外の場合はfalse。

$stream->isSorted(): bool

反復可能なソースのアイテムは同等でなければなりません。

iterableソースが空であるか、要素が1つしかない場合、trueを返します。 

 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
逆になります

iterableソースが逆の降順でソートされている場合、trueを返します。それ以外の場合はfalse。

$stream->isReversed(): bool

反復可能なソースのアイテムは同等でなければなりません。

iterableソースが空であるか、要素が1つしかない場合、trueを返します。 

 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
一致しない

要素がない場合は、予定関数と一致する場合はtrueを返します。

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

iterableソースとすべての指定されたコレクションが同じ場合、trueを返します。

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

空のイテラブルリストの場合、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
同じカウント

iterableソースとすべての指定されたコレクションが同じ長さの場合、trueを返します。

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

空のイテラブルリストの場合、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

ストリーム削減端子操作

平均する

反復可能なソースをそのアイテムの平均平均に減らします。

$stream->toAverage(): mixed

iterableソースが空である場合、nullを返します。 

 use IterTools  Stream ;

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

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

反復可能なソースをその長さに減らします。

$stream->toCount(): mixed 

 use IterTools  Stream ;

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

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

反復可能なソースを最初の要素に減らします。

$stream->toFirst(): mixed

iterableソースが空である場合、 LengthExceptionをスローします。 

 use IterTools  Stream ;

$ input = [ 10 , 20 , 30 ];

$ result = Stream:: of ( $ input )
    -> toFirst ();
// 10
最初と最後まで

反復可能なソースを最初と最後の要素に減らします。

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

iterableソースが空である場合、 LengthExceptionをスローします。 

 use IterTools  Stream ;

$ input = [ 10 , 20 , 30 ];

$ result = Stream:: of ( $ input )
    -> toFirstAndLast ();
// [10, 30]
持続するために

反復可能なソースをその最後の要素に減らします。

$stream->toLast(): mixed

iterableソースが空である場合、 LengthExceptionをスローします。 

 use IterTools  Stream ;

$ input = [ 10 , 20 , 30 ];

$ result = Stream:: of ( $ input )
    -> toLast ();
// 30
マックスへ

反復可能なソースを最大値に削減します。

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

  • オプションの呼び出し可能なPARAM $compareBy 、同等の値を返す必要があります。
  • $compareByが提供されていない場合、指定されたコレクションの項目は同等でなければなりません。
  • コレクションが空の場合、nullを返します。 
 use IterTools  Stream ;

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

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

反復可能なソースを最小値に減らします。

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

  • オプションの呼び出し可能なPARAM $compareBy 、同等の値を返す必要があります。
  • $compareByが提供されていない場合、指定されたコレクションの項目は同等でなければなりません。
  • コレクションが空の場合、nullを返します。 
 use IterTools  Stream ;

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

$ result = Stream:: of ( $ iterable )
    -> toMin ();
// -3
最小マックスへ

ストリームを上限と下限の配列（最大およびmin）に減らします。

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

  • オプションの呼び出し可能なPARAM $compareBy 、同等の値を返す必要があります。
  • $compareByが提供されていない場合、指定されたコレクションの項目は同等でなければなりません。
  • 与えられたコレクションが空である場合[null, null]を返します。 
 use IterTools  Stream ;

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

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

NTH位置でのストリームを値に減らします。

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

iterableソースが空である場合、nullを返します。 

 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
製品に

ストリームをアイテムの製品に削減します。

$stream->toProduct(): mixed

iterableソースが空である場合、nullを返します。 

 use IterTools  Stream ;

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

$ result = Stream:: of ( $ iterable )
    -> toProduct ();
// 120
ランダム値に

ストリームは、その中のランダムな値に縮小します。

$stream->toRandomValue(): mixed 

 use IterTools  Stream ;

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

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

ストリームをその範囲に減らします（最大と最小の差）。

$stream->toRange(): int|float

iterableソースが空の場合は0返します。 

 use IterTools  Stream ;

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

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

すべての要素を結ぶ文字列に減らします。

  • アイテム間に挿入するオプションのセパレーター。
  • 文字列にプリデントするオプションのプレフィックス。
  • 文字列に追加するオプションのサフィックス。

$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!
要約する

反復可能なソースをそのアイテムの合計に減らします。

$stream->toSum(): mixed 

 use IterTools  Stream ;

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

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

array_reduce（）関数のような反復ソースを削減します。

ただし、 array_reduce()とは異なり、すべての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

変換端子操作

配列に

ストリーム要素の配列を返します。

$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]
連想配列へ

ストリーム要素のキー価値マップを返します。

$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, ... ]
ティー

いくつかの独立した（複製）ストリームを返します。

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

副作用端子操作

それぞれを呼び出します

ストリーム内の各アイテムで呼び出し可能なアクションを実行します。

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

ストリーム内の各アイテムを印刷します。

  • アイテムは印刷可能でなければなりません。

$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!
印刷ライン

独自のラインにストリーム内の各アイテムを印刷します。

  • アイテムは印刷可能でなければなりません。

$stream->println(): void 

 use IterTools  Stream ;

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

Stream:: of ( $ words )-> printLn ();
// IterTools
// PHP
// v1.0
CSVファイルへ

ストリームの内容を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
ファイルする

ストリームの内容をファイルに書き込みます。

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

ピークストリーム

他のストリーム操作間のストリーム全体を覗き込んで、ストリームを変更せずにアクションを実行します。

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

ピークプリント

他のストリーム操作間の各要素を覗き込んで、ストリームを変更せずに各アイテムを印刷します。

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

 use IterTools  Stream ;

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

Peek Printr

ストリームを変更せずに、他のストリーム操作の間の各要素を覗き込んで各アイテムprint_r 。

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

 use IterTools  Stream ;

Stream:: of ([ ' some ' , ' items ' ])
  -> map ( ' strtoupper ' )
  -> peekPrintR ()
  -> foreach ( $ someComplexCallable );
rを印刷します

ストリーム内の各アイテムprint_r 。

$stream->printR(): void 

 use IterTools  Stream ;

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

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

var_dumpストリーム内の各アイテム。

$stream->varDump(): void 

 use IterTools  Stream ;

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

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

構成

Itertoolsを組み合わせて、新しい反復構成を作成できます。

ジップ文字列

 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

チェーン文字列

 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

厳格で強制的なタイプ

オプションがある場合、デフォルトは厳密なタイプの比較を行います。

  • スカラー：タイプごとに厳密に比較します
  • オブジェクト：常に異なるインスタンスを互いに等しくないように扱います
  • 配列：シリアル化を比較します

タイプ強制（非厳密なタイプ）が利用可能で、オプションのフラグを介して有効になっている場合：

  • スカラー：タイプジャグリングを介して値で比較します
  • オブジェクト：シリアル化を比較します
  • 配列：シリアル化を比較します

基準

itertools PHPは次の基準に準拠しています。

  • PSR-1-基本コーディング標準（http://www.php-fig.org/psr/psr-1/）
  • PSR-4-Autoloader（http://www.php-fig.org/psr/psr-4/）
  • PSR-12-拡張コーディングスタイルガイド（http://www.php-fig.org/psr/psr-12/）

ライセンス

Itertools PHPは、MITライセンスに基づいてライセンスされています。

他の言語の同様のライブラリ

IterTools functionality is not limited to PHP and Python. Other languages have similar libraries. Familiar functionality is available when working in other languages.

  • IterTools TypeScript/Javascript
  • IterTools Python: The original!
拡大する
追加情報
関連アプリ
おすすめ
関連情報 すべて