javascript - quel est le but de déclarer une variable une fonction en premier? (Déclarant deux fois variable)

Question

Voici le code que je l'ai rencontré:

var c = function() {}, 
     c = { 
      autoSelectFirst: !1, 
      appendTo: "body", 
      serviceUrl: null, 
      lookup: null, 
      .. etc.. 
      lookupFilter: function(a, b, c) { 
       return -1 !== a.value.toLowerCase().indexOf(c) 
      }, 
      .. etc.. 
     }; 

Pourquoi c d'abord déclaré comme une fonction vide puis re-déclarée comme un objet? Cela ne remplace-t-il pas simplement la déclaration de fonction? Je suppose que c'est une construction JS fondamentale.

Answer 1

Sur la base de cet exemple de code de la question initiale:

var c = function() {}, 
    c = { 
     autoSelectFirst: !1, 
     appendTo: "body", 
     serviceUrl: null, 
     lookup: null, 
     .. etc.. 
     lookupFilter: function(a, b, c) { 
      return -1 !== a.value.toLowerCase().indexOf(c) 
     }, 
     .. etc.. 
    }; 

La partie c = function() {}, dans le code qui est inclus dans votre question n'a pas de point. Il est comme faire:

var x = 1, x = 3; 

Il n'y a aucun point à attribuer une valeur à la variable puis attribuer immédiatement une autre valeur.

Le code que vous montrez générerait exactement le même résultat (avec moins de confusion) comme ceci:

var c = { 
     autoSelectFirst: !1, 
     appendTo: "body", 
     serviceUrl: null, 
     lookup: null, 
     .. etc.. 
     lookupFilter: function(a, b, c) { 
      return -1 !== a.value.toLowerCase().indexOf(c) 
     }, 
     .. etc.. 
    }; 

Sur la base des commentaires pour savoir où ce code a été trouvé, il semble que cela fait partie d'un certain code automatique processus de génération ou de minimisation.

FYI, Javascript n'utilise pas l'expression "tableau associatif". La deuxième déclaration est un objet Javascript.

Answer 2

J'ai trouvé le fichier en question en ligne, et il se trouve qu'il y a une bonne raison à cela. Tout d'abord, il convient de noter que le code dans la question provient d'une source minifiée qui a été indentée.

est ici un morceau de code:

var c=function(){},c={autoSelectFirst:!1,appendTo:"body",serviceUrl:null,lookup:null, 
onSelect:null,width:"auto",minChars:1,maxHeight:300,deferRequestBy:0,params:{}, 
formatResult:g.formatResult,delimiter:null,zIndex:9999,type:"GET",noCache:!1, 
onSearchStart:c,onSearchComplete:c,onSearchError:c, 
// -----------^------------------^---------------^ 

Donc, c'est le code dans la question, mais un peu plus. La chose importante à noter est que la variable c est utilisée dans la création de l'objet littéral, avec onSearchStart:c,onSearchComplete:c,onSearchError:c,.

Quelle est la valeur c affectant dans l'objet? Parce que l'objet est encore en cours de création, cela signifie que c fait toujours référence à la fonction, donc des propriétés comme onSearchStart, qui semblent être des gestionnaires d'événements obtiennent la fonction vide par défaut.

Cela a beaucoup plus de sens.

Pour vérifier, j'ai également trouvé la source originale, non-vérifiée. Voici le code correspondant:

// v---originally it's called `noop` 
var noop = function() { }, 
    that = this, 
    defaults = { 
     autoSelectFirst: false, 
     appendTo: 'body', 
     serviceUrl: null, 
     lookup: null, 
     onSelect: null, 
     width: 'auto', 
     minChars: 1, 
     maxHeight: 300, 
     deferRequestBy: 0, 
     params: {}, 
     formatResult: YithAutocomplete.formatResult, 
     delimiter: null, 
     zIndex: 9999, 
     type: 'GET', 
     noCache: false, 
     onSearchStart: noop, // <---here it's being used 
     onSearchComplete: noop, // <---here it's being used 
     onSearchError: noop, // <---here it's being used 

Il est donc clair maintenant que le noop, qui représente généralement sans opération, a son propre nom et est en effet utilisé dans l'objet créé juste en dessous. En outre, c'est le seulement lieu noop est utilisé dans le fichier entier. Donc apparemment le minifier était assez intelligent pour voir que la variable initialement appelée noop n'allait plus être utilisée, donc il était libre de réutiliser ce nom de variable pour l'objet.Un peu impressionnant d'analyse de code, IMO.