运算符

算术运算符

算术运算符 0+NaN --> NaN NaN和任何数字做运算，结果都是NaN

+号

• +号两侧都是数字类型 作用 ：求两个数字的和
• +号有一侧是字符串类型或者是引用值时 其作用都是字符串拼接

null+'heaven' --> 'null'+'heaven'--> 'nullheaven'

null+function(){}
      1. null+'function(){}'
      2. 'null'+'function(){}
      3. ''nullfunction(){}'

 false+[1,23]
          1. false + '1,23'
          2. 'false1,23'

• 会先把非字符串类型的转换成字符串
• 转换的字符串和另外一个字符串拼接

-号

• -号两侧都是数字类型 作用 ：求两个数字的差
• 都是转换成数字类型在进行求两个数字的差

 true-false -->  1
 2-[3] --> 2-'3' --> 2-3 -->-1

*号

• *号两侧都是数字类型 作用 ：求两个数字的积
• 都是转换成数字类型在进行求两个数字的积

/号

• /号两侧都是数字类型 作用 ：求两个数字的商
• 都是转换成数字类型在进行求两个数字的积

 2/[1]  --> 2/1  --> 2
 2/[1,2]  --> 2/NaN   -->  NaN

%号

• %号两侧都是数字类型 作用 ：求两个数字的余数（模）
• 都是转换成数字类型在进行求两个数字的模

 2%3  --> 2
 3%2  --> 1

结论：除加号之外的运算符 作用只有一个 即只做对应的数学运算

一元运算符

一元运算符 + - 该运算符只操作一个数据

+2 正号 对一个数字取正 如果操作的是非数字类型 则会隐式转换成数字类型

 +false  -->  +0  --> 0
 +[1,23] --> +NaN  --> NaN

-2 负号 对一个数字取负 如果操作的是非数字类型 则会隐式转换成数字类型

-1==>-1
-true==>-1

-true+false  -1+0   -->  -1

+null+function(){} 一元运算符和算术运算符 谁先算？

猜测 先算一元运算符

  1.  0+function(){}
  2.  0+'function(){}'
  3.  '0function(){}'

结论：一元运算符 的优先级高于 算术运算符

自增自减运算符

自增运算符

a++ 的作用 后加加

• 让变量a在自动增加1
• a++的结果是没有改变之前的变量a

++a 的作用 前加加

• 让变量a在自动增加1
• ++a的结果是改变之后的变量a

自减运算符

a-- 的作用 后减减

• 让变量a在自动减少1
• a--的结果是没有改变之前的变量a

–a 的作用 前减减

• 让变量a在自动减少1
• --a的结果是改变之后的变量a

例子

var a = 3;
var b = a++ + ++a;
     1.   a=4
     2.   a++ -->3
     3.   a=5
     4.   ++a -->5

 var a = 3;
 var c = ++a + a++
     1.  a=4
     2.  ++a --> 4
     3.  a=5
     4.  a++  --> 4

比较运算符

==
==判断两个数据是否相等 相等则结果是true 不相等是false

结论:

1. ==两侧都是原始值(非null undefined)时 会把==两侧的数据转换成数字进行比较

2. null和undefined 在==判断时 总是false

特例

 null==undefined  --> true
 null==null   -->  true
 undefined==undefined  --> true

NaN==NaN   --> false

3. ==两侧有一侧是引用值时 会把==两侧的数据转换成字符串进行比较
4. ==两侧都是引用值时 直接返回false
5. ==两侧有一个是引用值 一个是字符串 会把==两侧的数据转换成字符串进行比较
6. ==两侧有一个是引用值 另一侧是非字符串 会把==两侧的数据转换成数字进行比较

!=

!= 判断两个数据是否不相等 不相等则结果是true 相等则结果是false

结论：跟==号运算一致结果相反

===
=== 判断两个数据是否全等 全等则结果是true 不全等则是false

结论 ： 数据类型不一致 直接是false

!==

!== 判断两个数据是否不全等 不相等则结果是true 相等则是false

结论 ： 数据类型不一致 直接是true

其他比较运算符

1. > 说明：大于 大于则结果是false 小于则是true
2. < 说明：小于 小于则结果是true 大于则是false
3. >= 说明：大于或等于 大于或等于则结果是false 小于或等于则是true
4. <= 说明： 小于或等于 小于则结果是true 大于或等于则是false

在比较不同数据类型的值时,数据会隐式转换成数字类型

字符串和字符串比较时，会按照字符串对应的unicode编码值比较 （田忌赛马）（从第一个开始比较那个大取那个值）

逻辑运算符

&&(逻辑与)
&& 对两侧的布尔值进行与运算符

作用是找到两侧布尔值中的假值（false）

true&&[1,3]  -->  [1,3]

[1,3]&&typeof null  --> 'object'

[1,3]&&NaN&&typeof null  --> NaN

||(逻辑或)
|| 对两侧的布尔值进行或运算符

作用是找到两侧布尔值中的真值（true）

 false||’heaven’   -->  'heaven'

null||typeof  undefined  --> 'undefined'

null||typeof  undefined|| typeof  typeof undefined  -->'undefined'

!(逻辑非)
!对布尔值取反

例子

1. ! true --> false
2. ! false --> true

如果!后面跟的不是布尔值 则

1. 先把!后面的js数据 转成布尔值
2. 在取反

例如

1. !0 --> !false --> true
2. !2 --> !true --> false

练习

(!!''+!!" "-!!false)&&null
            1.  (false+true-false)&&null
            2.  (0+1-0)&&null
            3.  1&&null
            4.  null
                
 (!!''+!!" "-!!false)||[1,2]&&null

            1.  1||[1,2]&&null
            2.  1||null
            3.  1

赋值运算符

JavaScript中的赋值运算可以分为简单赋值运算和复合赋值运算。简单赋值运算是将赋值运算符（=）右边表达式的值保存到左边的变量中；而复合赋值运算混合了其他操作（例如算术运算操作）和赋值操作。例如：

sum+=i;          //等同于sum=sum+i;

JavaScript中的赋值运算符如下表所示。

运算符的优先级

扩展

如何取出数组中的数据

var a = [0,-1,"huasheng",true]

如何获取里面的单一数据



数组里面是有索引的0,1,2,3...每个索引后面都有相对应的数据

比如：提取出数组中的数据true

这样数组中的true单一数据就提取出来了

如何取出字符串中的下标

var a = "heaven"

如何获取里面的其中一个字母

字符串里面是有下标的0,1,2,3...每个索引后面都有相对应的下标跟获取数组里面的单一数据基本相同

比如：提取出字符串中的下标v

这样字符串中的v下标就提取出来了

例子

(![]+[])[+!![]]
1、(false+[])[+!![]]
2、"false"[+true]
3、"false"[1]
4、"a"