Filter (funksjon av høyere orden) - Filter (higher-order function)

I funksjonell programmering er filter en funksjon av høyere orden som behandler en datastruktur (vanligvis en liste ) i en eller annen rekkefølge for å produsere en ny datastruktur som inneholder nøyaktig de elementene i den opprinnelige datastrukturen som et gitt predikat returnerer den boolske verdien for true .

Eksempel

I Haskell , kodeeksemplet

 filter even [1..10]

evaluerer til listen 2, 4, ..., 10 ved å bruke predikatet evenpå hvert element i listen over heltall 1, 2, ..., 10 i den rekkefølgen og lage en ny liste over de elementene som predikatet returnerer den boolske verdien true for , og gir derved en liste som bare inneholder de jevne medlemmene på listen. Omvendt, kodeeksemplet

 filter (not . even) [1..10]

evalueres til listen 1, 3, ..., 9 ved å samle de elementer i listen over hele tall 1, 2, ..., 10 for hvilke de underliggende evenreturnerer den boolske verdi falske (med .å være den funksjon sammensetningen operatør ).

Visuelt eksempel

Nedenfor kan du se en oversikt over hvert trinn i filterprosessen for en liste med heltall i X = [0, 5, 8, 3, 2, 1]henhold til funksjonen:

Denne funksjonen uttrykker at selv om returverdien er , ellers er det . Dette er predikatet.

bruk av filterfunksjonens behandlingstrinn
Visning av behandlingstrinn ved bruk av filterfunksjon på en liste

Språksammenligning

Filter er en standardfunksjon for mange programmeringsspråk , f.eks. Haskell, OCaml , Standard ML eller Erlang . Common Lisp gir funksjonene remove-ifog remove-if-not. Skjema forespørsler for implementering (Srfl) 1 gir en implementering av filter for språket ordningen . C ++ gir algoritmene remove_if (muterende) og remove_copy_if(ikke-muterende); C ++ 11 gir i tillegg copy_if(ikke-muterende). Smalltalk gir select:metoden for samlinger. Filter kan også realiseres ved hjelp av listeforståelser på språk som støtter dem.

I Haskell, filterkan implementeres slik:

 filter :: (a -> Bool) -> [a] -> [a]
 filter _ []     = []
 filter p (x:xs) = [x | p x] ++ filter p xs

Her []angir den tomme listen, ++listen sammenkoblingsoperasjon, og [x | p x]angir en liste som betinget holder en verdi x, hvis betingelsen p xholder (evalueres til True).

Filtrer på forskjellige språk
Språk Filter Merknader
APL (pred array)/array
eller
pred{⍵/⍨⍺⍺ ⍵}array
Det andre eksemplet er et APL -dop .
C# 3.0 ienum.Where(pred)
eller
The whereleddet
Hvor er en utvidelsesmetode
ienum er en IEnumerable
På samme måte på alle .NET -språk
CFML obj.filter(func) Hvor objer en matrise eller en struktur. Den funcmottar som argument hvert elements verdi.
Clojure (filter predicate list) Eller, via listeforståelse :(for [x list :when (pred x)] x)
Vanlig Lisp (remove-if inverted-pred list)
(remove-if (complement pred) list)
(remove-if-not pred list)
Funksjonen remove-if-nothar blitt avviklet til fordel for ekvivalenten remove-ifder predikatet komplementeres. Dermed skal filteret (remove-if-not #'oddp '(0 1 2 3))skrives (remove-if (complement #'oddp) '(0 1 2 3))eller enklere: (remove-if #'evenp '(0 1 2 3))der evenpreturneres den inverterte verdien av oddp.
C ++ std::remove_copy_if(begin, end, result, prednot)
std::copy_if(begin, end, result, pred) (C++11)
i topptekst <algoritme>
begynner , slutter , resultat er iterators
predikat er reversert
D std.algorithm.filter!(pred)(list)
Erlang lists:filter(Fun, List) Eller, via listeforståelse :[ X || X <- List, Fun(X) ]
Groovy list.findAll(pred)
Haskell filter pred list Eller, via listeforståelse :[x | x <- list, pred x]
Haxe list.filter(pred)
Lambda.filter(list, pred)
Eller, via listeforståelse :[x | x <- list, pred x]
J (#~ pred) list Et eksempel på en monadisk krok. # er kopi, ~ reverserer argumenter.(f g) y = y f (g y)
Julia filter(pred, array) dictFilterfunksjonen godtar også datatype. Eller, via listeforståelse :[x for x in array if pred(x)]
Java 8+ stream.filter(pred)
JavaScript 1.6 array.filter(pred)
Kotlin array.filter(pred)
Mathematica Select[list, pred]
Objective-C ( kakao i Mac OS X 10.4+) [array filteredArrayUsingPredicate:pred] preder et NSPredicate -objekt, som kan være begrenset i uttrykksfullhet
F# , OCaml , Standard ML List.filter pred list
PARI/fastlege select(expr, list) Rekkefølgen er reversert i v. 2.4.2.
Perl grep block list
grep expr, list
PHP array_filter(array, pred)
Prolog filter(+Closure,+List,-List) Siden ISO/IEC 13211-1: 1995/Cor.2: 2012 inneholder kjernestandarden lukkeapplikasjon via call/N
Python filter(func, list) Eller, via liste forståelse : . I Python 3 ble den endret for å returnere en iterator i stedet for en liste. Den komplementære funksjonaliteten, som returnerer en iterator over elementer som predikatet er usant for, er også tilgjengelig i standardbiblioteket som i modulen. [x for x in list if pred(x)]filterfilterfalseitertools
Rubin enum.find_all {block}
enum.select {block}
enum er en oppregning
Rust iterator.filter(pred) iteratorer en Iteratorog filtermetoden returnerer en ny iterator; preder en funksjon (spesifikt FnMut) som mottar iteratorens element og returnerer abool
S , R. Filter(pred,array)
array[pred(array)]
I det andre tilfellet må pred være en vektorisert funksjon
Scala list.filter(pred) Eller, via for-forståelse: for(x <- list; if pred) yield x
Skjema R 6 RS (filter pred list)
(remove inverted pred list)
(partition pred list list)
Småprat aCollection select: aBlock
Fort array.filter(pred)
filter(sequence, pred)
XPath , XQuery list[block]
filter(list, func)
I blockkontekstelementet .inneholder gjeldende verdi

Varianter

Filter skaper resultatet uten å endre den opprinnelige listen. Mange programmeringsspråk gir også varianter som ødeleggende endrer listeargumentet i stedet for raskere ytelse. Andre varianter av filter (f.eks. Haskell dropWhileog partition) er også vanlige. En vanlig minneoptimalisering for rent funksjonelle programmeringsspråk er å ha inngangslisten og det filtrerte resultatet til å dele den lengste felles halen ( haledeling ).

Se også

Referanser