Anonyme Funktion

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

Die folgende Funktion verdoppelt ihr Argument:

(lambda (x) (* x 2))

Um diese Funktion im selben Zug zu verwenden, kann die Funktion direkt auf ein Argument angewendet werden:

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

Der Wert dieses Ausdrucks ist 10.

Das nächste Beispiel definiert eine Funktion höherer Ordnung und nennt sie meinFilter. Das erste Argument dieser Funktion ist eine weitere Funktion. Im unteren Teil des Beispiels wird für dieses Argument der lambda-Ausdruck angegeben.

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

Das Ergebnis der Berechnung ist

 (0 2 4 6 8)

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

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 + " ");
    }
}

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

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

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 + " ");
    }
}

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

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

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.