javascript高级语法学习

可维护的代码意味着：
    可读的
    一致的
    可预测的
    看上去就像是同一个人写的
    已记录

命名函数表达式 
(function fn(){})
他是表达式的原因是因为括号 ()是一个分组操作符，它的内部只能包含表达式


eval('(' + json + ')')
JSON字符串通常被包含在一个圆括号里，会让解析器强制将JSON的花括号解析成表达式而不是代码块


JavaScript核心
1.对象Object
Object是一个属性的集合，并且都拥有一个单独的原型对象[prototype object]. 这个原型对象[prototype object]可以是一个

object或者null值。

2.原型链__proto__
原型链是一个由对象组成的有限对象链用于实现继承和共享属性。
var a = {
  x: 10,
  calculate: function (z) {
    return this.x + this.y + z
  }
};
 
var b = {
  y: 20,
  __proto__: a
};
 
var c = {
  y: 30,
  __proto__: a
};
 
// 调用继承过来的方法
b.calculate(30); // 60

3.构造函数constructor
自动为创建的新对象设置了原型对象(prototype object) 。原型对象存放于 ConstructorFunction.prototype 属性中 。
// 构造函数
function fn(y) {
  this.y = y;
}
// 继承属性"x"
Foo.prototype.x = 10;
var b = new Foo(20);
b.__proto__ === fn.prototype; // true

// "fn.prototype"自动创建了一个特殊的属性"constructor"，并指向b的构造函数本身
b.constructor === fn; // true
fn.prototype.constructor === fn // true


4.执行上下文
var a = function (e) {
   return {
        // 暴露公开的成员
        add: function (x, y) {
        }
    };
}
调用：
ar o = new a('e');
o.add(2, 2);

引用全局变量
(function ($) {
    调用：$
} (jQuery));

var o = (function ($) {
	var my = {name = 'sn'}
	return my;
})(jQuery);
调用：o.name

扩展
var o = (function (my) {
    my.add = function () {};
    return my;
} (obj));

松耦合扩展
var o = o || {} ;
var o = (function (my) {
    return my;
} (jQuery || {})); 

克隆与继承
var o = (function (old) {
    var my = {},key;
    for (key in old) {
        if (old.hasOwnProperty(key)) {
            my[key] = old[key];
        }
    }
    return my;
} (obj));
子模块
obj.sub = (function () {
    var my = {};
    return my;
} ());

 

函数语法
if (typeof Function.prototype.method !== "function") {
    Function.prototype.method = function (name, call) {
        this.prototype[name] = call;
        return this;
    };
}
扩展对象
var fn = function (name) {
    this.name = name;
}
.method('get',
	function () {
	return this.name;
})
调用
var a = new fn('p');
a.get(); 

 

var app = app || {};
(function () {
   app = {
        isArray: isArray,
        inArray: indexOf
    };
} ());

 

// 第一个参数为要应用的function，第二个参数是需要传入的最少参数个数
        function funcArgs(func, minArgs) {
            if (minArgs == undefined) {
                minArgs = 1;
            }
            function func(oargs) {
                return function () {
                    // 优化处理，如果调用时没有参数，返回该函数本身
                    var args = Array.prototype.slice.call(arguments);
                    var nrgs = oargs.concat(args);
                    if (nrgs.length >= minArgs) {
                        return func.apply(this, nrgs);
                    } else {
                        //返回该函数本身
                        return func(nrgs);
                    }
                };
            }
            return func([]);
        }
        //定义加法
        var plus = funcArgs(function () {
            var result = 0;
            for (var i = 0; i < arguments.length; ++i) {
                result += arguments[i];
            }
            return result;
        }, 2);
        //定义减法
        var minus = funcArgs(function (x) {
            var result = x;
            for (var i = 1; i < arguments.length; ++i) {
                result -= arguments[i];
            }
            return result;
        }, 2);

        plus(3, 2)       // 正常调用
        plus(3)          // 偏应用，返回一个函数（返回值为3+参数值）
        plus(3)(2)       // 完整应用（返回5）
        plus()(3)()()(2) // 返回 5
        plus(3, 2, 4, 5) // 可以接收多个参数
        plus(3)(2, 3, 5) // 同理

 

        //添加方法（函数）
        Function.prototype.method = function (name, fn) {
            this.prototype[name] = fn;
            return this;
        };
        //给构造函数添加方法
        Array.method('filter', function (fn, obj) { var a = []; return a; });
        //队列实现
        window.Queue = function () { }
        window.Queue
        .method("add", function (a, b) { return a + b; })
        .method("sub", function (a, b) { return a - b; });
        //调用
        var obj = new window.Queue();
        console.log(obj.add(1, 2));  //3
        console.log(obj.sub(3, 1));  //2

 

passport.pop = passport.pop || {};
passport.pop.insertScript = passport.pop.insertScript ||
function (b, a) {
    var e = document,
	c = e.createElement("script");
    c.type = "text/javascript";
    c.charset = "UTF-8";
    if (c.readyState) {
        c.onreadystatechange = function () {
            if (c.readyState == "loaded" || c.readyState == "complete") {
                c.onreadystatechange = null;
                a && a()
            }
        }
    } else {
        c.onload = function () {
            a && a()
        }
    }
    c.src = b;
    e.getElementsByTagName("head")[0].appendChild(c)
};