Js常用方法

:::常用链接 MDN

网道

数组方法：pop() 、push() 、shift() 、unshift() 、 reverse() 、 sort() 、 splice() 会改变原数组 :::

Array

类方法

:o:Array.isArray

let arr = ['1','2','3'];
console.log(Array.isArray(arr))

实例方法

增

:o:push

:boom:（push：推入）栈方法，push()方法接收任意数量参数，并将它们添加到数组末尾，返回数组最新长度（特别注意，返回的不是数组，是长度），下面来看例子

let arr = ['1','2','3'];
let count = arr.push('你','我','他');
console.log(count); //6
console.log(arr); //["1", "2", "3", "你", "我", "他"]

:o:unshift

:boom:(shift:转移)unshift()方法就是在数组开头添加任意多个值，并返回数组的新长度，看下面例子

let arr = ["1", "2", "3", "你", "我", "他"];
let str = arr.unshift('4','5');
console.log(str); //8
console.log(arr); //["4", "5", "1", "2", "3", "你", "我", "他"]

:o:splice

:boom:(splice:拼接)splice()方法有很多种使用方式，但主要用来数组中间插入元素，有三种不同的使用方式。（对原数组进行的操作）,返回一个包含被删除的元素的数组，如果没有删除元素，则返回空数组。

• 插入和替换：

需要给splice()传入三个参数：开始位置、0（要删除的元素数量）、要插入的元素，第三个之后可以是任意多个要插入的元素。

• 替换：

splice()在删除元素的同时可以指定wei

插入

//插入
let arr3 = [0,1,5,10,15,20,25];
let arr4 = arr3.splice(1,0,'我','他'); //从索引1这个位置开始，删除0个，插入'我','他'
console.log(arr3) //[0, "我", "他", 1, 5, 10, 15, 20, 25]
console.log(arr4) //[] 没有删除元素返回空数组

:o:concat

:boom:(concat:合并多个数组)concat()方法会创建当前数组的副本，然后把它的参数添加到副本末尾，最后返回这新构建的数组,不影响原数组。看例子：

let arr = [0,1,5,10,15];
let arr2 = arr.concat('你',['我','他']);
console.log(arr2);
console.log(arr);

删

:o:pop

:boom:（pop：弹出）栈方法，pop()方法删除数组最后一项，同时减少数组length值，返回被删除的项，下面来看例子

let arr = ["1", "2", "3", "你", "我", "他"];
let str = arr.pop();
console.log(str); //他

:o:shift

:boom:(shift:转移)shift()方法会删除数组第一项并返回它，然后数组长度减1，看下面例子

let arr = ["1", "2", "3", "你", "我", "他"];
let str = arr.shift();
console.log(str); //1
console.log(arr); //["2", "3", "你", "我", "他"]

:o:splice

:boom:(splice:拼接)splice()方法有很多种使用方式，但主要用来数组中间插入元素，有三种不同的使用方式。（对原数组进行的操作）,返回一个包含被删除的元素的数组，如果没有删除元素，则返回空数组。

• 删除：

需要给splice()传入两个参数：要删除开始第一个元素的位置和要删除的元素数量。

//删除
let arr = [0,1,5,10,15,20,25];
let arr2 = arr.splice(1,2) 
console.log(arr) //[0, 10, 15, 20, 25]
console.log(arr2) //[1, 5] 返回包含被删除的元素的数组

:o:slice

:boom:(slice:切片)slice()方法用于创建一个包含原有数组一个或多个元素的新数组，接收一个或两个参数，注意，不影响原数组。看例子：

let arr = [0,1,5,10,15,20,25];

let arr2 = arr.slice(1); //索引为1的及之后的全部
console.log(arr2);//[1, 5, 10, 15, 20, 25]

let arr3 = arr.slice(1,4); //不包括索引为4上的
console.log(arr3); //[1, 5, 10]
console.log(arr); //[0, 1, 5, 10, 15, 20, 25]

改

:o:splice

