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