Einführung in Operatormethoden in Javascript

Operatoren in js umfassen arithmetische Operatoren und relationale Operatoren umfassen unäre Operatoren und binäre Operatoren umfassen Größer-als-, Gleich-, kleiner-als- und Identitätsoperatoren.

Arithmetische Operatoren

Arithmetische Operationen in JavaScript werden hauptsächlich durch arithmetische Operatoren implementiert. Zu den arithmetischen Operatoren gehören unäre arithmetische Operatoren und binäre arithmetische Operatoren.

Unäre arithmetische Operatoren

Unäre arithmetische Operatoren werden auf einen einzelnen Operanden angewendet und erzeugen einen neuen Wert. In JavaScript haben unäre Operatoren eine hohe Priorität und sind alle rechtsassoziativ

Unäre arithmetische Operatoren umfassen unäre Addition (+), unäre Subtraktion (-) sowie Inkrement (+ +) und Dekrement (--).

Unäres Plus (+)

Der unäre Plus-Operator wird durch ein Pluszeichen (+) dargestellt, das vor dem Wert steht, und hat keinen Einfluss auf den Wert

var num = 25;
num = +num; //25

Wenn Sie den unären Plusoperator auf einen nicht numerischen Wert anwenden, wird die Transformationsfunktion Number() aufgerufen, um den Wert umzuwandeln

var s1 = '01';
var s2 = '1.1';
var s3 = 'z';
var b = false;
var f = 1.1;
var o = {
    valueOf:function(){
        return -1;
    }
};

s1 = +s1;//1
s2 = +s2;//1.1
s3 = +s3;//NaN
b = +b;//0
f = +f;//1.1
o = +o;//-1

Verwenden Sie den unären Plusoperator vor new Date(). , Sie können eine Datumszeichenfolge in Millisekunden umwandeln

console.log(new Date());//on Jul 11 2016 20:25:54 GMT+0800 (中国标准时间)
console.log(+new Date());//1468239954076

Unäres Minus (-)

Der unäre Minusoperator wird hauptsächlich zur Darstellung negativer Zahlen verwendet

var num = 25;
num = -num;//-25

Wenn das unäre Minus Operator wird verwendet Wenn es sich nicht um einen numerischen Wert handelt, wird der Wert mithilfe der Konvertierungsfunktion Number() konvertiert, und dann wird der erhaltene Wert in eine negative Zahl konvertiert

var s1 = '01';
var s2 = '1.1';
var s3 = 'z';
var b = false;
var f = 1.1;
var o = {
    valueOf:function(){
        return -1;
    }
};

s1 = -s1;//-1
s2 = -s2;//-1.1
s3 = -s3;//NaN
b = -b;//0
f = -f;//-1.1
o = -o;//1

Die unären Additions- und unären Subtraktionsoperatoren werden hauptsächlich für grundlegende arithmetische Operationen verwendet und können auch beim Konvertieren von Datentypen verwendet werden operand ist ein L-Wert (Variable, Array-Element oder Objekteigenschaft). Der Operator wandelt den Operanden über die Konvertierungsfunktion Number() in eine Zahl um, addiert dann 1 zur Zahl und weist den hinzugefügten Wert einer Variablen, einem numerischen Element oder einem Objektattribut erneut zu.

var age = 29;
++age;
//相当于
var age = 29;
age = age +1;

Inkrement++-Operator Der Rückgabewert hängt davon ab von seiner Position relativ zum Operanden. Wenn der Operator vor dem Operanden steht, wird er als Vorinkrementoperator bezeichnet. Er führt eine Inkrementierungsberechnung für den Operanden durch und gibt den berechneten Wert zurück. Wenn der Operator hinter dem Operanden steht, wird er als Post-Inkrement-Operator bezeichnet. Er führt eine inkrementelle Berechnung für den Operanden durch, gibt jedoch einen nicht inkrementierten Wert

var i = 1, j = ++i;
//i=2 j=2

var i = 1, j = i++;
//i=2 j=1

dekrementell (--)

zurück. -Der Operand des Operators ist ebenfalls ein L-Wert. Er wandelt den Operanden über die Konvertierungsfunktion Number() in eine Zahl um, subtrahiert dann 1 und weist den berechneten Wert neu zu. Operanden

sind die gleichen wie das Inkrement + +-Operator. Der Rückgabewert des Dekrementoperators hängt von seiner Position relativ zum Operanden ab. Wenn der Dekrementoperator vor dem Operanden steht, wird der Operand um 1 dekrementiert und der Rückgabewert wird um 1 dekrementiert. Wenn der Dekrementierungsoperator hinter dem Operanden steht, wird der Operand um 1 dekrementiert und der Wert vor der Dekrementierung um 1 wird zurückgegeben