:boom:(splice:拼接)splice()方法有很多种使用方式，但主要用来数组中间插入元素，有三种不同的使用方式。（对原数组进行的操作）,返回一个包含被删除的元素的数组，如果没有删除元素，则返回空数组。

• 替换：

splice()在删除元素的同时可以指定wei

插入

//插入
let arr3 = [0,1,5,10,15,20,25];
let arr4 = arr3.splice(1,0,'我','他'); //从索引1这个位置开始，删除0个，插入'我','他'
console.log(arr3) //[0, "我", "他", 1, 5, 10, 15, 20, 25]
console.log(arr4) //[] 没有删除元素返回空数组

查

:o:indexOf、includes

:boom:indexOf()和includes()方法都是从数组第一项开始搜索，indexOf()返回元素所在数组的索引，如果没找到就返回-1，includes()返回布尔值，表示找到至少一个与指定元素匹配的项，没找到就返回false，需要注意的是，includes是ES7新增的，且会使用全等（===）进行比较，要求两项必须严格相等。看例子：

let arr = [1,3,5,7,10,7,13,15];
console.log(arr.indexOf(5))  //2
console.log(arr.includes(10))  //true

//寻找包含7的项，从索引为4的位置开始向后搜索
console.log(arr.indexOf(7,4))  //5

//寻找包含10的项，从索引为5的位置开始向后搜索
console.log(arr.includes(10,5)) //false

:o:lastIndexOf

:boom:lastIndexOf()和indexOf()一样，只不过是从最后面开始向前寻找

:o:find

:boom:返回第一个匹配的元素

const people = [{name:'张三',age:24},{name:'李四',age:26}]
people.find((ele,index,array) => ele.age < 25)  //{name:'张三',age:24}

排序方法

:o:reverse、sort

:boom:(reverse:颠倒)reverse()方法能让数组元素反向排序，看例子：

let arr = ['1','2','3','4','5','6'];
console.log(arr.reverse())  //["6", "5", "4", "3", "2", "1"]

:boom:(sort:排序)sort()方法默认情况下会按升序（从小到大）重新排列数组元素，为此，sort()方法会在每一项元素上调用String()转型函数，然后比较字符串来决定顺序，即使元素都是数值，也会这样处理，看例子：

let arr = [0,1,5,10,15];
console.log(arr.sort())  //[0, 1, 10, 15, 5],经过调用方法后反而排错了

:x:经过调用方法后反而排错了，这是它的排序原理所导致，为此，sort()还可以接收一个比较函数，用于判断哪个值应该排前面。

比较函数接收两个参数，如果第一个参数应该排在第二个参数前面就返回负值，如果第一个参数应该排在第二个参数后面就返回正值，相等返回0。

let arr = [0,1,5,10,15];
console.log(arr.sort(compare)) //[0, 1, 5, 10, 15]
function compare(value1,value2){
    if(value1<value2){
        return -1
    }else if(value1>value2){
        return 1
    }else{
        return 0
    }
}
//简写方式
arr.sort((a,b) => a-b ) //升序
arr.sort((a,b) => b-a ) //降序
console.log(arr)//[0, 1, 5, 10, 15]

//降序，把-1和1位置调换就行

填充方法

:o:fill

:boom:使用fill()方法可以向一个已有数组插入全部或部分相同的值

let arr = ['1','2','3','4','5','6'];

//用5填充整个数组
arr.fill(5);
console.log(arr) //[5, 5, 5, 5, 5, 5]

//用5填充索引大于等于3的元素
arr.fill(5,3);
console.log(arr) //['1','2','3', 5, 5, 5]

//用5填充索引大于等于1且小于3的元素
arr.fill(5,1,3);
console.log(arr)  //["1", 5, 5, "4", "5", "6"]

转换方法

:o:toString

:boom:使用toString()方法返回由数组中每个值的等效字符串拼接而成的一个以逗号分隔的字符串

let arr = ['1',2,'3',4,'5','6'];
console.log(arr.toString()) //1,2,3,4,5,6
console.log(typeof arr.toString()) //string

