jsAPI

常用API

Array：

concat()

arr = [1,2]
arr1 = [3,4]
arr2 = [5,6]
console.log(arr1.concat(arr2,arr3)); // 1,2,3,4,5,6

arr.concat(arr1,arr2…) 用于返回一个合并的数组，对原数组无影响

join()

   arr1 = [1, 2, 3, 4, 5, 6]
   console.log(arr1.join());//1,2,3,4,5,6
   console.log(arr1.join(':'));1:2:3:4:5:6

arr.join() 返回一个数组转化成的字符串 默认为英文状态的,分隔，对原数组无影响

toString()

  		arr1 = [1, 2, 3]
        let result = arr1.toString();
        console.log(result)//1,2,3

arr.toString() 用于将数组转化成字符串，每项用,隔开，对原数组没影响，（）里面不能有任何东西

push()

arr1 = [1, 2, 3, 4, 5, 6]
let resylt = arr1.push('1', '2')
console.log(resylt);// 8
console.log(arr1);//[1, 2, 3, 4, 5, 6, '1', '2']

arr.push() 方法用于在数组的末尾添加一个/多个项，如果是多个 用逗号隔开 返回添加之后数组的长度，改变原数组

pop()

		arr1 = [1, 2, 3, 4, 5, 16]
        let result = arr1.pop();
        console.log(result);// 16 
        console.log(arr1);//[1, 2, 3, 4, 5]

arr.pop()方法用于删除数组最后一项，无参数，返回被删除的最后一项，改变原数组

unshift()

   		arr1 = [1, 2, 3]
        let result = arr1.unshift('0', '-1');
        console.log(result) // 5
        console.log(arr1); //['0', '-1', 1, 2, 3]

arr.unshift()方法用于在数组开头添加一个或多个项，改变原数组，返回添加之后数组长度

shift()

		arr1 = [1, 2, 3]
        let result = arr1.shift();
        console.log(result)// 1
        console.log(arr1);

arr.shift()方法用于删除数组第一项，改变原数组，返回删除的第一项，就是删除的那一项

reverse()

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

注意： arr.reverse() 用来反转数组，返回arr反转后的数组,并且arr自身也会被反转

indexOf()

  		arr1 = [1, 2, 3, 3]
        let result = arr1.indexOf(3);
        console.log(arr1);//1,2,3,3
        console.log(result)//2

arr.indexOf(要查找的元素) 返回查找到的数组索引号，没有返回-1

lastIndexOf()

	    arr1 = [1, 2, 3, 3]
        let result = arr1.lastIndexOf(3);
        console.log(result)//3

arr.lastIndexOf(要查找的元素)从数组最后一项向前查找, 返回查找到的数组索引号，没有返回-1

slice()

		arr1 = [1, 2, 3, 4, 5, 6, 7]
        let result = arr1.slice(0, 4);
        let result1 = arr1.slice(1);
        console.log(result)// [1, 2, 3, 4]
        console.log(result1)// [2, 3, 4, 5, 6, 7]

start: 开始截取的索引值(包括) end: 结束的索引值(不包括)

arr.slice(start,end) 方法用于截取数组，对原数组没有影响，返回值为截取下来的数组

如果只有一个参数则从这个位置截取到最后

splice()

 		arr1 = [1, 2, 3, 4, 5, 6, 7]
        let result = arr1.splice(0,2);
        console.log(result);//[1, 2]
        console.log(arr1);//[3, 4, 5, 6, 7]

arr.splice(start,count,newItem)

作用：删除数组中的某些项
参数： start 开始删除的索引位置
count 要删除几个 非必填 如果不填 删除后面所有 如果是0 就不删除
newItem 除了前两个参数（start和count）之后的参数都是新的添加项,从开始删除的位置,添加新的项
返回值：删除的项的数组
注意：会改变原数组

delete

 		arr1 = [1, 2, 3, 4, 5, 6, 7]
        console.log(delete arr1[0]); //true
        console.log(arr1)//[empty, 2, 3, 4, 5, 6, 7]

delete 可以删除数组指定位置内容，但是会保留位置

