JS 学习笔记--10---基本包装类型

练习中使用的浏览器是IE10，如果有什么错误或者不同意见，希望各位朋友能够指正，练习代码附在后面

1、基本包装类型：   

　　首先是基本类型，但又是特殊的引用类型，因为他们可以调用系统的方法，这种类型就称为基本包装类型。主要有：Boolean,Number,String 三种。这些类型与其他引用类型相似，但同时也具有与各自基本引用类型相关的特殊行为。实际上，每当我们创建一个基本类型的时候，系统会在后台默认的创建一个基本包装类型的变量。

　　用String类型举例说明：用字面形式定义的String类型的变量box，如果给它添加属性和方法，然后打印出来，属性的输出结果是undefined，方法的运行结果是会报错。而用new String('c')方法定义的String变量[此时已经是object类型了]，给它添加属性和方法都能够正常运行。但是这两种创建方式都能够调用系统的内置方法，通过  对象.方法(参数)  的形式调用，比如方法 box.substring(3)[后面解释]，而这种形式的调用明显是一个对象的形式调用方法，故称其为基本包装类型。

　　这三种类型的变量用 new 运算符声明变量的时候，也可以给自己添加属性和方法，但是最好不要这样做，因为很可能搞不清楚到底是什么类型的变量，因为通过new运算符创建的变量通过typeof检测出来的结果是 object 类型的变量

2、Boolean  类型就两个值 true和false，基本上没有什么方法，和属性

3、Number 类型一些静态属性

　　静态属性：不需要对象就可以使用的属性，通过 类型名.属性名 访问(Number.MAX_VALUE);  

　　Number 类型中包含的静态属性大概有：MAX_VALUE, MIN_VALUE, NEGATIVE_INFINITY, NaN， POSITIVE_INFINITY, 以及用来扩展方法和属性的 prototype等

4、Number 对象的一些方法

Number 对象的一些方法
方法名	描述
num.toString()	将数字转换成字符串返回
num.toLocaleString()	将数字转换成本地字符串形式返回，会将每三位数字用一个逗号隔开，并且通过四舍五入的方式将多余的小数位保留到三位
num.toFixed(n)	将数字保留小数点后面指定位数并转换成字符串显示，小数位数不足时在后面补0
num.toExponential(n)	将数字按照科学计数法形式，并且保留指定位数的小数，然后转换成字符串，位数是指转换成科学计算法后小数点后位数
num.toPrecision(n)	将数字按照科学计算法或者点分法保留指定位数的有效数字个数并且转换成字符串，如果整数部分大于要保存的有效位个数对应的值，转换成科学计算法表示，如果小于就按照原数字形式进行保存，只是对小数位数进行四舍五入，如果数字小于要保留的有效数字组成的数，在后面添加一个小数点然后补0(有小数点直接补0)。参数代表的是结果的有效数字的位数

5、String 类型包含的三个属性

　　length：返回字符串的长度，也就是字符个数，汉字也只是算一个字符

　　constructor：返回创建String对象的方法：function String(){[native code]}

　　prototype：用于添加属性和方法来扩展字符串的定义

6、String对象包含的方法--通用方法

　　toString(),valueOf(),toLocaleString() 这三种方法前面已经用过，就不在解释了。

7、String 对象包含的方法--取字符的方法  

　　str.charAt(3):获得字符串str中从0开始索引为3的字符

　　str.charCodeAt(3):获得字符串str中从0开始，索引为3的字符的ASCII编码

　　str[3]：获得字符串str中从0开始索引为1的字符,但是这种方式可能存在浏览器的兼容性问题

8、字符串操作方法  

　　str.concat(str1,str2):和数组中的concat()方法是类似的，基于当前字符串，在后面添加上字符串str1，str2，组成一个新的字符串，并且返回,源字符串str不会改变，参数任意个

　　str.slice(n,m)：从索引为n的字符开始截取，一直到索引为m但是不包括索引为m的字符为止，返回截取后的子字符串，源字符串str不变

　　str.substring(n,m):功能上面和slice相同，只是在有些参数方面处理不同

　　str.substr(n,m):同样是截取字符串，从索引为n的字符开始截取，截取的个数为m个，返回子字符串，原来的字符串不变。