:boom:toLocaleString()方法和它差不多，具体可查阅第四版红宝书146页

:o:join

:boom:join()接收一个参数，即字符串分隔符，返回包含所有项的字符串，看下面例子

let arr = ['1','2','3','4','5','6'];
console.log(arr.join()) //1,2,3,4,5,6  只调用的话会返回以','隔开的字符串
console.log(arr.join(''))  //123456
console.log(arr.join(',')) //1,2,3,4,5,6
console.log(arr.join('||')) //1||2||3||4||5||6
console.log(arr.join(' ')) //1 2 3 4 5 6

迭代方法

:::tip 5个迭代方法，每个迭代方法都接收两个参数，一个是以数组中每一项元素为参数运行的函数，（非必须）另一个是作为函数运行上下文的作用域对象（影响函数值this的值）。这个传入的函数又可以接收三个参数：数组元素、元素索引、数组本身。

:boom:注意：这些方法都不改变原数组 :::

:o:forEach

:boom:（forEach：为每一个）对数组每一项都运行传入的函数，没有返回值

let arr = [1,3,5,7,{num:10},7,13,15];
arr.forEach((item,index,arr) => {
    if(item>10){
        item +=1; 
        console.log("我无法改变原数组,也没有返回值，但如果原数组中的数据是对象，可以改变该对象身上的属性") 
    }
})
console.log(arr) //[1, 3, 5, 7, 10, 7, 13, 15]

:o:every

:boom:对数组每一项都运行传入的函数，如果对每一项函数都返回true，这个方法会返回true

let arr = [1,3,5,7,10,7,13,15];
let arr2 = arr.every((item,index,arr) => item>1)
console.log(arr2) //false

:o:some

:boom:对数组每一项都运行传入的函数，如果有一项函数返回true，这个方法会返回true

let arr = [1,3,5,7,10,7,13,15];
let arr2 = arr.some((item,index,arr) => item>1)
console.log(arr2) //true

:o:filter

:boom:（filter：过滤器）对数组每一项都运行传入的函数，将判断结果为true的项组成数组之后返回

let arr = [1,3,5,7,10,7,13,15];
let arr2 = arr.filter((item,index,arr) => item>10)
console.log(arr2) //[13, 15]
console.log(arr) //[1,3,5,7,10,7,13,15]

:o:map

:boom:（map：地图，理解成映射）map()方法会返回一个数组，这个数组的每一项都是对原始数组中同样位置的元素运行传入函数而返回的结果。

let arr = [1,3,5,7,10,7,13,15];
let arr2 = arr.map((item,index,arr) => item+1)
// let arr2 = arr.map((item,index,arr) => {
//      return item+1  //这样写的话要加return
//  })
console.log(arr2) //[2, 4, 6, 8, 11, 8, 14, 16]
console.log(arr) //[1,3,5,7,10,7,13,15]

:o:for of

let arr = [12,34,23,12,55]
for (const item of arr) {
    console.log(item)
}

归并方法

:o:reduce

:::tip :boom:（reduce：归纳为）这两个方法都接收两个参数，一个是对数组中每一项都会运行的归并函数，（可选的）第二个是以之为归并起点的初始值。传给这两个方法的函数又可接收四个参数：上一个归并值、当前项、当前项的索引和数组本身

:boom:这个函数返回的任何值都会作为下一次调用同一个函数的第一个参数。如果没有给这两个方法传入可选的第二个参数（作为归并起点值），则第一次迭代将从数组的第二项开始，因此传给归并函数的第一个参数是数组的第一项，第二次参数是数组的第二项。 :::

:boom:没有第二个参数

const array = [15, 16, 17, 18, 19];

function reducer(previousValue, currentValue, currentIndex, array) {
  const returns = previousValue + currentValue;
  return returns;
}
array.reduce(reducer);

情况：

:boom:有第二个参数

const array = [15, 16, 17, 18, 19];

