JavaScript引用类型

　　引用类型的值(对象)是引用类型的一个实例。在ECMAScript中引用类型是一种数据结构，用于组织数据和功能。与Java、C++等面向对象语言区别：JavaScript没有面向对象的类和接口的基本结构。JavaScript通过引用类型弥补类的缺陷。引用类型通过new来创建实例对象。ECMAScript 6 已经引入class。以下内容基于ECMAScript5。

一、Object类型

　　Object是所有引用类型的基类，都直接或者间接继承Object内置的行为。

创建Object实例有两种方式：

1、通过构造函数创建对象
var obj=new Object();//通过new 构造函数创建对象
var obj = Object; //可以不使用new创建
2、通过字面量创建对象
var obj={
　　name:"hello",
　　say:function(){do...}
}

　　通过字面量创建对象，代码量少，封装数据，通常可以使用字面量创建。

访问对象属性有两种方式：

1、通过.号访问
console.log(obj.name);//访问
2、通过[]号访问
console.log(obj[name]);

　　通过[]号访问对象属性，优点在于[name]的name可以是变量，动态获取属性。同时[]可以添加一些不符合变量规则的变量名称。

　　Object构造函数，根据传入的参数类型，返回对应的类型。　　

var obj = new Object("test");
console.log(obj instanceof String);
VM295:1 true
var obj = new Object(25);
console.log(obj instanceof Number);
VM348:1 true

 

二、Array类型

　　ECMAScript的数组与其他语言的数组都是有序的列表，但是ECMASript的数组可以存储任何数据类型(弱类型)。同一数组可以存储不同类型的数据类型，数据的长度是动态增长，以容纳新的数据项。同时数组引用类型，因此它的实例对象可以添加属性。

　　创建Array对象有两种方式：　　

1、通过构造函数创建
var arr = new Array();
var arr1 =new Array(20);//创建长度为20的数组,请数据项为undefined
var arr2 = new Array("test");//长度为1，第一项的值为test

2、通过字面量创建
var arr = [];//创建空数组
var arr1 = [1,2];//创建长度为2的数组
var arr2 = ["test1","test2"];//创建长度为2的数组
var arr3 = [1,2,];//不建议使用，不通浏览器解析的长度不一致

数组长度和访问数组元素：数组索引是基于0起始的正整数。

var  arr = ["test1","test2"];
console.log(arr.length);//长度为2
//数组通过基于0的索引访问
console.log(arr[0]);
arr[3]="test4";
console.log(arr[3]);//输出test4
arr.length=1;//将长度设置为1,此时arr的值为["test1"],通过控制长度可以删除数据项

 

与Java的数组不一样，JavaScript的数组不会出现越界异常，负数的下标也不会出错(如果对象不存在负数的属性)，都返回undefined。 因为数组也是引用类型，可以为它的实例化对象添加属性。当使用arr[key]=value，如果key为正整数，则为数组的索引，如果key为其他则为数组的属性。

 

var arr=new Array();
arr[-1]="test1";
console.log(arr[-1]);//输出test1

通过arr[key]key不为正整数,则为arr对象添加属性，arr["test"]="test"等价于arr.test="test" 。

var arr = new Array();
arr["test"]="test";
console.log(arr["test"]);//输出test

数组Array.prototype属性：

判读数组：

1、instanceof  在只有一个全局环境下能正确判断Array。

var arr =new Array();
if(arr instanceof Array){

}

2、ECMAScrit5定义了isArray()方法解决instanceof不足。

var arr = new Array();
if(Array.isArray(arr)){
}
Array.isArray(arr);//true

 数组转换：

1、toString方法，此方法返回字符串形式，并且每个数据项以,隔开

var arr = ["test1","test2"];
arr.toString();//输出"test1,test2"

2、valueOf方法，此方法返回数组

var arr = ["test1","test2",10];
arr.valueOf();//输出["test1","test2",10]

3、join方法，默认输出以,为分隔符的字符串

var arr= ["test1,test2,10"];
arr.join();//输出以,号隔开的字符串"test1,test2,10"
arr.join(undefined);//输出以,号隔开的字符串"test1,test2,10"
arr.join("|");//输出以|分割的字符串"test1|test2|10"

 4、数组的栈模式，后入先出。推入push和弹出pop 

