前端学习day38&day39&day40：09-JS基础之各类型常用api

常用API

1.Number

        ⑴toFixed()

                四舍五入指定小数位数，返回结果为字符串。

let num = 3.1415926
// 保留两位小数
let str1 = num.toFixed(2) // 3.14
// 保留三位小数
let str2 = num.toFixed(3) // 3.142

        ⑵Number.isNaN()

                判断一个数是否是NaN，返回布尔值(可以省略Number)。

Number.isNaN('123') // false 

Number.isNaN(456) // false

Number.isNaN(true) // false

Number.isNaN(NaN) // true

        ⑶Number.isFinite() 

                检测某个值是否是有限数字(可以省略Number)          ps:finite [ˈfaɪnaɪt] 有限的;有限制的;限定的

Number.isFinite(123) // true
Number.isFinite(12346546546545646546464646465456456456) // true
Number.isFinite(true) // false
Number.isFinite('abd') // false
Number.isFinite(NaN) // false

        ⑷Number.isInteger()

                检测某个值是否为整数(不可以省略Number)           ps:Integer [ˈɪntɪdʒə(r)] 数据类型;个数;封装类;整数;数值型;整数

Number.isInteger(123) // true
Number.isInteger(123.0) // true
Number.isInteger(123.1) // false
Number.isInteger('abc') // false

        ⑸Number.parseInt()

                parseInt()函数可解析一个字符串，并返回一个整数。           ps:parse [pɑːz]  (对句子)作语法分析;作句法分析

                前面的Number可以省略(可以解析字符串)，从第一个不是空格的字符开始，到第一个不是数字的地方结束。

Number.parseInt('123.456') // 123
Number.parseInt('123aaa') // 123
Number.parseInt('123.456aaa') // 123
Number.parseInt('a123') // NaN

        ⑹Number.parseFloat()

                parseFloat()函数可解析一个字符串，并返回一个浮点数。

                前面的Number可以省略(可以解析字符串)

Number.parseFloat('123.456') // 123.456
Number.parseFloat('123aaa') // 123
Number.parseFloat('123.456aaa') // 123.456
Number.parseFloat('a123') // NaN

2.String

        ⑴charCodeAt() 

                返回字符串指定位置的字符的unicode编码

let str = "abcde"
str.charCodeAt(2)   // 99 

        ⑵String.fromCharCode() 

                 通过unicode编码排序值返回对应的字符

String.fromCharCode(99) // c

        ⑶substring()

                substring(startNum, endNum)：截取字符串，就算参数互换位置substring()方法也可以识别，并可以将位置调整正确。

let str = "hello"
str.substring(1,2) // e
// startNum 参数起始位置(包含), endNum 参数结束位置(不包含)
// endNum 参数不写 默认截取所有

        ⑷substr()

                substr(startNum, length)：截取字符串

let str = "hello"
str.substr(1,2) //el
// startNum 参数为起始位置(包含), length 参数截取长度
// length 参数不写 默认截取所有

        ⑸slice()

                slice的使用与substring相同，但是参数位置不能互换           ps:slice [slaɪs]  把…切成(薄)片;切;

        ⑹trim()

                清除左右空格，中间的空格不会管           ps:trim [trɪm]  修剪;修整;切去，割掉，剪下，除去(不必要的部分);

let str = " hello  "
str.trim() // "hello"

        ⑺replace() 

                replace(str, repStr)：替换字符串，只会替换第一个检索到的字符串项。

let str = "12345abcdef"
let str1 = str.replace(2,4)
console.log(str1) // 14345abcdef
// str参数为查找字符串的被替换字符, repStr 参数值 将替换str值
// 如果没有查询到将返回原字符串

        ⑻split()

                将字符串切割成数组，接收的参数为切割点(按什么去切割)           ps:split [splɪt]  分开，使分开(成为几个部分);

let str = "hello"
console.log(str.split("e"))  // ["h", "llo"]

        ⑼indexOf()

                indexOf(Str, [index])：查找到字符串中和参数对应的字符时返回下标，否则返回-1，检索范围是从index开始一直到最后

