Wissenspunkte von JavaScript, die leicht übersehen werden

Dieses Mal werde ich Ihnen Wissenspunkte über JavaScript vermitteln, die leicht übersehen werden. Welche Vorsichtsmaßnahmen über JavaScript auftreten, sehen wir uns hier an.

1. Alle Schlüssel des Objekts abrufen:

var arr = ['a', 'b', 'c'];Object.keys(arr ); //["0","1","2"]var obj={name:Jack,age:12}Object.keys(obj)//["name","age"]Object.getOwnPropertyNames(obj)

2. Attribute und Methoden der Funktion

Rückgabe folgt by Der Funktionsname nach dem Funktionsschlüsselwort.

function f1() {}
f1.name // 'f1'var f2 = function () {};
f2.name // ''var f3 = function myName() {};
f3.name // 'myName'

Längenattribut: Gibt die Anzahl der Parameter zurück, die voraussichtlich an die Funktion übergeben werden, d. h. die Anzahl der Parameter in der Funktionsdefinition. Die toString-Methode der Funktion

function f(a, b) {}
f.length // 2

gibt den Quellcode der Funktion zurück.

function f() {
  a();
  b();
  c();
}
f.toString()// function f() {//  a();//  b();//  c();// }

3. Normalerweise besteht der häufigste Anlass für eine Auswertung darin, JSON-Datenzeichenfolgen zu analysieren, aber der richtige Ansatz sollte darin bestehen, die vom Browser bereitgestellte JSON.parse-Methode zu verwenden

4 .

Bitweiser Operator wird verwendet, um Binärbits direkt zu berechnen. Es gibt insgesamt 7.

Oder-Operation (oder): Das Symbol ist |, was bedeutet, dass das Ergebnis 0 ist, wenn beide Binärbits 0 sind, andernfalls 1.

Und-Operation (und): Das Symbol ist &, was bedeutet, dass das Ergebnis 1 ist, wenn beide Binärbits 1 sind, andernfalls 0.

Keine Operation (nicht): Das Symbol ist ~, was die Invertierung eines Binärbits bedeutet.

Exklusive ODER-Verknüpfung (xor): Das Symbol ist ^, was bedeutet, dass das Ergebnis 1 ist, wenn die beiden Binärbits nicht gleich sind, andernfalls 0.

Linksverschiebungsbetrieb (Linksverschiebung): Das Symbol ist 9935626566f6bab0bc78b0ded5aad7c1>.

Der Rechtsverschiebungsoperator bedeutet, den Binärwert einer Zahl um die angegebene Anzahl von Stellen nach rechts zu verschieben, den Kopf mit 0 aufzufüllen, d. h. durch die angegebene Potenz von 2 zu dividieren (das höchste Bit, das Vorzeichenbit). , beteiligt sich nicht an der Bewegung).

4 > ,

// ist dezimal 2
*/-4 >> 1// -2/*
// Weil die Binärform von -4 11111111111111111111111111100 ist,
// Verschieben Sie ein Bit nach rechts, addieren Sie 1 zum Kopf und erhalten Sie 111111111111111111111111111111110,
// ist die Dezimalzahl -2
*/


Rechtsverschiebungsoperation mit Vorzeichenbit (mit Nullen gefüllte Rechtsverschiebung): Das Vorzeichen ist >>>
Dieser Operator bedeutet, die binäre Form einer Zahl nach rechts zu verschieben, einschließlich des Vorzeichenbits, und 0 am Kopf hinzuzufügen. Daher gibt diese Operation immer einen positiven Wert zurück. Für positive Zahlen ist das Ergebnis dieser Operation genau das gleiche wie beim rechten Verschiebungsoperator (»). Der Hauptunterschied besteht darin, dass negative Zahlen

4 >>> >> 1/ / 2147483646/*
// Da die Binärform von -4 11111111111111111111111111100 ist,

// Verschiebe das Vorzeichenbit um ein Bit nach rechts und erhalte 0111111111111111111111111110,

// Das ist 2147483646 in Dezimalzahl.
*/


5. Der native Fehlertyp von JavaScript

SyntaxError ist ein Syntaxfehler, der beim Parsen des Codes auftritt.

ReferenceError ist ein Fehler, der auftritt, wenn auf eine Variable verwiesen wird, die nicht existiert.

// 变量名错误var 1a;// 缺少括号console.log 'hello');

RangeError ist ein Fehler, der auftritt, wenn ein Wert den gültigen Bereich überschreitet. Es gibt mehrere Hauptsituationen: Zum einen ist die Array-Länge eine negative Zahl, zum anderen liegen die Methodenparameter des Number-Objekts außerhalb des zulässigen Bereichs und der Funktionsstapel überschreitet den Maximalwert.

unknownVariable// ReferenceError: unknownVariable is not definedconsole.log() = 1// ReferenceError: Invalid left-hand side in assignmentthis = 1// ReferenceError: Invalid left-hand side in assignment

new Array(-1)// RangeError: Ungültige Array-Länge(1234).toExponential(21)// RangeError: toExponential()-Argument muss zwischen 0 und 20 liegen

TypeError ist ein Fehler, der auftritt, wenn eine Variable oder ein Parameter nicht den erwarteten Typ hat. Wenn Sie den neuen Befehl beispielsweise für primitive Typen wie Zeichenfolgen, boolesche Werte und numerische Werte verwenden, wird dieser Fehler ausgegeben, da der Parameter des neuen Befehls ein Konstruktor sein sollte.