sort()

	  let ar1 = ['a', 'r', 'b', 's', 'c', 'd']
        let ar2 = [9, 4, 7, 34, 8, 1, 2, 0]
        let ar3 = [9, 4, 7, 34, 8, 1, 2, 0]
        ar1.sort();
        ar2.sort((a, b) => {
            return a - b
        })
        ar3.sort((a, b) => {
            return b - a
        })
        console.log(ar1); //['a', 'b', 'c', 'd', 'r', 's']
        console.log(ar2);// [0, 1, 2, 4, 7, 8, 9, 34]
        console.log(ar3);// [34, 9, 8, 7, 4, 2, 1, 0]

arr.sort() 方法用于对数组的元素进行排序。
排序顺序可以是字母或数字，并按升序或降序。
默认排序顺序为按字母升序。

Object：

Object.is()

Object.is() 判断两个值是否相等

Object.assign()

​ 第一个参数是目标对象，后面的都是源对象，将后面对象的属性复制到目标对象身上，有同名属性则覆盖，如果源对象的属性值是一个对象，则拷贝他的引用, 返回值是目标对象，同时目标对象也会被修改，Object.assign(target,source1,source2…)

 		let obj1 = { a: 1 }
        let obj2 = { a: 11, b: 2, e: { r: 1 } }
        let obj3 = { a: 111, c: 3, b: 21, d: function () { console.log(123); } }

        let result = Object.assign(obj1, obj2, obj3)
        console.log(result);
        console.log(obj1);

这个方法数组也可以用，源数组同索引会覆盖目标数组索引的值

       let arr = [0, 2, 3]
        let arr1 = [1]
        Object.assign(arr, arr1)
        console.log(arr); // [1,2,3]

Object.create()

Object.create()有两个参数，第一个参数是必须的，是新建对象的原型对象，第二个参数是可选的，是新创建的实例对象上的属性

		let obj1 = { a: 1, sayhello: function (x) { console.log(x); } }
        let b = Object.create(obj1, { 'a': { value: 12 } })
        console.log(b);
        b.sayhello('asd')

这个方法可以用来实现继承，既就是让第一个参数为被继承的对象，实际上就是改变新生成对象的__proto_——的指向

如果第一个参数为null 则新生成的对象不具有Object的方法可用

let a = Object.create(null, {
            'a': {
                value: 's'
            }
        })
        console.log(a.toString()); // 报错，a.toString is not a function

而如果将 null 换位 {} , 则a.toString 不会报错

Object.create() 和 new的区别在于 Object.create() 一秒生成600多个 ，而new 一秒可以生成20000多个

for …in

for…in 用来遍历对象的可枚举属性(包括自有属性和继承属性)

 let a = { a: 1, b: 2, c: 2 }
        Object.defineProperty(a, 'e', {
            value: 6,
            enumerable: false
        })
        for (b in a) {
            console.log(b);
        }
        console.log(a);

Object.keys(obj)

Object.keys(obj) 用来返回obj身上可枚举属性构成的数组(不包括继承) 返回值是一个表示给定对象的所有可枚举属性的字符串数组。

  let a1 = { a: 1, b: 2, c: 2 }
        Object.defineProperty(a1, 'e', {
            value: 6,
            enumerable: false
        })
        let a = Object.create(a1, {
            's': { value: '4', enumerable: true },
            's1': { value: '4', enumerable: true }
            , 's11': { value: '4', enumerable: true }
            , 's111': { value: '4', enumerable: true }
        })
        for (b in a) {
            console.log(b);
        }
        console.log(Object.keys(a)); // ['s', 's1', 's11', 's111']

Object.values(obj)

Object.values(Obj)用来返回自身可枚举属性的属性值构成的数据(不包括继承)，与keys相似

let a1 = { a: 1, b: 2, c: 2 }
        Object.defineProperty(a1, 'e', {
            value: 6,
            enumerable: false
        })
        let a = Object.create(a1, {
            's': { value: 41, enumerable: true },
            's1': { value: '411', enumerable: true }
            , 's11': { value: '4111', enumerable: true }
            , 's111': { value: '4111', enumerable: true }
        })
        console.log(Object.keys(a)); // ['s', 's1', 's11', 's111']
        console.log(Object.values(a));// [41, '411', '4111', '4111']

注意： Object.keys(obj) 和 Object.values(obj)方法有一个共同点就是 如果对象的属性是number的话，输出顺序会呈现升序

const obj3 = { 100: 'a', 2: 'b', 7: 'c' }
console.log(Object.values(obj3)) // ['b', 'c', 'a']

String

concat()

