你应该知道的javascript（一些知识点小汇复习）

作用域

JavaScript类似于C的语法，因此， 一个代码块（括在一对花括号里的一组语句会创造一个作用域）

var foo = "test";
        if (true)
            var foo = "new test";
        alert(foo); //output "new test"

        {
            var foo = "old test"; //output "old test"
            alert(foo);
        }
        //精通JavaScript里面的写法
        (function() {
            var foo = "old test"; //output "old test"
            alert(foo);
        })();

自动插入分号

window.onload = function() {
            alert(getReturn1()); //output undefined
            alert(getReturn2()); //output object
        }

        function getReturn1() {
            return//这里会自动插入分号，等于返回一个 undefined
            {
                state: true
            };
        }
        function getReturn2() {
            return {
                state: true
            }; //这样才能得到这个json对象
        }

typeof

typeof是一个一元运算符，它返回的结果始终是一个字符串，对不同的操作数，它返回不同的结果。
具体的规则如下：

一、对于数字类型的操作数而言， typeof 返回的值是 number。比如说：typeof(1)，返回的值就是number。
上面是举的常规数字，对于非常规的数字类型而言，其结果返回的也是number。比如typeof(NaN)，NaN在<>Script中代表的是特殊非数字值，虽然它本身是一个数字类型。
在JavaScript中，特殊的数字类型还有几种：
Infinity 表示无穷大特殊值
NaN 特殊的非数字值
Number.MAX_VALUE 可表示的最大数字
Number.MIN_VALUE 可表示的最小数字（与零最接近）
Number.NaN 特殊的非数字值
Number.POSITIVE_INFINITY 表示正无穷大的特殊值
Number.NEGATIVE_INFINITY  表示负无穷大的特殊值
以上特殊类型，在用typeof进行运算进，其结果都将是number。
二、对于字符串类型， typeof 返回的值是 string。比如typeof("123")返回的值是string。
三、对于布尔类型， typeof 返回的值是 boolean 。比如typeof(true)返回的值是boolean。
四、对于对象、数组、null 返回的值是 object 。比如typeof(window)，typeof(document)，typeof(null)返回的值都是object。
五、对于函数类型，返回的值是 function。比如：typeof(eval)，typeof(Date)返回的值都是function。
六、如果运算数是没有定义的（比如说不存在的变量、函数或者undefined），将返回undefined。比如：typeof(sss)、typeof(undefined)都返回undefined。

ps： null的undefined最简明的区别说明

null :表示无值;
undefined : 表示一个未声明的变量，或已声明但没有赋值的变量，或一个并不存在的对象属性。==运算符将两者看作相等。如果要区分两者，要使用===或typeof运算符。
使用if (!object){}两者就都包含了

   

parseInt（）

.       alert(parseInt("18po")); //18
        alert(parseInt("08")); //0 如果参数为0开始，那么将会使用8进制计算。parseInt("08"，10);这样即可
         alert(parseInt("po18")); //NaN
        alert(parseInt("dsds"));//NaN

浮点数字

alert((0.1+0.2).toFixed(1));//这样才能得到0.3； 因为js的浮点数计算有bug
                            //0.1+0.2  会得到0.30000000000000000000004类似这样的数字

关于NaN

假值

window.onload = function() {
            if (!0)
                document.getElementById("div").innerHTML += "0<br>"
            if (!NaN)
                document.getElementById("div").innerHTML += "NaN<br>"
            if (!'')
                document.getElementById("div").innerHTML += "''空字符串<br>"
            if (!false)
                document.getElementById("div").innerHTML += "false<br>"
            if (!null)
                document.getElementById("div").innerHTML += "null<br>"
            if (!undefined)
                document.getElementById("div").innerHTML += "undefined<br>"
        }
        //以上都会输出

==运算符

 

对象原型链