参数情况(源字符串：abc123abc)	slice()	substring()	substr()	结果
(3)	从索引为3的字符开始截取，直到最后	从索引为4的字符开始截取，直到最后	从索引为5的字符开始截取，直到最后	123abc,123abc, 123abc
(3,5)/(3,'5')	从索引为3的字符开始截取，一直截取到索引为5的字符(不包含此字符),数值字符串自动转换成数值	从索引为3的字符开始截取，一直截取到索引为6的字符(不包含此字符),数值字符串自动转换成数值	从索引为3的字符开始截取，截取的字符个数为5个，如果剩下字符不足5个就截取剩下的所有,数值字符串自动转换成数值	12,12,1
(3,5,'qq')	和上面一样，忽略第三个参数	和上面一样，忽略第三个参数	和上面一样，忽略第三个参数	12,12,13abc
(3,'y')	第二个参数为非数值，返回为0，(3,0)	第二个参数为非数值，返回为0，因为比第一个参数小，进行交换(0,3)	当参数为非数字的时候返回为0，然后开始截取(3,0)	空，abc，空(截取字符个数为0个)
(3,5.7)	第二个参数为浮点数，将对其进行取整处理，舍去小数位(3,5)	第二个参数为浮点数，将对其进行取整处理，舍去小数位(3,6)	第二个参数为浮点数，将对其进行取整处理，舍去小数位(3,7)	12,12,12abc
(-5)	只有一个参数且为负，用字符串长度加上这个负值，返回的正值作为真正的参数进行处理,结果为   (4)	只有一个参数，且为负数的时候，直接处理为0，故返回的是整个字符串	只有一个参数且为负数的时候，将长度和这个负数相加，得到的正值作为真正的参数进行处理,结果为：(4)	23abc,abc123abc, 23abc
(3,-1)	第二个参数为负，同样是用长度和起相加，将得到的正数作为真真的参数，结果为(3,8)	第二个参数为负数的时候，直接返回0，此时由于第二个参数为0小于第一个参数，故将两个参数进行交换位置，结果为(0,3)	第二个参数为负数，直接返回为0，也就是代表截取的字符串长度为0，参数结果为(3,0)	123abc,abc,空(长度为0)
	结果：两个参数只要有一个是负数，都按照长度加来处理为正数	两个参数，只要有一个参数为负数，就处理为0，然后比较两个参数的大小是否是前小后大，不是就交换	第一个参数为负数的时候，用长度加负数来处理为正数，第二个参数为负数的时候直接处理为0

　　JS中对substr()函数进行传递负数的时候可能会存在兼容性的问题，应注意使用

9、获取子字符串位置的方法  　　如果没有找到则均是返回 -1

　　str.indexOf(str2,num):从索引为num开始的地方向后查找字符串str1中包含的子字符串str2的位置，如果没有找到则返回 -1，找到了则返回字符str2的首字符的索引，起始位置包含索引为num的字符，如果省略num则默认的是0。注：找到一个立即返回

　　str.lastIndexOf(str2,num)：和上面的功能是一样的,同样是以num为索引的字符开始查找，只不过是从后向前开始找，如果没有找到就返回-1,省略num，默认的是str.length-1开始

10、大小写转换的方法  

　　str.toLowerCase(): 将字符串str中的所有英文字符转换成小写

　　str.toUpperCase(): 将字符串str中的所有的英文字符转换长大写

　　str.toLocaleLowerCase(): 转换成本地小写字符，我们国家基本上是一样的

　　str.toLocaleUpperCase(): 转换成本地大写字符

11、字符串的模式匹配方法 　　主要是针对正则表达式的

　　str.match(patt); str.search(patt);  str.replace(patt,str2);  str.split(patt);

12、其他方法：  

　　String.fromCharCode('a'): 静态方法[能通过String类点出来的方法就是String类型的静态方法]，返回字符在ASCII中的编码