var arr= ["test1,test2,10"];
arr.push("test3");//数组末尾追加元素，长度加1
var tmp  = arr.pop();//数组末尾删除元素，并且返回最后一个元素
console.log(tmp);//输出 test3
arr.push("test3",20,30);//追加多个元素

 5、数组的队列模式，先进先出。unshift头部插入和shift头部删除

var arr= ["test1,test2,10"];
arr.unshift("test",20);//数组头部插入两个元素
console.log(arr.toString());//输出"test,20,test1,test2,10"
var tmp = arr.shift();//删除数组头部一个元素,并且返回第一个元素
console.log(tmp);//test

 6、数组排序sort、reverse,默认字符串排序

var arr= [1,2,3,4];
arr.reverse();//[4, 3, 2, 1]输出反序数组
arr.push(11,20);
arr.sort();//[1, 11, 2, 20, 3, 4]并不符合数字输出
//用于排序的回调函数,策略模式
function compara(val1,val2){
    if(val1>val2){
        return -1;  
    }else if(val1<val2){
        return 1;  
    }else{
        return 0;
    }
}
arr.sort(compara);
console.log(arr);//输出[20, 11, 4, 3, 2, 1]反序
console.log(arr.reverse());[1, 2, 3, 4, 11, 20]

7、数组操作：concat与slice，这两个方法均不会对原数组进行改变。

　　concat方法会基于当前的数组创建一个新的数组。执行步骤为：首先创建一个数组的副本，然后根据传入的参数，在数组末尾追加，最后返回数组副本。参数可以传递普通的字符串和数组。

var arr=[1,2,3,4];
arr.concat();//未传入参数，只是拷贝副本
[1, 2, 3, 4]
arr.concat(5,6);//追加两个元素
[1, 2, 3, 4, 5, 6]
arr.concat(7,[8,9]);//追加一个元素和数组
[1, 2, 3, 4, 7, 8, 9]
arr;//原数组的不变
[1, 2, 3, 4]

　　slice基于当前数组的一或多项元素创建新的数组。slice可以接受1或2个元素，如果只有一个参数的情况返回以参数为起始位置至数组末尾的新数组，如果2个参数，则返回以第一个参数为起始索引第二个参数为结束(end>arr.length?arr.length:end)的新数组。如果参数为负数，通过arr.length+(-val)来确定位置,此方法可以作为拷贝数组使用，slice()与slice(0)效果一样，拷贝当前数组。

var arr=[1,2,3,4];
arr.slice();
[1, 2, 3, 4]
var arr1 = arr.slice();
[1, 2, 3, 4]
arr1
[1, 2, 3, 4]
arr.slice(0);
[1, 2, 3, 4]
arr.slice(1);
[2, 3, 4]
arr.slice(1,3);
[2, 3]
arr.slice(1,5);//当结束位置超出索引范围，只返回实际的长度
[2, 3, 4]
arr.slice(-2,-1);//起始位置为4-2=2,结束位置为4-1=3
[3]
arr.slice(-2,-3);//如果结束位置大于起始位置则返回[]

 8、splice，数组中最为强大的方法，可以实现数组替换、删除、插入，并返回被截取的数组。关键取决于第二个参数的值。

　　删除数组元素，通过传入两个参数即可删除数组指定位置和个数的元素，第一个参数为索引位置，第二个参数为长度(0大于)。　

var arr=[1,2,3,4];
arr
[1, 2, 3, 4]
var sub=arr.splice(0,2);//从第0个位置开始截取2个元素，并返回新的数组
sub
[1, 2]
arr
[3, 4]//原数组被截取两个元素

var arr=[1,2,3,4];

  var sub = arr.splice(-3,2);//如果第一个参数为负数，则length-3

  sub
  [2, 3]
  arr
  [1, 4]

 　　指定位置插入元素，通过传入三个以上参数即可在指定位置插入元素，第一个参数为索引位置，第二个参数为长度(0或undefined)，第三及以上为新元素。

var arr=[1,2,3,4];
var insert= arr.splice(2,0,5,6);//在索引为2的位置插入新元素
insert;//返回[]
arr
[1, 2, 5, 6, 3, 4]