function reducer(previousValue, currentValue, currentIndex, array) {
  const returns = previousValue + currentValue;
  return returns;
}
array.reduce(reducer,10);

情况：

:o:reduceRight

reduceRight()只是从最后一项开始遍历至第一项的区别

let arr = [1,2,3,4,5];
let arr2 = arr.reduceRight((prev,cur,index,arr) => prev + cur)
console.log(arr2) //15
console.log(arr) //[1, 2, 3, 4, 5]

Object

属性枚举

:boom:注意：forin 和 Object.keys的枚举顺序不一定按顺序

:o:for in

:boom:了解for in 之前先了解一下 in 操作符，in 操作符用来判断某属性属性是否在该对象上，即使在该对象的原型上也算

function obj(){this.age = 12}
obj.prototype.name = 'jj'
let obj2 = new obj()
console.log('age' in obj2) //true
console.log(obj2.hasOwnProperty('name')) //false
console.log('name' in obj2) //true

:boom: for in 可以用来迭代对象的键

//for in
let obj = {name:'zhangsan',age:23}
for(key in obj){
  if(obj.hasOwnProperty(key)){
    console.log(key) // 'name' 'age'
  }
}

:o:Object.keys

:boom:Object.keys(obj)会遍历对象的属性并组成数组返回

let obj = { name: 'zhangsan', age: 23 }
console.log(Object.keys(obj)) //['name', 'age']

:o:Object.getOwnPropertyNames

:boom:Object.getOwnPropertyNames(obj)会遍历对象的属性并组成数组返回

let obj = { name: 'zhangsan', age: 23 }
console.log(Object.getOwnPropertyNames(obj)) //['name', 'age']

:o:Object.assign

:boom:Object.assign(target,source)方法用于将所有键值对从一个或多个源对象分配到目标对象。它将返回目标对象。（常用于浅拷贝）

const target = {b:2};
const source = { b: 4, c: 5 };

const returnedTarget = Object.assign(target, source);

console.log(target);
// expected output: Object { b: 4, c: 5 }
console.log(returnedTarget);
// expected output: Object { b: 4, c: 5 }

:o:Object.getOwnPropertySymbols

:boom:见红宝书233页

对象迭代

:o:Object.values

:boom:Object.values(obj)返回属性值组成的数组

let obj = { name: 'zhangsan', age: 23 }
console.log(Object.values(obj)) //['zhangsan', 23]

:o:Object.entries

:boom:Object.entries(obj)返回键值对组成的数组（entries：条目)

let obj = { name: 'zhangsan', age: 23 }
console.log(Object.entries(obj)) //[['name', 'zhangsan'],['age', 23]]

String

更多详细内容

实例方法

增

:o:concat

:boom:concat()方法用于将一个或多个字符串拼接成一个新的字符串。:boom:原字符串不变

let authorName = "Rs'90 "
let blogName = '夏日的の蝉';
let result = authorName.concat(blogName)
console.log(result) //Rs'90 夏日的の蝉
console.log(authorName)  //Rs'90

删

:o:slice

:boom:slice()方法返回调用它们的字符串的子字符串，接收一或两个参数，第一个参数表示开始的位置，第二个表示子字符串结束的位置。:boom:原字符串不变

let authorName = "Rs'90 "
let blogName = '夏日的の蝉';
let result = authorName.concat(blogName)
console.log(result) //Rs'90 夏日的の蝉
console.log(result.slice(5,10)) //夏日的の蝉
console.log(authorName)  //Rs'90

:o:substr

:o:substring

substring方法返回一个字符串在开始索引到结束索引之间的一个子集, 或从开始索引直到字符串的末尾的一个子集。substr方法不建议使用，可能会被废弃

let stringValue = "hello world";   
console.log(stringValue.substring(3)); // "lo world"   
console.log(stringValue.substring(3,7)); // "lo w"   
console.log(stringValue.substr(3, 7)); // 从索引3开始，长度为7

改

:o:trim

:boom:（trim：切除）trim()这个方法会创建字符串的副本，删除前后的所有空格然后返回，不改变原字符串。

