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)
};