　　指定位置替换元素，通过传入三个以上参数即可在指定位置插入元素，第一个参数为索引位置，第二个参数为长度(>0)，第三及以上为新元素。

var arr=[1,2,3,4];
var change = arr.splice(2,2,7,8);//替换两个元素并且返回截取的数组
change;
[3, 4]
arr
[1, 2, 7, 8]

 9、查找元素位置：indexOf()和lastIndexOf()。两个方法接收两个参数，第一个为查找的项，第二个为起始位置。indexOf从头到尾查找，lastIndexOf相反。返回值返为匹配到位置，如果是-1表示未能查询到。

var arr= ["test1","test2",10];
arr;
["test1", "test2", 10]
arr.indexOf("test2");
1
arr.indexOf("10",1);
-1
arr.indexOf(10,1);
2
arr.lastIndexOf(10);
2
arr.lastIndexOf("test1");
0
arr.lastIndexOf("test1",1);
0
arr.lastIndexOf(10,1);
-1

10、数组迭代

　　ECMAScript新增5个迭代方法：每个方法接收两个参数，第一个参数为当前项要运行的function,第二个参数为运行function的作用域影响this的值。function传入参数：数据项、数据项的索引位置、数组对象本身。function(item,index,arr){do...}

　　every():给定数组每一项运行function，如果该函数对每一项都返回true，则返回值为true，否则相反。

　　filter():给定数组每一项运行function，如果该函数会返回true，则返回为true项组成的数组。

　　forEach()：给定数组每一项运行function，没有返回值。与for迭代数组用法一致。

　　map():给定数组每一项运行function，返回每次函数调用的结果组成的数组。

　　some():给定运行数组每一项运行function，如果该函数对任一项返回true，则返回值为true，否则相反。与every相反。

every:

var arr=[1,2,3,4];
var result = arr.every(function(item,index,arr){return item>3});
result;//并非每一项都大于3，所以返回值为false
false
arr;//原数组未发生变化
[1, 2, 3, 4]

filter:

var arr=[1,2,3,4];
var filter = arr.filter(function(item,index,arr){return item>2});
filter;//返回符合大于2的数组
[3, 4]
arr;//原数组未发生变化
[1, 2, 3, 4]

map:

var arr=[1,2,3,4];
var map = arr.map(function(item,index,arr){return item+3;});
map;//每项执行结果组成的数组
[4, 5, 6, 7]
arr;//原数组未发生变化
[1, 2, 3, 4]

some：

var arr=[1,2,3,4];
var some = arr.some(function(item,index,arr){return item>2});
some;//执行结果只有任一项为true，则返回true
true
arr;//原数组未发生变化
[1, 2, 3, 4]

 11、缩小方法：reduce和reduceRight。两个行数都接收两个参数，第一个为每项执行的行数，第二个参数为缩小的初始值。function接收4个参数：前一个值、当前值、项的索引和数组。前一个值即前一次执行function结果。reduce从头往后执行，reduceRight相反。　　

var arr=[1,2,3,4];
var reduce=arr.reduce(function(per,cur,item,arr){return per+cur});
reduce;//将前次计算结果和本次相加返回最终的结果
10
arr;//原数组未发生变化
[1, 2, 3, 4]
var reduce=arr.reduce(function(per,cur,item,arr){return per+cur},20);//20为基础值，结果为30=20+10

12、数组填充：fill方法可以作为初始化数组使用,方法接收3个参数，第一个为填充的属性，第二个为起始位置，第三个为结束位置。也可以作为数据替换使用。

var arr = Array(20);
arr;
[undefined × 20]
arr.fill(10,0,5);//填充10到0-5索引的元素
[10, 10, 10, 10, 10, undefined × 15]
arr;
[10, 10, 10, 10, 10, undefined × 15]
arr.fill(20,5,20);//填充5-20
[10, 10, 10, 10, 10, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20]
arr;
[10, 10, 10, 10, 10, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20]

13、数组包含元素：include判断数组是否包含某项,返回true或者false。相比indexOf方法，include可以在if(arr.include(key)),不需像indexOf要判断是否大于0等；可以支持对NaN的判断,[a,b,NaN].include(NaN)

