一些容易错的JS知识

void();

上面表达式的结果是：

void  0; //undefined
void (0);//undefined
void (); //SyntaxError 语法错误

NOSCRIPT标签

用来定义在脚本未被执行时的替代内容。也可以用在检测浏览器是否支持脚本，若不支持脚本则可以显示NOSCRIPT标签里的innerText
noscript:用以在不支持js的浏览器中显示替代的内容，这个元素可以包含能够出现在文档中任何html元素，script元素除外。包含在noscript元素的内容只有在下列情况下才会显示出来

1.浏览器不支持脚本
2.浏览器支持脚本，但脚本被禁用

options

window.onload = function(){ 
//首先获得下拉框的节点对象； 
var obj = 
document.getElementById("obj"); 
//1.如何获得当前选中的值？： 
var value = obj.value; 
//2.如何获得该下拉框所有的option的节点对象 
var options = obj.options; 
//注意：得到的options是一个对象数组 
//3.如何获得第几个option的value值?比如我要获取第一option的value,可以这样： 
var value1 =options[0].value; 
//4.如何获得第几个option的文本内容?比如我要获取第一option的文本,可以这样： 
var text1 = options[0].text; 
//5.如何获得当前选中的option的索引？ 
var index = obj.selectedIndex; 
//6.如何获得当前选中的option的文本内容？ 

//从第2个问题，我们已经获得所有的option的对象数组options了 
//又从第5个问题，我们获取到了当前选中的option的索引值 
//所以我们只要同options[index]下标的方法得到当前选中的option了 
var selectedText =options[index].text; }

+new Array(017) 输出？（）

+new Array(017) 等价于 + new Array(15) （15的八进制是17）

按照规则，数组对象应该采用Number，所以先执行valueOf，发现valueOf返回的是自己，所以继续执行toString，过程如下：

Number(new Array(15)) 
// new Array(15).valueOf()不是原始值,所以执行toString()
Number(new Array(15).toString()) 
Number(",,,,,,,,,,,,,,") 
NaN
所以答案是NaN

引用类型

var a=[1], b=a;
a=[];
console.log(b)
// [1]

var a=[1], b=a;
a.length=0;
console.log(a)
// []

单例模式

是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。
单例模式的要点有三个；一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。
angularjs的服务是一个单例对象或函数，对外提供特定的功能。

JavaScript RegExp 对象

有 3 个方法：test()、exec() 和 compile()。

(1) test() 方法用来检测一个字符串是否匹配某个正则表达式，如果匹配成功，返回 true ，否则返回 false；
(2) exec() 方法用来检索字符串中与正则表达式匹配的值。exec() 方法返回一个数组，其中存放匹配的结果。如果未找到匹配的值，则返回 null；
(3) compile() 方法可以在脚本执行过程中编译正则表达式，也可以改变已有表达式。

JavaScript中运算符优先级

https://www.cnblogs.com/thinkguo/p/7446880.html
括号 new 逻辑运算乘除，加减，大小余，等于，赋值，展开

（）括号
new(..) 带参数的new
...(..) 函数调用
++ 、-- 后置叠加/减
!,~,+,-，++ ，--，typeof,void,delete 逻辑非，按位非，前置叠加，一元运算符
^ 幂运算
*，/ ,% 乘除取余
+，- 加减
按位移动
<,<=,>,>=, in , instanceof 大于小于
== ，！=， === ，！== 等于
按位逻辑运算
赋值
展开运算
逗号

在 JS 里，声明函数只有 2 种方法：

// 输出
var f = function g() {
        return 23;
    };
typeof g();  // Error;

第 1 种： function foo(){...} （函数声明）
第 2 种： var foo = function(){...} （等号后面必须是匿名函数，这句实质是函数表达式）

除此之外，类似于 var foo = function bar(){...} 这样的东西统一按 2 方法处理，即在函数外部无法通过 bar 访问到函数，因为这已经变成了一个表达式。

但为什么不是 "undefined"？
这里如果求 typeof g ，会返回 undefined，但求的是 g()，所以会去先去调用函数 g，这里就会直接抛出异常，所以是 Error。

原型链

var F=function(){};
Object.prototype.a=function(){};
Function.prototype .b=function(){};
var f=new F();
console.log(f.a,f.b,F.a,F.b)
// ƒ (){} undefined ƒ (){} ƒ (){}

f.__proto__ === F.prototype
// true
F.prototype.__proto__===Object.prototype
// true
f.__proto__.__proto__ === Object.prototype
// true
F.__proto__===Function.prototype
// true

类型转换

三元运算符先“分清是非”，再决定今后该走哪条路，“==”运算符比较“喜欢”Number类型。（我就不严谨地这么一说，若要刨根问底，请看《JavaScript权威指南》）

console.log(([])?true:false);    // Boolean([])  true
console.log(([]==false?true:false));   // true
console.log(({}==false)?true:false)   // false

下面是题目的类型转换结果：

Boolean([]); //true
Number([]); //0
Number({}); // NaN
Number(false); //0
因此：

console.log(([])?true:fasle);// => console.log((true)?true:false);
console.log([]==false?true:false); // => console.log(0==0?true:false);
console.log(({}==false)?true:false); // => console.log((NaN==0)?true:false);

总结来说

1.false 、 0、 '' 、 [] 是相等的
2.null、undefined 是相等的，且等于自身
1. NaN、{} 和什么的都不相等，自己跟自己都不相等

NaN == NaN  //false
NaN == undefined //false
NaN == false //false
NaN == null //false
NaN==[]  //false
NaN==''  //false
NaN=={}  //false

false == false  //true
false == undefined  //false
false == null  //false
false == []  //true
false == {}  //false
false == ''  //true

undefined == undefined //true
undefined == null  //true
undefined == false //false
undefined == [] //false
undefined == {}  //false
undefined == '' //false

null == null   //true
null == NaN  //false  
null == []  //false
null == {}  //false
null == undefined  //true

0==false    //true   
0 == []  //true
0 == {}  //false
0 == null  //false
0 == undefined //false
0 == '' //true
0 == NaN //false

false == []  //true
false == {}  //false
false == null  //false
false == undefined  //false
false == ''  //true
false == NaN  //false

[]=={} //false

Boolean([])   //true
Boolean({})   //true
Boolean(null)  //false
Boolean(NaN) //false
Boolean(undefined)  //false
Boolean('')  //false
Boolean(0)  //false

Number(undefined)  //NaN
Number({})    //NaN
Number(NaN)  //NaN
Number('')  //0
Number([])    //0
Number(false)  //0
Number(null)  //0