let blogName = '  夏日的の蝉  ';
console.log(blogName.trim())
console.log(blogName)

:o:repeat

:boom:repeat()这个方法接收一个整数参数，表示要复制多少次，然后返回拼接所有副本后的结果。不改变原字符串。

let blogName = '夏日的の蝉';
console.log(blogName.repeat(4)) //夏日的の蝉夏日的の蝉夏日的の蝉夏日的の蝉
console.log(blogName) //夏日的の蝉

:o:padStart、padEnd

复制字符串，如果小于指定长度，则在相应一边填充字符，直至满足长度条件

let stringValue = "foo";  
console.log(stringValue.padStart(6)); // " foo"  因为没有第二参数，所以用空字符填充至6位   
console.log(stringValue.padStart(9, ".")); // "......foo"   

查

:o:charAt

:boom:charAt()返回给定索引位置的字符，参数应为整数。

let name = '夏日的の蝉';
console.log(name.charAt(4)); //蝉

:o:charCodeAt

:boom:fromCharCode()方法可以查看指定码元的字符编码，返回指定索引位置的码元值，参数应为整数。

let name = '夏日的の蝉';
console.log(name.charCodeAt(4)); //34633

:o:indexOf、lastIndexOf

:boom:这两个方法从字符串中搜索传入的字符串并返回位置，如果没找到就返回-1，也可传入第二个参数，表示开始搜索的位置。注意：当传入的字符串为空字符串''时，返回0，不返还-1。两者的区别在于lastIndexOf()从后往前的方向找。

let blogName = '夏日的の蝉';
console.log(blogName.indexOf('')) //0
console.log(blogName.indexOf('蝉')) //4
console.log(blogName.indexOf('夏')) //0
console.log(blogName.indexOf('夏',1)) //-1
console.log(blogName.indexOf('荣')) //-1
console.log(blogName.indexOf('夏的')) //-1

:o:startsWith

:o:endsWith

:o:includes

:boom:这三个方法都会从字符串中搜索传入的字符串，返回表示是否包含的布尔值。他们区别在于startsWith()检查开始于索引0的匹配项，endsWith()检查开始于索引(string.length - substring.length)的匹配项,而includes()检查整个字符串。

let message = 'foobarbaz';
console.log(message.stratsWith('foo')) //true
console.log(message.stratsWith('bar')) //false

console.log(message.endsWith('baz')) // true
console.log(message.endssWith('bar')) //false

console.log(message.includes('bar')) //true
console.log(message.includes('qux')) //false

:boom:startsWith()和includes()可以传入第二个参数，表示开始搜索的位置

---

字符串的大小写转换

:o:toLowerCase

:o:toLocaleLowerCase

:o:toUpperCase

:o:toLocaleUpperCase

:boom:(lowercase：小写字母)toLocaleLowerCase()和toLocaleUpperCase()方法旨在基于特定地区实现。

let blogName = 'xiariのchan';
console.log(blogName.toLowerCase()) //xiariのchan
console.log(blogName.toLocaelLowerCase()) //xiariのchan
console.log(blogName.toUpperCase()) //XIARIのCHAN
console.log(blogName.toLocaleUpperCase()) //XIARIのCHAN
console.log(blogName) //xiariのchan

在不知道代码设计什么语言（如土耳其语），则最好使用地区特定的转换方法。

模板匹配

:o:match

:boom:（match:配对）match()方法对字符串进行正则匹配，匹配成功返回一个数组，匹配失败返回null。

var s = '_x_x';
var r1 = /x/;
var r2 = /y/;

s.match(r1) // ["x"]
s.match(r2) // null 

//如果正则表达式带有g修饰符，则该方法与正则对象的exec方法行为不同，会一次性返回所有匹配成功的结果。
var s = 'abba';
var r = /a/g;

s.match(r) // ["a", "a"]
r.exec(s) // ["a"]

:boom:注意：设置正则表达式的lastIndex属性，对match方法无效，匹配总是从字符串的第一个字符开始。

