idles

Idles: una biblioteca funcional de PHP

Una biblioteca de utilidad funcional PHP, puerto de las bibliotecas JavaScript LOdash/FP y Ramda a PHP.

Todas las funciones están libres de efectos secundarios y automáticamente curry , los datos son inmutables .

El parámetro de colección Iterable generalmente se suministra el último para hacer que el curry sea conveniente.

La evaluación perezosa / retrasada se admite en tuberías funcionales.

Vaya a https://idlephp.tech para obtener más detalles, documentación y ejemplos.

Requisitos

PHP 7.4 o superior

Instalación

composer require miroshnikov/idles

Hoja de ruta

Nota

Actualmente, Idles está bajo desarrollo activo. La hoja de ruta es agregar todos los métodos de las bibliotecas de Ladash y Ramda y algunas herramientas funcionales.

Documentación

Formación

concatismo

concat(?iterable $ array, $ value ): iterable

Concatina $array con iterables/valores adicionales

contar

count(callable $ predicate , ?iterable $ collection ): int

Cuenta el número de artículos en $collection que coincide con el $predicate

cuenta

countBy(callable $ iteratee , ?iterable $ collection ): array

Devuelve una matriz: [ $iteratee($value) => Número de veces el $iteratee($value) se encontró en $collection ]

gota

drop(int $ n , ?iterable $ collection ): iterable

Omita el primer $n elemens y devuelve el resto de los iterables

renovado

dropRight(int $ n , ?iterable $ collection ): iterable

Omita los últimos $n elementos

findindex

findIndex(callable $ predicate , ?iterable $ collection ): int

Como find pero devuelve el índice del predicado de primer elemento devuelve verdady para, -1 si no se encuentra

findlastIndex

findLastIndex(callable $ predicate , ?iterable $ collection ): int

Como find pero devuelve el índice del predicado de último elemento devuelve verdady para, -1 si no se encuentra

aplanar

flatten(?iterable $ collection ): iterable

Aplana iterable de un solo nivel de profundidad.

plano

flattenDeep(?iterable $ collection ): iterable

Recursivamente se aplana iterable.

platillo

flattenDepth(int $ depth , ?iterable $ collection ): iterable

Aplanar recursivamente la matriz hasta los tiempos de profundidad.

desde los juegos

fromPairs(?iterable $ collection ): array

Crea un nuevo registro de una lista de pares de valores clave. El inverso de toPairs .

cabeza

head(?iterable $ collecton )

Obtiene el primer elemento de ITerable

índice

indexOf( $ value , ?iterable $ collection ): int

Devuelve el índice de la primera ocurrencia de $value en $collection , else -1.

intersección

intersection(?iterable $ record1 , ?iterable $ record2 ): array

Devuelve valores únicos que se incluyen en ambos registros

intersección

intersectionBy(callable $ iteratee , ?iterable $ record1 , ?iterable $ record2 ): array

Como intersection , pero invoca $iteratee para cada elemento antes de la comparación.

intersección con

intersectionWith(callable $ comparator , ?iterable $ record1 , ?iterable $ record2 ): array

Como intersection pero invoca $comparator para comparar elementos.

unirse

join(string $ separator , ?iterable $ collection ): string

Se une a elementos iterables separados por $separator

último

last(?iterable $ collecton )

Obtiene el último elemento de Iterable

enésimo

 nth (int $ offset , ?iterable $ collection )

Devuelve el elemento $offset . Si $offset es negativo, el elemento a la longitud del índice + $offset se devuelve.

eliminar

remove(int $ start , int $ count , ?iterable $ iterable ): array

Elimina artículos de $iterable que comienza en $start y contiene elementos $count .

rebanada

slice(int $ start , int ? $ end , ?iterable $ collection ): iterable

Retrasa una porción de $iterable de $start Up hasta, pero sin incluir, $end .

llevar

take(int $ n , ?iterable $ collection ): iterable

Toma n primeros elementos de itererable

mira

takeRight(int $ n , ?iterable $ collection ): array

