Jewiki unterstützen. Jewiki, die größte Online-Enzy­klo­pädie zum Judentum.

Helfen Sie Jewiki mit einer kleinen oder auch größeren Spende. Einmalig oder regelmäßig, damit die Zukunft von Jewiki gesichert bleibt ...

Vielen Dank für Ihr Engagement! (→ Spendenkonten)

How to read Jewiki in your desired language · Comment lire Jewiki dans votre langue préférée · Cómo leer Jewiki en su idioma preferido · בשפה הרצויה Jewiki כיצד לקרוא · Как читать Jewiki на предпочитаемом вами языке · كيف تقرأ Jewiki باللغة التي تريدها · Como ler o Jewiki na sua língua preferida

Anonyme Funktion

Aus Jewiki
Wechseln zu: Navigation, Suche

Eine anonyme Funktion (Funktionsliteral, Lambdafunktion oder Lambdaausdruck) ist eine Funktionsdefinition, die nicht an einen Bezeichner gebunden ist. Eine anonyme Funktion, die Zugriff auf ihren Erstellungskontext erhält, wird Closure genannt. Anonyme Funktionen werden häufig als Argumente an Funktionen höherer Ordnung übergeben oder zum Erstellen des Ergebnisses einer Funktion höherer Ordnung verwendet, die eine Funktion zurückgeben muss. Wenn eine Funktion nur an einer Stelle verwendet wird und einen begrenzten Umfang hat, kann eine anonyme Funktion syntaktisch einfacher sein als die Verwendung einer benannten Funktion. Anonyme Funktionen sind in funktionalen Programmiersprachen und anderen Sprachen mit First-Class-Funktionen allgegenwärtig, wo sie für den Funktionstyp dieselbe Rolle erfüllen wie Literale für andere Datentypen.

Anonyme Funktionen wurden ursprünglich von Alonzo Church mit seiner Erfindung des Lambda-Kalküls im Jahr 1936 geprägt, in dem alle Funktionen anonym sind. Anonyme Funktionen sind seit Lisp im Jahr 1958 ein Merkmal von Programmiersprachen, und eine wachsende Anzahl moderner Programmiersprachen unterstützt anonyme Funktionen.

Benannte Funktionen

Im Gegensatz zu einer anonymen Funktion erhält eine benannte Funktionen bei ihrer Deklaration einen eindeutigen Bezeichner, unter dem sie anschließend angesprochen wird. Der Name der Funktion wird vom Compiler oder vom Laufzeitsystem dazu verwendet, mit Hilfe der Symboltabelle oder eines dynamischen Verfahrens die Funktionsdefinition zu identifizieren und dort hinterlegten Code auszuführen.

Beispiel in JavaScript

function Bezeichner_meiner_Funktion() {
    console.log("Hallo, Welt!");
}

Bezeichner_meiner_Funktion();

Beispiel in C

#include <stdio.h>

void Bezeichner_meiner_Funktion() {
    puts("Hallo, Welt!");
}

int main() {
    Bezeichner_meiner_Funktion();
}

Beispiele

Common Lisp

(lambda (x) (* x 2))

Um diese Funktion, die einen Wert verdoppelt, im selben Zug zu verwenden, kann die Funktion direkt mit einem Argument angewendet werden:

((lambda (x) (* x 2)) 5)

Worauf 10 zurückgegeben wird.

(defun meinFilter (eigenschaft liste)
    (cond ((null liste) nil)
        ((if (funcall eigenschaft (car liste))
            (cons (car liste) (meinFilter eigenschaft (cdr liste)))
            (meinFilter eigenschaft (cdr liste))))))

(print (meinFilter (lambda (wert) (= (mod wert 2) 0))' (0 1 2 3 4 5 6 7 8 9)))

C++

Lambdaausdrücke bieten semantisch ähnliche Möglichkeiten wie das verwandte Konzept der Funktionszeiger. In C++ können anonyme Funktionen folgendermaßen definiert werden:

[capture]<template>(parameter) -> type { body }

  • capture: Übertrag der angegebenen Symbole in den Gültigkeitsbereich des Lambda-Ausdrucks
  • template: Liste der Templateparameter
  • parameter: Liste der Übergabeparameter
  • type: Rückgabetyp
  • body: Funktionsrumpf
#include <functional>
#include <iostream>
#include <vector>

using namespace std;

vector<int> meinFilter(function<bool(int)> eigenschaft, const vector<int> &liste) {
    auto sieb = vector<int>();
    sieb.reserve(liste.size());

    for (int element: liste)
        if (eigenschaft(element))
            sieb.push_back(element);

    return sieb;
}

int main() {
    vector<int> liste = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    auto sieb = meinFilter([](int wert) { return wert % 2 == 0; }, liste);
        
    for (int element: sieb)
        cout << element << " ";

    return 0;
}

C#

using System;
using System.Collections.Generic;

delegate bool Funktion(int wert);

class Programm {
    static List<int> meinFilter(Funktion eigenschaft, List<int> liste) {
        var sieb = new List<int>();
        sieb.Capacity = liste.Count;

        foreach (var element in liste)
            if (eigenschaft(element))
                sieb.Add(element);

        return sieb;
    }

    public static void Main(string[] args) {
        var liste = new List<int>() {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
        var sieb = meinFilter(wert => wert % 2 == 0, liste);

        foreach (int element in sieb)
            Console.Write(element + " ");
    }
}

Haskell

meinFilter eigenschaft liste = [element | element <- liste, eigenschaft element]

main = print $ meinFilter (\wert -> mod wert 2 == 0) [0..9]

Java

In Java mussten für diesen Zweck früher anonyme innere Klassen[1] verwendet werden. Ab Version 8 stehen sogenannte Lambda-Ausdrücke zur Verfügung.[2]

import java.util.ArrayList;
import java.util.Arrays;
import java.util.function.IntPredicate;
import java.util.List;

class Main {
    static List<Integer> meinFilter(IntPredicate eigenschaft, List<Integer> liste) {
        var sieb = new ArrayList<Integer>();

        for (Integer element: liste)
            if (eigenschaft.test(element))
                sieb.add(element);

        return sieb;
    }

    public static void main(String[] args) {
        var liste = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
        var sieb = meinFilter(wert -> wert % 2 == 0, liste);

        for (var element: sieb)
            System.out.print(element + " ");
    }
}

JavaScript

function meinFilter(eigenschaft, liste) {
    let sieb = [];

    for (let element of liste)
        if (eigenschaft(element))
            sieb.push(element);

    return sieb;
}

let liste = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
console.log(meinFilter(wert => wert % 2 == 0, liste));

Python

def meinFilter(eigenschaft, liste):
    sieb = []

    for element in liste:
        if eigenschaft(element):
            sieb.append(element)

    return sieb

liste = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(meinFilter(lambda wert: wert % 2 == 0, liste))

Einzelnachweise

  1. Christian Ullenboom: Java ist auch eine Insel. 13., aktualisierte Auflage. Galileo Press, Bonn 2017, ISBN 978-3-8362-5869-2, 8.5 Anonyme innere Klassen (openbook.galileocomputing.de).
  2. Angelika Langer: Lambda-Ausdrücke und Methoden-Referenzen. November 2013, abgerufen am 17. April 2020.
Dieser Artikel basiert ursprünglich auf dem Artikel Anonyme Funktion aus der freien Enzyklopädie Wikipedia und steht unter der Doppellizenz GNU-Lizenz für freie Dokumentation und Creative Commons CC-BY-SA 3.0 Unported. In der Wikipedia ist eine Liste der ursprünglichen Wikipedia-Autoren verfügbar.