Préface
Les avantages des bonnes habitudes d'écriture JavaScript sont évidents. Aujourd'hui, Bin Go recommande des spécifications de programmation JavaScript Dojo, qui sont de très bonnes spécifications de style de programmation JavaScript. Il est recommandé d'apprendre de cette spécification pour écrire JavaScript. Merci à I.FelingLucky pour la traduction.
séquence
Toute violence à ce guide est autorisée si elle améliore la lisibilité.
Tous les codes doivent être facilités à lire les autres.
Référence de lecture rapide
API de base Veuillez utiliser le style suivant:
| structure | règle | Commentaires |
| Module | inférieur inférieur | N'utilisez pas plusieurs sémantiques (jamais plusieurs mots) |
| gentil | chameau | |
| Méthodes publiques | mélanger | D'autres appels externes peuvent également utiliser Lower_Case (), dans ce style |
| Variables publiques | mélanger | |
| constante | Chameau ou capital |
Bien que ce qui suit ne soit pas nécessaire, il est recommandé d'utiliser:
| structure | règle |
| Méthode privée | Mixte, exemple: _MixedCase |
| Variables privées | Mixte, exemple: _MixedCase |
| Paramètres de la méthode | Mixte, exemple: _MixedCase, mixtescase |
| Variable locale | Mixte, exemple: _MixedCase, mixtescase |
Spécifications de dénomination
1. Le nom de la variable doit être des lettres minuscules.
2. La dénomination des classes utilise des règles de dénomination de chameau, telles que:
Compte, EventHandler
3. Les constantes doivent être déclarées à l'avant d'un objet (classe) ou d'une variable d'énumération. La dénomination d'une variable d'énumération doit avoir une signification pratique et ses membres doivent utiliser des règles de dénomination de chameau ou capitaliser:
La copie de code est la suivante:
var nodetypes = {
Élément: 1,
Document: 2
}
4. Les mots abrégés ne peuvent pas utiliser les noms de capital comme noms de variables:
getInnerHtml (), getxml (), xmldocument
5. La commande de la méthode doit être un verbe ou une phrase verbale:
obj.getsomeValue ()
6. La dénomination des classes publiques doit être nommée en utilisant des noms mixtes (mixtes).
7. Le nom d'une variable CSS doit utiliser sa même variable de classe publique correspondante.
8. Les membres d'attribut variable de la classe privée doivent être nommés avec un nom mixte (mixtes) et souligné (_). Par exemple:
La copie de code est la suivante:
var myClass = function () {
var _buffer;
this.dosomething = function () {
};
}
9. Si la variable est définie sur privé, elle doit être soulignée à elle.
this._someprivatevariable = instruction;
10. Les variables communes doivent utiliser un nom de type cohérent avec leur nom:
Settopic (sujet) // La rubrique variable est une variable de type
11. Tous les noms de variables doivent utiliser les noms anglais.
12. Si une variable a une large portée (grande portée), les variables globales doivent être utilisées; À l'heure actuelle, il peut être conçu comme des membres d'une classe. Si la portée relative est des variables plus petites ou privées, utilisez des mots concis pour le nommer.
13. Si une variable a sa valeur de retour implicite, évitez d'utiliser ses méthodes similaires:
Gethandler (); // Évitez d'utiliser GetEventHandler ()
14. Les variables publiques doivent clairement exprimer leurs propres attributs pour éviter l'ambiguïté dans le sens, comme:
Mousevent-handler
, pas mseevthdlr.
Veuillez faire attention à cette disposition à nouveau, les avantages de le faire sont très évidents. Il peut clairement exprimer la signification définie par l'expression. Par exemple:
dojo.events.mouse.handler // au lieu de dojo.events.mouse.mouseventhandler
15. Les classes / constructeurs peuvent être nommés en utilisant le nom qui étend sa classe de base, afin que le nom de sa classe de base puisse être trouvé correctement et rapidement:
Event-Handler
Uiecenthandler
Mousevent-handler
La classe de base peut réduire sa dénomination tout en décrivant clairement ses propriétés:
Mouseventhandler par opposition à MouseiEventHandler.
Spécifications de dénomination spéciales
Le terme "get / set" ne doit pas être lié à un champ à moins qu'il ne soit défini comme une variable privée.
Le nom de variable précédé de "est" devrait être une valeur booléenne et peut être "a", "can" ou "devrait".
Le terme "calcul" comme nom de variable doit être une variable qui a été calculée.
Le terme «trouver» comme nom de variable doit être une variable qui a été trouvée terminée.
Le terme "initialiser" ou "init" comme nom de variable doit être une classe ou un autre type de variable qui a été instancié (initialisé).
Les variables de contrôle de l'interface utilisateur (interface utilisateur) doivent être suivies du nom du type de contrôle, par exemple: LeftComboBOx, TopScrollPane.
Le numéro pluriel doit avoir sa convention de nom commun (Texte d'origine: Le formulaire pluriel doit être utilisé pour nommer des collections).
Les noms de variables commençant par "num" ou "count" sont conventionnellement numériques (objet).
Des variables de répétition sont recommandées d'utiliser des variables avec des noms tels que "i", "j", "k" (et ainsi de suite).
Les termes supplémentaires doivent utiliser des mots supplémentaires, tels que: obtenir / définir, ajouter / supprimer, créer / détruire, démarrer / arrêter, insérer / supprimer, commencer / fin, etc.
Essayez d'utiliser l'abréviation si possible.
Évitez l'ambiguïté des noms de variables booléennes, par exemple:
Isptherror, Isnotfound est illégal
La classe d'erreur recommande d'ajouter "Exception" ou "Erreur" au nom de la variable.
Si une méthode renvoie une classe, elle doit indiquer ce qu'elle revient sur son nom; S'il s'agit d'un processus, cela devrait indiquer ce qu'il a fait.
document
Veuillez utiliser 4 onglets vierges pour acquérir.
Si votre éditeur prend en charge les balises de fichier, veuillez ajouter la ligne suivante pour rendre notre code plus facile à lire:
// vim: ts = 4: noet: tw = 0:
Note du traducteur: les étrangers utilisent plus souvent les éditeurs VIM, vous pouvez donc choisir de suivre cet article.
Le pliage du code doit être fait et être logique:
La copie de code est la suivante:
var someexpression = expression1
+ Expression2
+ Expression3;
var o = someObject.get (
Expression1,
Expression2,
Expression3
));
Remarque: L'indentation de l'expression doit être cohérente avec la déclaration variable.
Remarque: Les paramètres de la fonction doivent être explicitement en retrait et les règles d'indentation sont cohérentes avec d'autres blocs.
variable
mise en page
morceau
Un extrait de code normal devrait ressembler à ceci:
La copie de code est la suivante:
tandis que (! Isdone) {
Dosomething ();
isdone = moretodo ();
}
La déclaration IF devrait ressembler à ceci:
La copie de code est la suivante:
if (Somecondition) {
déclarations;
} else if (someothercondition) {
déclarations;
} autre {
déclarations;
}
La déclaration For devrait ressembler à ceci:
La copie de code est la suivante:
pour (initialisation; condition; mise à jour) {
déclarations;
}
La déclaration while devrait ressembler à ceci:
La copie de code est la suivante:
tandis que (! Isdone) {
Dosomething ();
isdone = moretodo ();
}
Le DO… La déclaration de temps devrait ressembler à ceci:
La copie de code est la suivante:
faire {
déclarations;
} while (condition);
L'instruction Switch devrait ressembler à ceci:
La copie de code est la suivante:
commutateur (condition) {
Case ABC:
déclarations;
// tombe
Case Def:
déclarations;
casser;
défaut:
déclarations;
casser;
}
L'essai… la déclaration de catch devrait ressembler à ceci:
La copie de code est la suivante:
essayer {
déclarations;
} catch (ex) {
déclarations;
} enfin {
déclarations;
}
SIME-LINE Si autre, tandis que ou pour les déclarations doit également être incluse entre parenthèses, mais ils peuvent être écrits comme ceci:
if (condition) {instruction; }
while (condition) {instruction; }
for (Intialization; condition; update) {instruction; }
vide
Commentaires
document
Ce qui suit fournit quelques fonctions ou objets de base Méthodes Description:
Résumé: Une brève description du but de cette fonction ou de la mise en œuvre d'objets
Description: Une brève description de cette fonction ou classe
Retour: décrit ce que cette fonction renvoie (sans inclure le type de retour)
Informations sur la fonction de base
La copie de code est la suivante:
fonction(){
// Résumé: Bientôt, nous aurons suffisamment de trésors pour gouverner tout le New Jersey.
// Description: Ou nous pourrions simplement obtenir un nouveau colocataire.
// Regardez, vous allez le trouver. Il ne vous crie pas dessus.
// Tout ce que j'essaye de faire, c'est le faire sourire et chanter
// lui et danse autour de lui et il me pose juste.
// Il m'a dit de monter dans le congélateur parce qu'il y avait un carnaval là-dedans.
// retourne: Regardez, une bande de bananarama!
}
Informations sur la fonction d'objet
Aucune description de valeur de retour
La copie de code est la suivante:
{
// Résumé: Dingle, engagez la machine arc-en-ciel!
// description:
// vous dire quoi, j'aurais aimé être - oh mon g - ce faisceau,
// À venir comme ça, la vitesse, vous voudrez peut-être ajuster cela.
// Il a vraiment fait un numéro sur mon dos, là. Je veux dire, et je ne le fais pas
// Je veux dire un coup de fouetlash, encore, parce que c'est un peu trop loin,
// Mais, vous êtes blessé, non?
}
Déclaration des fonctions
Dans certains cas, l'appel et la déclaration des fonctions sont invisibles. Dans ce cas, nous n'avons aucun moyen d'inclure des instructions, etc. (pour les appels de programme) dans la fonction. Si vous rencontrez cette situation, vous pouvez utiliser une classe pour résumer la fonction.
Remarque: Cette méthode ne peut être utilisée que sans paramètres initialisés de la fonction. Sinon, ils seront ignorés.
La copie de code est la suivante:
dojo.declare (
"Foo",
nul,
{
// Résumé: Ouf, c'est sûr relaxant, frylock.
// description:
// il y a des milliers d'années, avant l'aube de
// homme comme nous le connaissions, il y avait Sir Santa de Claus: An
// créativité en forme de singe fabriquant des jouets grossiers et inutiles
// de dino-os, les lançant à une créativité en forme de chimpanzé avec
// les mains froissées, quelle que soit la façon dont ils se comportaient
// l'année précédente.
// retourne: sauf si Carl paie des frais aux anciens de l'Elfin dans l'espace.
}
));
<h3> Paramètres </h3>
<l>
<li> Type simple
Les types simples de paramètres peuvent être directement commentés et expliqués dans la définition du paramètre de fonction.
[cc lang = "javascript"] fonction (/ * string * / foo, / * int * / bar) ...
Paramètres de type variable
Voici quelques modificateurs à référence:
? Paramètres facultatifs
... La plage de paramètres du visage est incertaine
Tableau
fonction (/ * string? * / foo, /*int...*/ bar, / * String [] * / baz) ...
Description du paramètre global
Si vous souhaitez ajouter une description, vous pouvez les déplacer vers le bloc d'initialisation.
Le format d'information de base est: * Clé * Champ de description (* clé * phrase description)
Le format de paramètres et de variables est: * clé * ~ * type * ~ champ de description (* clé * ~ * type * ~ phrase description)
Remarque: * Mots-clés * et ~ * type * ~ peut être exprimé dans n'importe quelle lettre et nombres.
La copie de code est la suivante:
fonction (foo, bar) {
// foo: chaîne
// utilisé pour être le premier paramètre
// bar: int
// utilisé pour être le deuxième paramètre
}
variable
Étant donné que les déclarations de variables d'instance, les variables prototypes et les variables externes sont cohérentes, il existe de nombreuses méthodes pour déclarer et modifier les variables. La définition et le positionnement spécifiques doivent indiquer le nom, le type, la portée et d'autres informations de la variable au premier emplacement où la variable apparaît.
La copie de code est la suivante:
fonction foo () {
// mystring: chaîne
// fois: int
// Combien de fois imprimer MyString
// séparateur: chaîne
// quoi imprimer entre MyString *
this.mystring = "texte de placeholder";
this.Times = 5;
}
foo.prototype.setstring = function (mystring) {
this.mystring = mystring;
}
foo.prototype.toString = function () {
for (int i = 0; i <this.Times; i ++) {
dojo.debug (this.mystring);
dojo.debug (foo.separator);
}
}
foo.separator = "=====";
Commentaires variables dans les objets
Une méthode d'annotation cohérente avec les valeurs et les méthodes des objets doit être utilisée, comme lorsqu'ils déclarent:
La copie de code est la suivante:
{
// clé: chaîne
// une valeur simple
clé: "valeur",
// key2: chaîne
// une autre valeur simple
}
Valeur de retour
Étant donné que les fonctions peuvent renvoyer plusieurs valeurs différentes (types) en même temps, chaque valeur de retour doit être ajoutée au commentaire du type de retour. Les commentaires sont commentés dans la ligne. Si toutes les valeurs de retour sont du même type, le type renvoyé est spécifié; S'il existe plusieurs valeurs de retour différentes, le type de retour est marqué comme "mixte".
La copie de code est la suivante:
fonction() {
if (arguments.length) {
Renvoie "vous avez passé des arguments"; // Chaîne
} autre {
retourne false; // boolean
}
}
Pseudocode (à discuter)
Parfois, vous devez ajouter une description de processus fonctionnelle pour cette fonction et cette classe dans une fonction ou une classe. Si vous prévoyez de le faire, vous pouvez utiliser / * ======= (= les caractères doivent apparaître 5 fois ou plus). L'avantage est que vous n'avez pas à ajouter ces choses au code (Note du traducteur: L'auteur d'origine peut signifier un système de gestion de code).
De cette façon, il y aura un très long commentaire dans / * ===== et ==== * /. Vous pouvez envisager de le supprimer après l'ajustement de la fonction.
La copie de code est la suivante:
/ * =======
module.pseudo.kwargs = {
// URL: chaîne
// l'emplacement du fichier
URL: "",
// mimeType: chaîne
// texte / html, texte / xml, etc.
mimeType: ""
}
===== * /
function (/ * module.pseudo.kwargs * / kwargs) {
dojo.debug (kwargs.url);
dojo.debug (kwargs.mimetype);
}
Lien original: http://dojotoolkit.org/developer/styleguide
Traduit par: i.felingLucky {at} gmail.com de http://www.gracecode.com