Devuelve una porción de iterable con n elementos tomados desde el final.

uniq

uniq(?iterable $ collection ): array

Elimina duplicados usando ===

Único

uniqBy(callable $ iteratee , ?iterable $ collection ): array

Como uniq pero aplica $iteratee fist

uniqwith

uniqWith(callable $ predicate , ?iterable $ collection ): array

Como uniq pero usa $predicate para comparar elementos

sin

without(array $ values , ?iterable $ collection ): iterable

Devuelve $iterable sin $values

cremallera

 zip (iterable $ a , iterable $ b ): iterable

Crea una iterable de elementos agrupados, el primero de los cuales contiene los primeros elementos de los iterables dados, el segundo contiene los segundos elementos, y así sucesivamente.

cremallera

 zipWith (callable $ iteratee , iterable $ a , iterable $ b ): iterable

Como zip excepto que acepta $iteratee para especificar cómo se deben combinar los valores agrupados.

Recopilación

todo

all(?callable $ predicate , ?iterable $ collection ): bool

Cheques si $predicate devuelve truthy para todos los elementos de $collection . Detente una vez que devuelve falsey

cualquier

any(callable $ predicate , ?iterable $ collection ): bool

Cheques si $predicate devuelve verdady para cualquier elemento de $collection . Se detiene en primera vez encontrado.

cada

each(callable $ iteratee , ?iterable $ collection ): iterable

Itera sobre elementos de $collection . Iterere puede salir temprano de la iteración devolviendo false .

filtrar

filter(callable $ predicate , ?iterable $ collection ): iterable

Devuelve Elementos $predicate devuelve verdady para.

encontrar

find(?callable $ predicate , ?iterable $ collection )

Devuelve el primer elemento $predicate devuelve verdady para.

mapa de piso

flatMap(callable $ iteratee , ?iterable $ collection ): iterable

Mapas luego aplanar

platero

flatMapDeep(callable $ iteratee , ?iterable $ collection ): iterable

Como flatMap pero aplana recursivamente los resultados.

platero

flatMapDepth(callable $ iteratee , int $ depth , ?iterable $ collection ): iterable

Como flatMap pero aplana los resultados mapeados hasta $depth

grupo

groupBy(callable $ iteratee , ?iterable $ collection ): array

Crea una matriz compuesta de claves generadas al ejecutar cada valor a través de $iteratee .

incluir

includes( $ value , ?iterable $ collection ): bool

Cheques si $value está en $collection .

índice

indexBy(callable $ iteratee , ?iterable $ collection ): iterable

Crea un registro compuesto por claves generadas a partir de los resultados de ejecutar cada elemento de $collection a través de $iteratee .

mapa

 map (callable $ iteratee , ?iterable $ collection )

Ejecute cada elemento en $collection a través de $iteratee .

pedido

 orderBy (array $ iteratees , array $ orders , ?iterable $ collection )

Como sortBy pero permite especificar las órdenes de clasificación

dividir

partition(callable $ predicate , ?iterable $ collection ): array

Dividido $collection en dos grupos, el primero de los cuales contiene elementos $predicate devoluciones para la verdad, el segundo de los cuales contiene elementos $predicate devuelve falsos.

reducir

 reduce (callable $ iteratee , $ accumulator , ?iterable $ collection )

Reduce $collection a un valor que es el resultado acumulado de ejecutar cada elemento en colección a través de $iteratee

resolver

 resolve (array $ resolvers , array $ record ): array

Agrega nuevas propiedades a $record usando $resolvers .

clasificar

sort(array $ comparator , ?iterable $ collection ): array

Clasifica $collection usando $comparator ( $a <=> $b ) función

Ordenar por

sortBy(array $ comparators , ?iterable $ collection ): array

Clasifica $collection en orden ascendente de acuerdo con $comparators .

sortwith

sortWith(array $ comparators , ?iterable $ collection ): array

Clasifica una $collection según una variedad de funciones de comparación ( $a <=> $b )

valores

values(?iterable $ collection ): iterable