URIError ist ein Fehler, der ausgelöst wird, wenn der Parameter

der URI-bezogenen Funktion

new 123//TypeError: number is not a funcvar obj = {};
obj.unknownMethod()// TypeError: obj.unknownMethod is not a function

falsch ist. Dies betrifft hauptsächlich encodeURI(), decodeURI(), encodeURIComponent(), decodeURIComponent(), escape( ) und unescape().

Wenn die Eval-Funktion nicht korrekt ausgeführt wird, wird ein EvalError ausgegeben. Dieser Fehlertyp erscheint in ES5 nicht mehr und wird nur beibehalten, um die Kompatibilität mit vorherigem Code sicherzustellen.

decodeURI('%2')// URIError: URI malformed

6. Angepasste Fehler

Der obige Code passt ein Fehlerobjekt UserError an und lässt es das Fehlerobjekt erben. Anschließend können Sie diesen benutzerdefinierten Fehler generieren.

function UserError(message) {   this.message = message || "默认信息";   this.name = "UserError";
}
UserError.prototype = new Error();
UserError.prototype.constructor = UserError;

new UserError("Dies ist ein benutzerdefinierter Fehler!");

7. JavaScript-Programmierstil

Einrückung

Wählen Sie die Einrückung mit der Leertaste oder der Tabulatortaste. Sie können nur Wählen Sie einen Typ und verwechseln Sie sie nicht. Wenn Sie ein Projekt auf halbem Weg hinzufügen, folgen Sie dem Stil des Originalprogramms.

Block
Die geschweiften Klammern am Anfang des Blocks beginnen keine neue Zeile, sondern müssen dem Block wie folgt folgen:

Klammern

block{
    ···
}

Gibt an, dass beim Aufruf der Funktion kein Leerzeichen zwischen dem Funktionsnamen und der linken Klammer steht.

gibt an, dass beim Definieren einer Funktion kein Leerzeichen zwischen dem Funktionsnamen und der linken Klammer steht.

其他情况时，前面位置的语法元素与左括号之间，都有一个空格。

行尾的分号
建议不要省略

全局变量
JavaScript最大的语法缺点，可能就是全局变量对于任何一个代码块，都是可读可写。这对代码的模块化和重复使用，非常不利。
因此，避免使用全局变量。如果不得不使用，用大写字母表示变量名，比如UPPER_CASE。

变量声明
JavaScript会自动将变量声明”提升”（hoist）到代码块（block）的头部。

if (!o) {  var o = {};
}// 等同于var o;if (!o) {
  o = {};
}

为了避免可能出现的问题，最好把变量声明都放在代码块的头部。

for (var i = 0; i < 10; i++) {  // ...}// 写成var i;for (i = 0; i < 10; i++) {  // ...}

另外，所有函数都应该在使用之前定义，函数内部的变量声明，都应该放在函数的头部。

new命令
JavaScript使用new命令，从构造函数生成一个新对象。

var o = new myObject();

上面这种做法的问题是，一旦你忘了加上new，myObject()内部的this关键字就会指向全局对象，导致所有绑定在this上面的变量，都变成全局变量。
因此，建议使用Object.create()命令，替代new命令。如果不得不使用new，为了防止出错，最好在视觉上把构造函数与其他函数区分开来。比如，构造函数的函数名，采用首字母大写（InitialCap），其他函数名一律首字母小写。

with语句
禁止使用with语句。

相等和严格相等
不要使用“相等”（==）运算符，只使用“严格相等”（===）运算符。

语句的合并
有些程序员追求简洁，喜欢合并不同目的的语句。比如，原来的语句是

a = b;if (a) {  // ...}```

他喜欢写成下面这样。

if (a = b) {
// ...
}

虽然语句少了一行，但是可读性大打折扣，而且会造成误读，让别人误解这行代码的意思是下面这样。

```if （a === b）{  // ...}```

建议不要将不同目的的语句，合并成一行。
- 自增和自减运算符
自增（++）和自减（--）运算符，放在变量的前面或后面，返回的值不一样，很容易发生错误。事实上，所有的++运算符都可以用+= 1代替。

- switch…case结构switch...case结构要求，在每一个case的最后一行必须是break语句，否则会接着运行下一个case。这样不仅容易忘记，还会造成代码的冗长。
而且，switch...case不使用大括号，不利于代码形式的统一。此外，这种结构类似于goto语句，容易造成程序流程的混乱，使得代码结构混乱不堪，不符合面向对象编程的原则。

function doAction(action) {
switch (action) {
case 'hack':
return 'hack';
break;
case 'slash':
return 'slash';
break;
case 'run':
return 'run';
break;
default:
throw new Error('Invalid action.');
}
}

上面的代码建议改写成对象结构。

function doAction(action) {
var actions = {
'hack': function () {
return 'hack';
},
'slash': function () {
return 'slash';
},
'run': function () {
return 'run';
}
};
if (typeof actions[action] !== 'function') {
throw new Error('Invalid action.');
}
return actionsaction;
}```

建议避免使用switch...case结构，用对象结构代替。

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

Javascript的策略模式

用JS实现排序算法

Das obige ist der detaillierte Inhalt vonWissenspunkte von JavaScript, die leicht übersehen werden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!