ES5的一些新鲜玩意儿

 一.解析JSON

 JSON.parse()能够把JSON格式的文本转换成ECMAScript值（对象或者数组）。

语法:JSON.parse(text[,revier])   ————参数 text表示一个有效的JSON字符串，最后返回的是一个对象或者数组。

var jsontext='{"name":"张三","qq":"11111","phone":["010-666666","010-777777"]}';  //JSON字符串
		var contact=JSON.parse(jsontext);    //JSON.parse()方法
		document.write(contact.name+","+contact.qq+","+contact.phone[1]);   //张三,11111,010-777777

来说下,revier这个参数函数常见的作用吧，一般用来过滤，可选参数revier是一个带有key,value两个参数的函数，其作用于结果，让过滤和转换返回值成为可能，则先于父对象转换嵌套对象。值得注意的是，如果函数返回的是一个null或者undefined，则删除成员。

		var n='{"a":"1.5","b":"2.3"}';  //JSON字符串
		var result=JSON.parse(n,int);    //JSON.parse方法，有两个参数，一个为json字符串，一个为reviver参数函数
		document.write(result.a);
		function int(key,value){      // reviver参数函数

			if(typeof value =='string'){  //取出每一个对象的value，进行操作
				return parseInt(value);
			}
			else {
				return value;
			}
		}   //输出结果为1；

二.序列化JSON

JSON.stringify()函数能够将JS值转换为JSON字符串。

JSON.stringify(value[,replace][,space]) ————value为要转换的JS值，通常为对象或者数组。  replace为用于转换结果的函数或者数组。space为格式。

值得注意的是：replace为函数时，JSON.stringify()将调用该函数，并传入每个成员的建和值，使用的是返回值而不是原值。如果函数返回的是undefined，则排除该成员/

replace为数组，则仅转换该数组中具有键值的成员，当value也为数组时，将忽略replace数组。

                var arr=["a","b","c"];  //数组
		var str=JSON.stringify(arr);    //调用JSON.stringify()方法，转化为JSON字符串
		document.write(str);
		document.write("<br/>");


		var newArr =JSON.parse(str);    //调用JSON.parse()方法，重新转化为JS数组，并输出。
		while(newArr.length>0){
			document.write(newArr.pop()+"<br/>");
		}

再来看看，JSON.stringify()有第二个参数并且为函数的情况。

     var nums={
			"first":7,
			"second":14,
			"third":13
		}
		var luckyNums =JSON.stringify(nums,replacer);  
		document.write(luckyNums);
		function replacer(key,value){   //replacer为参数函数，目的是过滤原数组中的成员。
			if(value==13){
				return undefined;   //返回undefined ,移除该成员   
			}
			else{
				return value;
			}

		}   //输出  {"first":7,"second":14}

再来看一个第二个参数为数组的情况下。

                var nums={
			"first":"HUHUI",
			"second":"is",
			"third":"coder"
		}
		var replacer=["first"];  //第二个参数为数组，只有该数组中具有键值的成员，才能输出。
		var luckyNums =JSON.stringify(nums,replacer);
	    document.write(luckyNums);  //{"first":"HUHUI"}

三.Object

1.创建对象：

     Object.create(prototype,descriptpors)   ——prototype:必需参数，要作原型的对象，可以为null。descriptpors：可选参数，包含一个或多个属性描述符的JS对象。

     

 var newObj = Object.create(null,{   //var 一个新对象，使用create这个方法，第一个参数为指定原型对象，此处为null。第二个参数为一个或多个属性描述符的JS对象，value是作为描述符出现的
        size:{
            value:"larger",
            enumerable:true
        },
        shpae:{
            value:"round",
            enumerable:true
        }
    });
    document.write(newObj.size +"<br/>")
    document.write(newObj.shape +"<br/>")
    document.write(Object.getPrototypeOf(newObj) +"<br/>");  //larger
                                                                                       // undefined
                                                                                          // null

    2.定义属性：

  Object.defineProperty(object,properyname,descriptor)  ——object：必需参数，指定要添加或修改属性的对象。properyname:必需参数，表示一个包含属性名称的字符。descriptor：必需属性，定义属性的描述符。

Object.defineProperty（）的返回值为已修改的对象。

和Object.defineProperties()

 var obj={};  //创建一个新的空对象  
   Object.defineProperty(obj,"newDataProperty",{     //使用Object.defineProperty定义属性
       value:101,
       writable:true,
       enumerable:true,
       configurable:true
   });
   document.write(obj.newDataProperty +"<br/>");  //101
   obj.newDataProperty=102;   // /修改属性
   document.write(obj.newDataProperty);   //102

3.访问属性：

   Object.getPrototype(object)  ——参数object表示指定的对象，返回值是参数object的原型对象。

Object.getOwnPropertyNames(object) ——返回对象私有的属性名称，而不是从原型链上继承的。参数object表示一个对象，返回的是一个数组。

function Pasta(grain,width,shape) {  //定义一个构造函数 
      this.grain=grain;
      this.width=width;
      this.shape=shape;
      this.toStirng =function(){
          return (this.grain+","+this.width+","+this.shape);
      }
    }
    var spaghetti = new Pasta("wheat",0.2,"circle");   //使用构造函数，new一个对象
    var arr=Object.getOwnPropertyNames(spaghetti);  //使用Object.getOwnPropertyNames（），获取它的原生属性。返回的是一个数组。
    document.write(arr +"<br/>");   //grain,width,shape,toStirng
    document.write( arr instanceof Array);  //true

