Best Practices für JavaScript
Vermeiden Sie globale Variablen, vermeiden Sie new, vermeiden Sie ==, vermeiden Sieeval()
Vermeiden Sie globale Variablen
Minimieren Sie die Verwendung globaler Variablen.
Dazu gehören alle Datentypen, Objekte und Funktionen.
Globale Variablen und Funktionen können von anderen Skripten überschrieben werden.
Verwenden Sie stattdessen lokale Variablen und lernen Sie, wie man Closures verwendet .
Deklarieren Sie immer lokale Variablen
Alle in einer Funktion verwendeten Variablen sollten als lokale Variablen deklariert werden.
Lokale Variablen müssen mit dem var
Schlüsselwort oder dem letSchlüsselwort oder dem constSchlüsselwort deklariert werden, sonst werden sie zu globalen Variablen.
Der strikte Modus erlaubt keine nicht deklarierten Variablen.
Erklärungen oben
Es ist eine gute Programmierpraxis, alle Deklarationen am Anfang jedes Skripts oder jeder Funktion zu platzieren.
Dieser Wille:
- Geben Sie einen saubereren Code ein
- Stellen Sie einen einzigen Ort bereit, an dem Sie nach lokalen Variablen suchen können
- Erleichtern Sie das Vermeiden unerwünschter (implizierter) globaler Variablen
- Reduzieren Sie die Möglichkeit unerwünschter erneuter Deklarationen
// Declare at the beginning
let firstName, lastName, price, discount, fullPrice;
// Use later
firstName = "John";
lastName = "Doe";
price = 19.90;
discount = 0.10;
fullPrice = price - discount;
Dies gilt auch für Schleifenvariablen:
for (let i = 0; i < 5; i++)
{
Variablen initialisieren
Es ist eine gute Codierungspraxis, Variablen zu initialisieren, wenn Sie sie deklarieren.
Dieser Wille:
- Geben Sie einen saubereren Code ein
- Stellen Sie einen einzelnen Ort zum Initialisieren von Variablen bereit
- Vermeiden Sie undefinierte Werte
// Declare and initiate at the beginning
let firstName = "",
let lastName = "",
let price = 0,
let discount = 0,
let fullPrice = 0,
const myArray = [],
const myObject = {};
Das Initialisieren von Variablen vermittelt eine Vorstellung von der beabsichtigten Verwendung (und dem beabsichtigten Datentyp).
Deklarieren Sie Objekte mit const
Das Deklarieren von Objekten mit const verhindert versehentliche Typänderungen:
Beispiel
let car = {type:"Fiat", model:"500", color:"white"};
car = "Fiat"; // Changes object to string
const car = {type:"Fiat", model:"500", color:"white"};
car = "Fiat"; // Not possible
Deklarieren Sie Arrays mit const
Das Deklarieren von Arrays mit const verhindert versehentliche Typänderungen:
Beispiel
let cars = ["Saab", "Volvo", "BMW"];
cars = 3; // Changes array to number
const cars = ["Saab", "Volvo", "BMW"];
cars = 3; // Not possible
Neues Objekt nicht verwenden()
- Verwenden Sie
""stattnew String() - Verwenden Sie
0stattnew Number() - Verwenden Sie
falsestattnew Boolean() - Verwenden Sie
{}stattnew Object() - Verwenden Sie
[]stattnew Array() - Verwenden Sie
/()/stattnew RegExp() - Verwenden Sie
function (){}stattnew Function()
Beispiel
let x1 = ""; // new primitive string
let x2 = 0; // new primitive number
let x3 = false; // new primitive boolean
const x4 = {}; // new object
const x5 = []; // new array object
const x6 = /()/; // new regexp object
const x7 = function(){}; // new function object
Hüten Sie sich vor automatischen Typkonvertierungen
JavaScript ist lose typisiert.
Eine Variable kann alle Datentypen enthalten.
Eine Variable kann ihren Datentyp ändern:
Beispiel
let x = "Hello"; // typeof x is a string
x = 5; // changes typeof x to a number
Beachten Sie, dass Zahlen versehentlich in Zeichenfolgen oder NaN(Not a Number) umgewandelt werden können.
Bei mathematischen Operationen kann JavaScript Zahlen in Strings umwandeln:
Beispiel
let x = 5 + 7; // x.valueOf() is 12, typeof x is a number
let x = 5 + "7"; // x.valueOf() is 57, typeof x is a string
let x = "5" + 7; // x.valueOf() is 57, typeof x is a string
let x = 5 - 7; // x.valueOf() is -2, typeof x is a number
let x = 5 - "7"; // x.valueOf() is -2, typeof x is a number
let x = "5" - 7; // x.valueOf() is -2, typeof x is a number
let x = 5 - "x"; // x.valueOf() is NaN, typeof x is a number
Das Subtrahieren einer Zeichenfolge von einer Zeichenfolge erzeugt keinen Fehler, sondern gibt NaN(Not a Number) zurück:
Beispiel
"Hello" - "Dolly" // returns NaN
Verwenden Sie === Vergleich
Der ==Vergleichsoperator konvertiert vor dem Vergleich immer (in übereinstimmende Typen).
Der ===Operator erzwingt den Vergleich von Werten und Typ:
Beispiel
0 == ""; // true
1 == "1"; // true
1 == true; // true
0 === ""; // false
1 === "1"; // false
1 === true;
// false
Parametervorgaben verwenden
Wenn eine Funktion mit einem fehlenden Argument aufgerufen wird, wird der Wert des fehlenden Arguments auf gesetzt
undefined.
Undefinierte Werte können Ihren Code beschädigen. Es ist eine gute Angewohnheit, Argumenten Standardwerte zuzuweisen.
Beispiel
function myFunction(x, y) {
if (y === undefined) {
y = 0;
}
}
ECMAScript 2015 erlaubt Standardparameter in der Funktionsdefinition:
function (a=1, b=1) { /*function code*/ }
Lesen Sie mehr über Funktionsparameter und Argumente unter Funktionsparameter
Beenden Sie Ihre Schalter mit Standardeinstellungen
Beenden Sie Ihre switchAnweisungen immer mit einem default. Auch wenn Sie denken, dass es nicht nötig ist.
Beispiel
switch (new Date().getDay()) {
case 0:
day = "Sunday";
break;
case 1:
day = "Monday";
break;
case 2:
day = "Tuesday";
break;
case 3:
day = "Wednesday";
break;
case 4:
day = "Thursday";
break;
case 5:
day = "Friday";
break;
case 6:
day = "Saturday";
break;
default:
day =
"Unknown";
}
Vermeiden Sie Number, String und Boolean als Objekte
Behandeln Sie Zahlen, Zeichenfolgen oder boolesche Werte immer als primitive Werte. Nicht als Objekte.
Das Deklarieren dieser Typen als Objekte verlangsamt die Ausführungsgeschwindigkeit und erzeugt unangenehme Nebenwirkungen:
Beispiel
let x = "John";
let y = new String("John");
(x === y) // is false because x is a string and y is an object.
Oder noch schlimmer:
Beispiel
let x = new String("John");
let y = new String("John");
(x == y) // is false because you cannot compare objects.
Vermeiden Sie die Verwendung von eval()
Die eval()Funktion wird verwendet, um Text als Code auszuführen. In fast allen Fällen sollte es nicht notwendig sein, es zu verwenden.
Da es erlaubt, beliebigen Code auszuführen, stellt es auch ein Sicherheitsproblem dar.