你应该知道的几个js知识

1.在javascript的块级作用域是以函数来决定的.

     if(true){
         var scopeName = "felayman";
     }
    print(scopeName);

 <span style="font-size:18px;"> function scope(){
        if(true){
            var scopeName = "felayman";
        }
    }</span>

2.javascript中的变量查找链,如

 <span style="font-size:18px;">   var scope = "golbalScope";
    var fun = function(){
       alert(scopr);
        var scope = "funcScope";
    };
    fun();</span>

抛弃掉上一级环境的var scope = "golbalScope";也就是var scope = "golbalScope";会被变量scope所在的环境给屏蔽掉,然后当程序执行到alert(scope);的时候,但是

scope在当前环境中并没有进行初始化,因而输出了undefined.

3.javascript的函数作用域的嵌套

<span style="font-size:18px;"> var fun = function(){
    var scope = "scope_one";
    (function(){
        alert(scope);
        var scope = "scope_two";
        (function(){
            alert(scope);
        })();
    })();
};
fun();</span>

<span style="font-size:18px;">function print(s){document.write(s+"<br/>")};
  var getResult = function(){
    var count = 0;
    var get = function(){
        count++;
        return count;
    };
    return get;
};
var counter = getResult();
print(counter());
print(counter());
print(counter());</span>

<span style="font-size:18px;">/**
 * Created by felayman on 2014/5/27.
 */
  function print(s){document.write(s+"<br/>")};
  var getResult = function(){
    var count = 0;
    var get = function(){
        count++;
        return count;
    };
    print(get());
    print(get());
    print(get());
};
getResult()</span>;

 function print(s){document.write(s+"<br/>")}
    var func1 = {
        name:"func1scope",
        func:function(){
            print(this.name);
        }
    };
    var func2 = {
        name:"func2scope"
    };
    func1.func();  //输出func1
    func2.func = func1.func;
    func2.func();  //输出func2
    var name = "windowscopr";
    window.func = func1.func;
    func();

5.call和apply

如果说在javascript中最让人困惑和难以理解的,

其中call和apply的功能是以不同的对象作为上下文来调用某个对象的函数,或者--就是允许在一个对象中去调用另一个对象中的同名函数(没有会被复制)并执行(摘自--NodeJS开发指南).如下面的例子:

<span style="font-size:18px;">var oneUser = {
    name:"oneUser",
    getName:function(){
        alert(this.name);
    }
};
var otherUser = {
    name:"otherUser",
};
oneUser.getName.call(otherUser);</span>

如果要给原型一个定义,百度百科上说的很详细,但是很抽象,很难理解,而在NodeJs开发指南中,作者用了一个很好的例子----原型就好像是一件艺术品的原件,我们通过一台100%精确的机器把这个原件复制出很多件,如果我们了解类似java的面向对象语言的话,就会知道,在java中所有的对象都来自于类,而C++中所有的对象来自于构造器,但是javascript是一种基于面向对象语言,它既有类似C++的构造器,也有类似类的原型.其实我更倾向于一篇博文中的理解,在javascript中

,原型就是java中的一个类的一个对象,该对象存储该类的所有静态属性或方法.我更建议使用这种方法来理解原型.因为的确是这样的,javascript中使用原型的目的就是让某一类型的所有对象共享一些属性和函数,提供代码的复用性,同时也隐藏一些属性和函数的细节,即提高其内聚性和封装性,这也是javascript基于面向对象的特性.

<span style="font-size:18px;">function Person(name,age,job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.getInfo = function(){
        return "name ="+this.name+",age = "+ this.age+",job = " +this.job;
    }
}
</span>

<span style="font-size:18px;">function Person(name,age,job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.getInfo = function(){
        return "name ="+this.name+",age = "+ this.age+",job = " +this.job;
    }
    this.say = function(){
        alert("人都会说话");
    }
}
</span>

这样的代码是允许的,但是不是被建议的,因为我们在创建一个Person对象的时候,就会在内存中生成say()函数的内容空间,或许在少量的这样的行为的时候我们允许这么做,但是我们再思考一下,如果一个函数中有大量的行为或者属性都像say()函数一样是每一个Person对象所共同拥有的,必然Person会说话,会跑,会思考,会苦,会笑.........如果有了大量类似的属性或行为的话,我们还是写在函数内部的话,就不好了,因为我们在创建基量很大的对象数量的时候,我们就额外增加了非必须且可避免的内存开销了,因为每个对象在内存中都会开辟其所拥有的方法空间,这是不建议的,因此,我们使用了原型的话,这个问题就可以避免了,我们只需要在内存的其他地方创建一个原型对象,改对象保存着Person所有的共同属性或者方法,只要在每个Person实例对象中保存一个指向改内存空间的引用或句柄即可.这样当我们即使创建再多Person实例对象,也没有多少内存开销,这个理解就是javascript原型的特性之一.因此上述代码改写成下面就好了:

<span style="font-size:18px;">function Person(name,age,job){
    this.name = name;
    this.age = age;
    this.job = job;
}
Person.prototype.getInfo = function(){
    return "name = "+this.name+",age = "+this.age+",job ="+this.job;
};
Person.prototype.say  =function(){
    console.log("人都会说话");
};</span>

你应该知道的几个js知识,古老的榕树,5-wow.com