Redéfinition de la fonction JavaScript

Est-il possible de redéfinir une fonction JavaScript à partir de l'intérieur de son propre corps. Par exemple, je pourrais faire par la suite?

function never_called_again(args) {
  //Do some stuff
  never_called_again = function (new_args) {
    //Do some new stuff
  }
}

Est ci-dessus et valide-t-elle la sémantique correcte? Je ne veux pas créer une nouvelle variable globale avec l'ancien nom de la fonction, parce que je suis en train de faire ce genre de chose n'est pas dans la portée globale, mais à partir de divers objets étendues, et je ne veux pas les collisions de noms quand j'ai redéfinir la fonction à l'intérieur de ces domaines locaux.

source d'informationauteur davidk01

javascript

Oui, vous pouvez redéfinir une fonction de cette façon.

function never_called_again(args) {
    console.log('Func 1', args);

    never_called_again = function (new_args, x) {
        console.log('Func 2', new_args, x);
    }
}

never_called_again('arg A', 'arg B');

never_called_again('arg A', 'arg B');

Rendements ceci:

Func 1 arg A
Func 2 arg A arg B

40

Il est en effet possible de redéfinir une fonction à partir de son corps. La technique est utilisée dans le soi-disant Paresseux Définition De La Fonction Du Motif.

Il ressemble à ceci:
```
//Lazy Function Definition Pattern
var foo = function() {
    var t = new Date();
    foo = function() {
        return t;
    };
    return foo();
}
```
Cette fonction stocke la Date du premier appel, et renvoie cette Date par la suite.

Si vous comparer ce avec la motif de modulela différence est que l'initialisation ne se produit que quand il est d'abord appelé, pas quand elle est définie. Pour coûteux initialisations il peut être un énorme bénéficier.
```
//Conditional Module Pattern
var foo = (function() {
    var t;
    return function() {
        if (t) {
            return t;
        }
        t = new Date();
        return t;
    }
})();
```

C'est tout à fait possible de redéfinir un objet de fonction dans tout ce que vous voulez dès le premier appel.

La raison pour cela est possible parce que la cession des évaluations est gérée à partir de la droite vers la gauche. Cela signifie que la portée de la fonction est capturé lors de l'exécution de celui-ci (dans ce cas, lorsque vous appelez la fonction).

Cela signifie que, au moment de l'exécution, la fonction de l'objet qui est exécutée et l'original de la définition de fonction sont en fait deux choses différentes, ce qui permet à la redéfinition de la fonction d'origine comme, eh bien... rien.

L'un des meilleurs (et des plus cool) façons de les utiliser, c'est par la création d'une fonction qui est, par essence, de sa propre usine. De cette façon, vous n'avez pas à effectuer autour d'un grand nombre de définitions d'objets qui ne sont pas va être utilisé.

Exemple:

d = function(type){
    switch(type.toUpperCase()){
        case 'A' :
            d = (
                    function(){
                        return {
                            name : 'A',
                            getName : function(){return this.name;}
                        };
                    }
                )();
                break;

        case 'B' :
            d = (
                function(){
                    return {
                        name : 'B',
                        getName : function(){return this.name;}
                    };
                }
            )();
            break;

        default:
            d = (
                function(){
                    return {
                        name : 'DEFAULT',
                        getName : function(){return this.name;}
                    };
                }
            )();
            break;
    }
};

console.dir(d);
d('A');
console.dir(d);
console.log(d.getName());

Votre exemple de base est le même:

var never_called_again = function(args) {
     //do some stuff
     never_called_again = function (new_args) {
      //do some new stuff
     }
}

Puisque vous savez sans doute que cela fonctionne:

var a = 1;

function myFunction() {
     //do some stuff
     a = 2;
}

myFunction();

alert(a) //==> 2

il est clair que le premier exemple fonctionne aussi.

Si vous avez réellement voulez pour ce faire ou pas est plus question ouverte. Il va les rendre le code plus difficile à comprendre?

Oui, c'est possible, et il ne va pas créer une fonction globale. J'ai vérifié cela dans Internet Explorer 6, Firefox, Chrome, et Opéra.
Considérons le code suivant:

  <head>
     <title>Never called again</title>
     <style type="text/css">
     </style>

     <script type="text/javascript">

          function hello()   {
             function never_called_again(args) {
                alert("Hello world " + never_called_again);
                //do some stuff
                never_called_again = function (new_args) {
                    //do some new stuff
                    alert("hello " + never_called_again);
                }
             }
             never_called_again();
             never_called_again();

          }

      </script>

  </head>
  <body onload="">

     <button onclick="hello(); never_called_again();">Call</button>
  </body>

Cela print "Hello World {code de la fonction}" la première fois de la never_called_again et la deuxième fois, il affichera "bonjour {changé de code de la fonction}" la deuxième fois.

Mais quand on l'appelle sur le onclick du bouton, il renvoie une erreur indiquant que la fonction n'est pas définie, ce qui indique clairement que la fonction a été ré-défini (et non pas créé à l'échelle mondiale).

1

À proprement parler, non, il n'est pas possible de redéfinir une fonction JavaScript. Si c'est un peu une question de sémantique.

Une fonction peut remplacer sa référence, dans certaines limites, avec un autre fonction, qui sert comme un tour de main, où une autre fonction s'affiche à la place de la première. par exemple,
```
greet_once = function() {
  console.log('Hello.');
  greet_once = function() { console.log('Can I help you?') };
};
```
De même, une fonction peut utiliser l'état d'un closured portée à se comporter différemment la deuxième fois de son nom (évidemment pas de "redéfinition").

L'exemple suivant illustre pourquoi le schéma ci-dessus n'est pas redéfinition, car il dépend de la portée parent qui ne peut être partagée avec le contexte appelant.
```
greet_always = function() {
  greet_once = function() {
    console.log('Hello.')
    greet_once = function() { console.log('Can I help you?') }
  };
  return greet_once()
}()

greet_always()
greet_always()
```
La fonction appelée comme greet_always (qui imprime toujours "Bonjour") est le même, attribué à l'origine à greet_once.

Le plus proche je crois que vous pouvez obtenir à la redéfinition d'une fonction est de réaffecter ses appliquent et l'appel de méthodes, ce qui produit un scénario où myFunction.call() est différente de myFunction()ce qui est étrange, mais éventuellement utile.

Vous devez vous connecter pour publier un commentaire.