var age = 29;
--age;
//相当于
var age = 29;
age = age - 1;

Die Priorität des Inkrementierungsoperators ist dieselbe wie bei der Ausführungsanweisung, und die gesamte Anweisung wird die gleiche sein von links nach rechts ausgewertet werden

var num1 = 2;
var num2 = 20;
var num3 = --num1 + num2;//21
var num4 = num1 + num2;//21

Post-Inkrement-Operatoren werden ausgeführt, nachdem die sie enthaltende Anweisung ausgewertet wurde

var num1 = 2;
var num2 = 20;
var num3 = num1-- + num2;//22
var num4 = num1 + num2;//21

Binäre arithmetische Operatoren

Binäre arithmetische Operatoren umfassen Addition (+) , Subtraktion (-), Multiplikation (*), Division (/) und Rest (%)

Addition (+)

In den meisten Programmiersprachen ist die Addition normalerweise ein einfaches numerisches Operationssymbol. In ECMAScript weist die Additionsoperation jedoch eine große Anzahl spezieller Verhaltensweisen auf. Sie kann nicht nur numerische Additionsoperationen ausführen, sondern auch eine Zeichenfolgenverkettung durchführen.

[1] Wenn einer der Operanden ein Objekt ist, wird dies auch der Fall sein in Originalwert konvertiert werden: Datumsobjekte führen die Konvertierung über die toString()-Methode durch, und andere Objekte führen die Konvertierung über die valueOf()-Methode durch. Da die valueOf()-Methode der meisten Objekte keinen primitiven Wert zurückgeben kann, erfolgt die Konvertierung über die toString()-Methode

[Hinweis] Mit Ausnahme von einwertigen Arrays, die in Zahlen konvertiert werden, andere native Objekte werden über die toString()-Methode in Zahlen umgewandelt.

[2] Wenn nach der Konvertierung des Objekts in den ursprünglichen Wert einer der Operanden ein String ist, wird auch der andere Operand konvertiert in eine Zeichenfolge und die Zeichenfolgenverkettung, andernfalls werden beide Operanden für die Addition in Zahlen oder NaN konvertiert. und true wird in 1 umgewandelt

//单数值数组和valueOf()返回值为数值的自定义对象会转换为数值
console.log(1 + []);//1
var o = {
    valueOf: function(){
        return -1;
    }
}
console.log(1 + o);//0

Daher können Sie mithilfe der Eigenschaften des Plus-Operators ''+ verwenden, um jede Art von Wert in eine Zeichenfolge umzuwandeln

Subtraktion (-)

Im Vergleich zur Addition ist die Subtraktion viel einfacher und beinhaltet nur die Subtraktion von Zahlen. Verwenden Sie die Konvertierungsfunktion Number(), um nicht numerische Typen in numerische Werte oder NaN umzuwandeln

//其他原生对象则转换为字符串
console.log(1 + {});//'1[object Object]'
console.log(1 + [1,2]);//'11,2'
console.log(1 + new Date());//'1Thu Jun 16 2016 10:27:13 GMT+0800 (中国标准时间)'
console.log(1 + /0/);//'1/0/'

Eine Besonderheit der Addition besteht darin, dass beim Hinzufügen des Zeit-Datumsobjekts toString() zum Konvertieren verwendet wird in eine Zeichenfolge, während in anderen mathematischen Operationen, einschließlich Subtraktion, Multiplikation, Division, Rest usw., die Konvertierungsfunktion Number() verwendet wird, um das Zeit-Datumsobjekt mit valueOf() in eine Zahl umzuwandeln 🎜> undefiniert wird in NaN konvertiert und null wird in 0 konvertiert. , false wird in 0 konvertiert, true wird in 1 konvertiert

console.log('' + undefined);//'undefined'
console.log('' + null);//'null'
console.log('' + false);//'false'
console.log('' + true);//'true'

Multiplikation (*)

Der Multiplikationsoperator wird dargestellt durch Ein Sternchen (*) wird verwendet, um das Produkt zweier Werte zu berechnen. Die Konvertierungsfunktion Number() konvertiert nicht-numerische Typen in numerische Werte oder NaN. Mit der Operation des zweiten Operanden wird der nicht-numerische Typ umgewandelt wird auch über die Konvertierungsfunktion Number() in einen numerischen Wert oder NaN

konvertiert

Infinity / Infinity;//NaN
0 / 0;//NaN
非0数值 / 0;//Infinity或-Infinity
Infinity / 0;//Infinity
Infinity / 非0数值;//Infinity

求模(%)

求模(余数)操作符是由一个百分号(%)表示，是第一个操作数除以第二个操作数的余数

//r是余数，n是被除数，d是除数，
//q是整数，在n/d为负时为负，在n/d为正时为正，它应该在不超过n和d的商的前提下尽可能大
r = n - (d * q)