　　str.localeCompare(str2): 比较字符串str1和字符串str2的大小，从第一个字符开始，一个一个字符开始比较，如果某一个字符不相同则返回，相同一直往后比较，直到不同或者字符串结束。返回的规则是，如果正在比较的字符，str中的字符的ASCII码值大于str2中的码制就返回正数，多数为 1，如果小于就返回负数，多数为 -1，如果相等就比较下一个字符，如果两个字符串相等就返回0.

 13、练习代码：

 /*
 //字面量形式定义变量，添加属性和方法，不支持属性和方法
     var box='abcdefg';
     box.name='name';
     box.run=function(){
             alert('runFunction');
         };
     alert(box);            //abcdefg
     alert(box.name);    //undefined
     alert(typeof box);    //string
     alert(box.substring(3));//defg    调用系统内置函数，索引从0开始，从第三个字符开始截取字符串
                                 //这种通过  对象.方法(参数)  调用形式明显是引用类型
     alert(box.run());        //error:对象不支持方法

 //new 方法定义变量，添加属性和方法，支持
     var box=new String('abcdefg');
     box.name='name';
     box.run=function(){
             return 'runFunction';
         };
     alert(box);                //abcdefg
     alert(box.name);        //name
     alert(typeof box);        //object
     alert(box.substring(3));//defg
     alert(box.run());        //runFunction

 //上面两中方法中可以看出，不过是字面量形式还是new方法创建的变量都可以调用系统内置
 //的函数 substring()，而且是通过 对象.方法(参数) 这种对象才具有的形式调用的方法
 //故把这种本身是基本类型(字面量形式定义),但是又是特殊的引用类型，
 //(因为他们可以调用系统内置函数)，叫做基本包装类型

 */

 /*        Number  类型
 // 属性    对象.属性名
     box.MAX_VALUE

 //静态属性，直接通过 类名.属性名
     alert(Number.MAX_VALUE);    // 获取Numebr类型的最大值
     alert(Number.MIN_VALUE);    // 获取Numebr类型的最小值
     alert(Number.NaN);            // 获取NaN
     alert(Number.NEGATIVE_INFINITY);    //获取负无穷
     alert(Number.POSITIVE_INFINITY);    //获取正无穷

 // Number 对象的方法
     var box=10000.3456;
     alert(box.toString());        //10000.3456
     alert(box.toLocaleString());//10,000.346    用逗号按照每三位隔开显示，并且小数点后面只是按照四舍五入保存三位
     alert(box.toFixed(3));        //10000.346        转换成字符串，并且按照四舍五入的形式保存3位小数
     alert(10000.34.toFixed(3));    //10000.340        小数位数不足在后面填0

   // 以科学计算法来保存指定的小数点后面的位数，位数是指转换成科学计算法后小数点后位数
     alert(box.toExponential());    //1.00003456e+4        转换成字符串，以科学计数法的形式显示
     alert(box.toExponential(2));//1.00e+4        保存小数点后面指定的位数，以科学计数法显示
     alert(typeof box.toExponential(2));  //string
     alert(0.003.toExponential(3));        //3.000e+-3

   //toPrecision(5);方法，是按照科学计算法或者点形式保存数据，按照参数保留有效位数
   //括号中的参数是指保留的有效数的位数，如果整数部分位数大于参数，则以科学计算法表示
   //如果整数部分小于有效位数，小数点后面按照有效位数进行四舍五入进行取数
   //如果是小于一的小数，同样在后面补0凑齐有效位数的个数
     var box=10000.3456;
     alert(box.toPrecision());            //10000.3456
     alert(box.toPrecision(3));            //1.00e+4
     alert(typeof box.toPrecision(2));    //string
     alert(box.toPrecision(8));            //10000.346
     alert(box.toPrecision(9));            //10000.3456
     alert(0.003.toPrecision(4));            //0.003000

 */

 /*    String 类型
 // 三个属性  length  constructor  prototype
     var box='abc';
     alert(box.length);        //3    返回字符串的长度
     alert(box.constructor);    // 返回创建String对象的函数  function String(){[native code]}

 //  基本方法  toString()  valueOf()  toLocaleString() 这些方法都返回字符串的基本值
     var box='abcdefg';
     alert(box.toString());        //abcdefg
     alert(box.toLocaleString());//abcdefg
     alert(box.valueOf());        //abcdefg

 // 字符方法 charAt()  charCodeAt()
     var str="ab_cd_123";
     alert(str.charAt(3));        // c    返回从0开始，索引为 3 的字符
     alert(str.charCodeAt(3));    // 99    返回从0开始，索引为 3 的字符的ASCII 的编码
     alert(str[1]);    //b        返回字符串中索引为 1 的字符
     alert('我司字符串'.charAt(-1));    //超出索引范围，返回为空字符串

 // 字符串操作方法  concat()  slice()  substring()  substr()
  //str.concat(str2,str3...); 和数组中的concat()方法是一样的，基于当前字符串，拼接后返回一个新的字符串
     var str='abc';
     alert(str.concat('123','abc'));    //abc123abc
     alert(str);    //abc

 // slice()方法和substring()方法在所有参数为正数的情况下是一样的，基于元字符串进行截取返回
     var str='abc123def';
     alert(str.slice(3));            //123def    从索引为3的字符开始截取，一直到字符串结束
     alert(str.slice(3,5))            //12        从索引为3的字符开始截取，一直到索引为5结束，不包裹索引为5的字符
     alert(str.slice(3,5,'qq'));        //12        多个参数时，同样只是认前两个
     alert(str.slice(3,'y'));        //第二个参数为非数值时返回为0
     alert(str.slice(3,5.7));        //第二个数为浮点数的时候，对数进行取整
     alert(str.slice(3,'7'));        //123d        将数值字符串转换成了数值
     alert(str.slice(3,1));        //第二个参数小于第一个参数的时候，返回为空
     alert(str.slice(3,-1));        //123de        参数为负数时，计算方式为：str.length+(-1)等价于(3,8)
     alert(str.slice(-5));        //23abc
     alert(str.slice(-5,7));        //(4,7)23a
     alert(str);                        //abc123def

     alert(str.substring(3))            //123def
     alert(str.substring(3,5));        //12
     alert(str.substring(3,5,'qq'));    //12
     alert(str.substring(5,2));        //c12    第二个参数小于第一个参数的时候,将两个参数进行交换
     alert(str.substring(3,'y'));    //第二个参数为非数值时，返回为0，然和第一个参数换位
     alert(str.substring(3,'7'));    //123d        将数值字符串转换成了数值
     alert(str.substring(3,5.9));    //12        第二个数为浮点数的时候，对数进行取整
     alert(str.substring(3,-1));        //abc        参数为负数时，直接返回为0，然后将较小的数提前
     alert(str.substring(-5,3));        //abc
     alert(str.substring(-5));    //abc123abc    参数为负，处理为0，返回全部
     alert(str.substring(-5,7));        //abc123a    第一个参数为负，当做0处理，截取到索引为七但不包含七的字符

     alert(str);                        //abc123def

 //str.substr(m,n);    从索引为m出开始，截取n个字符，返回，
     var str='abc123def';
     alert(str.substr(3));        //123def    只有一个参数，一直截取到结尾
     alert(str.substr(3,2));        //12        从索引为3开始截取两个字符，参数二为截取字符的个数
     alert(str.substr(3,'3'));    //123        数值型字符串，会自动的转换成数值
     alert(str.substr(3,'r'));    // 空        非数值型字符串，转换成数值为0，截取0个字符
     alert(str.substr(3,4.6));    // 123d        小数时，舍去小数，只取整数位
     alert(str.substr(3,-4));    // 空        负数的时候，直接返回为0，不交换位置 (3,0)
     alert(str.substr(3,2,'gg'));    //12    以后的参数都不认，弱类型语言，参数个数可以不匹配
     alert(str.substr(-5));        //23def        从最后一个字符开始向前数第5个字符处开始截取，直到结束
     alert(str.substr(-5,3));    //23d        从倒数第5个字符开始向后截取3个字符

     alert(str);                        //abc123def

 // 获取字符位置的函数  indexOf()   lastIndexOf()
 //indexOf('c');  返回字符串中从做到右第一个字符 c 的索引,如果没有找到就返回-1
     var str='abc123defabc';
     alert(str.indexOf('a'));        //0
     alert(str.indexOf('ab'));        //0
     alert(str.indexOf('ac'));        //-1
     alert(str.indexOf('a',3));        //9        从索引为3的字符开始向后查找子字符串 "a"，包括第三个字符

 //lastIndexOf('c');    返回字符串从右到做第一个字符 c 的索引，如果没有找到就返回-1
     var str='abc123defabc';
     alert(str.lastIndexOf('a'));    //9
     alert(str.lastIndexOf('ab'));    //9
     alert(str.lastIndexOf('ac'));    //-1
     alert(str.lastIndexOf('a',9));    //9        从索引为9的字符处开始向前查找子字符串“a”，包括第九个字符

 // 练习  找到字符串中包含全部的字符 L
     var str='aL123LdelfaLbc';
     var arr=[];
     var box=str.indexOf('L');    //先获取一次，进行判断是否存在字符 L
     while(box>-1){                //如果值大于-1，说明当前还存在字符 L
         arr.push(box);            //存入数组  等价于 arr[arr.length]=box;
         box=box+1;                //改变下次查找的位置，因为box处字符也算在内，故要加1
         box=str.indexOf('L',box);
     }
     alert(arr);    //1,5,11    默认是区分大小写的

 // toLowerCase() toUpperCase() 将字符串中的字符转换成小写或者大写
     var str='abcABC123';
     alert(str.toLowerCase());    //abcabc123
     alert(str.toUpperCase());    //ABCABC123
     str='abcABc但';
     alert(str.toLowerCase());    //abcabc但
     alert(str.toUpperCase());    //ABCABc但

 // toLocaleLowerCase()  toLocaleUpperCase() 转换成本地大小写字符,基本上看不出效果
     var str='abcABC';
     alert(str.toLocaleLowerCase());        //abcabc
     alert(str.toLocaleUpperCase());        //ABCABC

 // 模式匹配方法  search(pattern),march(pattern),replace(pattern),split(pattern)
 // 这些方法主要是针对的正则表达式

 // 静态方法  fromCharCode('');    输出对应ascii值对应的字符
     alert(String.fromCharCode(66));    //B

 // 比较两个字符串的大小 str.localeCompare(st);  先比较第一个字符，如果相等在比较后面字符
 //如果字符串中的字符在ASCII表中比参数字符串中对应索引处的字符编码大，就返回正数，一般为 1
 //如果小 就返回为负数，一般为 -1
 //如果相等就继续比较下一个字符，直到比完为止，如果还是相等就返回 0
     var str="dog";
     alert(str.localeCompare('abc'));    //1  str 字符串大于子字符串 abc
     alert(str.localeCompare('fff'));    //1
     alert(str.localeCompare('dog'));    //0
 */