str.concat(str1,str2…) 用来连接一个或者多个字符串，对原字符串没有影响，返回新连接的字符串

  let str = 'str'
        let str1 = 'ing'
        let str2 = str.concat(str1)
        console.log(str2); // string
        console.log(str1); // ing
        console.log(str); //str

slice(start,end)

str.slice(start,end)用来截取str字符串字串，从start索引开始，end索引结束（不包括），对原字符串没影响，返回新截取的子串,参数是负数表示从后截取（如果参数为负数，将所有负值参数都转换为字符串长度加负值）

   let str = 'string'
        let str2 = str.slice(0, 2)
        console.log(str); // string
        console.log(str2); // st

substring(start,end)

str.subString(start,end)用来截取str字符串字串，从start索引开始，end索引结束结束（不包括），对原字符串没影响，返回新截取的子串,参数是负数转化为0，只有一个参数表示从该索引截取到末尾

   let str = 'string'
        let str2 = str.substring(1)
        console.log(str); // string
        console.log(str2); // tring

substr(start,count)

str.subStr(start,count)用来是截取str字符串，从start索引开始，count是截取的个数，对原字符串没影响，返回新截取的字串，如果第一个参数为负数，则用该数＋字符串长度，第二个数为负数，转化为0

 		let str = 'string'
        let str2 = str.substr(0, 4)
        console.log(str); // string
        console.log(str2); // stri

trim()

    	let str = '  string   '
        console.log(str);
        console.log(str.trim());
        console.log(str.trimLeft());
        console.log(str.trimRight());
        console.log(str);

trim() 返回 str清除左右边的空格之后字符串，对str原字符串不改变

repeat(count)

str.repeat(count) 用来返回将str字符串复制count后的新字符串，对原字符串没有影响

let str = '  string   '
        console.log(str.repeat(3))// string     string     string   
        console.log(str);// '  string   '

padEnd(len[,other]) \ padStart(len[,other])

当字符串长度小于len时，使用other进行填充

var str = "abc";
var res1 = str.padEnd(5, ".");//"abc.."
var res2 = str.padStart(5, ".")//"..abc"

toLowerCase() \ toUpperCase()

大小写转化

var str = "aBc";
var res1 = str.toLowerCase();//"abc"
var res2 = str.toUpperCase();//"ABC"

charAt()

		let a = 'sAcxSSS'
        let x = a.charAt(1)
        console.log(x); //. A

str.charAt(index) 用于返回str指定索引的字符

indexOf()

str.indexOf(char) 用于返回char字符在str字符串中首次出现的位置索引 没有找到返回-1,

它还可以有第二个参数，表示从这个索引开始搜索

		let a = 'sAcxSSS'
        let result = a.indexOf('c')
        console.log(result); //2

includes()

str.includes(‘str1’)用于返回str字符串中是否包含str1这个子串 返回布尔值

它还可以有第二个参数，表示从这个索引开始搜索

let a = 'sSAcxSSS'
        let result = a.includes('SSS')
        console.log(result); //true

replace()

str.replace(oldValue,newValue) 用于返回str中oldValue替换成newValue的字符串，只会替换匹配到的第一个

不会改变原字符串，也可以是正则表达式

let a = 'sSAcxSSSaSSS'
        let result = a.replace('SSS', 'AAA')
        console.log(result); //sSAcxAAAaSSS

replaceAll(oldValue,newValue) 用于返回str中oldValue替换成newValue的字符串，会替换所有

不会改变原字符串，也可以是正则表达式

   let a = 'sSAcxSSSaSSS'
        let result = a.replaceAll('SSS', 'AAA')
        console.log(result); //sSAcxAAAaAAA

search()

search() 方法用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串。返回与指定查找的字符串或者正则表达式相匹配的 String 对象起始位置。

		let a = 'sSAcxSSSaSSS'
        let result = a.search('SSS')
        console.log(result); //5

split()方法

split(分隔符)方法用于把一个字符串转化为数组

      let a = 'SSSSSSS:aAAAAAA'
        let result = a.split(':')
        let result1 = a.split('a')
        console.log(result); //['SSSSSSS', 'aAAAAAA']
        console.log(result1);['SSSSSSS:', 'AAAAAA']

substring()

substring(start,end) 用于返回指定下标之间的子字符串 左闭右开

 		let a = '0123456'
        let result = a.substring(1, 3)
        console.log(result); //12