let str="hello"
console.log(str.indexOf("e")) // 1
// Str 参数为查找字符, index 参数为查找开始的位置
// index参数不写 默认从0开始

        ⑽lastIndexOf() 

                返回结果与indexOf相同，检索方向为从后往前

        ⑾includes(),startsWith(),endsWith()

                ①includes(str, [index])：返回布尔值，表示是否找到了参数字符串
                ②startsWith(str, [index])：返回布尔值，表示参数字符串是否在原字符串的头部
                ③endsWith(str, [index])：返回布尔值，表示参数字符串是否在原字符串的尾部

let str = "apple banana";
str.includes("apple") // true


let str = "http://www.baidu.com";
str.startsWith("http");      // true
str.startsWith("https");      // false

let str = "http://www.baidu.com";
str.endsWith("com");      // true
str.endsWith("cn");      // false

// Str 参数为查找字符, index 参数为查找开始的位置
// index参数不写则默认从0开始

        ⑿repeat()

                repeat(n)：目标将字符串重复n次，参数如果是小数，会被向下取整

let str = "ysc";
let repstr = str.repeat(3);
console.log(repstr);  //yscyscysc
// 参数n为重复的次数   参数如果是小数，会被向下取整

        ⒀ charAt()

                获取某个字符串项，函数参数传下标序号，可取出字符串对应下标序号的字符

let str = "ysc666"; 
console.log(str.charAt(str.length-1)); //  6

3.Array

        ⑴push() 

                  push(data, [data])：依次往数组最后面添加数组项，可以同时添加多个(会改变原数组)，返回值为改变后的length

let arr = [1,2,3]
let arr1 = arr.push(4,5)
console.log(arr)  // [1,2,3,4,5]  
// 返回值为新数组的length（该方法会改变原数组）

        ⑵pop()  

                删除数组最后一项(会改变原数组)，返回值为被删除的数据

let arr = [1,2,3]
let arr1 = arr.pop()
console.log(arr) // [1,2]
// 返回值是删除的数值（该方法会改变原数组）

        ⑶shift()

                移除数组中第一项并返回该项(会改变原数组)           ps:shift [ʃɪft]  转移;挪动;赶快;快速移动;变换;更替;变动

let arr = [1,2,3]
let arr1 = arr.shift()
console.log(arr)     // [2,3]
// 返回值是删除的数值（该方法会改变原数组）

        ⑷unshift()

                 在数组最前面添加任意数组项，可以同时添加多个(会改变原数组)，返回值为新数组的length

let arr = [1,2,3]
let arr1 = arr.unshift(0)    // 改变原数组       
console.log(arr) // [0,1,2,3] 
// 返回值新数组的length（该方法会改变原数组）

        ⑸splice()

                splice(index, num, info)：具有截取、替换、添加功能的方法(会改变原数组)，返回裁剪的数组。           ps:splice [splaɪs]   剪接

                index:从数组第几项开始裁剪（必选）

                num:裁剪几个（必选）

                info:替换进去的数组项（可选）

//- index 从数组第几个项开始
//- num  截取的数量 
//- info 从截取位置开始添加数组项
//- 会改变原数组  返回截取的数组

let arr = [1,2,3,4,5]
arr.splice(2,3,"a","b")
console.log(arr)

//1)截取方法     截取数量
let arr = [1,2,3,4]
arr.splice(1,2)

//2)添加方法    截取数量为零
arr.splice(1,0,1)
arr.splice(1,0,1,2,3)  // 添加多个  

//4)替代方法    截取数量与添加相同
arr.splice(0,1,5)

        ⑹sort() 

                sort(function)：数组排序

// function 参数为一个函数体   函数体接收两个形参
// 不传参数 根据ASCII码表 来比较数组中的第一个值排序