/*
  每个对象实例都有个属性成员用于指向到它的instanceof 对象(暂称为父对象)的原型(prototype)
  我们把这种层层指向父原型的关系称为[原型链 prototype chian]
  原型也具有父原型，因为它往往也是一个对象实例，除非我们人为地去改变它


  Function的父原型指向到Function的原型，Function.prototype的父原型是Object的原型
  Object的父原型也指向到Function的原型，Object.prototype是所有父原型的顶层
  在spiderMonkey引擎中，父原型可以通过 __proto__ 进行访问
*/

Function.prototype.hi = function(){alert('hi Function');}
Object.prototype.hi = function(){alert('hi Object');}

var a = function(){
  this.txt = "a";
}
a.prototype = {
  say:function(){alert('a');}
}

alert(a instanceof Function);//a是Function的实例;
alert(a.__proto__ === Function.prototype);//a的父原型指向到Function的原型;

alert(Function instanceof Object);//Function是Object的实例;
alert(Function.__proto__ === Function.prototype);//Function的父原型指向到Function的原型;
alert(Function.prototype.__proto__ === Object.prototype);//Function的原型的父原型指向到Object的原型

alert(Object.__proto__ === Function.prototype);//Object的父原型指向到Function的原型;
alert(Object.prototype.__proto__);//Object的原型是所有父原型的顶端，它不再具有父原型;


alert(a.prototype instanceof Object);//a的原型也是一个对象
alert(a.prototype.__proto__ === Object.prototype);//a的原型的父原型指向Object的原型



var A = function(){};
A.prototype = new a();
A.prototype.say = function(){
  alert('A');
}

alert(A instanceof Function);//A是Function的实例
alert(A.__proto__ === Function.prototype);//A的父原型指向到Function的原型
alert(A.prototype instanceof a);//A的原型是a的实例
alert(A.prototype.__proto__ === a.prototype);//A的原型的父原型指向到a的原型


var iA = new A();//iA是A的实例,iA.__proto__ === A.prototype
var iB = new a();//iB是a的实例,iB.__proto__ === a.prototype

iA.hi();
/*
iA本身没有hi方法（构造中没有，自己也没有定义过），
于是找iA的prototype，没有找到，
于是找iA.__proto__即A.prototype，也没有找到，
于是再找A.prototype.__proto__即a.prototype，仍然没有发现，
继续查找a.prototype.__proto__即Object.prototype，哇，发现了hi，于是调用它，停止查找
输出：hi Object
*/

iB.hi();
/*
iB本身没有hi方法（构造中没有，自己也没有定义过），
于是找iB的prototype，没有找到，
于是找iB.__proto__即a.prototype，仍然没有发现，
继续查找a.prototype.__proto__即Object.prototype，哇，发现了hi，于是调用它，停止查找
输出：hi Object
*/

a.hi();
/*
a本身没有hi方法（构造中没有，自己也没有定义过），
于是找a的prototype，没有找到，
于是找a.__prototype__既Function.prototype，哇，发现了hi，于是调用它，停止查找
输出：hi Function
*/

iA.say();
/*
iA本身没有say方法（构造中没有，自己也没有定义过），
于是找iA的prototype，没有找到，
于是找iA.__proto__即A.prototype，也没有找到，
于是再找A.prototype.__proto__即a.prototype，哇，发现了hi，于是调用它，停止查找
所以，这里调用的是A.prototype.say
输出：A
*/

iB.say();
/*
iB本身没有say方法（构造中没有，自己也没有定义过），
于是找iB的prototype，没有找到，
于是找iB.__proto__即a.prototype，哇，发现了say，于是调用它，停止查找
所以，这里调用的是a.prototype.say
输出：a
*/

iA.bad();
/*
iA本身没有hi方法（构造中没有，自己也没有定义过），
于是找iA的prototype，没有找到，
于是找iA.__proto__即A.prototype，也没有找到，
于是再找A.prototype.__proto__即a.prototype，仍然没有发现，
继续查找a.prototype.__proto__即Object.prototype，终于是找不到了，停止查找
返回错误，iA.bad不是一个function
*/