Pourquoi dit-on que xxx n'est pas une fonction

Question

pourquoi est-ce pas ok?

aContract = function(){}; 
aContract.prototype = { 
    someFunction: function() { 
     alert('yo'); 
    }, 
    someOtherFunction: some$Other$Function 
}; 

var some$Other$Function = function() { 
    alert('Yo yo yo'); 
}; 

var c = new aContract(); 
c.someFunction(); 
c.someOtherFunction(); 

Firebug dit c.someOtherFunction est pas une fonction

Mais cela fonctionne très bien

aContract = function(){}; 
aContract.prototype = { 
    someFunction: function() { 
     alert('yo'); 
    }, 
    someOtherFunction: some$Other$Function 
}; 

function some$Other$Function() { 
    alert('Yo yo yo'); 
}; 

var c = new aContract(); 
c.someFunction(); 
c.someOtherFunction(); 

Qu'est-ce que je manque ici ??? Je préfère coder en javascript en utilisant la première méthode, qui fonctionne généralement bien, mais ne semble pas fonctionner correctement lorsque je prototype.

Merci, ~ ck Sandy Eggo

Answer 1

Vous avez attribué some$Other$Function à aContract.prototype.someOtherFunction avant de créer réellement some$Other$Function. L'ordre des déclarations est important. Si vous passez l'ordre des choses que vous serez bien:

var some$Other$Function = function() { 
    alert('Yo yo yo'); 
}; 

aContract = function(){}; 
aContract.prototype = { 
    someFunction: function() { 
     alert('yo'); 
    }, 
    someOtherFunction: some$Other$Function 
}; 

Answer 2

Au moment où cette évaluation est:

aContract.prototype = { ... } 

cela n'a pas encore été évalué:

var some$Other$Function = function() { ... } 

Ainsi aContract.prototype.someOtherFunction est défini sur undefined.

La raison pour laquelle la seconde fonctionne est parce que la fonction déclarations (dont le second est, le premier est une expression) sont évalués avant toute autre déclaration. Il y a plus de détails ici: Named function expressions demystified

Answer 3

Il semble que, dans la portée globale, var fonctionne différemment que dans les étendues de fonctions locales. Dans les étendues fonction-locales, les variables déclarées var sont levées en haut de la fonction (c'est-à-dire que toute variable déclarée n'importe où dans une fonction avec le mot-clé var est disponible ailleurs dans cette fonction). Mais dans la portée globale, seule l'utilisation du mot-clé function pour déclarer une variable donne le même résultat (c'est-à-dire qu'une variable déclarée avec le mot clé function sera disponible n'importe où dans cette portée globale, même dans les lignes précédant cette déclaration).

Answer 4

Cela est dû au levage. Les instructions de fonction sont déplacées vers le haut de leur portée.

Edit: JavaScript de vérification Crockford: La page Good Parts 113.