JavaScript大杂烩13 - 总结ECMAScript 5新功能

                var Dog = {
  name : ‘dog‘,
  speak : function () { alert(‘Woof!‘); }
};
var dog = Object.create(Dog);
dog.speak();

Object.create = function (o) {
    function F() {}
    F.prototype = o;
    returnnew F();
};

                Object.create(prototype, descriptors)
参数
prototype:必需。 要用作原型的对象。 可以为 
                null
                ，一般也可以在需要的时候使用getPrototypeOf方法获取。
descriptors: 可选。 定义的一组属性的对象字面量，该对象包含了每个属性的描述对象。
属性描述对象称为属性的attributes对象，其含有如下成员：
value：表示该属性的值，默认为undefined。
writable：表示该属性的值(value)是否可以改变，默认为true。这个值如果是false的话，即使是继承的子类的话，也无法修改属性的值，这个也是讲得通的。
enumerable： 表示该属性是否可枚举，默认为true，也就是该属性会出现在for...in和Object.keys()等操作中。
configurable：表示“可配置性”，默认为true。如果设为false，表示无法删除该属性，也不得改变attributes对象(value属性除外)，也就是configurable属性控制了attributes对象本身的可写性。
get：表示该属性的取值函数(getter)，默认为undefined。
set：表示该属性的存值函数(setter)，默认为undefined。
返回值
一个具有指定的内部原型且包含指定的属性（如果有）的新对象。
            

                var Shape = { twoDimensional: true, color: ‘Red‘};
var Square = Object.create(Shape, {
  // 简单的属性，不包含任何的其他逻辑的属性
  type: { value: ‘square‘, enumerable: true, writable: true },
  // 复杂一点的属性，包含有一些逻辑的属性  size: {
    get: function() { returnthis.__size__;},
    set: function(pSize) {
      if (pSize > 10) alert(‘Too large...‘);
      // 其他的处理逻辑，例如简单的保存一下this.__size__ = pSize;
    },
    enumerable: true
  }
});
var square = Object.create(Square);
square.type = ‘rectangle‘;
alert(square.type);
square.size = 9;
alert(square.size);

                var Square = Object.create(Shape, (function () {
    var m_size;
 
    return {
      // 简单的属性，不包含任何的其他逻辑的属性
      type: { value: ‘square‘, enumerable: true, writable: true },
      // 复杂一点的属性，包含有一些逻辑的属性      size: {
        get: function() { return m_size;},
        set: function(pSize) {
          // 常见的条件检查if (pSize > 10) alert(‘Too large...‘);
          // 其他的处理逻辑，例如简单的保存一下
          m_size = pSize;
        },
        enumerable: true
      }
    };
}()));

                var Shape = { twoDimensional: true, color: ‘Red‘};
var square = Object.create(Shape);
Object.defineProperty(square, ‘type‘, {
    value : ‘square‘,
    enumerable : true,
    writable: true
});
square.type = ‘rectangle‘;
alert(square.type);

                var Shape = { twoDimensional: true, color: ‘Red‘};
var square = Object.create(Shape);
Object.defineProperties(square, (function () {
    var m_size;
 
    return {
      // 简单的属性，不包含任何的其他逻辑的属性
      type: { value: ‘square‘, enumerable: true, writable: true },
      // 复杂一点的属性，包含有一些逻辑的属性      size: {
        get: function() { return m_size;},
        set: function(pSize) {
          // 常见的条件检查if (pSize > 10) alert(‘Too large...‘);
          // 其他的处理逻辑，例如简单的保存一下
          m_size = pSize;
        },
        enumerable: true
      }
    };
}()));
square.type = ‘rectangle‘;
alert(square.type);
square.size = 9;
alert(square.size);

                var Shape = {
  get type() { returnthis.__type__;},
  set type(value) { this.__type__ = value;}
};
var square = Object.create(Shape);
square.type = ‘rectangle‘;
alert(square.type);

                var o = { name: ‘frank‘};
Object.defineProperties(o, {
        p1: { value: 1, enumerable: true },
        p2: { value: 2, enumerable: false }
});
alert(Object.keys(o));
alert(Object.getOwnPropertyNames(o));

                preventExtensions方法禁止对象添加新属性，isExtensible检测对象是否使用了preventExtensions方法。
seal方法禁止对象添加新属性和禁止删除已有属性，isSealed检测对象是否使用了seal方法。
freeze方法禁止对对象做任何修改，不能添加新属性和删除已有属性，也不能修改对象的属性值，isFrozen检测对象是否使用了freeze方法。
            

                var o = { name: ‘frank‘};
Object.preventExtensions(o);
o.age = 10;
alert(o.age); //undefined，代表无法添加新属性Object.seal(o);
delete o.name;
alert(o.name); // 删除不了Object.freeze(o);
o.name = ‘dong‘;
alert(o.name); // 无法修改

                var a = [‘a‘,‘b‘,‘c‘,‘b‘];
alert(a.indexOf(‘b‘)); // 1
alert(a.indexOf(‘y‘)); // -1
alert(a.lastIndexOf(‘b‘)); // 3

[1, 2, 3].map(function(item, index, arr){
    return item * item;
});
// [1, 4, 9]

[].map.call(‘abc‘, function (x) { return x.toUpperCase() })
// [ ‘A‘, ‘B‘, ‘C‘ ]
// 或者
‘abc‘.split(‘‘).map(function (x) { return x.toUpperCase() })
// [ ‘A‘, ‘B‘, ‘C‘ ]

[1, 2, 3].forEach(function(item, index, arr){
    console.log("array[" + index + "] = " + item);
});
// array[0] = 1
// array[1] = 2
// array[2] = 3

                var out = [];
[1, 2, 3].map(function(item, index, arr){
    this.push(item * item);
}, out);
out // [1, 4, 9]

[1,2,3,4,5].filter(function(item){
    return (item>3);
})
// [4,5]

[1, 2, 3, 4, 5].filter(function(item, index, arr){
    return index % 2 === 0;
});
// [1, 3, 5]

[1, 2, 3, 4, 5].some(function(item, index, arr){
    return item >= 3;
});
// 返回true

[1, 2, 3, 4, 5].every(function(item, index, arr){
    return item >= 3;
});
// 返回false

                用来累计的变量（即当前状态）
数组的当前元素
当前元素在数组中的序号（从0开始）
原数组
            

[1, 2, 3, 4, 5].reduce(function(x, y){
    return x+y;
});
// 15

Array.prototype.sum = function (){
    returnthis.reduce(function (partial, value){
        return partial + value;
    })
};
[3,4,5,6,10].sum()
// 28

[1, 2, 3, 4, 5].reduce(function(x, y){
    return x+y;
}, 10);
// 25

                function
                 findLongest(entries) {
  
                return entries.reduce(function (longest, entry) {
    return entry.length > longest.length ? entry : longest;
  }, ‘‘);
}

                var names = [‘Collis‘, ‘Cyan‘];
Array.isArray(names); // true

                //
                 仅仅绑定了this，还需要主动的通过对象去调用
tooltip.show = showText.bind(tooltip);
tooltip.show();
overlay.show = showText.bind(overlay);
overlay.show();
// 直接调用的apply/call形式showText.call(tooltip);
showText.call(overlay);

                Date.now()

                //
                 1364026285194类似的数字
            

                window.performance.now()

                //
                 21311140.415类似的数字
            

alert(new Date().toJSON());

" hello world ".trim()
// "hello world"