Spiegare questa confusa sintassi tutorial del dojo per la dichiarazione

Question

Sto leggendo la sintassi per l'utilizzo di dojo's declare per la creazione della classe. La descrizione è confusa:

The declare function is defined in the dojo/_base/declare module. declare accepts three arguments: className, superClass, and properties. 
ClassName 

The className argument represents the name of the class, including the namespace, to be created. Named classes are placed within the global scope. The className can also represent the inheritance chain via the namespace. 
Named Class 

// Create a new class named "mynamespace.MyClass" 
declare("mynamespace.MyClass", null, { 

    // Custom properties and methods here 

}); 

A class named mynamespace.MyClass is now globally available within the application. 

Named classes should only be created if they will be used with the Dojo parser. All other classes should omit the className parameter. 
"Anonymous" Class 

// Create a scoped, anonymous class 
var MyClass = declare(null, { 

    // Custom properties and methods here 

}); 

The MyClass is now only available within its given scope. 
SuperClass(es) 

The SuperClass argument can be null, one existing class, or an array of existing classes. If a new class inherits from more than one class, the first class in the list will be the base prototype, the rest will be considered "mixins". 
Class with No Inheritance 

var MyClass = declare(null, { 

    // Custom properties and methods here 

}); 

null signifies that this class has no classes to inherit from. 
Class Inheriting from Another Class 

var MySubClass = declare(MyClass, { 

    // MySubClass now has all of MyClass's properties and methods 
    // These properties and methods override parent's 

}); 

La sintassi è esattamente lo stesso per la creazione di una classe non di nome e una classe senza superclasse:

var MyClass = declare(null, { 
    // Custom properties and methods here 
}); 

mi aspetto la sintassi per una classe senza super classe e senza alcun nome per essere come questo:

var MyClass = declare(null, null, { 
    // Custom properties and methods here 
}); 

io vengo da un background linguaggio tipizzato, quindi forse ho frainteso come funziona in JavaScript. Non riesco a capire come qualcuno che legge il codice (senza commenti) possa conoscere la differenza tra i due, se la sintassi delle esercitazioni è corretta.

mi sarei aspettato la sintassi di essere qualcosa di simile:

/*class without a name:*/ declare(null, SuperClass, {}) 

/*class without a name or super class:*/ declare(null, null, {}) 

/*class with a name but no super class:*/ declare("ClassName", null, {}) 

Forse questo è prolisso, ma almeno è facile dire che cosa ogni parametro è per.

Answer 1

Beh, lo considerano un costruttore di overload:

// class with a name 
declare(className: String, superClass: Array, classDeclaration: Object); 

// class without a name 
declare(superClass: Array, classDeclaration: Object); 

utilizzare un array vuoto [] o null per nessun superClass.

N.B .: A partire da Dojo 1.8, non è necessario per le classi denominate, perché dojo/parser può utilizzare un id di modulo (mid, ad esempio "mynamespace/MyClass") per l'istanziazione. Considero le classi nominate obsolete e contro la manutenibilità del codice.