Devuelve un icertilizado de valores indexado en $collection .

Función

siempre

 always ( $ value )

Devuelve una función que siempre devuelve el valor dado.

aplicar

 applyTo ( $ value , callable $ interceptor )

Devuelve $interceptor($value) .

ary

 ary (int $ n , callable $ fn ): callable

Crea una función que invoca $fn , con hasta $n argumentos, ignorando cualquier argumento adicional.

ascender

 ascend (callable $ func , $ a , $ b ): callable

Hace una función de comparación ascendente a partir de una función que devuelve un valor que se puede comparar con <=>

intentar

 attempt (callable $ fn )

Llama a $fn , devolviendo el resultado o la excepción atrapada.

componer

 compose (callable . . . $ funcs ): callable

Como pipe , pero invoca las funciones de derecha a izquierda.

curry

 curry (callable $ f ): callable

Idles_ const se puede usar como marcador de posición.

Curryright

 curryRight (callable $ f ): callable

Como curry pero los argumentos se preparan.

bajar

 descend (callable $ func , $ a , $ b ): callable

Hace una función de comparación descendente a partir de una función que devuelve un valor que se puede comparar con <=>

voltear

 flip (callable $ fn ): callable

Devuelve una nueva función curry con los dos primeros argumentos revertidos

yux

 juxt (array $ funcs ): callable

Aplica una lista de funciones a una lista de valores.

memorarse

 memoize (callable $ func ): callable

Crea una función que memoiza el resultado de $func . $resolver devuelve la tecla de caché MAP, args [0] de forma predeterminada.

negar

 negate (callable $ predicate ): callable

Crea una función que niega el resultado de la función $predicate .

una vez

 once (callable $ fn ): callable

$fn solo se llama una vez, el primer valor se devuelve en invocaciones posteriores.

parcial

 partial (callable $ fn , array $ partials ): callable

Crea una función que invoca $fn con $partials preferidos a los argumentos. Idles_ const se puede usar como marcador de posición.

parcial

 partialRight (callable $ fn , array $ partials ): callable

Como partial pero se agregan $partials .

tubo

 pipe (callable . . . $ funcs ): callable

Composición de función de izquierda a derecha. El primer argumento puede tener alguna aridad; Los argumentos restantes deben ser unaros.

grifo

 tap (callable $ interceptor , $ value )

Llama $interceptor($value) y luego devuelve el $value original

veces

 times (callable $ iteratee , int $ n ): array

Llama a los iteradoe $n veces, devolviendo una matriz de los resultados de cada invocación.

truco

 tryCatch (callable $ tryer , callable $ catcher , $ value )

Llama $tryer , si se lanza, llama a $catcher

unario

 unary (callable $ fn ): callable

ary(1, $fn)

Lógica

pasajero

 allPass (array $ predicates ): callable

Devuelve una función que verifica si sus argumentos pasan los $predicates .

Anypass

 anyPass (array $ predicates ): callable

Devuelve una función que verifica si sus argumentos pasan alguno de los $predicates .

ambos

 both (callable $ func1 , callable $ func2 ): callable

La función resultante devuelve $func1(...$args) si es falsy o $func2(...$args) de lo contrario, cortocircuitado

condición

 cond (array $ pairs ): callable

Itera más de $pairs e invoca la función correspondiente del primer predicado para devolver la verdad.

predeterminado

 defaultTo ( $ default )( $ value )

Devuelve $value ?? $default

cualquiera

 either (callable $ func1 , callable $ func2 ): callable

La función resultante devuelve $func1(...$args) si es verdad o $func2(...$args) de lo contrario, cortocircuitado.

ifelse

 ifElse (callable $ predicate , callable $ onTrue , callable $ onFalse ): callable

La función resultante devuelve $onTrue(...$args) si $predicate(...$args) es verdad o $onFalse(...$args) de lo contrario.

no

 not ( $ a ): bool

¡Devuelve !$a

a menos que

 unless (callable $ predicate , callable $ whenFalse , mixed $ value )