arr;
[10, 10, 10, 10, 10, 30, 30, 30, 30, 30, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20]
arr.push("test");
21
arr.includes("test");
true
arr.includes("111");//数组元素不存在"111"
false

　　数组总结：

　　1、Array为列表数据结构，同时也是引用类型，可以通过arr[key]="value"和arr.key=value添加属性，key为符号变量的命名，且不为正整数。

      2、jion、toString、toLocalString输出字符串。

　　3、执行方法会改变原数组：push、pop、shift、unshift、splice、fill、sort、reverse

　　4、通过改变数组长度，可以改变数组内容

　　5、fill、include属于ECMAScript6的内容

　　6、关于ECMAScript 6的数组扩展可以参考：http://es6.ruanyifeng.com/#docs/array 

三、Date类型

　　创建Date实例可以通过new Date();,没有传入参数，对象自动获取当前日期和时间。如果想要创建指定的date实例，可以通过传入Date.prase("2016-01-1")实例化，如果参数不能表示时间则返回NaN。Date.UTC()，同样也能实现，但必须指定前面两个参数例如：Date.UTC(2000,0);在UTC中月份从0开始0~11，天1~31，小时0~23。

var date =new Date();//可以传入毫秒数
date
Fri Mar 03 2017 22:43:12 GMT+0800 (中国标准时间)
var date =new Date(Date.parse("2016-01-01"));
date
Fri Jan 01 2016 08:00:00 GMT+0800 (中国标准时间)
var date =new Date(Date.parse(2016,1));
date;
Fri Jan 01 2016 08:00:00 GMT+0800 (中国标准时间)

　　ECMAScript5添加了Date.now()方法用于获取当前的毫秒数。

var date = Date.now();//获取当前的毫秒数
date;
1488552453848
date.valueOf();//返回date的毫秒数
1488552453848

　　Date.prototype方法

getDate()//返回月份中的天数 1~3
getDay()//返回星期几  0表示周末，1-6表示周一到周六
getFullYear()//返回年
getHours()//返回小时，0~23
getMilliseconds()//返回毫秒数 29
getMinutes()//返回分钟0~59
getMonth()//返回月份，0~11
getSeconds()//0~59
getTime()//返回日期的毫秒数 1488552890029
getTimezoneOffset()//返回本地与UTC相差的分钟数
getUTCDate()
getUTCDay
getUTCDay()
getUTCFullYear()
getUTCHours()
getUTCMilliseconds()
getUTCMinutes()
getUTCMonth()
getUTCSeconds()
getYear()//117  2017-1900
toDateString()//"Fri Mar 03 2017"
toJSON()//"2017-03-03T14:54:50.029Z"
toLocaleDateString()
toLocaleString()
toLocaleTimeString()//"下午10:54:50"
toString()
toTimeString()//"22:54:50 GMT+0800 (中国标准时间)"
valueOf()//返回毫秒数

四、RegExp类型

　　正则表达式支持三种匹配模式：

• g：代表全局匹配，字符串会从头匹配到尾。
• i：忽略匹配大小写。
• m：代表匹配多行文本。

     正在表达式元符号：(、)、[、]、{、}、|、*、?、.、+。元符号在表达式中有特殊的含义,因此当字符串要匹配包含以上符合时候需要使用转义字符进行转换。例如：\[bc\]

　　创建RegExp对象有两种方式：

　　1、通过构造函数创建

　　var reg=new RegExp(parrtern,flag);接收两个参数(都是字符串)，第一个参数要匹配的模式，第二个为匹配标志。　　

var reg = new RegExp("[bc]at","g");//匹配全局  b或者c  at
var str = "cat,bat,dat";
reg.exec(str);
["cat"]
reg.exec(str);
["bat"]
reg.exec(str);
null

　　2、通过字面量创建

　　var reg = /[bc]at/gi;格式为/parttern/flags　　

var reg = /[bc]at/gi;//创建一个匹配全局的不区分大小写
var str="cat,Bat,dat";
reg.exec(str);
["cat"]
reg.exec(str);
["Bat"]
reg.exec(str);
null

