ホームページ > 記事 > ウェブフロントエンド > JavaScript の演算子メソッドの概要

JavaScript の演算子メソッドの概要

不言オリジナル: 2018-07-16 17:53:141179ブラウズ

js の演算子には、算術演算子と関係演算子が含まれ、算術演算子には、大なり、等しい、小なり、および一致演算子が含まれます。

算術演算子

JavaScript の算術演算は、主に算術演算子によって実装されます。算術演算子には、単項算術演算子と二項算術演算子が含まれます。

単項算術演算子

単項算術演算子は、単一のオペランドで使用され、新しい値を生成します。 JavaScript では、単項演算子は優先順位が高く、単項加算 (+)、単項減算 (-)、増分 (++)、および減分 (+) を含むすべての右結合です。

単項プラス演算子は値の前に置かれたプラス記号 (+) で表され、値には影響を与えません

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

単項プラス演算子を数値以外の値に適用するとき、Number( ) この値を変換するために変換関数が呼び出されます

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

new Date() の前に 1 ドルのプラス記号を使用して、日付文字列を日付ミリ秒に変換します

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

1 ドルマイナス (-)

1 ドル減算演算子主に負の数値を表すために使用されます

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

数値以外の値に単項減算演算子が使用される場合、値は Number() 変換関数を使用して変換され、結果の値は負の数値に変換されます

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

1 ドルプラス 1 ドル減算演算子は主に基本的な算術演算に使用され、データ型の変換にも使用できます

increment (++)

increment++ 演算子は、左の値であるオペランドをインクリメント (1 を加算) します。 (左辺値) (変数、配列要素、またはオブジェクトのプロパティ)。演算子は、Number() 変換関数を通じてオペランドを数値に変換し、その数値に 1 を加算し、加算された値を変数、数値要素、またはオブジェクト属性に再割り当てします

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

インクリメント ++ 演算子の戻り値オペランドに対する相対的な位置に依存します。演算子がオペランドの前にある場合、それは前置インクリメント演算子と呼ばれ、オペランドに対してインクリメント計算を実行し、計算された値を返します。演算子がオペランドの後にある場合、後置インクリメント演算子と呼ばれます。オペランドに対して増分計算を実行しますが、インクリメントされていない値を返します

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

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

decrement (--)

Decrease -- 演算子のオペランドも同様です。 Number() 変換関数によってオペランドを数値に変換し、1 を減算し、計算された値をオペランド

と increment++ に再割り当てします。同じ演算子、decrement -- 演算子の戻り値はその演算子によって異なります。デクリメント演算子がオペランドの前にある場合、オペランドは 1 だけデクリメントされ、デクリメント後の値が返されます。デクリメント演算子がオペランドの後にある場合、オペランドは1減算され、1減算前の値が返されます

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

前置インクリメント演算子は実行ステートメントと同じ優先順位を持ち、ステートメント全体が左から評価されます右へ

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

ポストインクリメント演算子は、それを含むステートメントが評価された後に実行されます

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

二項算術演算子

二項算術演算子には、加算 (+)、減算 (-)、乗算 (*)、除算 (/)、および剰余 (%)

加算 (+)

ほとんどのプログラミング言語では、加算は通常単純な数値演算子ですが、ECMAScript では、加算演算には多数の特別な動作があり、数値加算演算を実行できるだけではありません。

【1】オペランドの1つがオブジェクトの場合、そのオブジェクトは元の値に変換されます。日付オブジェクトはtoString()メソッドで変換し、その他のオブジェクトはvalueOf()メソッドで変換します。。ほとんどのオブジェクトの valueOf() メソッドはプリミティブ値を返すことができないため、変換は toString() メソッドを通じて実行されます

[注] 数値に変換される単一値配列に加えて、他のネイティブオブジェクトも変換されますtoString()メソッドで文字列に変換文字列形式

[2] オブジェクトを元の値に変換した後、一方のオペランドが文字列の場合、もう一方のオペランドも文字列に変換され、文字列連結が行われます。それ以外の場合、2 つのオペランドは加算演算の数値または NaN に変換されます

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

//其他原生对象则转换为字符串
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/'

算術加算を実行すると、unknown は NaN に変換され、null は 0 に変換され、false は 0 に変換され、true は 1 に変換されます

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

そのため、プラス演算子Featureを使用すると、''+を使用して、あらゆる種類の値を文字列に変換できます

減算(-)

加算と比較して、減算ははるかに単純であり、数値の減算のみを必要とします。 Number() 変換関数を使用して、非数値型を数値または NaN に変換します。一方、減算、乗算、除算、剰余などの他の数学演算では、 Number() 変換関数を使用して、 valueOf() を使用して時刻 Date オブジェクトを数値に変換します。 0 に変換され、false は 0 に変換され、true は 1 に変換されます

console.log(1 - {});//NaN
console.log(1 - [1,2]);//NaN
console.log(1 - /0/);//NaN
console.log(1 - []);//1

乗算 (*)

乗算演算子はアスタリスク (*) で表され、2 つの値の積を計算するために使用されます。型は Number() 変換関数によって数値または NaN に変換されます

console.log(new Date() + 1);//'Thu Jun 16 2016 11:11:49 GMT+0800 (中国标准时间)1'
console.log(new Date() - 1);//1466046941641

除算 (/)

除算演算子は、最初のオペランドを 2 番目のオペランドで除算する演算を実行します。また、Number() 変換関数または NaN

を通じて非数値型を数値に変換します。

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