匿名函数

匿名函数的优势
1.可以节省全局变量
2.可以节省一些代码:讲一个函数调用操作委托给另一个函数
3.有助于提高性能
匿名函数笔记
原贴:js匿名函数和闭包总结 - 范仁义 - 博客园 (cnblogs.com)
一句话总结:匿名函数的最主要作用是创建闭包,闭包就是将函数内部和函数外部连接起来的一座桥梁.内层的函数可以使用外侧函数的所有变量,即使外层函数已经执行完毕. 闭包可以用来模仿块级作用域等等.
匿名函数基本格式:

var fn = function(){}//匿名函数赋值给变量

(function(){//匿名函数通过表达式自我执行
)();

var name = 'The window';
var obj={
  name:'my obj';
  get:function(){
    return function(){
      return this.name;
    }
  }
}
obj.get()();//全局变量name的值'The window'
obj.get().call(obj);//使用call()强制this指向obj

闭包的作用
1.通过闭包可以访问局部变量
2.可以让局部变量始终保持在内存中:避免使用全局变量
3.循环函数中的匿名函数和闭包问题

function add(){
    var num = 100;
    return function(){num++;}
};
var fn = add();//初始化
fn();//执行里面的匿名函数
fn=null;//记得要释放内存

getter和setter

var getValue,setValue;
(function(){
    var secret = 0;
    getValue = function(){
        return secret;
    };
    setValue = function(v){
        secret = v;
    };
})

迭代器

function setup(x)
{
    var i=0;
    return function(){
        return x[i++];
    }
}
var next = setup([1,2,3]);

对象

function f(){return arguments.callee;};//返回自身引用

//匿名函数递归调用
(
    function(count)
    {
        if(count < 5)
            arguments.callee(++count);
    }
)(1);

所有的引用类型都继承了 Object,所有的对象都拥有 Object 具有的一些默认的方法。如：hasOwnProperty()、propertyIsEnumerable()、toLocaleString()、toString() 和 valueOf()

继承

简单的继承

function A(){
    this.name = "A";
};
function B(){
    this.name = "B";
}
A.prototype = new B();
//对prototype完全重写时,会对它的constructor产生负面影响
A.prototype.constructor = A;

JavaScript中的8种继承
原贴:https://cloud.tencent.com/developer/article/1851143

1.原型链继承
缺点:
无法实现多继承
引用类型的值会被实例共享
子类型无法给超类型传递参数

function Parent(){
    this.parentName = "father";
}
Parent.prototype.getParentName = function(){
    return this.parentName;
}
function Child(){
    this.childName = '子类';
}
Child.prototype = new Parent();
Child.prototype.getChildName = function(){
    return this.childName;
}
console.log(new Child().getParentName());

2.借用构造函数继承（对象冒充）
缺点:
不能继承超类原型上的属性和方法
无法实现函数复用，由于 call 有多个父类实例的副本，性能损耗
原型链丢失

function Parent(name){
    this.name = name;
}
function Child(name){
    Parent.call(this,name);//将Parent的name属性复制到Child中
    this.age = 24;
}
var c1=new Child("ming");
console.log(c1.name);

3.组合模式继承(原型链+借用构造函数继承)
缺点:
调用了 2 次超类型构造函数：一次在子类构造函数内，另一次是将子类的原型指向父类构造的实例

function Parent(name) {
    this.name = name;
}
Parent.prototype.getName=function()
{
    return this.name;
}
function Child(name)
{
    Parent.call(this,name);
    this.age = 24
}
//补充[借用构造函数继承]中丢失的原型链
Child.prototype = new Parent('父类');
var c1 = new Child("c1");
console.log(c1.getName()==c1.name);//true

4.共享原型继承
缺点:
只能继承父类原型属性方法，不能继承构造函数属性方法
引用类型的值会被实例共享

function Parent(){}
Parent.prototype.hobbies = ["sing","dance","rap"];
function Child(name)
{
    this.name = name;
}
Child.prototype = Parent.prototype;
var c1 = new Child('c1');
console.log(c1.hobbies);

5.原型式继承:ES5 新增了 Object.create() 方法规范化了原型式继承

function createAnother(o)
{
    function F(){}
    F.prototype = o;
    return new F();
}
var o1 = {
    name:'父类对象',
    say:function(){}
}
var o2 = createAnother(o1);
console.log(o2.name);

6.寄生式继承:结合原型式继承和工厂模式，创建一个仅用于封装继承过程的函数

function createAnother(origin)
{
    var clone = Object.create(origin);//原型式继承
    clone.sayHi = function(){console.log("Hi");}
    return clone;
}
var o1 = {
    name:'父对象',
    hobbies:["sing","dance","rap"]
};
var o2 = createAnother(o1);
o2.sayHi();

7.寄生组合式继承:JavaScript中最完美的继承方式

//写法
function inheritPrototype(SubType,SuperType)
{
    var prototype = Object.create(SuperType.prototype);
    prototype.constructor = SubType;
    SubType.prototype = prototype;
}
//实例
function Parent(name)
{
    this.name = name;
}
Parent.prototype.getName = function(){
    return this.name;
}
function Child(name){
    Parent.call(this,name);
    this.age = 24;
}
Child.prototype = Object.create(Parent.prototype);
Child.prototype.constructor = Child;

var c1 = new Child('c1');
console.log(c1.name);