Der Stil, den Sie für Ihr Projekt auswählen, sollte das höchste Kriterium sein. Stellen Sie es als Beschreibung in Ihrem Projekt ein und verknüpfen Sie es mit diesem Dokument als Garantie für Konsistenz, Lesbarkeit und Wartbarkeit von Codestilen.
1. leer
1. Mischen Sie niemals Räume und Registerkarten.
2. Starten Sie ein Projekt, wählen Sie Soft -Einklage (Speicherplatz) oder Registerkarte (als Einklingelmethode), bevor Sie den Code schreiben, und verwenden Sie ihn als höchstes Kriterium.
A). Für die Lesbarkeit empfehle ich immer, 2 -Buchstaben -Breiteneinzüge in Ihren Bearbeitungen zu entwerfen - dies entspricht zwei Leerzeichen oder zwei Leerzeichen anstelle einer Registerkarte.
3. Wenn Ihr Editor es unterstützt, schalten Sie immer die Einstellung "Unsichtbare Zeichen anzeigen" ein. Die Vorteile sind:
A). Konsistenz sicherstellen
B). Entfernen Sie die Räume am Ende der Linie
C). Leere Leerzeichen entfernen
D). Einreichung und Vergleich sind lesbarer
2. Verschönerung der Grammatik
A. Zahnspangen, Zahnspangen, Linienbrüche
Die Codekopie lautet wie folgt:
// if/else/for/whit/try hat normalerweise Zahnspangen, lockige Zahnspangen und mehrere Linien
// Dies hilft lesbar
// 2.a.1.1
// Beispiel für eine schwierige Syntax
if (Zustand) dosomething ();
während (Bedingung) iteriert ++;
für (var i = 0; i <100; i ++) einigeIterativefn ();
// 2.a.1.1
// Nutze Räume verwenden, um die Lesbarkeit zu verbessern
if (Zustand) {
// Stellungnahme
}
while (Bedingung) {
// Stellungnahme
}
für (var i = 0; i <100; i ++) {
// Stellungnahme
}
// Bessere Übung:
var i,
Länge = 100;
für (i = 0; i <länge; i ++) {
// Stellungnahme
}
// oder...
var i = 0,
Länge = 100;
für (; i <länge; i ++) {
// Stellungnahme
}
var prop;
für (Prop im Objekt) {
// Stellungnahme
}
if (wahr) {
// Stellungnahme
} anders {
// Stellungnahme
}
B. Zuweisen, Deklaration, Funktion (benannte Funktionen, Funktionsausdrücke, Konstruktorfunktionen)
Die Codekopie lautet wie folgt:
// 2.b.1.1
// Variable
var foo = "bar",
num = 1,
UNDEF;
// wörtliche Identifizierung:
var array = [],
Object = {};
// 2.b.1.2
// Wenn Sie nur einen `var` innerhalb eines Bereichs (Funktion) verwenden, verbessert die Lesbarkeit
// und erstellen Sie Ihre Anweisungsliste ordentlich (sparen Sie auch ein paar Tastatur -Eingaben).
// nicht gut
var foo = "";
var bar = "";
var qux;
// Gut
var foo = "",
bar = "",
Quux;
// oder..
var // Kommentare zu diesen Variablen
foo = "",
bar = "",
Quux;
// 2.b.1.3
// Die `var` -Anweisung muss immer ganz oben in jedem Bereich (Funktion) stehen (Funktion)
// auch für Konstanten von ECMascript 6 geeignet
// nicht gut
Funktion foo () {
// Es gibt eine Anweisung vor der Variablen
var bar = "",
Qux;
}
// Gut
Funktion foo () {
var bar = "",
Qux;
// Alle Aussagen sind nach der Variablen
}
// 2.b.2.1
// Funktionsfunktionserklärung
Funktion foo (arg1, argn) {
}
// wie man benutzt
foo (arg1, argn);
// 2.b.2.2
// Funktionsfunktionserklärung
Funktion Square (Nummer) {
Rückgabenummer * Nummer;
}
// wie man benutzt
Quadrat (10);
// sehr unnatürliche Fortsetzung des Passstils
Funktion Square (Nummer, Rückruf) {
Rückruf (Nummer * Nummer);
}
Quadrat (10, Funktion (Quadrat) {
// Rückrufinhalt
});
// 2.b.2.3
// Funktionsausdruck
var square = function (number) {
// Wertvolle und relevante Inhalte zurückgeben
Rückgabenummer * Nummer;
};
// Funktionsausdruck mit Identifikator
// Dieses bevorzugte Formular verfügt über zusätzliche Funktionen, die es ihm ermöglichen, sich selbst anzurufen
// und es gibt eine Kennung im Stapel
var factorial = function factorial (number) {
if (Nummer <2) {
Rückkehr 1;
}
Rückgabenummer * faktorial (Nummer 1);
};
// 2.b.2.4
// Konstruktorenerklärung
Funktion foobar (Optionen) {
this.options = Optionen;
}
// wie man benutzt
var foobar = new foobar ({a: "alpha"});
foobar.options;
// {a: "alpha"}
C. Ausnahme, Details
Die Codekopie lautet wie folgt:
// 2.c.1.1
// Funktionen mit Rückrufen
foo (function () {
// Hinweis: Es gibt keine Leerzeichen in den Klammern und "Funktion" des ersten Funktionsaufrufs
});
// Die Funktion akzeptiert "Array" als Argument ohne Leerzeichen
foo (["Alpha", "Beta"]);
// 2.c.1.2
// Die Funktion akzeptiert "Objekt" als Argument ohne Leerzeichen
foo ({{
A: "Alpha",
B: "Beta"
});
// Die Funktion akzeptiert das "String" wörtlich als Argument, ohne Leerzeichen
Foo ("Bar");
// Es gibt keine Räume in den Klammern, die für die Gruppierung verwendet werden
if (! ("foo" in obj)) {
}
D. Konsistenz gewinnt immer
In den Abschnitten 2.a-2.c wird der leere Platz als Empfehlungsmethode vorgeschlagen, basierend auf einem einfachen, höheren Zweck: Vereinigung. Es ist erwähnenswert, dass die Formatierungspräferenzen wie "interner leerer Speicherplatz" optional sein müssen, aber es darf nur eine Art von Quellcode des gesamten Projekts geben.
Die Codekopie lautet wie folgt:
// 2.d.1.1
if (Zustand) {
// Stellungnahme
}
while (Bedingung) {
// Stellungnahme
}
für (var i = 0; i <100; i ++) {
// Stellungnahme
}
if (wahr) {
// Stellungnahme
} anders {
// Stellungnahme
}
E. Anführungszeichen
Es spielt keine Rolle, ob Sie einzelne oder doppelte Zitate wählen, sie machen keinen Parsingunterschied im JavaScript. Was unbedingt vorgeschrieben werden muss, ist die Konsistenz. Mischen Sie niemals zwei Zitate im selben Projekt, wählen Sie eine aus und halten Sie ihn konsistent.
F. Ende der Linie und leere Linie
Leere Verlassen wird den Unterschied durchbrechen und die Verwendung von Änderungen ist unlesbar. Erwägen Sie, einen vorkommenden Haken einzubeziehen, der am Ende der Linie und leeren Linien automatisch Leerzeichen löscht.
3. Typ Erkennung (von JQuery Core Style -Richtlinien)
A. Direkttyp (tatsächlicher Typ, tatsächlicher Typ)
String:
Die Codekopie lautet wie folgt:
typeof variable === "String"
Nummer:
Die Codekopie lautet wie folgt:
typeof variable === "Nummer"
Boolean:
Die Codekopie lautet wie folgt:
typeof variable === "boolean"
Objekt:
Die Codekopie lautet wie folgt:
typeof variable === "Objekt"
Array:
Die Codekopie lautet wie folgt:
Array.isArray (Array -LikeObject)
(Wenn möglich)
Knoten:
Die Codekopie lautet wie folgt:
Elem.nodetype === 1
NULL:
Die Codekopie lautet wie folgt:
variable === null
null oder undefiniert:
Die Codekopie lautet wie folgt:
variable == null
undefiniert:
Globale Variablen:
Die Codekopie lautet wie folgt:
typeof variable === "undefiniert"
Lokale Variablen:
Die Codekopie lautet wie folgt:
variable === undefiniert
Eigentum:
Die Codekopie lautet wie folgt:
Object.Prop === undefiniert
Object.hasownProperty (Prop)
"Prop" im Objekt
B. Typ konvertieren (erzwungener Typ, gezwungene Typen)
Betrachten Sie die Bedeutung der folgenden ...
Gegeben HTML:
Die Codekopie lautet wie folgt:
<Eingabe type = "text" id = "foo-input" value = "1">
// 3.b.1.1
// `foo` wurde ein Wert von` 0` zugewiesen, tippen Sie `number``
var foo = 0;
// typeof foo;
// "Nummer"
...
// Im nachfolgenden Code müssen Sie `foo` aktualisieren und einen neuen Wert zuweisen, der im Eingabeelement erhalten wird
foo = document.getElementById ("Foo-Input"). Wert;
// Wenn Sie jetzt `typeof foo` testen, wird das Ergebnis" String "sein
// Dies bedeutet, dass Sie bei der Erkennung von `foo` in der IF -Anweisung eine Logik haben:
if (foo === 1) {
wichtigTask ();
}
// `WORMENTASK ()` wird niemals ausgeführt, auch wenn "foo" einen Wert von "1" hat
// 3.b.1.2
// Sie können den +/- unären Operator geschickt verwenden, um den Typ zu werfen, um das Problem zu lösen:
foo = +document.getElementById ("Foo-Input"). Wert;
// ^ + Der Unary -Operator konvertiert das Betriebsobjekt nach rechts in "Nummer"
// typeof foo;
// "Nummer"
if (foo === 1) {
wichtigTask ();
}
// `wichtigTask ()` wird aufgerufen
Hier sind einige Beispiele für das Casting:
Die Codekopie lautet wie folgt:
// 3.b.2.1
var number = 1,,
String = "1",
bool = falsch;
Nummer;
// 1
Nummer + "";
// "1"
String;
// "1"
+String;
// 1
+String ++;
// 1
String;
// 2
bool;
// FALSCH
+bool;
// 0
bool + "";
// "FALSCH"
// 3.b.2.2
var number = 1,,
String = "1",
bool = wahr;
String === Zahl;
// FALSCH
String === Nummer + "";
// WAHR
+String === Zahl;
// WAHR
bool === Zahl;
// FALSCH
+bool === Zahl;
// WAHR
bool === String;
// FALSCH
bool === !! String;
// WAHR
// 3.b.2.3
var array = ["a", "b", "c"];
!! ~ Array.Indexof ("a");
// WAHR
!! ~ Array.Indexof ("B");
// WAHR
!! ~ Array.Indexof ("C");
// WAHR
!! ~ Array.Indexof ("D");
// FALSCH
// Es ist erwähnenswert, dass die oben genannten "unnötig klug" sind
// Verwenden Sie ein klares Schema, um die zurückgegebenen Werte zu vergleichen
// zum Beispiel indexof:
if (array.indexof ("a")> = 0) {
// ...
}
// 3.b.2.3
var num = 2,5;
ParseInt (num, 10);
// Äquivalent zu ...
~~ num;
Num >> 0;
Num >>> 0;
// Die Ergebnisse sind alle 2
// Denken Sie immer daran, dass negative Werte unterschiedlich behandelt werden ...
var neg = -2,5;
ParseInt (Neg, 10);
// Äquivalent zu ...
~~ neg;
neg >> 0;
// Die Ergebnisse sind alle -2
// Aber...
neg >>> 0;
// Das Ergebnis ist 4294967294
4. Vergleichende Operationen
Die Codekopie lautet wie folgt:
// 4.1.1
// Wenn nur ein Array eine Länge hat, relativ zu verwenden:
if (array.length> 0) ...
// ... Um die Echtheit zu bestimmen, verwenden Sie dies bitte:
if (array.length) ...
// 4.1.2
// Wenn nur beurteilt wird, ob ein Array leer ist, ist dies im Vergleich zur Verwendung:
if (array.length === 0) ...
// ... Um die Echtheit zu bestimmen, verwenden Sie dies bitte:
if (! array.length) ...
// 4.1.3
// Wenn nur beurteilt wird, ob eine Zeichenfolge leer ist, ist dies im Verhältnis zur Verwendung dieser:
if (String! == "") ...
// ... Um die Echtheit zu bestimmen, verwenden Sie dies bitte:
if (String) ...
// 4.1.4
// Wenn nur beurteilt wird, dass eine Zeichenfolge leer ist, ist dies im Vergleich zur Verwendung:
if (string === "") ...
// ... Um die Echtheit zu bestimmen, verwenden Sie dies bitte:
if (! String) ...
// 4.1.5
// Wenn nur beurteilt wird, dass eine Referenz wahr ist, relativ zu verwenden:
if (foo === true) ...
// ... urteilen Sie genau wie Sie denken, genießen Sie die Vorteile eingebauter Funktionen:
if (foo) ...
// 4.1.6
// Wenn nur beurteilt wird, dass eine Referenz falsch ist, ist dies im Vergleich zur Verwendung:
if (foo === false) ...
// ... konvertieren Sie es mit dem Ausrufezeichen in true
if (! foo) ...
// ... Es ist zu beachten, dass dies 0, "", Null, undefiniert, Nan übereinstimmen wird
// Wenn Sie _must_ ein boolescher Typ Falsch sind, verwenden Sie dies bitte:
if (foo === false) ...
// 4.1.7
// Wenn Sie eine Referenz berechnen möchten, kann sie null oder undefiniert sein, aber es ist nicht falsch, "" oder 0,.
// relativ zur Verwendung dieser:
if (foo === null || foo === undefiniert) ...
// ... genießen Sie die Vorteile von == Typ Casting wie folgt:
if (foo == null) ...
// Denken Sie daran, dass die Verwendung von == `null` übereinstimmen` null` und `undefined`
// aber nicht `false`," "oder 0
null == undefiniert
Beurteilen Sie immer die besten und genauen Werte, das obige ist eher ein Leitfaden als ein Dogma.
Die Codekopie lautet wie folgt:
// 4.2.1
// Anweisungen für Typumwandlungs- und Vergleichsvorgänge
// erstmals `===`, `==` befolgt (es sei denn, ein loser Typvergleich ist erforderlich)
// `===` tippt nicht immer die Konvertierung ein, was bedeutet:
"1" === 1;
// FALSCH
// `==` konvertiert den Typ, was bedeutet:
"1" == 1;
// WAHR
// 4.2.2
// boolean, true & fake
// boolean:
Richtig, falsch
// real:
"Foo", 1
// Pseudo:
"", 0, null, undefiniert, nan, void 0
5. Praktischer Stil
Die Codekopie lautet wie folgt:
// 5.1.1
// ein praktisches Modul
(Funktion (global) {
var module = (function () {
var data = "Secret";
zurückkehren {
// Dies ist ein boolescher Wert
bool: wahr,
// eine Zeichenfolge
String: "a String",
// ein Array
Array: [1, 2, 3, 4],
// ein Objekt
Objekt: {
Lang: "en-us"
},
getData: function () {
// Erhalten Sie den Wert von `Data`
Daten zurückgeben;
},
setData: function (value) {
// Gibt den zugewiesenen Wert von `Data` zurück
return (data = value);
}
};
}) ();
// Einige andere werden hier erscheinen
// Verwandeln Sie Ihr Modul in ein globales Objekt
global.module = modul;
})( Das );
// 5.2.1
// eine praktische Build -Funktion
(Funktion (global) {
Funktion ctor (foo) {
this.foo = foo;
gib dies zurück;
}
Ctor.prototype.getfoo = function () {
kehre diesen.foo zurück;
};
Ctor.prototype.setfoo = function (val) {
return (this.foo = val);
};
// Verwenden Sie nicht "new", um die Build -Funktion aufzurufen. Möglicherweise tun Sie dies:
var ctor = function (foo) {
Neue CTOR zurückgeben (Foo);
};
// Verwandeln Sie unsere Build -Funktion in ein globales Objekt
global.ctor = ctor;
})( Das );
6. Benennung
A. Sie sind kein menschlicher Compiler/Kompressor. Versuchen Sie also, sich in einen zu verwandeln.
Der folgende Code ist ein Beispiel für eine sehr schlechte Benennung:
Die Codekopie lautet wie folgt:
// 6.A.1.1
// schlechte Namenscode
Funktion q (s) {
return document.querySelectorall (en);
}
var i, a = [], els = q ("#foo");
für (i = 0; i <elsgth; i ++) {a.push (els [i]);}
Es besteht kein Zweifel, dass Sie einen solchen Code geschrieben haben - hoffe, er wird ab heute nicht wieder erscheinen.
Hier ist ein Code mit derselben Logik, jedoch mit einer robusteren, passenderen Benennung (und einer lesbaren Struktur):
Die Codekopie lautet wie folgt:
// 6.A.2.1
// Verbesserter benannter Beispielcode
Funktionsabfrage (Selector) {
return document.querySelectorAll (Selektor);
}
var idx = 0,,
Elemente = [],
Matches = Abfrage ("#foo"),
Länge = Übereinstimmungen.Length;
für (; idx <länge; idx ++) {
Elements.push (Übereinstimmung [IDX]);
}
Einige zusätzliche Namenstipps:
Die Codekopie lautet wie folgt:
// 6.A.3.1
// named String
"Hund" ist eine Schnur
// 6.A.3.2
// benennen Arrays
"[" Hunde "]" ist ein Array, das die "Hundeschnur" enthält
// 6.A.3.3
// Namensfunktionen, Objekte, Instanzen usw. Namen nennen.
Camlcase; Funktions- und VAR -Deklarationen
// 6.A.3.4
// Nennen Sie den Bauherr, den Prototyp usw.
Pascalcase; Aufbaufunktion
// 6.A.3.5
// reguläre Ausdrücke benennen
rdesc = //;
// 6.A.3.6
// vom Google Closure Library Style Guide
Funktionsnameslikethis;
varibenameslikethis;
Constructornameslikethis;
EnumnamesLikethis;
methodnameslikethis;
Symbolisch_constants_like_this;
B. stellen Sie sich dem
Zusätzlich zur Verwendung eines bekannten Aufrufs und der Anwendung wird .bind (this) oder ein funktionell entsprichtes, der ihm entspricht. Erstellen Sie eine Boundfunktionserklärung für nachfolgende Anrufe, wobei Alias verwendet wird, wenn keine bessere Option vorhanden ist.
Die Codekopie lautet wie folgt:
// 6.b.1
Funktionsgerät (opts) {
this.Value = null;
// Erstellen Sie einen neuen asynchronen Strom, dies wird kontinuierlich aufgerufen
Stream.read (opts.Path, Funktion (Daten) {
// Verwenden Sie Stream, um den neuesten Datenwert zurückzugeben und den Wert der Instanz zu aktualisieren
this.Value = Daten;
} .bind (this));
// steuern Sie die Häufigkeit des Ereignisauslösens
setInterval (function () {
// eine kontrollierte Veranstaltung veröffentlichen
this.emit ("Ereignis");
} .bind (this), opts.freq || 100);
}
// Angenommen, wir haben den Eventemitter geerbt;)
Wenn es nicht ausgeführt werden kann, ist das Äquivalent von .bind in den meisten modernen JavaScript -Bibliotheken erhältlich.
Die Codekopie lautet wie folgt:
// 6.b.2
// Beispiel: Lodash/Unterstrich, _.bind ()
Funktionsgerät (opts) {
this.Value = null;
Stream.read (opts.Path, _.bind (Funktion (Daten) {
this.Value = Daten;
}, Das) );
setInterval (_. Bind (function () {
this.emit ("Ereignis");
}, dies), opts.freq || 100);
}
// Beispiel: jQuery.proxy
Funktionsgerät (opts) {
this.Value = null;
stream.read (opts.path, jquery.proxy (function (data) {
this.Value = Daten;
}, Das) );
setInterval (jQuery.proxy (function () {
this.emit ("Ereignis");
}, dies), opts.freq || 100);
}
// Beispiel: dojo.hitch
Funktionsgerät (opts) {
this.Value = null;
stream.read (opts.path, dojo.hitch (this, function (data) {
this.Value = Daten;
}));
setInterval (dojo.hitch (this, function () {
this.emit ("Ereignis");
}), opts.freq || 100);
}
Stellen Sie einen Kandidaten für einen Alias dafür ein, mit dem Sie sich als Kenner selbst befinden. Dies hat sehr wahrscheinlich Fehler und sollte so weit wie möglich vermieden werden.
Die Codekopie lautet wie folgt:
// 6.b.3
Funktionsgerät (opts) {
var self = this;
this.Value = null;
Stream.read (opts.Path, Funktion (Daten) {
self.Value = Daten;
});
setInterval (function () {
self.emit ("event");
}, opts.freq || 100);
}
C. Verwenden Sie ThisArg
Mehrere Prototypmethoden in ES 5.1 haben ein spezielles Thisarg -Tag integriert. Verwenden Sie ihn so weit wie möglich
Die Codekopie lautet wie folgt:
// 6.c.1
var obj;
obj = {f: "foo", b: "bar", q: "qux"};
Object.Keys (OBJ) .foreach (Funktion (Schlüssel) {
// | this | Es ist jetzt `obj`
console.log (dieser [Schlüssel]);
}, obj); // <- Der letzte Parameter ist `thisarg`
// ausdrucken ...
// "foo"
// "Bar"
// "Qux"
ThisArg kann in Array.Prototype.Every, Array.Prototype.foreach, Array.Prototype.Some, Array.Prototype.map und Array.Prototype.filter verwendet werden.
7. Misc
Die Ideen und Ideen, die dieser Teil erklären wird, sind nicht dogmatisch. Stattdessen ist es mehr ermutigt, neugierig auf bestehende Praktiken zu sein, um zu versuchen, eine bessere Lösung für die Erfüllung allgemeiner JavaScript -Programmieraufgaben zu liefern.
A. Vermeiden Sie die Verwendung von Switch. Die moderne Methodenverfolgung fungiert Blacklist mit Switch -Ausdrücken.
Es scheint, dass sowohl Firefox als auch Chrome signifikante Verbesserungen für die Wechsel von Aussagen vorgenommen haben. http://jsperf.com/switch-vs-objekt-litereral-vs-module
Es ist erwähnenswert
Die Codekopie lautet wie folgt:
// 7.a.1.1
// Beispiel für Schalteranweisung
Switch (foo) {
Fall "Alpha":
Alpha();
brechen;
Fall "Beta":
Beta();
brechen;
Standard:
// Standardzweig
brechen;
}
// 7.a.1.2
// Eine Methode, die Kombination und Wiederverwendung unterstützen kann, besteht darin, ein Objekt zu verwenden, um "Fälle" zu speichern.
// Verwenden Sie eine Funktion, um die Delegation durchzuführen:
VAR -Fälle, Delegator;
// Der Rückgabewert dient nur zur Erklärung
Fälle = {{
Alpha: function () {
// Stellungnahme
// ein Rückgabewert
return ["alpha", argumente.length];
},
Beta: function () {
// Stellungnahme
// ein Rückgabewert
return ["Beta", Argumente.Length];
},
_Default: function () {
// Stellungnahme
// ein Rückgabewert
return ["Standard", Argumente.Length];
}
};
delegator = function () {
var args, key, delegieren;
// `argument` in ein Array konvertieren
args = [] .lice.call (Argumente);
// den letzten Wert aus "Argument" extrahieren
Key = args.shift ();
// Rufen Sie die Standardzweigs an
delegate = cases._default;
// die Methode aus dem Objekt delegieren
if (cases.hasownProperty (Schlüssel)) {
Delegate = Fälle [Schlüssel];
}
// Der Umfang von ARG kann auf einen bestimmten Wert eingestellt werden,
// In diesem Fall | NULL | ist in Ordnung
return delegate.apply (null, args);
};
// 7.a.1.3
// Verwenden Sie die API in 7.A.1.2:
Delegator ("Alpha", 1, 2, 3, 4, 5);
// ["Alpha", 5]
// Natürlich kann der Wert des `case' -Schlüssels leicht auf jeden Wert geändert werden
var Casertkey, ein Teilspot;
// Gibt es mögliche Eingaben von irgendeiner Form?
einigeuSerinput = 9;
if (einigeUserinput> 10) {
Casekey = "Alpha";
} anders {
Casekey = "Beta";
}
// oder...
Casekey = EinigeuSerinput> 10? "Alpha": "Beta";
// Dann...
Delegator (CASSKEY, einigeUserinput);
// ["Beta", 1]
// Natürlich kann das getan werden ...
Delegator ();
// ["Standard", 0]
B. Werte im Voraus zurücksenden, um die Lesbarkeit des Codes ohne viel Leistungsunterschied zu verbessern
Die Codekopie lautet wie folgt:
// 7.b.1.1
// nicht gut:
Funktion returnLate (foo) {
var ret;
if (foo) {
ret = "foo";
} anders {
ret = "quux";
}
Rückkehr;
}
// Gut:
Funktion returnary (foo) {
if (foo) {
zurück "foo";
}
zurück "quux";
}
8. Native & Host -Objekte (Hinweis: Ich habe immer gedacht, dass Host -Objekte nicht übersetzt werden sollten, daher werde ich sie nach der allgemeinen Schreibmethode übersetzen).
Das grundlegendste Prinzip ist:
Mach nichts Dummes, die Dinge werden immer besser.
Um dieses Konzept zu stärken, sehen Sie sich diese Demonstration an:
"Alles ist erlaubt: native Erweiterung" von Andrew Dupont (JSCONF2011, Portland, Oregon)
http://blip.tv/jsconf/jsconf2011-andrew-dupont-ething-is-permited-extending-built-ins-5211542
9. Kommentare
Einzelzeilen -Kommentare werden als erste Wahl über dem Code platziert
Mehrere Zeilen sind in Ordnung
Kommentare am Ende der Zeile sollten vermieden werden!
Die JSDOC -Methode ist auch gut, aber es braucht mehr Zeit
10. Verwenden Sie allein eine Sprache
Unabhängig davon, in welcher Sprache das Programmbleiben (oder Team) vorsieht, dass das Programm verwendet wird, sollte das Programm nur in derselben Sprache geschrieben werden.
Anhang
Komma zuerst
Alle Projekte, die dieses Dokument als grundlegender Stilhandbuch verwenden, erlauben keine Vorkomma-Codeformate, es sei denn, der Autor ist ausdrücklich angegeben oder erforderlich.