Devuelve $predicate($value) ? $value : $whenFalse($value)

cuando

 when (callable $ predicate , callable $ whenTrue , mixed $ value )

Devuelve $predicate($value) ? $whenTrue($value) : $value

Matemáticas

agregar

 add (int|float $ a , int|float $ b ): int|float

$ A + $ B

dic

 dec (int $ number ): int

Devuelve $ Número - 1

dividir

 divide (int|float $ a , int|float $ b ): int|float

$ A / $ B

GT

 gt ( $ a , $ b ): bool

$ a> $ b

gte

 gte ( $ a , $ b ): bool

$ a> = $ b

Cª

 inc (int $ number ): int

Devuelve $ número + 1

teniente

 lt ( $ a , $ b ): bool

$ a <$ b

LTE

 lte ( $ a , $ b ): bool

$ a <= $ b

módulo

 modulo (int|float $ a , int|float $ b ): int

$ A % $ B

multiplicar

 multiply (int|float $ a , int|float $ b ): int|float

$ a * $ b

redondo

 round (int $ precision , int|float $ number ): float

Ronda $number a $precision especificada

sustraer

 subtract (int|float $ a , int|float $ b ): int|float

$ A - $ B

suma

sum(?iterable $ collection ): int|float

Suma elementos en itererable

sumby

sumBy(?callable $ iteratee , ?iterable $ collection ): int|float

Al igual que sum , pero $iteratee se invoca para cada elemento en Iterable para generar el valor a sumar.

Registro

asignado

 assignDeep (array $ iterables ): array

Fusiona propiedades recursivamente, las teclas numéricas se sobrescriben.

valores predeterminados

defaults(?iterable $ record1 , ?iterable $ record2 ): array

Fusiona propiedades de derecha a izquierda, se sobrescriben las teclas numéricas.

evolucionar

evolve(array $ transformations , ?iterable $ record ): array

Crea un nuevo registro al llamar recursivamente las funciones de transformación con propiedades $record .

extender

extend(?iterable $ source1 , ?iterable $ source2 ): array

Fusiona propiedades, las teclas numéricas se sobrescriben.

tiene

has(string|int $ key , ?iterable $ record ): bool

Cheques si $record tiene $key

cascabel

hasPath(string|int|array $ path , ?iterable $ record ): bool

Cheques si existe $path en $record

invertir

invert(?iterable $ collection ): array

Reemplaza las claves con valores. Las teclas duplicadas se sobrescriben.

llaves

keys(?iterable $ record ): iterable

Devuelve un Itreable de claves indexado en $record .

unir

merge(?iterable $ source1 , ?iterable $ source2 ): array

Fusiona las propiedades, se agregan teclas numéricas.

fusionado

 mergeDeep (array $ iterables ): array

Fusiona propiedades de forma recursiva, se adjuntan las teclas numéricas.

mértica

mergeLeft(?iterable $ left , ?iterable $ right ): array

Llama merge($right, $left)

mergewith

mergeWith(callable $ customizer , ?iterable $ left , ?iterable $ right ): array

Al igual que merge , pero si existe una clave en ambos registros, $customizer se llama a los valores asociados con la clave

modifipático

 modifyPath (array|string|int $ path , callable $ updater , ?iterable $ record )

Crea un nuevo registro aplicando una función de $updater al valor en la $path dada.

obtof

 objOf (string $ key , $ value ): array

Crea una array que contiene un solo par de valores clave =>.

omitir

omit(array $ keys , ?iterable $ collection ): iterable

Lo contrario de pick . Devuelve el registro sin $keys .

omitby

omitBy(callable $ predicate , ?iterable $ record ): iterable

Lo opuesto al pickBy . Devuelve propiedades de $record que $predicate devuelve falsificación para.

camino

 path (array|string $ path , ?iterable $ collection )

Recuperar el valor en una ruta determinada.

caminos

paths(array $ paths , ?iterable $ collection ): array

Claves en, valores fuera. Se conserva el orden.

elegir