:o:search

:boom:（search:搜索）search()方法，返回第一个满足条件的匹配结果在整个字符串中的位置。如果没有任何匹配，则返回-1。

'_x_x'.search(/x/) // 1  在索引为1的位置

:o:replace

:boom:（replace:替换）replace()方法可以替换匹配的值。它接受两个参数，第一个是正则表达式，表示搜索模式，第二个是替换的内容。如果不加g修饰符，就替换第一个匹配成功的值，否则替换所有匹配成功的值。。

'aaa'.replace('a', 'b') // "baa"
'aaa'.replace(/a/, 'b') // "baa"
'aaa'.replace(/a/g, 'b') // "bbb"

replace方法的一个应用，就是消除字符串首尾两端的空格。

var str = '  #id div.class  ';

str.replace(/^\s+|\s+$/g, '')
// "#id div.class"

replace方法的第二个参数可以使用美元符号$，用来指代所替换的内容。

• $&：匹配的子字符串。
• $`：匹配结果前面的文本。
• $'：匹配结果后面的文本。
• $n：匹配成功的第n组内容，n是从1开始的自然数。
• $$：指代美元符号$。

'hello world'.replace(/(\w+)\s(\w+)/, '$2 $1')
// "world hello"

'abc'.replace('b', '[$`-$&-$\']')
// "a[a-b-c]c"

replace方法的第二个参数还可以是一个函数，将每一个匹配内容替换为函数返回值。

'3 and 5'.replace(/[0-9]+/g, function (match) {
  return 2 * match;
})
// "6 and 10"

var a = 'The quick brown fox jumped over the lazy dog.';
var pattern = /quick|brown|lazy/ig;

a.replace(pattern, function replacer(match) {
  return match.toUpperCase();
});
// The QUICK BROWN fox jumped over the LAZY dog.

作为replace方法第二个参数的替换函数，可以接受多个参数。其中，第一个参数是捕捉到的内容，第二个参数是捕捉到的组匹配（有多少个组匹配，就有多少个对应的参数）。此外，最后还可以添加两个参数，倒数第二个参数是捕捉到的内容在整个字符串中的位置（比如从第五个位置开始），最后一个参数是原字符串。下面是一个网页模板替换的例子。

var prices = {
  'p1': '$1.99',
  'p2': '$9.99',
  'p3': '$5.00'
};

var template = '<span id="p1"></span>'
  + '<span id="p2"></span>'
  + '<span id="p3"></span>';

template.replace(
  /(<span id=")(.*?)(">)(<\/span>)/g,
  function(match, $1, $2, $3, $4){
    return $1 + $2 + $3 + prices[$2] + $4;
  }
);
// "<span id="p1">$1.99</span><span id="p2">$9.99</span><span id="p3">$5.00</span>"

上面代码的捕捉模式中，有四个括号，所以会产生四个组匹配，在匹配函数中用$1到$4表示。匹配函数的作用是将价格插入模板中。

转换方法

:o:split

:boom:(split：分离)splice()方法会根据传入的分隔符将字符串拆分成数组。作为分隔符的参数可以是字符串，也可以是RegExp对象，还可以传入第二次参数，即数组大小，确保返回的数组不会超过指定大小。

let colorText = 'red,blue,green,yellow';
let colors1 = colorText.split(','); //["red", "blue", "green", "yellow"]
let colors2 = colorText.split(',',2); //["red", "blue"]
let colors3 = colorText.split(/[^,]+/); //["", ",", ",", ",", ""]
let colors4 = colorText.split(' '); //["red,blue,green,yellow"]

console.log(colorText) //red,blue,green,yellow

colorText.split(',',2); 表示基于逗号进行拆分，拆分两个组成新数组返回。

JSON

:o:JSON.stringify

:x:注意：JSON字符串必须使用双引号，单引号会导致语法错误 :boom:JSON.stringify()方法可以将js对象序列化成JSON字符串

