Quelle est la différence entre une "fermeture" et un "lambda'?

toutes les fermetures ne sont pas des lambdas et toutes les lambdas ne sont pas des fermetures. Les deux sont des fonctions, mais pas nécessairement de la manière dont nous sommes habitués à les connaître.

un lambda est essentiellement une fonction qui est définie en ligne plutôt que la méthode standard de déclaration des fonctions. Les Lambdas peuvent souvent se transmettre sous forme d'objets.

une fermeture est une fonction qui entoure son état en faisant référence à des champs extérieurs à son corps. Le clos de l'état reste à travers les invocations de la fermeture.

dans un langage orienté objet, les fermetures sont normalement fournies par l'intermédiaire d'objets. Cependant, certains langages OO (par exemple C#) implémentent une fonctionnalité spéciale qui est plus proche de la définition des fermetures fournie par les langages purement fonctionnels (tels que lisp) qui n'ont pas d'objets pour l'état de fermeture.

ce qui est intéressant, c'est que L'introduction de Lambdas et de fermetures en C# apporte programmation fonctionnelle plus près à intégrer l'utilisation.

c'est aussi simple que cela: lambda est une construction de langage, c'est-à-dire une syntaxe simple pour les fonctions anonymes; une fermeture est une technique pour la mettre en œuvre -- ou n'importe quelles fonctions de première classe, pour cette matière, nommé ou anonyme.

plus précisément, une fermeture est la façon dont une fonction de première classe est représentée à l'exécution, comme une paire de son" code "et un environnement" fermeture " sur toutes les variables non locales utilisées dans ce code. De cette façon, ces variables sont encore accessibles même lorsque les portées extérieures d'où ils proviennent ont déjà été enlevées.

malheureusement, il existe de nombreux langages qui ne prennent pas en charge les fonctions en tant que valeurs de première classe, ou ne les prennent en charge que sous une forme invalidée. Ainsi, les gens utilisent souvent le terme "fermeture" pour distinguer "la chose réelle".

du point de vue des langages de programmation, ce sont deux choses complètement différentes.

fondamentalement, pour un langage complet, nous n'avons besoin que d'éléments très limités, par exemple l'abstraction, l'application et la réduction. L'Abstraction et l'application fournissent la façon dont vous pouvez construire l'expression lamdba, et la réduction dertermines le sens de l'expression lambda.

Lambda fournit un moyen vous pouvez abstraire le processus de calcul. pour exemple, pour calculer la somme de deux nombres, un processus qui prend deux paramètres x, y et retourne x+y peut être abstrait. Dans scheme, vous pouvez l'écrire comme

(lambda (x y) (+ x y))

, Vous pouvez renommer les paramètres, mais la tâche qu'il accomplit ne change pas. Dans presque tous les langages de programmation, vous pouvez donner l'expression lambda un nom, qui sont des fonctions nommées. Mais il n'y a pas beaucoup de différence, ils peuvent être considérés conceptuellement comme du simple sucre de syntaxe.

OK, maintenant imaginez comment cela peut être mis en œuvre. Chaque fois que nous appliquons l'expression lambda à certaines expressions, par exemple

((lambda (x y) (+ x y)) 2 3)

nous pouvons simplement remplacer les paramètres par l'expression à évaluer. Ce modèle est déjà très puissant. Mais ce modèle ne nous permet pas de changer les valeurs des symboles, par exemple nous ne pouvons pas imiter le changement de statut. Donc nous avons besoin d'un modèle plus complexe. Pour faire court, chaque fois que nous voulons calculer le sens de la lambda expression, nous mettons la paire de symbole et la valeur correspondante dans un environnement(ou une table). Ensuite, le reste (+ x y) est évalué en regardant les symboles correspondants dans le tableau. Maintenant, si nous fournir certaines primitives pour fonctionner sur l'environnement directement, nous pouvons modéliser les changements de statut!

avec ce fond, Vérifiez cette fonction:

(lambda (x y) (+ x y z))

Nous savons que lorsque nous évaluons l'expression lambda, x y sera lié dans une nouvelle table. Mais comment et où peut-on chercher z up? En fait z est appelé une variable libre. Il doit y avoir un extérieur un environnement qui contient z. Dans le cas contraire, le sens de l'expression ne peut pas être déterminé uniquement par X et Y. Pour que ce soit clair, vous pouvez écrire quelque chose comme suit dans scheme:

((lambda (z) (lambda (x y) (+ x y z))) 1)

donc z serait lié à 1 dans une table extérieure. Nous obtenons toujours une fonction qui accepte deux paramètres, mais le vrai sens il dépend aussi de l'environnement extérieur. En d'autres termes l'environnement extérieur se ferme sur les variables libres. Avec l'aide de set! on peut créer une fonction dynamique, j'.e, ce n'est pas une fonction au sens mathématique. Ce qu'il renvoie dépend non seulement de l'entrée, mais aussi de z.

C'est quelque chose que vous connaissez déjà très bien, une méthode d'objets presque toujours s'appuie sur l'état des objets. C'est pourquoi certains disent: "les fermetures sont des objets du pauvre. "Mais nous pourrions aussi considérer les objets comme des fermetures de pauvres puisque nous comme la première classe de fonctions.

j'utilise le schéma pour illustrer les idées en raison de ce schéma est l'une des langues les plus anciennes qui a de véritables fermetures. Tous les matériaux ici sont beaucoup mieux présentés dans le chapitre 3 du SICP.

pour résumer, lambda et closure sont des concepts vraiment différents. Une lambda est une fonction. Une fermeture est une paire de lambda et l'environnement correspondant qui ferme la lambda.

Concept est le même que décrit ci-dessus, mais si vous êtes de PHP background, cela expliquer plus en utilisant le code PHP.

$input = array(1, 2, 3, 4, 5);
$output = array_filter($input, function ($v) { return $v > 2; });

fonction ($v) { return $v > 2; } est la définition de la fonction lambda. On peut même stocker dans une variable, de sorte qu'il peut être réutilisable:

$max = function ($v) { return $v > 2; };

$input = array(1, 2, 3, 4, 5);
$output = array_filter($input, $max);

maintenant, que faire si vous voulez changer le nombre maximum autorisé dans le tableau filtré? Vous devriez écrire une autre fonction lambda ou créer une fermeture (PHP 5.3):

$max_comp = function ($max) {
  return function ($v) use ($max) { return $v > $max; };
};

$input = array(1, 2, 3, 4, 5);
$output = array_filter($input, $max_comp(2));

Une fermeture est une fonction qui est évaluée dans son propre environnement, qui a une ou plusieurs variables liées qui peuvent être accessibles lorsque la fonction est appelée. Ils viennent du monde de la programmation fonctionnelle, où il y a un certain nombre de concepts en jeu. Les fermetures sont comme les fonctions lambda, mais plus intelligentes dans le sens où elles ont la capacité d'interagir avec des variables de l'environnement extérieur où la fermeture est définie.

Voici un exemple plus simple de fermeture PHP:

$string = "Hello World!";
$closure = function() use ($string) { echo $string; };

$closure();

bien expliqué dans cet article.

cette question Est vieille et a obtenu de nombreuses réponses. Maintenant, avec Java 8 et Lambda officiel qui sont des projets de fermeture non officiels, il ravive la question.

la réponse dans le contexte Java (via Lambdas et les fermetures-Quelle est la différence? ):

"Une fermeture est une expression lambda jumelé avec un environnement qui lie chacun de ses variables libres d'une valeur. En Java, les expressions lambda seront implémentées par des moyens les deux termes sont donc devenus interchangeables dans la communauté."

pour parler simplement, la fermeture est un truc à propos de scope, lambda est une fonction anonyme. Nous pouvons réaliser la fermeture avec lambda plus élégamment et lambda est souvent utilisé comme un paramètre passé à une fonction plus élevée

Un lambda est juste une fonction anonyme - une fonction définie sans nom.Une fermeture est toute fonction qui se ferme sur l'environnement dans lequel elle a été définie. Cela signifie qu'il peut accéder à des variables qui ne sont pas dans sa liste de paramètres.

cela dépend si une fonction utilise une variable externe ou non pour effectuer l'opération.

variables externes - variables définies en dehors du champ d'une fonction.

• les expressions Lambda sont apatrides parce qu'elles dépendent de paramètres, de variables internes ou de constantes pour effectuer des opérations.

  Function<Integer,Integer> lambda = t -> {
      int n = 2
      return t * n 
  }
  

• Fermeture hold state parce qu'il utilise des variables externes (c'est-à-dire des variables définies en dehors de la portée du corps de fonction) ainsi que des paramètres et des constantes pour effectuer des opérations.

  int n = 2
  
  Function<Integer,Integer> closure = t -> {
      return t * n 
  }
  

lorsque Java crée la fermeture, il conserve la variable n avec la fonction de sorte qu'elle puisse être référencée lorsqu'elle est passée à d'autres fonctions ou utilisée n'importe où.