let arr = [22,44,11,33,55]
arr.sort(function(a,b){
    return a - b //从小到大排列
    return b - a //从大到小排列
})
console.log(arr)

        ⑺concat() 

                合并两个数组为一个新的数组且不改变原数组，返回一个合并好的新数组

let arr1 = [1,2,3]
let arr2 = ["a","b","c"]
let arr = arr1.concat(arr2)
console.log(arr)

        ⑻join()

                 join(str)：根据参数规则(按什么去拼接)返回新的字符串且不改变原数组

let arr = [1,2,3,4]
let arr1 = arr.join("-")
console.log(arr1) // 1-2-3-4
// 将数组合并成字符串

        ⑼reverse()

                 数组反向排序，会改变原数组

let arr = [1,2,3,4]
let arr1 = arr.reverse()
console.log(arr1)  // [4, 3, 2, 1]

        ⑽slice()

                slice(startNum, endNum)：截取数组(不改变原数组)，返回截取成功的数组。结束序号不写则默认从开始序号截取到最后一项；不写任何序号那就是截取全部项。           ps:slice [slaɪs]   把…切成(薄)片;切;割;划;

let arr = [1,2,3,4]
arr.slice(1,3)
// startNum 参数为起始位置(包含), endNum 参数结束位置(不包含)
// endNum 参数不写则默认截取所有项

        ⑾Array.isArray()

                判断是否是数组

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

        ⑿Array.from()

                把类数组(获取一组元素，arguments)对象转成数组（不改变类数组本身）

        ⒀indexOf(Str, [index])  

                查找到数组项时返回对应下标，否则返回-1，与字符串的indexOf方法的使用一样

let arr = [1,2,3]
arr.indexOf(2)
// Str参数为查找字符, 参数index为查找开始位置
// index参数不写则默认从0开始

        ⒁includes()

                查看数组中是否包含参数的值，返回布尔值

let arr = ["apple" , "origan","banana"];
let a = arr.includes("apple");
console.log(a);   // true

let b = arr.includes("apple2");
console.log(b);   // false

        ⒂forEach()

                循环数组，无返回值，需要使用几个就传几个参数，参数严格按照顺序传值。

                value:数组内的每一项

                index:数组每一项的下标

                arr:原数组

let arr = ["a","b","c","d"]
arr.forEach(function(value,index,arr){
    console.log(value,index,arr);
})

        ⒃map()

                正常情况下，需要配合return使用，返回新数组，如果没有return，这个方法就相当于forEach

                map方法如果没有return，则返回元素项数个undefined组成的新数组

// 整理数据结构
let arr= [
    {title: "aa",read: 100},
    {title: "bb",read: 20},
    {title: "cc",read: 50}
]
let newArr = arr.map((item,index,arr) => {
    let json = {};
    json.shop = `*${item.title}--`;
    json.price = `￥${item.read}元`
    return json;
})
console.log(arr);
console.log(newArr);

        ⒄reduce()

                用的极少，可以用来求数组的和、阶乘

                prev:上一次运算的结果

                cur:当前的值

                index:当前的下标

                arr:原数组

let arr = [1,2,3,4,5,6,7,8,9,10]
let res = arr.reduce((prev,cur,index,arr) => {
    return prev + cur;
})
console.log(res);  //55
// prev是上一次的运算结果,cur是当前的值,index是当前的下标,arr是当前的数组

        ⒅ filter()

                在原数组基础上筛选出一个符合要求的新数组出来，return的内容为真时就把符合条件的value用一个数组装好后返回出来。

let arr2 = [1, 2, 3, 4, 10];
let arr3 = arr2.filter( value => value > 2);
console.log(arr3);  // [3, 4, 10]

4.Object

        ⑴Object.assign(目标对象,需要合并的对象)

           ps:assign [əˈsaɪn]   分配(某物);分派，布置(工作、任务等);指定;指派;委派;派遣

let json = {a:1};
let json2 = {b:2};
let json3 = {c:3};

let obj = Object.assign({},json,json2,json3);
console.log(obj);     // {a: 1, b: 2, c: 3}