let body = {
    blogName: '夏日的の蝉',
    age: 1
}
console.log(body) //{blogName: "夏日的の蝉", age: 1}
console.log(JSON.stringify(body)) //{"blogName":"夏日的の蝉","age":1}

//JSON.stringify()还可以接收两个参数，第二个参数是过滤器，可以是数组或函数，第三个参数是用于缩进结果JSON字符串的选项。
let body = {
    blogName: '夏日的の蝉',
    age: 1,
    gender: '男'
}
console.log(body) //{blogName: "夏日的の蝉", age: 1}
console.log(JSON.stringify(body,['blogName','gender'])) //{"blogName":"夏日的の蝉","gender":"男"}

网道

:o:JSON.parse

:boom:JSON.parse()方法可以将JSON字符串转换成js对象

let body = {
    "blogName": '夏日的の蝉',
    "age": 1,
    "gender": '男'
}
console.log(JSON.parse(body)) //{blogName: "夏日的の蝉", age: 1, gender: "男"}

Math

:o:属性

API	介绍
Math.E	自然对数的基数e的值
Math.LN10	10为底的自然对数
Math.LN2	2为底的自然对数
Math.LOG2E	以2为底e的对数
Math.LOG10E	以10为底e的对数
Math.PI	π的值
Math.SQRT1_2	1/2的平方根
Math.SQRT2	2的平方根

:o:min和max

:boom:min()和max()都接收任意个值，返回这几个参数中的最小或最大值

let arr  = [1,12,5,78,15,6]
console.log(Math.min(...arr))//1
console.log(Math.max(...arr))//78

舍入方法

:o:Math.ceil()(ceil:天花板)向上去最接近的整数

:o:Math.floor()向下去最接近的整数

:o:Math.round()执行四舍五入

:o:Math.fround()返回数值最接近的单精度（32位）浮点值表示

console.log(Math.ceil(2.1))  //3
console.log(Math.floor(2.9))//2
console.log(Math.round(2.9))//3
console.log(Math.round(2.5))//3
console.log(Math.round(2.4))//2
console.log(Math.fround(2.4))//2.4000000953674316

:o:random

:boom:Math.random()方法返回0-1范围内的随机数，包含0但不包含1

console.log(Math.ceil(Math.random()*10))  //产生0-10范围内的数包含0和10
console.log(Math.floor(Math.random()*10))  //产生0-9范围内的数包含0和9
console.log(Math.floor(Math.random()*10 + 1))  //产生1-10范围内的数包含1和10

Number

:o:toString

:boom:toString()方法可以接收一个表示基数的参数，并返回相应基数形式的数值字符串 示例：

let num = 10;
console.log(num.toString()); //10
console.log(num.toString(2)); //1010
console.log(num.toString(8)); //12
console.log(num.toString(16)); //a

:o:toFixed

:boom:toFixed()方法返回包含指定小数点位数的数值字符串 示例：

let num = 11.3;
console.log(num.toFixed(2)); //11.30
console.log(num.toFixed(3)); //11.300

:o:Number

:boom:Number()是转换函数，可以用于任何类型。

console.log(Number('123')) //123
console.log(Number('12.3')) //12.3
console.log(Number('0123')) //123
console.log(Number('')) //0
console.log(Number(true)) //1
console.log(Number(false)) //0
console.log(Number(null)) //0
console.log(Number(undefine)) //NaN

:o:parseInt

:boom:parseInt()主要用于将字符串转为整数,可接收一或两个参数。

console.log(parseInt('123.45')) //123
console.log(parseInt('123.85')) //123
console.log(parseInt('123blue')) //123

//一2进制解析
console.log(parseInt('10',2)) //2
//以十六进制解析
console.log(parseInt('10',16)) //10

:o:parseFloat

:boom:parseInt()主要用于将字符串转为整数,可接收一或两个参数。

console.log(parseFloat('123.45')) //123.45
console.log(parseFloat('123blue')) //123
console.log(parseFloat('123.12.34')) //123.12
console.log(parseFloat('0123.12')) //123.12