pick(array $ keys , ?iterable $ collection ): iterable

Registro de devoluciones que contiene solo $keys

pickby

pickBy(callable $ predicate , ?iterable $ record ): iterable

Registro de devoluciones que contiene solo claves $predicate devuelve verdady para.

arrancar

 pluck (string|int $ key , ?iterable $ collection )

Devuelve una nueva matriz arrancando la misma propiedad con nombre de todos los registros en la matriz suministrada.

apuntalar

 prop (string|int $ key , ?iterable $ record )

Devolver la propiedad especificada.

pueblo

propEq(string|int $ key , $ value , ?iterable $ record ): bool

Devuelve $ registro [$ key] == $ valor

setpath

 setPath ( $ path , $ value , ?iterable $ record )

Devolver copia $record con $path establecida con $value

Topairs

toPairs(?iterable $ record ): iterable

Convierte un registro en una matriz de [$key, $value]

dónde

where(array $ spec , ?iterable $ record ): bool

Comprueba si $record satisface la especificación invocando las propiedades $spec con las propiedades correspondientes de $record .

whreeany

whereAny(array $ spec , ?iterable $ record ): bool

Comprueba si $record satisface la especificación invocando las propiedades $spec con las propiedades correspondientes de $record . Devuelve true si al menos uno de los predicados devuelve true .

Donde

whereEq(array $ spec , ?iterable $ test ): bool

Verifique si la $test satisface el $spec

Cadena

escapar

 escape (string $ s ): string

Convierte los personajes "&", "<", ">", '"' y" '"a sus entidades HTML correspondientes.

escapagexp

 escapeRegExp (string $ regexp ): string

Escapa de la expresión regular

dividir

 split (string $ separator , string $ s ): array

Splits String por $separator .

comienzo

 startsWith (string $ target , string $ s ): bool

Si la cadena comienza con $target .

agolutivo

 toLower (string $ s ): string

Convierte la cadena en minúsculas

tope

 toUpper (string $ s ): string

Convierte la cadena en la caja superior

palabras

 words (string $ pattern , string $ string ): array

Divide una cuerda en una matriz de sus palabras.

Utilizar

recolectar

collect(?iterable $ iterable ): array

Recoge cualquier iterable en array

ecualización

 eq ( $ a , $ b ): bool

$a == $b

iguales

 equals ( $ a , $ b ): bool

$a === $b

F

 F (... $ args ): bool

Siempre devuelve false

identidad

 identity ( $ value )

Devuelve el primer argumento que recibe.

iterar

 iterate (callable $ f , $ value ): iterable

Devuelve un generador de $value , $f($value) , $f($f($value)) etc.

justo

 just ( $ value ): Optional

Devuelve una opcional con el valor no nulo especificado

nada

nothing(): Optional

Devuelve una opcional vacía

ahora

 now (): int

Devuelve la marca de tiempo del número de segundos

Opcional

 just (mixed $ value ): Optional

Tal vez/opción Mónada (contenedor) que puede o no contener un valor no nulo. Tiene métodos:

isPresent(): bool - true si no está vacío
isEmpty(): bool - true si está vacío
get(): mixed - devuelve valor, excepción de tirar si está vacío
orElse(mixed $default): mixed : devuelve el valor contenido si lo opcional no es vacío o $default
orElseThrow(Exception $e) - Devuelve el valor contenido, si está presente, de lo contrario lanza una excepción
map(callable $f): Optional : si hay un valor presente, aplique el $f , y si el resultado no es nulo, devuelva una opcional que describe el resultado
flatMap(callable $f): Optional : use en lugar del map si $f devuelve opcional
filter(callable $predicate): Optional : si un valor está presente y coincide con el $predicate , devuelva una opcional con el valor, de lo contrario un opcional vacío.

tamaño

 size (array|Countable|object|string|callable $ value ): int

Devuelve el tamaño de un número contable de parámetros de una función, longitud de cadena o número de propiedades de un objeto

T

 T (... $ args ): bool

Siempre devuelve true