Javascript 对象二（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);   // 返回 80
myNumber.toString(8);    // 返回 200
myNumber.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); // 5
document.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)); // e
document.write(str.charCodeAt(1)); // 101

let str1 = 'hello wang';
document.write(str.concat(str1)); //hello lotushello wang
document.write(str.concat(str1, 'abc', '123')); // hello lotushello wangabc123
document.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() // true
arr instanceof Array // true
arr.constructor == array //true
Object.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...in
for(var i in arr){
    console.log(i); // 0 1 2 3 4 5
    console.log(arr[i]); //a b c 1 2 3
}

for...of
for(var item of arr){
    console.log(item); //a b c 1 2 3 undefined
}

for… in 、 for… of 的区别：
    1、推荐在循环对象属性的时候，使用for in，在遍历数组的时候推荐使用for of
    2、for…in 循环出来的是key, for…of循环出来的是value
    3、for…in 是ES5 标准，for …of 是ES6标准，兼容性可能存在些问题，请注意使用
    4、for...in 循环除了遍历数组元素外，还会遍历自定义属性，
    for...of只可以循环可迭代的可迭代属性，不可迭代属性在循环中被忽略了

• forEach() 、 map() 、 filter() 、every() 、 some()

1. forEach方法：被传递给foreach的函数会在数组的每个元素上执行一次；元素作为参数传递给该函数。

!* 未赋值的值是不会在foreach循环迭代的，但是手动赋值为undefined的元素是会被列出的
var arr=['a', 'b', 'c', , undefined, 1, 2, 3,];
arr.forEach( function( element,  index ) { //ES5
        console.log( index, element ); //0:"a" , 1:"b" , 2:"c" , 3:1 , 4:2 , 5:3 
})
arr.forEach( ( element, index ) => { //ES6
        console.log( index, element ); //0:"a" , 1:"b" , 2:"c" , 3:1 , 4:2 , 5:3 
})

2. map方法：通过callback对数组元素进行操作；并将所有操作结果放入数组中并返回该数组。

var arr=['a', 'b', 'c', , undefined, 1, 2, 3,];

var arr1 = arr.map( function( item ) { //ES5
        return item + "*";
})
 var arr1 = arr.map( item => { //ES6
        return 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 ) { //ES5
         if ( typeof item == 'number' ){
             return item;
         }
})
var arr1 = arr.filter( item => { //ES6
         if ( 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 ) { //ES5
        console.log( item );//a ,b ,c ;到1判断为假结束遍历，返回false
        if ( typeof item == 'string' ) return item;
})
var resault = arr.every( item =>{ //ES6
        if ( 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 2020 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); // 1
Math.round(2.4); // 2
Math.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) // 2
Math.min(a, b) // 1
Math.max(...arr); // 4

• abs(参数) ：返回数的绝对值
• ceil(参数) ： 向上取舍
• floor(参数) ： 向下取舍
• toSource() ：返回对象的各个属性值

Math.abs(-2) // 2
Math.abs(2) // 2

Math.ceil(2.123) // 3
Math.floor(2.123) // 2

RegExp 正则表达式 对象