Quelles sont les fonctions imbriquées? À quoi servent-ils?

Question

Je ne l'ai jamais utilisé les fonctions imbriquées, mais ont vu des références à eux en plusieurs langues (ainsi que les classes imbriquées, que je suppose sont liés).

• Qu'est-ce qu'une fonction imbriquée?
• Pourquoi?!?
• Que pouvez-vous faire avec une fonction imbriquée que vous ne pouvez pas faire autrement?
• Que pouvez-vous faire avec une fonction imbriquée cela est difficile ou inélégant sans fonctions imbriquées?

Je suppose que les fonctions imbriquées sont tout simplement un artefact de traiter tout comme un objet, et si les objets peuvent contenir d'autres objets, alors il suit.

Avez-fonctions imbriquées ont une portée (en général, je suppose langues diffèrent à ce sujet) comme variables à l'intérieur d'une fonction ont une portée?

S'il vous plaît ajouter la langue que vous faites référence si vous n'êtes pas certain que votre réponse est la langue agnostique.

-Adam

Answer 1

Une utilisation populaire des fonctions imbriquées est fermetures . Dans un scope langue lexicalement avec des fonctions de première classe, il est possible d'utiliser des fonctions pour stocker les données. Un exemple simple dans le schéma est un compteur:

(define (make-counter)
  (let ((count 0))                ; used to store the count
    (define (counter)             ; this is the counter we're creating
      (set! count (+ count 1))    ; increment the count
      count)                      ; return the new count
    counter))                     ; return the new counter function

(define mycounter (make-counter)) ; create a counter called mycounter

(mycounter)                       ; returns 1

(mycounter)                       ; returns 2

Dans cet exemple, nous imbriquer la fonction compteur dans la fonction make-contre, et en retournant cette fonction interne, nous sommes en mesure d'accéder aux données disponibles pour contrer quand il a été défini. Cette information est privé à cette instance de MyCounter - si nous devions créer un autre compteur, il utiliserait un autre endroit pour stocker le comptage interne. La poursuite de l'exemple précédent:

(define mycounter2 (make-counter))

(mycounter2)                      ; returns 1

(mycounter)                       ; returns 3

Answer 2

Il est utile pour récursion quand il y a seulement 1 méthode qui jamais appeler

string[] GetFiles(string path)
{
  void NestedGetFiles(string path, List<string> result)
  {
    result.AddRange( files in the current path);
    foreach(string subPath in FoldersInTheCurrentPath)
      NestedGetFiles(subPath, result);
  }

   List<string> result = new List<string>();
   NestedGetFiles(path, result);
   return result.ToArray();
}

Le code ci-dessus est complètement constitué mais est basé sur C # pour donner l'idée de ce que je veux dire. La seule méthode qui peut appeler NestedGetFiles est la méthode GetFiles.

Answer 3

Une fonction imbriquée est juste une fonction dans une autre fonction.

Oui, il est le résultat de tout être un objet. Comme vous pouvez avoir des variables visibles dans le champ d'application de la fonction et les variables peuvent pointer vers les fonctions que vous pouvez avoir une fonction qui est référencée par une variable locale.

Je ne pense pas qu'il y ait quelque chose que vous pouvez faire avec une fonction imbriquée que vous ne pouviez pas faire tout à fait sans. Beaucoup de temps il est logique, cependant. A savoir, chaque fois qu'une fonction est un « sous-fonction » d'une autre fonction.

Un cas d'utilisation commune pour moi est lorsqu'une fonction effectue beaucoup de logique compliquée, mais quelle est la fonction calcule / rendement est facile de faire abstraction de tous les cas dictés par la logique.

Answer 4

(C #): J'utiliser pour simplifier l'affichage Explorateur d'objets et de mieux structurer mes cours. Comme Roue de classe imbriquée dans la classe de camions.

Ne pas oublier ce détail: « Types peuvent accéder aux membres emboîtés privés et protégés du type contenant, y compris les membres privés ou protégés hérités. »

Answer 5

Fonctions emboîtées vous permettent d'encapsuler le code qui ne concerne que le fonctionnement interne d'une fonction au sein de cette fonction, tout en vous permettant de séparer ce code pour la lisibilité ou la généralisation. Dans certaines implémentations, ils permettent également l'accès à la portée extérieure. D:

int doStuff() {
    int result;
    void cleanUpReturn() {
        myResource1.release();
        myResource2.release();
        return result * 2 + 1;
    }

    auto myResource1 = getSomeResource();
    auto myResource2 = getSomeOtherResource();
    if(someCondition) {
        return cleanUpReturn();
    } else {
        doSomeOtherStuff();
        return cleanUpReturn();
    }
}

Bien sûr, dans ce cas, cela pourrait aussi être manipulé avec RAII, mais il est juste un exemple simple.

Answer 6

Ils peuvent aussi être utiles si vous avez besoin de passer d'une fonction à une autre fonction comme argument. Ils peuvent aussi être utiles pour faire des fonctions d'usine pour les fonctions d'usine (en Python):

>>> def GetIntMaker(x):
...   def GetInt():
...     return x
...   return GetInt
... 
>>> GetInt = GetIntMaker(1)
>>> GetInt()
1

Answer 7

Une fonction imbriquée est simplement une fonction définie dans le corps d'une autre fonction. Pourquoi? La seule raison pour laquelle je pouvais penser à du haut de ma tête est une fonction d'aide ou d'utilité.

Ceci est un exemple artificiel, mais l'ours avec moi. Disons que vous avez eu une fonction qui devait agir sur les résultats de deux requêtes et remplir un objet avec des valeurs de l'une des requêtes. Vous pouvez faire quelque chose comme ce qui suit.

function process(qryResult q1, qryResult q2) {

   object o;
   if (q1.someprop == "useme") {
       o.prop1 = q1.prop1;
       o.prop2 = q1.prop2;
       o.prop3 = q1.prop3;
   } else if (q2.someprop == "useme") {
       o.prop1 = q2.prop1;
       o.prop2 = q2.prop2;
       o.prop3 = q2.prop3;
   }

   return o;

}

Si vous aviez 20 propriétés, vous dupliquez le code pour définir l'objet encore et conduisant à une grande fonction. Vous pouvez ajouter une fonction simple imbriquée pour la copie des propriétés de la requête à l'objet. Comme ceci:

function process(qryResult q1, qryResult q2) {

   object o;
   if (q1.someprop == "useme") {
       fillObject(o,q1);
   } else if (q2.someprop == "useme") {
       fillObject(o,q2);
   }

   return o;

   function fillObject(object o, qryResult q) {
       o.prop1 = q.prop1;
       o.prop2 = q.prop2;
       o.prop3 = q.prop3;
   }


}

Il garde les choses un peu plus propre. At-il d'être une fonction imbriquée? Non, mais vous pouvez le faire de cette façon si la fonction de processus est le seul qui aurait à faire cette copie.