idles
1.0.0
Une bibliothèque utilitaire fonctionnelle PHP, le port de JavaScript Lodash / FP et les bibliothèques RAMDA à PHP.
Toutes les fonctions sont sans effet secondaire et au curry automatiquement , les données sont immuables .
Le paramètre de collecte itérable est généralement fourni en dernier pour rendre le currissant pratique.
L'évaluation paresseuse / retardée est prise en charge dans les pipelines fonctionnels.
Allez sur https://idlephp.tech pour plus de détails, de documentation et d'exemples.
PHP 7.4 ou plus
composer require miroshnikov/idles
Note
Rabote est actuellement en cours de développement actif. La feuille de route est d'ajouter toutes les méthodes des bibliothèques Lodash et Ramda et certains outils fonctionnels.
concat(?iterable $ array, $ value ): iterable Concatine $array avec des itérables / valeurs supplémentaires
count(callable $ predicate , ?iterable $ collection ): int Compte le nombre d'articles dans $collection correspondant au $predicate
countBy(callable $ iteratee , ?iterable $ collection ): array Renvoie un tableau: [ $iteratee($value) => Nombre de fois que les $iteratee($value) ont été trouvés dans $collection ]
drop(int $ n , ?iterable $ collection ): iterable Saute les premiers $n emens et renvoie le reste de l'itérable
dropRight(int $ n , ?iterable $ collection ): iterable Sauter les derniers éléments $n
findIndex(callable $ predicate , ?iterable $ collection ): int Comme find mais renvoie l'index du premier élément prédicat renvoie la vérité pour -1 si cela n'est pas trouvé
findLastIndex(callable $ predicate , ?iterable $ collection ): int Comme find mais renvoie l'indice du dernier élément prédicat renvoie la vérité pour -1 si cela n'est pas trouvé
flatten(?iterable $ collection ): iterableS'aplatit itérable à un seul niveau de profondeur.
flattenDeep(?iterable $ collection ): iterableS'aplatit récursivement itérable.
flattenDepth(int $ depth , ?iterable $ collection ): iterableAplatir récursivement le tableau jusqu'aux temps de profondeur.
fromPairs(?iterable $ collection ): array Crée un nouvel enregistrement à partir d'une liste de paires de valeurs clés. L'inverse de toPairs .
head(?iterable $ collecton )Obtient le premier élément d'Itéable
indexOf( $ value , ?iterable $ collection ): int Renvoie l'indice de la première occurrence de $value dans $collection , else -1.
intersection(?iterable $ record1 , ?iterable $ record2 ): arrayRenvoie des valeurs uniques qui sont incluses dans les deux enregistrements
intersectionBy(callable $ iteratee , ?iterable $ record1 , ?iterable $ record2 ): array Comme intersection mais invoque $iteratee pour chaque élément avant comparaison.
intersectionWith(callable $ comparator , ?iterable $ record1 , ?iterable $ record2 ): array Comme intersection mais invoque $comparator pour comparer les éléments.
join(string $ separator , ?iterable $ collection ): string Rejoint des éléments itérables séparés par $separator
last(?iterable $ collecton )Obtient le dernier élément de itérable
nth (int $ offset , ?iterable $ collection ) Renvoie l'élément $offset . Si $offset est négatif, l'élément à la longueur d'index + $offset est renvoyé.
remove(int $ start , int $ count , ?iterable $ iterable ): array Supprime les articles de $iterable à partir de $start et contenant des éléments $count .
slice(int $ start , int ? $ end , ?iterable $ collection ): iterable Retruns une tranche de $iterable de $start jusqu'à, mais sans compter, $end .
take(int $ n , ?iterable $ collection ): iterablePrend n les premiers éléments de itérable
takeRight(int $ n , ?iterable $ collection ): arrayRenvoie une tranche d'itération avec n éléments pris à la fin.
uniq(?iterable $ collection ): array Supprime les doublons en utilisant ===
uniqBy(callable $ iteratee , ?iterable $ collection ): array Comme uniq mais appliquez $iteratee Fist
uniqWith(callable $ predicate , ?iterable $ collection ): array Comme uniq mais utilise $predicate pour comparer les éléments
without(array $ values , ?iterable $ collection ): iterable Renvoie $iterable sans $values
zip (iterable $ a , iterable $ b ): iterableCrée un itérable d'éléments groupés, dont le premier contient les premiers éléments des itérables donnés, dont le second contient les deuxième éléments, etc.
zipWith (callable $ iteratee , iterable $ a , iterable $ b ): iterable Comme zip sauf qu'il accepte $iteratee pour spécifier comment les valeurs groupées doivent être combinées.
all(?callable $ predicate , ?iterable $ collection ): bool Vérifie si $predicate renvoie truthy pour tous les éléments de $collection . Arrête une fois qu'il renvoie falsey
any(callable $ predicate , ?iterable $ collection ): bool Vérifie si $predicate renvoie la vérité pour tout élément de $collection . S'arrête d'abord trouvé.
each(callable $ iteratee , ?iterable $ collection ): iterable Iterates sur les éléments de $collection . Itératee peut quitter l'itération tôt en revenant false .
filter(callable $ predicate , ?iterable $ collection ): iterable Renvoie des éléments $predicate renvoie la vérité pour.
find(?callable $ predicate , ?iterable $ collection ) Renvoie le premier élément $predicate renvoie la vérité.
flatMap(callable $ iteratee , ?iterable $ collection ): iterableCartes puis aplaties
flatMapDeep(callable $ iteratee , ?iterable $ collection ): iterable Comme flatMap mais aplatit récursivement les résultats.
flatMapDepth(callable $ iteratee , int $ depth , ?iterable $ collection ): iterable Comme flatMap mais aplatit les résultats cartographiés jusqu'à $depth
groupBy(callable $ iteratee , ?iterable $ collection ): array Crée un tableau composé de clés généré en exécutant chaque valeur via $iteratee .
includes( $ value , ?iterable $ collection ): bool Vérifie si $value est dans $collection .
indexBy(callable $ iteratee , ?iterable $ collection ): iterable Crée un enregistrement composé de clés généré à partir des résultats de l'exécution de chaque élément de $collection via $iteratee .
map (callable $ iteratee , ?iterable $ collection ) Exécutez chaque élément dans $collection via $iteratee .
orderBy (array $ iteratees , array $ orders , ?iterable $ collection ) Comme sortBy mais permet de spécifier les commandes de tri
partition(callable $ predicate , ?iterable $ collection ): array Split $collection en deux groupes, dont le premier contient des éléments $predicate renvoie la vérité pour, dont le second contient des éléments pour les rendements $predicate pour.
reduce (callable $ iteratee , $ accumulator , ?iterable $ collection ) Réduit $collection à une valeur qui est le résultat accumulé de la gestion de chaque élément de la collection via $iteratee
resolve (array $ resolvers , array $ record ): array Ajoute de nouvelles propriétés à $record à l'aide de $resolvers .
sort(array $ comparator , ?iterable $ collection ): array Trie de $collection en utilisant la comparaison $comparator ( $a <=> $b ) Fonction
sortBy(array $ comparators , ?iterable $ collection ): array Trie $collection en commande ascendante selon $comparators .
sortWith(array $ comparators , ?iterable $ collection ): array Trie une $collection selon un tableau de comparaison ( $a <=> $b ) fonctions
values(?iterable $ collection ): iterable Renvoie un itérable indexé de valeurs dans $collection .
always ( $ value )Renvoie une fonction qui renvoie toujours la valeur donnée.
applyTo ( $ value , callable $ interceptor ) Renvoie $interceptor($value) .
ary (int $ n , callable $ fn ): callable Crée une fonction qui invoque $fn , avec des arguments allant jusqu'à $n , ignorant tout argument supplémentaire.
ascend (callable $ func , $ a , $ b ): callable Fait une fonction de comparateur ascendant à partir d'une fonction qui renvoie une valeur qui peut être comparée à <=>
attempt (callable $ fn ) Appelle $fn , retournant soit le résultat ou l'exception capturée.
compose (callable . . . $ funcs ): callable Comme pipe mais invoque les fonctions de droite à gauche.
curry (callable $ f ): callable Idles_ const peut être utilisé comme espace réservé.
curryRight (callable $ f ): callable Comme curry , mais les arguments sont admissibles.
descend (callable $ func , $ a , $ b ): callable Fait une fonction de comparateur descendante à partir d'une fonction qui renvoie une valeur qui peut être comparée à <=>
flip (callable $ fn ): callableRenvoie une nouvelle fonction au curry avec les deux premiers arguments inversés
juxt (array $ funcs ): callableApplique une liste de fonctions à une liste de valeurs.
memoize (callable $ func ): callable Crée une fonction qui mémorise le résultat de $func . $resolver Renvoie la clé de cache de carte, args [0] par défaut.
negate (callable $ predicate ): callable Crée une fonction qui annule le résultat de la fonction $predicate .
once (callable $ fn ): callable $fn n'est appelé qu'une seule fois, la première valeur est renvoyée dans les invocations ultérieures.
partial (callable $ fn , array $ partials ): callable Crée une fonction qui invoque $fn avec $partials apparenté aux arguments. Idles_ const peut être utilisé comme espace réservé.
partialRight (callable $ fn , array $ partials ): callable Comme partial , mais $partials sont annexés.
pipe (callable . . . $ funcs ): callableComposition de la fonction de gauche à droite. Le premier argument peut avoir toute aité; Les arguments restants doivent être unares.
tap (callable $ interceptor , $ value ) Appels $interceptor($value) puis renvoie la $value d'origine
times (callable $ iteratee , int $ n ): array Appelle l'itateree $n fois, renvoyant un tableau des résultats de chaque invocation.
tryCatch (callable $ tryer , callable $ catcher , $ value ) Appels $tryer , s'il lance, appelle $catcher
unary (callable $ fn ): callable ary(1, $fn)
allPass (array $ predicates ): callable Renvoie une fonction qui vérifie si ses arguments transmettent tous $predicates .
anyPass (array $ predicates ): callable Renvoie une fonction qui vérifie si ses arguments transmettent l'un des $predicates .
both (callable $ func1 , callable $ func2 ): callable La fonction résultante renvoie $func1(...$args) s'il est falsy ou $func2(...$args) autrement, court-circuité
cond (array $ pairs ): callable Itère sur $pairs et invoque la fonction correspondante du premier prédicat pour retourner la vérité.
defaultTo ( $ default )( $ value ) Renvoie $value ?? $default
either (callable $ func1 , callable $ func2 ): callable La fonction résultante renvoie $func1(...$args) si c'est la vérité ou $func2(...$args) autrement, court-circuité.
ifElse (callable $ predicate , callable $ onTrue , callable $ onFalse ): callable La fonction résultante renvoie $onTrue(...$args) si $predicate(...$args) est la vérité ou $onFalse(...$args) autrement.
not ( $ a ): bool retourne !$a
unless (callable $ predicate , callable $ whenFalse , mixed $ value ) Renvoie $predicate($value) ? $value : $whenFalse($value)
when (callable $ predicate , callable $ whenTrue , mixed $ value ) Renvoie $predicate($value) ? $whenTrue($value) : $value
add (int|float $ a , int|float $ b ): int|float$ a + $ b
dec (int $ number ): intRetourne $ numéro - 1
divide (int|float $ a , int|float $ b ): int|float$ a / $ b
gt ( $ a , $ b ): bool$ a> $ b
gte ( $ a , $ b ): bool$ a> = $ b
inc (int $ number ): intRetourne $ numéro + 1
lt ( $ a , $ b ): bool$ a <$ b
lte ( $ a , $ b ): bool$ a <= $ b
modulo (int|float $ a , int|float $ b ): int$ a% $ b
multiply (int|float $ a , int|float $ b ): int|float$ a * $ b
round (int $ precision , int|float $ number ): float Rounds $number pour spécifier $precision
subtract (int|float $ a , int|float $ b ): int|float$ a - $ b
sum(?iterable $ collection ): int|floatRésume les éléments dans itérable
sumBy(?callable $ iteratee , ?iterable $ collection ): int|float Comme sum , mais $iteratee est invoqué pour chaque élément d'itable pour générer la valeur à résumer.
assignDeep (array $ iterables ): arrayFusion des propriétés récursivement, les clés numériques sont écrasées.
defaults(?iterable $ record1 , ?iterable $ record2 ): arrayMerge les propriétés de droite à gauche, les clés numériques sont écrasées.
evolve(array $ transformations , ?iterable $ record ): array Crée un nouvel enregistrement en appelant récursivement les fonctions de transformation avec les propriétés $record .
extend(?iterable $ source1 , ?iterable $ source2 ): arrayFusion des propriétés, les clés numériques sont écrasées.
has(string|int $ key , ?iterable $ record ): bool Chèques si $record a $key
hasPath(string|int|array $ path , ?iterable $ record ): bool Chèques si $path existe dans $record
invert(?iterable $ collection ): arrayRemplace les clés par des valeurs. Les clés en double sont écrasées.
keys(?iterable $ record ): iterable Renvoie un itérable indexé des clés dans $record .
merge(?iterable $ source1 , ?iterable $ source2 ): arrayMerges Propriétés, les clés numériques sont ajoutées.
mergeDeep (array $ iterables ): arrayFusion des propriétés récursivement, les clés numériques sont annexées.
mergeLeft(?iterable $ left , ?iterable $ right ): array appels merge($right, $left)
mergeWith(callable $ customizer , ?iterable $ left , ?iterable $ right ): array Comme merge mais si une clé existe dans les deux enregistrements, $customizer est appelé aux valeurs associées à la clé
modifyPath (array|string|int $ path , callable $ updater , ?iterable $ record ) Crée un nouvel enregistrement en appliquant une fonction $updater à la valeur du $path donné.
objOf (string $ key , $ value ): array Crée un array contenant une seule touche => paire de valeurs.
omit(array $ keys , ?iterable $ collection ): iterable L'opposé du pick . Renvoie un enregistrement sans $keys .
omitBy(callable $ predicate , ?iterable $ record ): iterable L'opposé de pickBy . Renvoie les propriétés de $record que $predicate renvoie Falsey pour.
path (array|string $ path , ?iterable $ collection )Récupérez la valeur sur un chemin donné.
paths(array $ paths , ?iterable $ collection ): arrayClés dans, valeurs. L'ordre est conservé.
pick(array $ keys , ?iterable $ collection ): iterable Renvoie un enregistrement ne contenant que $keys
pickBy(callable $ predicate , ?iterable $ record ): iterable Renvoie l'enregistrement contenant uniquement des touches $predicate renvoie la vérité pour.
pluck (string|int $ key , ?iterable $ collection )Renvoie un nouveau tableau en arrachant la même propriété nommée tous les enregistrements du tableau fourni.
prop (string|int $ key , ?iterable $ record )Retourner la propriété spécifiée.
propEq(string|int $ key , $ value , ?iterable $ record ): boolRenvoie $ enregistrer [$ key] == $ valeur
setPath ( $ path , $ value , ?iterable $ record ) Retour Copy $record avec $path Set avec $value
toPairs(?iterable $ record ): iterable Convertit un enregistrement en un tableau de [$key, $value]
where(array $ spec , ?iterable $ record ): bool Vérifie si $record satisfait la spécification en invoquant les propriétés $spec avec les propriétés correspondantes de $record .
whereAny(array $ spec , ?iterable $ record ): bool Vérifie si $record satisfait la spécification en invoquant les propriétés $spec avec les propriétés correspondantes de $record . Renvoie true si au moins un des prédicats revient true .
whereEq(array $ spec , ?iterable $ test ): bool Vérifiez si le $test satisfait la $spec
escape (string $ s ): stringConvertit les personnages "&", "<", ">", '"' et" '"à leurs entités HTML correspondantes.
escapeRegExp (string $ regexp ): stringÉchappe à l'expression régulière
split (string $ separator , string $ s ): array Divisait la chaîne par $separator .
startsWith (string $ target , string $ s ): bool Si la chaîne commence par $target .
toLower (string $ s ): stringConvertit la chaîne en minuscules
toUpper (string $ s ): stringConvertit la corde en majuscules
words (string $ pattern , string $ string ): arrayDivise la ficelle dans un tableau de ses mots.
collect(?iterable $ iterable ): array Recueille tout itérable dans array
eq ( $ a , $ b ): bool $a == $b
equals ( $ a , $ b ): bool $a === $b
F (... $ args ): bool Renvoie toujours false
identity ( $ value )Renvoie le premier argument qu'il reçoit.
iterate (callable $ f , $ value ): iterable Renvoie un générateur de $value , $f($value) , $f($f($value)) etc.
just ( $ value ): OptionalRenvoie un facultatif avec la valeur non nulle spécifiée
nothing(): OptionalRenvoie un facteur vide
now (): intRenvoie l'horodatage du nombre de secondes
just (mixed $ value ): OptionalPeut-être / option monad (conteneur) qui peut contenir ou non une valeur non nulle. A des méthodes:
isPresent(): bool - true sinon vide
isEmpty(): bool - true si vide
get(): mixed - renvoie la valeur, jetez l'exception si vide
orElse(mixed $default): mixed - renvoie la valeur contenue si l'option est non vide ou $default
orElseThrow(Exception $e) - Renvoie la valeur contenue, si elle est présente, autrement jetez une exception
map(callable $f): Optional - si une valeur est présente, appliquez-y le $f et si le résultat est non nul, renvoyez un facteur décrivant le résultat
flatMap(callable $f): Optional - utilisez au lieu de map si $f renvoie en option
filter(callable $predicate): Optional - si une valeur est présente et correspond au $predicate , renvoyez un facultatif avec la valeur, sinon un facultatif vide.
size (array|Countable|object|string|callable $ value ): intRenvoie la taille d'un nombre de paramètres dénombrables d'une fonction, de la chaîne ou du nombre de propriétés d'un objet
T (... $ args ): bool Renvoie toujours true