求模结果与第一个操作数的符号保持一致

console.log(5 % 2);//1
console.log(5 % -2);//1
console.log(-5 % 2);//-1
console.log(-5 % -2);//-1

关系运算符

关系运算符用于测试两个值之间的关系，根据关系是否存在而返回true或false，关系表达式总是返回一个布尔值，通常在if、while或for语句中使用关系表达式，用以控制程序的执行流程

javascript提供了===、!==、==、!=、<、<=、>、>=8个关系运算符，分为4类介绍关系运算符

恒等运算符

恒等运算符'==='，也叫严格相等运算符，首先计算其操作数的值，然后比较这两个值，比较过程没有任何类型转换，比较过程如下：

【1】如果两个值的类型不相同，则返回false

console.log(1 === '1');//false
console.log(1 === [1]);//false

【2】如果两个值都是Undefined、Null、Boolean、Number、String相同原始类型的值，值相同，就返回true，否则，返回false

console.log(undefined === undefined);//true
console.log(null === null);//true
console.log(true === true);//true
console.log(false === false);//true
console.log(1 === 1);//true
console.log(2.5 === 2.5);//true

[注意]不论什么进制的数字，在进行关系比较时，最终都转换为十进制进行运算

console.log(10 === 0xa);//true

在数字Number类型中，有一个值比较特殊，是NaN(not a number)，它与任何值都不相等；此外，数字Number类型中存在着+0和-0，虽然其符号不同，但值相等

console.log(NaN === NaN);//false
console.log(+0 === -0);//true

两个相同字符串值表现为：相同的长度和相同的字符对应相同的位置

console.log('abc' === 'abc');//true
console.log('abc' === 'acb');//false

【3】如果两个值引用同一个对象，则返回true，否则，返回false

[注意]更详细的解释是，javascript对象的比较是引用的比较，而不是值的比较。对象和其本身是相等的，但和其他任何对象都不相等。如果两个不同的对象具有相同数量的属性，相同的属性名和值，它们依然是不相等的

console.log([] === []);//false
console.log({} === {});//false    
console.log(function(){} === function(){});//false
var a = {};
b = a;
console.log(a === b);//true

恒不等运算符(!==)又叫严格不等于运算符，操作数的比较过程与恒等运算符相同，结果取反。如果'==='的比较结果是true，则'!=='的比较结果是false；如果'==='的比较结果是false，则'!=='的比较结果是true

console.log(1 !== '1');//true
console.log(1 !== 1);//false
console.log(true !== false);//true
console.log({} !== {});//true

相等运算符

相等运算符'=='和恒等运算符相似，但相等运算符的比较并不严格，如果两个操作数不是同一类型，相等运算符会尝试进行一些类型转换，然后再进行比较

当两个操作数类型相同时，比较规则和恒等运算符规则相同

console.log(undefined == undefined);//true
console.log(10 == 0xa);//true
console.log(NaN == NaN);//false
console.log([] == []);//false

当两个操作数类型不同时，相等运算符'=='会遵守如下规则：

【1】如果一个值是对象类型，另一值是原始类型，则对象类型会先使用valueOf()转换成原始值，如果结果还不是原始值，则再使用toString()方法转换，再进行比较

[注意]日期类只允许使用toString()方法转换为字符串。类似地，时间Date对象进行加法运算时使用toString()转换为字符串，而在其他数学运算，包括减法、乘法、除法、求余等运算中，都是使用Number()转换函数将时间Date对象使用valueOf()转换为数字

【2】在对象转换为原始值之后，如果两个操作数都是字符串，则进行字符串的比较

console.log(new Date() == 'Sat Jun 25 2016 11:07:20 GMT+0800 (中国标准时间)');//true

【3】在对象转换为原始值之后，如果至少有一个操作数不是字符串，则两个操作数都将通过Number()转型函数转换成数字进行数值比较

console.log(true == 1);//true
console.log(true == 0);//false
console.log(false == '1');//false
console.log(false == '0');//true
console.log(true == 'true');//false，相当于1 == NaN

console.log([1] == 1);//true，相当于1 == 1
console.log([1] == '1');//true，相当于'1' == '1'
console.log([] == 0);//true，相当于0 == 0
console.log([] == '0');//false，相当于'' == '0'

console.log([] == true);//false，相当于0 == 1
console.log([1] == true);//true，相当于1 == 1

var a = {
    valueOf:function(){
        return 1;
    },
    toString:function(){
        return '2';
    }
} 
console.log( a == '1');//true，相当于1 == 1

var a = {
    valueOf:function(){
        return {};
    },
    toString:function(){
        return '1';
    }
} 
console.log( a == 1);//true，相当于1 == 1

