Javascript 对象二（Number、String、Boolean、Array、Date、Math、RegExp）
Number 数字 对象String 字符串 对象Boolean 布尔 对象Array 数组 对象Date 日期 对象Math 算数 对象RegExp 正则表达式 对象Number 数字 对象
JavaScript中 数字不分为整数类型和浮点型类型，所有的数字都是由 浮点型类型。有 JavaScript 数字均为 64 位精度：整数最多为 15 位，小数的最大位数是 17八进制：前缀为 0。绝不要在数字前面写零，除非您需要进行八进制转换。十六进制： 前缀为 0 和 “x”输出16进制、8进制、2进制的方法：使用 toString() 方法var myNumber=128;myNumber.toString(16); // 返回 80myNumber.toString(8); // 返回 200myNumber.toString(2); // 返回 10000000
无穷大（Infinity）：正无穷大（Infinity），负无穷大（-Infinity）NaN 非数字值：用于指示某个值不是数字判断一个值是否是 NaN 值： 使用 isNaN() 全局函数来判断数字可以是数字或者对象。数字对象：
String 字符串 对象
字符串语法：
var str = 'hello';var str = "hello";var str = "'hello I'm Lotus" //字符串引号与内容引号不同var str = 'hello I\'m Lotus' //转义字符var str = "hello \" Lotus\""// 特殊字符： \' 单引号\" 双引号\\ 反斜杠\n 换行\r 回车\t tab制表符\b 退格符\f 换页符
字符串属性和方法：
length： 计算返回字符串长度
var str = "Lotus";var str1 = ' hello "小微"'document.write(str.length); // 5document.write(str1.length); // 11
chartAt(): 返回指定索引位置的字符
chartCodeAt(): 返回指定所以位置的Unicode值
concat() ： 字符串连接，返回连接后的字符串
indexOf() ：返回查找指定字符第一次出现的位置
lastIndexOf() ： 返回查找指定字符最后一次出现的位置
match() ：找到一个或者多个正则表达式的匹配
replace() ：替换与正则表达式匹配的子串
search() ：检索与正则表达式相匹配的值
slice()：返回提取的字符串片段
split() ：把字符串分隔为子字符串数组
substr() ：从起始索引提取字符串中指定数目的字符
substring()：提取字符串两个指定的索引之间的字符
toLowerCase()：把字符串转为小写
toUpperCase() ：把字符串转为大写
toString() ：返回字符串对象值
trim() ：移除字符串首尾空白
valueOf() ：返回某个字符串对象的原始值
let str = "hello lotus";document.write(str.charAt(1)); // edocument.write(str.charCodeAt(1)); // 101let str1 = 'hello wang';document.write(str.concat(str1)); //hello lotushello wangdocument.write(str.concat(str1, 'abc', '123')); // hello lotushello wangabc123document.write(str); // hello lotus
Boolean 布尔 对象
Boolean 对象用于转换一个不是 Boolean 类型的值转换为 Boolean 类型值 (true 或者false).
var myvar = new Boolean(1);myvar.constructor; // function Boolean() { [native code] }var bool = new Boolean(0);var myvar = bool.valueOf(); // false
布尔对象无初始值或者其值为: 0 -0 null “” false undefined NaN，对象的值为 false
Array 数组 对象
数组： 使用单独的变量名来存储一系列的值创建数组：1) 字面量let array = [];let arr = ['hello', 'world'];2）构造函数let arr = new Array(0;arr[0] = 'hello'简写：let arr = new Array('hello', 'world');3） ES6新增的Array.of()方法var arr=Array.of()var arr=Array.of(1,2,3)
访问数组：及索引访问数组的特定元素，第一个元素索引是[0]，第二个是[1]， 最后一个是 arr.length - 1数组检测： isArray() 、instanceof、.costructor、Object.prototype.toString.call([])==="[object Array]"、
let arr = [];arr.isArray() // truearr instanceof Array // truearr.constructor == array //trueObject.prototype.toString.call(arr)==="[object Array]" //true
数组的属性和方法：lenght：返回数组的长度，也可以用来截断数组
var arr=[1,2,3,4,5];console.log(arr.length); //5 ,返回数组的元素个数arr.length=3; //截断数组console.log(arr); //1，2，3
push()：向数组的尾部添加一项或多项；参数为单个值或者数组 ；
//返回添加元素后数组的长度；会改变原数组var arr=[1,2,3];console.log(arr.push('a')); //4 (4) [1, 2, 3, "a"]console.log(arr.push(['a','b','c'])); //5 (5) [1, 2, 3, "a", Array(3)]
pop()：删除数组最后一项；无参数；返回删除的那一项；会改变原数组
var arr=['a','b','c'];var tmp=arr.pop();console.log(tmp); //c (1)['a','b']
unshift()： 向数组开头添加一项或多项；参数为单个值或者数组 ；
//返回添加元素后数组的长度；会改变原数组var arr=[1,2,3];console.log(arr.unshift()('a'));//4 (4) ["a",1, 2, 3]console.log(arr.unshift()(['a','b','c']));//5 (5) [Array(3),"a",1, 2, 3]
shift()：向数组开头删除一项；无参数；返回删除的那一项；会改变原数组
var arr=['a','b','c'];var tmp=arr.shift();console.log(tmp); //c (1)['b','c']
splice()： 删除、插入、替换数组项；有参数；返回删除项组成的数组；会改变原数组
var arr=['a','b','c','d','e','f'];var tmp1=arr.splice(0,1);//删除一项console.log(arr,tmp1);//["b", "c", "d", "e", "f"], ["a"] var tmp2=arr.splice(1,1,'aaa');//替换一项console.log(arr,tmp2);// ["b", "aaa", "d", "e", "f"], ["c"]var tmp3=arr.splice(1,3,'bbb');//插入、替换多项console.log(arr,tmp3);// ["b", "bbb", "f"], ["aaa", "d", "e"]
copyWithin()：ES6新增，将数组指定位置（start to end）的元素复制到当前数组的其他位置（target）
这种复制会替换原位置的元素；返回替换之后的数组；改变原数组var arr=['a','b','c','d','e','f'];var tmp1=arr.copyWithin(3);//用索引0~4范围内的元素，替换索引3~4范围内的元素console.log(arr,tmp1);//["a", "b", "c", "a", "b", "c"],["a", "b", "c", "a", "b", "c"]var temp2 = arr.copyWithin(3, 2);//用索引2~4范围内的元素，替换索引3~4范围内的元素console.log(arr, temp2); // ["a", "b", "c", "c", "a", "b"],["a", "b", "c", "c", "a", "b"]
reverse()： 翻转原数组；无参数；返回翻转后的数组；会改变原数组
var arr = [1, 2, 3];var temp = arr.reverse();console.log(arr, temp); // [ 3, 2, 1 ] [ 3, 2, 1 ]
sort()：数组排序；参数compareFunction(compareFunction返回值>0时调换当前顺序，否则顺序不变)
返回排序后的数组；会改变原数组//从小到大排序var arr = [1, 4, 6, 7, 8, 3, 2];var tmp = arr.sort();//从小到大排序console.log(arr,tmp); //[1, 2, 3, 4, 6, 7, 8],[1, 2, 3, 4, 6, 7, 8]var tmp2=arr.sort().reverse();//从大到小排序console.log(arr, tmp2); // [8, 7, 6, 4, 3, 2, 1],[8, 7, 6, 4, 3, 2, 1] var tmp1 = arr.sort((a, b) => {//从小到大排序return a - b;})console.log(arr, temp1); // [ 1, 2, 3, 4, 6, 7, 8 ] [ 1, 2, 3, 4, 6, 7, 8 ]var tmp1 = arr.sort((a, b) => {//从大到小排序return b - a;})console.log(arr, temp1); // [ 1, 2, 3, 4, 6, 7, 8 ] [ 1, 2, 3, 4, 6, 7, 8 ]
concat()：拼接数组；参数类型可以是任意类型；返回拼接后的数组；原数组不发生改变
var arr=[1,2,3];var arr1=arr.concat(); //复制console.log(arr,arr1); //[1, 2, 3],[1, 2, 3]
slice()： 基于当前数组的一项或者多项创建一个数组；不会改变原数组
let arr = [0, 1, 2, 3, 4];let temp = arr.slice(1,3); // 返回从索引1（包括）位置到索引3（不包括）位置之前的元素console.log(arr, temp); // [0, 1, 2, 3, 4] [1, 2]let arr = [0, 1, 2, 3, 4]; //用于复制数组let temp = arr.slice(0); // 返回从索引0（包括）位置到数组结尾的所有元素console.log(arr, temp); // [0, 1, 2, 3, 4] [0, 1, 2, 3, 4]
indexOf()： 从数组开头查找元素在数组中的索引位置；返回在数组中的索引，没找到则返回-1
var arr=['a','b','c'];var tmp=arr.indexOf('b');console.log(arr,tmp); //["a", "b", "c"] , 1
lastIndexOf() ：从数组结尾查找元素在数组中的索引位置
遍历数组的方法：
传统方法：for循环、for...in循环、for...of循环
for:for(let i=0;i<arr.length;i++){console.log(arr[i]); // a b c 1 2 3}for...infor(var i in arr){console.log(i); // 0 1 2 3 4 5console.log(arr[i]); //a b c 1 2 3}for...offor(var item of arr){console.log(item); //a b c 1 2 3 undefined}for… in 、 for… of 的区别：1、推荐在循环对象属性的时候，使用for in，在遍历数组的时候推荐使用for of2、for…in 循环出来的是key, for…of循环出来的是value3、for…in 是ES5 标准，for …of 是ES6标准，兼容性可能存在些问题，请注意使用4、for...in 循环除了遍历数组元素外，还会遍历自定义属性，for...of只可以循环可迭代的可迭代属性，不可迭代属性在循环中被忽略了
forEach() 、 map() 、 filter() 、every() 、 some()forEach方法：被传递给foreach的函数会在数组的每个元素上执行一次；元素作为参数传递给该函数。
!* 未赋值的值是不会在foreach循环迭代的，但是手动赋值为undefined的元素是会被列出的var arr=['a', 'b', 'c', , undefined, 1, 2, 3,];arr.forEach( function( element, index ) {//ES5console.log( index, element ); //0:"a" , 1:"b" , 2:"c" , 3:1 , 4:2 , 5:3 })arr.forEach( ( element, index ) => {//ES6console.log( index, element ); //0:"a" , 1:"b" , 2:"c" , 3:1 , 4:2 , 5:3 })
map方法：通过callback对数组元素进行操作；并将所有操作结果放入数组中并返回该数组。
var arr=['a', 'b', 'c', , undefined, 1, 2, 3,];var arr1 = arr.map( function( item ) {//ES5return item + "*";})var arr1 = arr.map( item => {//ES6return item + "*";})console.log(arr1);//["a*", "b*", "c*", undefined × 1, "undefined*", "1*", "2*", "3*"]
3）filter方法：返回一个包含所有在回调函数上返回为true的元素新数组，
回调函数在此担任的是过滤器的角色，当元素符和条件，过滤器就返回true,而filter则会返回所有符合过滤条件的元素
var arr=['a', 'b', 'c', , undefined, 1, 2, 3,];var arr1 = arr.filter( function ( item ) {//ES5if ( typeof item == 'number' ){return item;}})var arr1 = arr.filter( item => {//ES6if ( typeof item == 'number' ) return item;})console.log(arr1); //[1,2,3]
4）every方法： 当数组中的每一个元素在callback上被返回true时就返回true
(注意：要求每一个单元项都返回true时才为true)var arr=['a', 'b', 'c', , undefined, 1, 2, 3,];var resault = arr.every( function ( item ) {//ES5console.log( item );//a ,b ,c ;到1判断为假结束遍历，返回falseif ( typeof item == 'string' ) return item;})var resault = arr.every( item =>{//ES6if ( typeof item == 'string' ) return item;})console.log(resault); //false
every()与filter()的区别是：
后者会返回所有符合过滤条件的元素；
前者会判断是不是数组中的所有元素都符合条件，并且返回的是布尔值
some方法：只要数组中有一项在callback上就返回true
every()与some()的区别是：前者要求所有元素都符合条件才返回true,
后者要求只要有符合条件的就返回true
Date 日期 对象
创建 Date 对象：new Date()let d = new Date(); //Thu May 14 14:27:45 GMT+0800 (中国标准时间)let d = new Date(millisecond); //
Date 对象的方法：
Math 算数 对象
执行常见的算数任务。
toFixed()： 把 Number 四舍五入为指定小数位数的数字。
var num =2.446242342;num = num.toFixed(2); // 输出结果为 2.45
round(参数)： 四舍五入。舍入与数字最接近的整数
Math.round(1); // 1Math.round(2.4); // 2Math.round(2.5); // 5//不能真正的四舍五入，有精度问题可以通过以下方式来确保精度是正确的：var num =2.446242342;num = Math.round((num + Number.EPSILON) * 100) / 100; // 输出结果为 2.45
random()：返回 0 到 1 之间的随机数max(参数1，参数2)：返回两者的最大者min(参数1，参数2)：返回两个给定的数中的较小的数
let a = 1, b = 2;let arr = [1,2,4,0]Math.max(a, b) // 2Math.min(a, b) // 1Math.max(...arr); // 4
abs(参数)：返回数的绝对值ceil(参数)： 向上取舍floor(参数)： 向下取舍toSource()：返回对象的各个属性值
Math.abs(-2) // 2Math.abs(2) // 2Math.ceil(2.123) // 3Math.floor(2.123) // 2