　　RegExp的实例属性：

• global:布尔值，表示是否设置g。
• ignoreCase:布尔值，表示是否设置i。
• multiline：布尔值，表示是否这是了m。
• lastIndex:整数，表示开始搜索下一个匹配项的字符位置，从0开始。
• source:按照字面量传入模式的字符串。　　

var reg = /[bc]at/gi;
reg.global;
true
reg.ignoreCase;
true
reg.multiline;
false
reg.lastIndex;
0
reg.source;
"[bc]at"

　　RegExp的实例方法：

• exec：接收一个参数(应用模式的字符串)，返回包含第一个匹配项信息的数组实例，如果没有匹配返回null。同时数组还有两个属性：input和index，index表示匹配项在字符串中的位置，input表示应用的正则表达式的字符串。如果匹配模式这是为g，每次返回一个匹配项，执行多次返回最新一次匹配项；如果没有设置g，多次执行方法，返回的都是第一个匹配项。

• var reg = /[bc]at/i;
  var str="cat,Bat,dat";
  reg.exec(str);
  Array[1]
  0: "cat"index: 0input: "cat,Bat,dat"length: 1__proto__: Array[0]
  reg.exec(str);//没有设置匹配模式g，多次调用exec都返回第一次匹配的项
  Array[1]
  0: "cat"index: 0input: "cat,Bat,dat"length: 1__proto__: Array[0]

   

• test:接收一个参数(应用模式的字符串)，返回boolean。如果正确匹配返回true，如果未能匹配返回false。

• var reg = /[bc]at/i;
  undefined
  var str="cat,Bat,dat";
  undefined
  reg.test(str);
  true

　　

　　RegExp构造函数属性：