[注意]如果一个值是null，另一个值是undefined，则返回true。虽然Number(null)是0，但null和0并不相等

console.log(null == undefined);//true
console.log(null == 0);//false

[注意]空字符串或空格字符串会转成0

console.log(null == []);//false
console.log(null == '');//false
console.log([] == ' ');//false，相当于'' == ' '
console.log([] == '');//true，相当于'' == ''
console.log(0 == '');//true

不相等运算符(!=)的操作数比较过程与相等运算符相同，结果取反。如果'=='的比较结果是true，则'!='的比较结果是false；如果'=='的比较结果是false，则'!='的比较结果是true

console.log(1 != '1');//false，相当于1 != 1
console.log(true != '1');//false，相当于1 != 1
console.log('true' != 1);//true，相当于NaN != 1
console.log([1] != '1');//false，相当于'1' != '1'
console.log([1] != true);//false，相当于1 != 1

大于运算符

大于运算符(>)用于比较两个操作数，如果第一个操作数大于第二个操作数，则大于运算符的计算结果为true，否则为false

大于运算符的操作数可能是任意类型，然而，只有数字和字符串才能真正执行比较操作，因此那些不是数字和字符串的操作数都将进行类型转换，类型转换规则如下：

【1】如果操作数是对象，则这个对象将先使用valueOf()转换成原始值，如果结果还不是原始值，则再使用toString()方法转换

[注意]实际上，在原生对象中，使用valueOf()方法转换为原始值的，只有转换为数字Number类型的时间Date对象，其他对象都通过toString()方法转换为字符串

【2】在对象转换为原始值之后，如果两个操作数都是字符串，则按照字母表的顺序对两个字符串进行比较，这里提到的字母表顺序是指组成这个字符串的16位unicode字符的索引顺序

console.log('b' > 'a');//true
console.log('B' > 'a');//false

console.log({} > '[a]');//true，相当于'[object Object]' > '[a]'
console.log({} > '[p]');//false，相当于'[object Object]' > '[p]'

console.log(['a'] > ['b']);//false，相当于'a' > 'b'
console.log([2] > [11]);//true，相当于'2' > '11'

【3】在对象转换为原始值之后，如果至少有一个操作数不是字符串，则两个操作数都转换成数字进行比较

[注意]在等于操作符中，时间Date()对象只允许通过toString()方法转换为字符串，而不允许通过valueOf()方法转换为数字；而在大于操作符中，时间Date()对象允许优先使用valueOf()方法转换为数字

console.log(new Date() > 100);//true，相当于1466826928667 > 100
console.log(true > [0]);//true，相当于 1 > 0

console.log(2 > 1);//true
console.log(11 > '2');//true，相当于11 > 2

console.log(NaN > 1);//false
console.log(1 > NaN);//false
console.log({} > true);//false，相当于 NaN > 1

对于数字和字符串来说，加号运算符和比较运算符的行为有所不同，加号运算符更偏爱字符串，如果它的一个操作数是字符串，就进行字符串连接。而比较运算符则更偏爱数字，只有在两个操作数都是字符串时，才进行字符串的比较

console.log(1 + 2);//3
console.log('1' + '2');//'12'
console.log('1' + 2);//'12'，相当于 '1' + '2'

console.log(2 > 1);//true
console.log('2' > '1');//true
console.log('2' > 1);//true，相当于 2 > 1

小于等于运算符(<=)并不依赖于小于或等于运算符的比较规则，而是遵循大于运算符的比较规则，结果取反。如果'>'的比较结果是true，则'<='的比较结果是false；如果'>'的比较结果是false，则'<='的比较结果是true

console.log(1 <= &#39;0&#39;);//false，相当于1 <= 0
console.log(true <= &#39;0&#39;);//false，相当于1 <= 0
console.log(&#39;true&#39; <= 0);//false，相当于NaN <= 0
console.log([1] <= &#39;0&#39;);//false，相当于&#39;1&#39; <= &#39;0&#39;
console.log([0] <= true);//true，相当于0 <= 1
console.log(1 <= 1);//true

小于运算符

小于运算符(<)用于比较两个操作数，如果第一个操作数小于第二个操作数，则小于运算符的计算结果为true，否则为false

小于运算符与大于运算符的类型转换规则类似，就不再赘述

同样地，大于等于运算符(>=)并不依赖于大于或等于运算符的比较规则，而是遵循小于运算符的比较规则，结果取反。如果'<'的比较结果是true，则'>='的结果是false；如果'<'的比较结果是false，则'>='的结果是true

相关推荐：

js与运算符和或运算符的妙用_javascript技巧

JS的递增/递减运算符和带操作的赋值运算符的等价式_javascript技巧

Das obige ist der detaillierte Inhalt vonEinführung in Operatormethoden in Javascript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!