目录
10 符号优先级
操作符
1 一元操作符
只能操作一个值的操作符叫做一元操作符。一元操作符是 ECMAScript 中最简单的操作符。
1. 递增和递减操作符
//自增 自减 递增 递减
//++ 前置递增操作 -- 前置递减操作符
var a=20;
++a; //前置++，就是先+1，再取值操作
a++; //后置++，就是先取值操作，再+1
--a; //前置--，就是先-1，再取值操作
a--; //后置--。就是先取值操作，再-1
// 一个变量只能保存一个数据
var a=10;
a=(a++)+(++a); //10+12
console.log(a);
拓展：笔试题
//笔试题 结果为-80 为什么？ var obj={age:20} var a=100 var c=(-a+++obj.age++) console.log(c) var c = (-a++ + obj.age++) //-100++ + 20++
var age = 29;
++age; //让age的值+1
var age = 29;
age = age + 1;
//等于以下代码
var age = 29;
--age;//age=age-1
//计算
var age = 29;
var anotherAge = --age + 2;
alert(age);//28
alert(anotherAge); //30
//由于前置递增和递减操作与执行语句的优先级相等，因此整个语句会从左至右被求值。
//计算
var num1 = 2;
var num2 = 20;
var num3 = --num1 + num2; //1+20=21 num1=1
var num4 = num1 + num2; //1+20=21var num1 = 2;
var num2 = 20;
var num3 = num1-- + num2; //2+20=22 num1=1
var num4 = num1 + num2; //1+20=21
//计算
var a = 2; //3 4
var b = 3; //4
var c = (++a) + (b++) + b + (a++) - a; //3 + 3 + 4 + 3 -4 =9所有这 4 个操作符对任何值都适用，也就是它们不仅适用于 整数型变量，还可以用于字符串、布尔值、浮点数值和对象类型的变量。在应用于不同的值时，递增和递减操作符遵循下列规则。
在应用于一个包含有效数字字符的字符串时，先将其转换为数字值，再执行加减 1 的操作。字符串变量变成数值变量。
var s1 = "2"; console.log(++s1); //3在应用于一个不包含有效数字字符的字符串时，将变量的值设置为 NaN。字符串变量变成数值变量。
var s2 = "z"; console.log(++s2); //NaN在应用于布尔值 false 时，先将其转换为 0 再执行加减 1 的操作。布尔值变量变成数值变量。
var b = false; console.log(++b); //1在应用于布尔值 true 时，先将其转换为 1 再执行加减 1 的操作。布尔值变量变成数值变量。
var b = true; console.log(++b); //2在应用于浮点数值时，执行加减 1 的操作。
var f = 1.1; console.log(--f); //0.1在应用于对象时，先调用对象的 valueOf()方法（后面章节将详细讨论）以取得一个可供操作的值。然后对该值应用前述规则。如果结果是 NaN，则在调用 toString()方法后再应用前述规则。对象变量变成数值变量。
var o = { valueOf: function () { return -1; } } console.log(--o); //-2
2.一元加和减操作符
一元加操作符以一个加号（+）表示，放在数值前面，对数值不会产生任何影响
var num = 25; num = +num; console.log(num); //结果为25
在对非数值应用一元加操作符时，该操作符会像 Number()转型函数一样对这个值执行转换。
换句话说，布尔值 false 和 true 将被转换为 0 和 1，字符串值会被按照一组特殊的规则进行解析，而对象是先调用它们的 valueOf()和（或） toString()方法，再转换得到的值。
var s1="01"; s1 = +s1; //1 var s2="1.1"; s2 = +s2; //1.1 var s3 = "z"; s3 = +s3; //NaN var b=false; b = +b; //0 var f = 1.1; f = +f; //1.1 var o = { valueOf: function(){ return -1; } } o = +o; //-1
一元减操作符主要用于表示负数
var num = 2; num = -num; console.log(num); //-2
在将一元减操作符应用于数值时，该值会变成负数
而当应用于非数值时，一元减操作符遵循与一元加操作符相同的规则，最后再将得到的数值转换为负数
var s1="01"; s1 = -s1; //-1 var s2="1.1"; s2 = -s2; //-1.1 var s3 = "z"; s3 = -s3; //NaN var b=false; b = -b; //-0 var f = 1.1; f = -f; //-1.1 var o = { valueOf: function(){ return -1; } } o = -o; //1一元加和减操作符主要用于基本的算术运算，也可以像前面示例所展示的一样用于转换数据类型。
2 逻辑操作符
在一门编程语言中，逻辑操作符的重要性堪比相等操作符。如果没有测试两个值关系的能力，那么诸如 if...else 和循环之类的语句就不会有用武之地了。
1. 逻辑非
开关思想：就是把一个变量中保存一个布尔值，然后在业务执行时，修改这个变量的值，为取反，然后通过变量的值执行分支业务
逻辑非操作符由一个叹号（！）表示，可以应用于 ECMAScript 中的任何值。无论这个值是什么数据类型，这个操作符都会返回一个布尔值。
逻辑非操作符首先会将它的操作数转换为一个布尔值，然后再对其求反。也就是说，逻辑非操作符遵循下列规则：
如果操作数是一个非空(null)对象，返回 false；
如果操作数是一个空字符串，返回 true；
如果操作数是一个非空字符串，返回 false；
如果操作数是数值 0，返回 true；
如果操作数是任意非 0 数值（包括 Infinity），返回 false；
如果操作数是 null，返回 true；
如果操作数是 NaN，返回 true；
如果操作数是 undefined，返回 true。
几个例子
alert(!false); //true alert(!"blue"); //false alert(!0); //true alert(!NaN); //true alert(!""); //true alert(!23); //false
同时使用两个逻辑非操作符，也可以用于将一个值转换为与其对应的布尔值
alert(!!"blue"); //true alert(!!0); //false alert(!!"") //false alert(!!" "); //true alert(!!324); //true
2. 逻辑与
var a=(b=0)&&(c=30);
console.log(a); //0 并不是a=false
console.log(b); //0
console.log(c); //undefined
//0为false
//取一个变量的数据时（1、没声明就报错 2、取的是最近一次保存的数据）
// js中变量保存数据（1、已经有就更行2、没有就隐藏声明逻辑与操作符由两个和号（&&）表示，有两个操作数，如下面的例子所示：
var result = true && false;
逻辑与的真值表如下：
逻辑与操作可以应用于任何类型的操作数，而不仅仅是布尔值。在有一个操作数不是布尔值的情况下，逻辑与操作就不一定返回布尔值；此时，它遵循下列规则：
如果第一个操作数是对象，则返回第二个操作数；
如果第二个操作数是对象，则只有在第一个操作数的求值结果为 true 的情况下才会返回该对象；
如果两个操作数都是对象（或非0数），则返回第二个操作数；
如果有一个操作数是 null，则返回 null；
如果有一个操作数是 NaN，则返回 NaN；
如果有一个操作数是 undefined，则返回 undefined；
如果有一个操作数是 0 ，则返回0；
逻辑与操作属于短路操作，即如果第一个操作数能够决定结果，那么就不会再对第二个操作数求值。 对于逻辑与操作而言，如果第一个操作数是 false，则无论第二个操作数是什么值，结果都不再可能是true 了。
var found = true; var result = (found && someUndefinedVariable); alert(result);
在上面的代码中，当执行逻辑与操作时会发生错误，因为变量 someUndefinedVariable 没有声明。由于变量 found 的值是 true，所以逻辑与操作符会继续对变量 someUndefinedVariable 求值。但 someUndefinedVariable 尚未定义，因此就会导致错误。这说明不能在逻辑与操作中使用未定义的值。
如果像下面这个例中一样，将 found 的值设置为 false，就不会发生错误了
var found = false; var result = (found && someUndefinedVariable); alert(result);
在这个例子中，警告框会显示出来。无论变量 someUndefinedVariable 有没有定义，也永远不会对它求值，因为第一个操作数的值是 false。而这也就意味着逻辑与操作的结果必定是 false，根本用不着再对&&右侧的操作数求值了。在使用逻辑与操作符时要始终铭记它是一个短路操作符。
3. 逻辑或
这个符号是面试官最喜欢问的问题，在开发中，一般是优化的代码最常用的js符号
逻辑或操作符由两个竖线符号（||）表示，有两个操作数，如下面的例子所示：
var result = true || false;
逻辑或的真值表如下：
与逻辑与操作相似，如果有一个操作数不是布尔值，逻辑或也不一定返回布尔值；此时，它遵循下列规则：
如果第一个操作数是对象，则返回第一个操作数；
如果第一个操作数的求值结果为 false，则返回第二个操作数；
如果两个操作数都是对象（或非0数），则返回第一个操作数；
如果两个操作数都是 null，则返回 null；
如果两个操作数都是 NaN，则返回 NaN；
如果两个操作数都是 undefined，则返回 undefined。
与逻辑与操作符相似，逻辑或操作符也是短路操作符。也就是说，如果第一个操作数的求值结果为true，那么结果就等于第一个操作数的值，就不会对第二个操作数求值了。
var found = true; var result = (found || someUndefinedVariable); alert(result);这个例子跟前面的例子一样，变量 someUndefinedVariable 也没有定义。但是，由于变量 found的值是 true，而变量 someUndefinedVariable 永远不会被求值，因此结果就会输出"true"。如果像下面这个例子一样，把 found 的值改为 false，就会导致错误：
var found = false; var result = (found || someUndefinedVariable); alert(result);
小练习：
var c = (a = 3) || (b = 4);
console.log(a); //3
console.log(b); //undefined
console.log(c); //3小技巧：我们可以利用逻辑或的这一行为来避免为变量赋 null 或 undefined 值。例如：
var myObject = preferredObject || backupObject;在这个例子中，变量 myObject 将被赋予等号后面两个值中的一个。变量 preferredObject 中包含优先赋给变量 myObject 的值，变量 backupObject 负责在 preferredObject 中不包含有效值的情况下提供后备值。如果 preferredObject 的值不是 null，那么它的值将被赋给 myObject；如果是 null，则将 backupObject 的值赋给 myObject。
隐式转换练习题
var str=false+1;
document.write(str);
var demo = false ==1;
document.write(demo);
if(typeof(a)&&-true + (+undefined)+""){
document.write("基础扎实");
}
if(11+"11"*2==33){
document.write("基础扎实")
}
!!" "+!!""-!!false||document.write("这个根本不会执行");
//运行结果 1false基础扎实基础扎实3 乘性操作符
ECMAScript 定义了 3 个乘性操作符：乘法、除法和求模。这些操作符与 Java、 C 或者 Perl 中的相应操作符用途类似，只不过在操作数为非数值的情况下会执行自动的类型转换。
1. 乘法
乘法操作符由一个星号（*）表示，用于计算两个数值的乘积。其语法类似于 C
var result = 34 * 56; 如果参与乘性计算的某个操作数不是数值，后台会先使用 Number()转型函数将其转换为数值。也就是说，空字符串将被当作0，布尔值 true 将被当作 1。
在处理特殊值的情况下，乘法操作符遵循下列特殊的规则：
如果操作数都是数值，执行常规的乘法计算，即两个正数或两个负数相乘的结果还是正数
如果只有一个操作数有符号，那么结果就是负数。如果乘积超过了 ECMAScript 数值的表示范围，则返回 Infinity 或-Infinity；
如果有一个操作数是 NaN，则结果是 NaN； NaN* 任何=NaN
如果是 Infinity 与 0 相乘，则结果是 NaN；// Infinity*0=NaN
如果是 Infinity 与非 0 数值相乘，则结果是 Infinity 或-Infinity，取决于有符号操作数的符号；infinity * 非0数值 = infinity/-infinity
如果是 Infinity * Infinity = Infinity；
如果有一个操作数不是数值，则在后台调用 Number()将其转换为数值，然后再应用上面的规则。
2. 除法
除法操作符由一个斜线符号（/）表示，执行第二个操作数除第一个操作数的计算，如下面的例子所示：
var result = 66 / 11;
与乘法操作符类似，除法操作符对特殊的值也有特殊的处理规则。这些规则如下：
如果操作数都是数值，执行常规的除法计算，即两个正数或两个负数相除的结果还是正数
如果只有一个操作数有符号，那么结果就是负数。如果商超过了 ECMAScript 数值的表示范围，则返回 Infinity 或-Infinity；
如果有一个操作数是 NaN，则结果是 NaN；
如果是 Infinity 被 Infinity 除，则结果是 NaN； // Infinity / Infinity = NaN
如果是零被零除，则结果是 NaN；
如果是非零数被零除，则结果是 Infinity 或-Infinity，取决于有符号操作数的符号；
如果是 Infinity被任何数值除,则结果是Infinity 或-Infinity，取决于有符号操作数的符号；
// Infinity/0=Infinity
如果有一个操作数不是数值，则在后台调用 Number()将其转换为数值，然后再应用上面的规则。
3. 求模
求模（余数）操作符由一个百分号（%）表示，用法如下：
var result = 26 % 5; // 26/5=5...1 结果为1
与另外两个乘性操作符类似，求模操作符会遵循下列特殊规则来处理特殊的值：
如果操作数都是数值，执行常规的除法计算，返回除得的余数；
如果被除数是无穷大值Infinity 而除数是有限大的数值，则结果是 NaN；// Infinity%？=NaN
如果被除数是有限大的数值而除数是零，则结果是 NaN；// 5%0=NaN
如果是 Infinity 被 Infinity 除，则结果是 NaN； // Infinity % Infinity = NaN
如果被除数是有限大的数值而除数是无穷大的数值，则结果是被除数； // 5%Infinity = 5
如果被除数是零，则结果是零；// 0%？=0
如果有一个操作数不是数值，则在后台调用 Number()将其转换为数值，然后再应用上面的规则
4 加性操作符
与乘性操作符类似，加性操作符也会在后台转换不同的数据类型。然而，对于加性操作符而言，相应的转换规则还稍微有点复杂。
1. 加法
加法操作符（+）的用法如下所示：
var result = 1 + 2;
如果两个操作符都是数值，执行常规的加法计算，然后根据下列规则返回结果：
如果有一个操作数是 NaN，则结果是 NaN；
如果是 Infinity 加 Infinity，则结果是 Infinity；
如果是-Infinity 加-Infinity，则结果是-Infinity；
如果是 Infinity 加-Infinity，则结果是 NaN；// Infinity +（- Infinity ）=NaN
如果是+0 加+0，则结果是+0；
如果是-0 加-0，则结果是-0；
如果是+0 加-0，则结果是+0。//+0-0=+0
不过，如果有一个操作数是字符串，那么就要应用如下规则：
如果两个操作数都是字符串，则将第二个操作数与第一个操作数拼接起来；
如果只有一个操作数是字符串，则将另一个操作数转换为字符串，然后再将两个字符串拼接起来；
如果有一个操作数是对象、数值或布尔值，则调用它们的 toString()方法取得相应的字符串值，然后再应用前面关于字符串的规则。对于 undefined 和 null，则分别调用 String()函数并取得字符串"undefined"和"null"。
var result1 = 5 + 5;
alert(result1); //10
var result2 = 5 + "5";
alert(result2); //552. 减法
减法操作符（-）是另一个极为常用的操作符，其用法如下所示：
var result = 2 - 1;
与加法操作符类似， ECMAScript 中的减法操作符在处理各种数据类型转换时，同样需要遵循一些
特殊规则，如下所示：
如果两个操作符都是数值，则执行常规的算术减法操作并返回结果；
如果有一个操作数是 NaN，则结果是 NaN；
如果是 Infinity 减 Infinity，则结果是 NaN；//infinity-infinity=NaN
如果是-Infinity 减-Infinity，则结果是 NaN；
如果是 Infinity 减-Infinity，则结果是 Infinity；
如果是-Infinity 减 Infinity，则结果是-Infinity；
如果是+0 减+0，则结果是+0；
如果是+0 减-0，则结果是-0；//+0-（-0）=（-0）
如果是-0 减-0，则结果是+0；
如果有一个操作数是字符串、布尔值、 null 或 undefined，则先在后台调用 Number()函数将其转换为数值，然后再根据前面的规则执行减法计算。如果转换的结果是 NaN，则减法的结果就是 NaN；
如果有一个操作数是对象，则调用对象的 valueOf()方法以取得表示该对象的数值。如果得到的值是 NaN，则减法的结果就是 NaN。如果对象没有 valueOf()方法，则调用其 toString()方法并将得到的字符串转换为数值。
alert(s1 = 5 - true) //4
alert(NaN - 1); //NaN
alert(5-3); //2
alert(5 - ""); //5
alert(5 - "2"); //3
alert(5 - null); //55 关系操作符
关系运算符用于检测两个值之间的关系，总是返回一个布尔值true或false。
(1)比较运算符
小于（<） 、大于（>） 、小于等于（<=）和 大于等于（>=）
var result1 = 5 > 3; // true var result2 = 5 < 3; // false
与 ECMAScript 中的其他操作符一样，当关系操作符的操作数使用了非数值时，也要进行数据转换或完成某些奇怪的操作。以下就是相应的规则。
如果两个操作数都是数值，则执行数值比较。
如果两个操作数都是字符串，则比较两个字符串对应的字符编码值。
如果一个操作数是数值，则将另一个操作数转换为一个数值，然后执行数值比较。
如果一个操作数是对象，则调用这个对象的 valueOf()方法，用得到的结果按照前面的规则执行比较。如果对象没有 valueOf()方法，则调用 toString()方法，并用得到的结果根据前面的规则执行比较。
如果一个操作数是布尔值，则先将其转换为数值，然后再执行比较。
在使用关系操作符比较两个字符串时，会执行一种奇怪的操作。很多人都会认为，在比较字符串值时，小于的意思是“在字母表中的位置靠前”，而大于则意味着“在字母表中的位置靠后”，但实际上完全不是那么回事。在比较字符串时，实际比较的是两个字符串中对应位置的每个字符的字符编码值。经过这么一番比较之后，再返回一个布尔值。由于大写字母的字符编码全部小于小写字母的字符编码，因此我们就会看到如下所示的奇怪现象：
var result = "Brick" < "alphabet";在这个例子中，字符串"Brick"被认为小于字符串"alphabet"。原因是字母 B 的字符编码为 66，而字母 a 的字符编码是 97。
如果要真正按字母表顺序比较字符串，就必须把两个操作数转换为相同的大小写形式（全部大写或全部小写），然后再执行比较，如下所示：
var result = "Brick".toLowerCase() < "alphabet".toLowerCase();
任何操作数与 NaN 进行关系比较，结果都是 false。
var result = "a" < 3;
(2)相等运算符
确定两个变量是否相等，ECMAScript 提供两组操作符：
相等和不相等——先转换成相似类型再比较， 全等和不全等——仅比较而不转换。
笔试题最喜欢在选择题中考==的比较表（背）
基本数据和基本数据：=== 看值和类型是否相等 ==就看值是否相等
引用数据和引用数据： 看是否是同一个引用 （【】==【】是false，因为是两个对象）
基本数据和引用数据：把引用数据转换为字符串 （【【】】 ==“1” 是false ）
（数组转字符串例子： var arr=[1,2,3,4] //转为 “1，2，3，4” ）
var arr=[]; //arr.tostring() 空数组会转换为字符串
var b="";
console.log(arr==b); //返回是true var arr=[[]]; //这是一个内存空间 外面是数组套一个空数组 （数组是一种对象，数组函数都是一种引用数据）
var arr2=[]; //这是另外一个内存空间
console.log(arr=arr2); //返回值是false1）相等和不相等
数值相等，类型可以不一样，因为会进行转换
ECMAScript 中的相等操作符由两个等于号（==）表示，如果两个操作数相等，则返回 true。而不相等操作符由叹号后跟等于号（!=）表示，如果两个操作数不相等，则返回 true。这两个操作符都会先转换操作数（通常称为强制转型），然后再比较它们的相等性。（两个==的操作数，类型可能不相等）
在转换不同的数据类型时，相等和不相等操作符遵循下列基本规则：
如果有一个操作数是布尔值，则在比较相等性之前先将其转换为数值——false 转换为 0，而true 转换为 1；
如果一个操作数是字符串，另一个操作数是数值，在比较相等性之前先将字符串转换为数值；
如果一个操作数是对象，另一个操作数不是，则调用对象的 valueOf()方法，用得到的基本类型值按照前面的规则进行比较；
这两个操作符在进行比较时则要遵循下列规则。
null 和 undefined 是相等的。
要比较相等性之前，不能将 null 和 undefined 转换成其他任何值（null == 0为false）。
如果有一个操作数是 NaN，则相等操作符返回 false，而不相等操作符返回 true。重要提示：即使两个操作数都是 NaN，相等操作符也返回 false；因为按照规则， NaN 不等于 NaN。NaN!=r任何-->
如果两个操作数都是对象，则比较它们是不是同一个对象。如果两个操作数都指向同一个对象，则相等操作符返回 true；否则，返回 false。
下表列出了一些特殊情况及比较结果：
2）全等和不全等
类型和数值完全相等
除了在比较之前不转换操作数之外，全等和不全等操作符与相等和不相等操作符没有什么区别。全等操作符由 3 个等于号（===）表示，它只在两个操作数未经转换就相等的情况下返回 true（类型和值都相等才相等），如下面的例子所示：
alert("55" == 55); //true
alert("55" === 55); //false不全等操作符由一个叹号后跟两个等于号（!==）表示，它在两个操作数未经转换就不相等的情况下返回 true。例如：
alert("55" != 55); //false
alert("55" !== 55); //truenull == undefined 会返回 true，因为它们是规定；
但 null === undefined 会返回 false，因为它们是不同类型的值。
由于相等和不相等操作符存在类型转换问题，而为了保持代码中数据类型的完整性，推荐使用全等和不全等操作符。
(3) in运算符
in运算符：检查右侧对象 里面 是否拥有 左侧 属性名，如果有返回true；反之，返回false。
var a = {
x: 1,
y: 2,
z: ''
};
console.log(a);
console.log('x' in a); //a能否使用x成员 true
console.log('z1' in a); //false
console.log('toString' in a); //true(4) instanceof运算符
检查左侧的对象 是否是 右侧类的实例，如果是返回true；
如果一个对象是一个“父类”的子类的实例，则一样返回true；
还有记住一点所有的对象都是Object的子类(后面原型链会讲到)。
var d = new Date();
console.log(d instanceof Date); //true
console.log(d instanceof Array); //false
console.log(d instanceof String); //false
console.log(d instanceof Object); //true6 条件操作符(三目运算)
开发时，建议使用if else，不建议使用这个
条件操作符应该算是 ECMAScript 中最灵活的一种操作符了，而且它遵循与 Java 中的条件操作符相同的语法形式，如下面的例子所示：
variable = boolean_expression ? true_value : false_value;本质上，这行代码的含义就是基于对 boolean_expression 求值的结果，决定给变量 variable赋什么值。如果求值结果为 true，则给变量 variable 赋 true_value 值；如果求值结果为 false，则给变量 variable 赋 false_value 值。
var max = (num1 > num2) ? num1 : num2; var myVar=("abc")?1:true;在这个例子中， max 中将会保存一个最大的值。这个表达式的意思是：如果 num1 大于 num2（关系表达式返回 true），则将 num1 的值赋给 max；如果 num1 小于或等于 num2 （关系表达式返回 false），则将 num2 的值赋给 max。
7 赋值操作符
var f1=new new Fn.rank()() //笔试题
简单的赋值操作符由等于号（=）表示，其作用就是把右侧的值赋给左侧的变量，如下面的例子所示：
var num = 10;
如果在等于号（=）前面再添加乘性操作符、加性操作符或位操作符，就可以完成复合赋值操作。
这种复合赋值操作相当于是对下面常规表达式的简写形式：
var num = 10; num = num + 10;其中的第二行代码可以用一个复合赋值来代替：
var num = 10; num += 10;//num=num+10
每个主要算术操作符（以及个别的其他操作符）都有对应的复合赋值操作符。这些操作符如下所示：
乘/赋值（*=）；
除/赋值（/=）；
模/赋值（%=）；
加/赋值（+=）；
减/赋值（-=）；
设计这些操作符的主要目的就是简化赋值操作。使用它们不会带来任何性能的提升。
8 逗号操作符
会把逗号隔开的表达式全部执行，最后一个运行的表达式的结果就是逗号运算符的结果
使用逗号操作符可以在一条语句中执行多个操作，如下面的例子所示：
console.log(num1,num2,num3) var num1=1, num2=2, num3=3;
逗号操作符多用于声明多个变量；但除此之外，逗号操作符还可以用于赋值。在用于赋值时，逗号操作符总会返回表达式中的最后一项，如下面的例子所示：
var a,b,c=20; //隐式操作 var a; var b; var c=20; var num = (5, 1, 4, 8, 0); // num 的值为 0 var re=(20+30,40,50) //结果为50
9 表达式计算
eval()可以解释运行由JavaScript源代码组成的字符串，并产生一个值；如果你使用了eval()，你要确定你确实需要使用它。
eval()只有一个参数。
如果传入的参数不是字符串，它直接返回这个参数。
如果参数是字符串，它会把字符串当成JavaScript代码进行编译，如果编译失败者抛出一个语法错误异常。如果编译成功，则开始执行这一段代码，并返回字符串中的最后一个表达式会或语句的值，如果最后一个表达式或语句没有值，则最终返回undefifined。如果字符串抛出一个异常，这个异常将把该调用传递给eval()。
关于eval最重要的是，它使用了调用它的变量作用域环境。也就是说，它查找变量的值和定义新变量和函数的操作和局部作用域中的代码完全一样。如果一个函数定义了一个局部变量x，然后调用eval(“x”)，它会返回局部变量的值。如果它调用eval(“x=1”)，它会改变局部变量的值。如果函数调用了eval(“vary=2;”),它声明了一个新的局部变量y，同样地，一个函数可以通过如下代码声明一个全局变量：
小练习：
console.log(num1,num2,num3)
var num1=1, num2=2, num3=3;
var num = (5, 1, 4, 8, 0); // num 的值为 0
eval("1+2"); // 3
console.log( eval(function f(){var x=10; return x+1;}) ); //非字符串
console.log( eval("function f(){var x=10; return x+1;}f();") ); //传入字符串
eval( "function f(){x=100;console.log(x);return x;};f();");
console.log(x);
var geval=eval; //使用别名geval调用eval将是全局eval
var x="global",y="global"; //global changed
function f(){
var x="local";
eval("x += ' changed';");
alert(x);//local changed
return x;
}
function g(){
var y="local";
geval("y += ' changed';");
alert(y); //local
} var arr=[1,2,3,5];
var re=arr.join("+");
console.log(re); //1+2+3+5
var re=eval("10+20");
console.log(re); //30
var arr=[20,30,23,43];
// var re=arr[0]+arr[1]+arr[2]+arr[3];
var re=eval(arr.join("+"));
console.log(re);10 表达式计算
20 19 18 经常考
new fn() 代表： (new fn()) new带参
new obj.fn() 代表 ： (new (obj.fn) ())
new new foo.rank()() 代表： new (new (foo.rank) ()) ()
2171
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