• input($_):最近一次要匹配的字符串。
• lastMatch($&):最近一次匹配的字符项。
• lastParen($+):最后一次匹配组。
• leftContext($+):匹配项的左边字符串。
• rightContext($`)：匹配项的右边字符串
• mulitline($*):boolean值，表示是否所有表达式都使用多行模式。
• $1~$9:用于存储多个捕获组

• var text="this has been a  short summer";
  var parrtern =/(.)hort/g;
  if(parrtern.test(text)){
      console.log(RegExp.input);
      console.log(RegExp.leftContext);
      console.log(RegExp.rightContext);
      console.log(RegExp.multiline);//chrome中没有
      console.log(RegExp.lastMatch);
      console.log(RegExp.lastParen);
  }
  VM699:4 this has been a  short summer //原始字符串
  VM699:5 this has been a  //左边的字符串
  VM699:6  summer　　//右边的字符串
  VM699:7 undefined   
  VM699:8 short  //最后匹配的项
  VM699:9 s　　//最后匹配的组

  var text="this has been a  short summer";
  var parrtern =/(.)hort/g;
  if(parrtern.test(text)){
      console.log(RegExp.$_);
      console.log(RegExp["$&"]);
      console.log(RegExp["$+"]);
      console.log(RegExp["$'"]);
  }
  VM766:4 this has been a  short summer
  VM766:5 short
  VM766:6 s
  VM766:7  summer　　

　　JavaScript正则表达式不能实现：

• 匹配字符串开始和结尾的\A和\Z锚，但支持以插入符号(^)和($)来匹配字符串的开始和结尾。
• 向后查找
• 并集和交集类
• 原子组
• s(单行)和x(无间隔)的匹配模式
• 条件匹配
• 正则表达式注释

　

五、Function类型

　　在ECMAScript中函数是一个神秘的东西，它是的本质是一个对象，是Function的实例对象。因此它和其他引用类型一样拥有属性和方法。由于函数是对象，函数名实际上是指向函数对象的指针，即也为变量。

　　函数声明的语法：　　

//第一种通过function关键+函数名称+参数
function sum(a,b){
    return a+b;  
}
//第二种通过定义变量和匿名方式定义函数
var sum=function(a,b){
　　return a+b;
}
//第三种通过构造函数定义函数，构造函数的参数最后一个标识函数体，其他表示参数
var sum = new Function("a","b","return a+b;");

　　1、从第二种方式定义，察函数名可以看成一个变量。从第三种方式定义，容易观察函数为Function的实例对象，即普通对象。

　　2、函数名仅为指向函数对象的指针，并非绑定函数　　

function sum(a,b){
    return a+b;
}
var sum_1=sum;//sum_1指向sum函数对象
sum=null;//将sum执行为null
sum_1(1,2);//依然能正确的执行
3
sum
null

　　3、第三种方式定义：会执行两次两次解析，第一次为ECMAScript的代码解析，第二次传入构造函数的字符串解析，因此性能低下。

　　4、第一种和第二种定义方式基本上没有区别，唯一的区别在于调用函数的时候，函数申明方式会被解析器优先读取并添加到执行的环境中(函数申明提升过程 function declaration hoisting)，而函数表达式只有解析器执行到它所在的代码行才会解析。第二种方式，只有执行到那一行的时候变量才会指向函数对象，因此在变量初始化之前调用就会出现错误。　

//第一种方式定义，函数会被优先解析，确保在任何代码执行之前函数可用
sum(1,2);
function sum(a,b){return a+b;}
3
//函数表达式，必须等到解析器执行到它所在的代码行，才会被真正的解析
sum(1,2);
var sum=function(a,b){return a+b;};
VM138:1 Uncaught TypeError: sum is not a function    //错误
at <anonymous>:1:1

　　函数没有重载：因为函数名为变量，指向函数对象的指针。下面例子可以看出，第一个sum的变量被第二个重新赋值，即指向第二个函数对象。　

var sum=function(a){
    return a;
}
sum =function(a){
    return a+10;  
}
sum(10);//结果为20
20

　　高阶函数(Higher-order function)：高阶函数的意思是它接收另一个函数作为参数。在 javascript 中，允许函数作为参数或者返回值传递，因为函数名可以认为是变量。Array引用类型包含多个高阶函数：例如map，filter，reduce等

//定义一个sum的函数
function sum(a,b){
    return a+b;
}
//定义一个callFunc的函数传入一个函数
function callFunc(func,a,b){
    return func(a,b);
}
callFunc(sum,1,2);
3

　　函数的内部属性：arguments和this。arguments保存函数实际接收的参数，类似数组，在ECMAScript 6中引入rest(用于获取显示参数之外的参数)。this引用的是函数据以执行的环境对象。arguments保存函数调用时候，实际传入的参数，如果函数没有显示定义参数，可以通过arguments接收参数。

function sum(a,b){
    var tmp1=arguments[0];//获取传入的第一个参数
    var tmp2=arguments[1];//获取传入的第二个参数
        console.log(arguments[2]);//获取传入的第三个参数
    return tmp1+tmp2;
}
undefined
sum.length;//函数定义参数个数
2
sum(1,2,4);
3
4

function sum(a,b){
    console.log("当前的this为：");
    console.log(this);
    var tmp1=arguments[0];//获取传入的第一个参数
    var tmp2=arguments[1];//获取传入的第二个参数
        console.log(arguments[2]);
    return tmp1+tmp2;
}
sum(1,2);//全局作用域调用，浏览器指向windows对象
var obj ={"test":"te"};
obj.sum=sum;
obj.sum(1,2);//指向obj对象

　　函数方法：call和apply。这两个方法不是从Object继承的。这两个方法的用于在特定的环境中调用函数，实际上等于设置函数this对象的值。apply和call接收两个参数，第一个为运行函数的作用域，第二个为参数，两者的区别在于第二个参数，apply接收一个数组的参数，call接收多个单独的参数。 这两个方法最大的优点是：用于扩充作用域，避免对象和函数的耦合。

function sum(a,b){
    console.log("当前的this为：");
    console.log(this);
    var tmp1=arguments[0];//获取传入的第一个参数
    var tmp2=arguments[1];//获取传入的第二个参数
        console.log(arguments[2]);
    return tmp1+tmp2;
}
var obj={};
sum.apply(obj,[1,2]);
VM802:2 当前的this为：
VM802:3 Object {}__proto__: Object
VM802:6 undefined
3
sum.call(obj,1,2);
VM802:2 当前的this为：
VM802:3 Object {}
VM802:6 undefined
3

　　bind方法，创建一个函数的实例，函数的this会被绑定到传给bind的参数上。　　

function sum(a,b){
    console.log("当前的this为：");
    console.log(this);
    var tmp1=arguments[0];//获取传入的第一个参数
    var tmp2=arguments[1];//获取传入的第二个参数
        console.log(arguments[2]);
    return tmp1+tmp2;
}
var obj={test:1};
undefined
var tt=sum.bind(obj);
tt();
VM858:2 当前的this为：
VM858:3 Object {test: 1}
VM858:6 undefined
NaN

 六、基本包装类型

　　ECMAScript中的基本类型有字符串、数字、布尔。ECMAScript为三种类型分别提供字符串String、Number、Boolean包装类。因此基本类型也可以有对应类型的行为。当读取基本类型时候，后台会为其创建对应的包装类对象，从而能够提供一些方法来处理数据。　　

var str = "test";//定义字符串变量
str;
"test"
str.substring(1,2);//调用substring方法
"e"

 　　上面代码中str为基本类型，但是可以调用substring方法，这是因为在读取str的基本类型时，后台为其创建一个String对象，然后在对象上调用substring方法，并且在执行完的时候，将对象赋值为null(销毁对象)，这与普通的引用类型使用new创建的作用域不一样(new创建会常驻内存)。同样适用于Boolean和Number类型。

var str=new String("test");
str.substring(1,2);
str=null;

　　基本类型的包装类型通过typeof返回都是object，所有的引用类型对象都会被转换为true，因此可以通过if(obj)来判断对象是否存在。 

var obj = new Object(25);
if(obj)
{console.log("true")}
VM425:2 true

　　但是使用new 基本类型包装类和不用使用new返回的类型是不一样的。　

//两种形式返回的类型不一致
var a="25";
var aNum=Number(a);
typeof aNum;
"number"
var bNum= new Number(a);
typeof bNum;
"object"

　　Number的方法：

//
Number.prototype
toExponential();//返回e指数标识,接收一个参数
toFixed();//返回多少位小数,接收一个参数
toLocaleString();//返回字符串
toPrecision()；//返回一种合适的表示：可能为e指数或者toFixed,接收一个参数
toString();//返回字符串进制表示,接收一个参数
valueOf();//返回基本类型的数值

接收一个进制表示的参数，默认为10进制
var num=10;
num.toString();
"10"
num.toString(2);
"1010"
num.toString(16);
"a"

var num = 99.220002;
num.toFixed(3);//返回3为小数
"99.220"
num.toPrecision(2);
"99"
num.toPrecision(3);
"99.2"
num.toPrecision(4);
"99.22"
num.toPrecision(10);
"99.22000200"
num.toPrecision(1);
"1e+2"
num.toString(2);//二进制表示
"1100011.001110000101001000001101000100110000110111111"
num.toString(16);//十六进制表示
"63.38520d130df8"
num.valueOf();
99.220002
num.toLocaleString();//输出字符串
"99.22"

　　String方法：

　　

//早期为HTML生成提供便利，但是最好不要使用这些方法
//However, be aware that typically these methods aren’t used, //because they tend to create nonsemantic markup.无法表达语义的标签
METHOD OUTPUT
anchor(name)      <a name=“name”>string</a>
big()                     <big>string</big>
bold()                   <b>string</b>
fixed()                  <tt>string</tt>
fontcolor(color)     <font color=“color”>string</font>
fontsize(size)        <font size=“size”>string</font>
italics()                 <i>string</i>
link(url)                <a href=“url”>string</a>
small()                  <small>string</small>
strike()                 <strike>string</strike>
sub()                    <sub>string</sub>
sup()                    <sup>string</sup>

　　Boolean方法：

 

七、单体内置对象

　　Global和Math。

　　Global所有定义为全局的变量或方法都是Global的属性。常见的方法：isNaN(),parseInt(),parseFloat(),encodeURI(),decodeURI()，alert()等。

　　在浏览器模式下，window是Global对象。　　

window.alert(11);
window.eval("alert(11)");//eval方法会执行字符串的内容
window.eval("console.log(11)");//eval方法会执行字符串的内容

Global内置属性：

　　Math对象：包含min(),max(),round(),random()等。