四.Array

  1.定位

  包括indexOf(),lastIndexOf().

array.indexOf(searchElement[,fromIndex]) ——array:表示一个数组对象。searchElement：必需，要在array中定位的值，fromIndex：可选，用于开始搜索的数组索引，如果忽略该参数，则从0开始。

 var array=["ab","cd","ef","cd"];   //创建一哥数组
 document.write(array.indexOf("cd")+"<br/>");  //1
 document.write(array.indexOf("cd",2)+"<br/>");  //3

lastIndexOf()，是从最后一个开始匹配的，用法与indexOf()相同。

2.迭代

    ①.forEach():为数组中每一个元素调用定义的回调函数。

   array.forEach(callbackFn[,thisArg]) ——array:一个数组元素，callbackFn:回调函数，对于数组中的每一个元素，都会执行这个回调，可以有三个参数。thisArg：可选参数，callbackFn函数中的this关键字可引用的对象。如果省略，则undefined会被作为this的值。

function callbackFn(value,index,array)  ——array包含该元素的数组对象。

 var numbers=[10,11,12];  //定义一个数组
 var sum=0;   //定义一个变量，用来计算
 numbers.forEach(   //调用forEach()方法
     function addNum(value) {sum +=value;  }  //执行回调函数 
 );
 document.write(sum)  //33

②.every

  array.every(callackFn[,thisArg]) ——thisArg:一个对象，注意是能在回调函数中为其引用this关键字的对象。

        如果callbackFn所有数组元素返回true，则返回为true，否则为false.

var checkNumRange =function(value){  //定义回调函数
     if(typeof value!=='number')
     return false;
     else 
     return value>=this.minimun&&value<=this.maximum;   //引用this，这个关键字
 }
 var numbers=[10,15,19];   //数组对象
 var obj={minimun:10,maximum:20}   //一个对象，注意是能在回调函数中为其引用this关键字的对象。
 if(numbers.every(checkNumRange,obj))
      document.write("都在指定范围内");
else
    document.write("部分不在指定范围内");    //都在指定范围内

③.some

 array.some(callackFn[,thisArg]) ——thisArg:一个对象，注意是能在回调函数中为其引用this关键字的对象。

  如果找到导致callbackFn返回true的元素，则some()会立即返回true.如果回调不对任何元素返回true，则some()方法会返回false.

function CheckIfEvent(value,index,ar) {
    if(value%2==0)  //判断是否为偶数，如果是返回true
    return true;
}
var numbers=[1,15,25,30,45];
var envens=numbers.some(CheckIfEvent);
if(envens)
document.write("不全是奇数");  //如果有一个返回的是true,那么立即返回true,此时说明有偶数存在。
else 
document.write("全是奇数");

④.map()

   map()方法将返回一个新数组，其中每个元素均为关联的原始数组元素的回调函数返回值。对于数组中的每个元素，map()方法都会调用callbackFn函数一次。map（）还可以作用于伪数组。比如arguments.

  function AreaOfCircle(radius) {  //定义回调函数
      var area =Math.PI*(radius*radius);   //计算面积
      return area.toFixed(0);
    }
    var radiu=[10,20,30];  //定义数组
    var area=radiu.map(AreaOfCircle);  //调用map方法
    document.write(area)       //314,1257,2827

⑤.filter()

  返回值是一个包含回调函数为其返回为true的所有值的新数组。如果回调函数的为array的所有元素返回false，那么这个新数组的长度为0.

  function CheckIfPrime(value,index,arr){  //定义判断是否为素数的方法
      high=Math.floor(Math.sqrt(value))+1;
      for(var div=2;div<high;div++){
          if(value%div==0){
              return false;
          }
      }
      return true;  //如果是素数，返回true,即为新数组中的元素
  }
  var numbers=[31,33,35,37,39,41,43,65,98];
  var prims=numbers.filter(CheckIfPrime);
  document.write(prims);

五.Function和String 

 es5为Function增加了一个原型方法bind(Function.prototype.bind),用来把函数绑定在指定对象上。从本质上来说，它允许在其他对象链中执行一个函数。

   也就是说，对于给定的函数，创建具有与原始函数相同的主体的绑定函数，在绑定函数中，this对象将解析为传入的对象。绑定函数具有指定的初始参数。

  function.bind(thisArg[,arg1[.arg2][],arg3])—— function：必需参数，一个函数对象。thisArg：必需参数，this关键字可在新函数中引用的对象。[,arg1[.arg2][],arg3]:可选参数，要传递到新函数的参数的列表。

var checkNumberRange =function(value){  //定义一个函数，判断传入的值，是否在给定的范围内
    if(typeof value !=='number')
    return false;
    else 
      return value>=this.minimum&&value<=this.maximum;
}
var ranger ={minimum:10,maximum:20};  //定义一个对象ranger
var boundCheckNumberRange =checkNumberRange.bind(ranger);  //把checkNumberRange绑定在ranger这个对象上
var result =boundCheckNumberRange(12);   //把函数的引用传递给result
document.write(result)   //true

对于，String，es5新提出了一个删除两边空格的方法。

var string ="   aaa  bbb   ";
var result=string.trim();
document.write(result)   //aaa  bbb  ,注意的是，不能删除中间的空格