JS内容整合 + ES6新增内容 持续更新中~

JS内容整合 + ES6新增内容 持续更新中~

数组方法

1、arr.push()

 		从数组后面添加元素，返回值为添加完成后的长度  改变原数组
    	let arr = [1,2,3]
        console.log(arr.push(9))  // 4
		console.log(arr) // [1,2,3,9]

2、arr.pop()

		从数组后面删除元素，只能是一个，返回的是删除的元素  改变原数组
    	let arr = [1,2,3]
        console.log(arr.pop()) // 3
		console.log(arr) // [1,2]

3、arr.shift()

		从数组前面删除元素，只能删除一个，返回值是删除的元素 改变原数组
    	let arr = [1,2,3]
        console.log(arr.shift())  // 1
		console.log(arr)  //[2,3]

4、arr.unshift()

		从数组前面添加元素，返回值是添加完后的数组长度 改变原数组
    	let arr = [1,2,3]
        console.log(arr.unshift(4)) // 4
		console.log(arr)  //[4,1,2]

5、arr.splice(i,n)

		 删除数组从i（索引值）开始 n(要删除的数量)个元素，返回一个由删除的元素组成的新数组 改变原数组
    	let arr = [1,2,3]
        console.log(arr.splice(1,2))  // [3]
		console.log(arr) // [1，2]

6、arr.concat()

		连接两个数组返回值为连接后的新数组  不改变原数组
    	let arr = [ 1,2,3]
        console.log(arr.concat([3,4])) // [1,2,3,4,5]
		console.log(arr) //[1,2,3]

7、arr.join()

		将数组转为字符串
    	let arr = [1,2,3]
        console.log(arr.join('')) //"123"

8、arr.sort()

 		将数组进行排序，返回值是排好的数组，默认是按照最左边第一位数字进行排序   传参自定义排序的时候则是比较整个数值   改变原数组
    	let arr = [1,21,12,23,34,44,45,67,9]
        console.log(arr.sort()) //[1, 12, 21, 23, 34, 44, 45, 67, 9]
		//从小到大排序
		let arr1 = arr.sort((a,b) => a - b)
        console.log(arr1) //  [1, 9, 12, 21, 23, 34, 44, 45, 67]
        console.log(arr) // [1, 9, 12, 21, 23, 34, 44, 45, 67]
		//从大到小排序
		let arr2 = arr.sort((a,b) => b - a)
        console.log(arr2) // [67, 45, 44, 34, 23, 21, 12, 9, 1]
        console.log(arr) // [67, 45, 44, 34, 23, 21, 12, 9, 1]

9、arr.reverse()

		将数组反转， 返回值是反转后的数组 改变原数组
    	let arr = [1,2,3]
    	console.log(arr.reverse()) // [3,2,1]
		console.log(arr)  // [3,2,1]

10、arr.slice(start, end)

		切去索引值statr到索引值end的数组，不包含end的值，不改变原数组
    	let arr = [1,2,3]
        console.log(arr.slice(0,2)) // [1,2]
		console.log(arr) // [1,2,3]

11、arr.forEach(callback)

		遍历数组，无返回值
    	let arr = [1,2,3]
        arr.forEach((value, index , array) => {
            //value ： 当前的值  index　当前索引　　array 原数组
        })

12、arr.map(callback)

		遍历数组，有返回值
    	let arr = [1,2,3]
        arr.map((value, index , array) => {
            //value ： 当前的值  index　当前索引　　array 原数组
        })

		** forEach 和 map的区别 
    	1、forEach 是和for循环一样，是for的替代，map是修改数组其中的数据
        2、map有return forEach没有

13、arr.filter(callback)

 		过滤数组，返回一个满足要求的数组
		let arr = [1,2,3]
        let arr1 = arr.filter(v => v < 3)
        console.log(arr1) //[1,2]

14、arr.every(callback)

		依据判断条件，数组的元素是否完全满足，满足返回true，否则返回false
    	let arr = [1,2,3]
        let arr1 = arr.every(v => v > 0) //true
        let arr2 = arr.every(v => v > 2) //false

15、arr.some(callback)

    	 依据判断条件，数组的元素是否有一个满足，满足返回true，否则返回false
  		let arr = [1,2,3]
        let arr1 = arr.every(v => v > 2) //true
        let arr2 = arr.every(v => v > 6) //false

16、arr.reduce(callback, initialVal)

 迭代数组的所有项，累加器，数组中的每个值（从左到右）合并，最终计算为一个值     ES6
    	参数 ： callback : previousValue 必选 --上一次调用回调返回的值，或者是提供的初始值(initialValue）
　　　　　　　　　　		   currentValue 必选 --数组中当前被处理的数组项
　　　　　　　　　　		   index 可选 --当前数组项在数组中的索引值
        	   initialValue : 可选 初始值
        实行方法：回调函数第一次执行时，preValue 和 curValue 可以是一个值，如果 initialValue 在调用 reduce() 时被提供，那么第一个 preValue 等于 initialValue ，并且curValue 等于数组中的第一个值；如果initialValue 未被提供，那么preValue 等于数组中的第一个值
        let arr = [1,2,3] 
        let arr1 = arr.reduce((preValue, curValue) => {
            preValue + curValue
        })		//6

17、 Array.isArray(arr)

    	用来确定传递的值是否是一个数组
        let arr = [1, 2, 3]
        console.log(Array.isArray(arr)) // true
        let arr1 = "1,2,3"
        console.log(Array.isArray(arr1))  //false

18、 Array.of()

		返回一个由参数组成的数组      ES6
   		console.log(Array.of(1, 2, 3))  //[ 1, 2, 3 ]

19、 Array.from()

		将数组对象转为数组  不改变原对象 返回新数组     ES6
    	let obj = {
            0: '1',
            1: '2',
            2: '3',
            'length': 3
        };
        let arr = Array.from(obj)
        console.log(arr)  // [ '1', '2', '3' ]
        let str = '123'
        let arr1 = Array.from(str)
        console.log(arr1)  // [ '1', '2', '3' ]

20、arr.copyWithin()

 		数组的指定位置复制  改变原数组  ES6
            arr.copyWithin(index, start, end)
                第一个参数：复制到指定目标索引位置。
                第二个参数：元素复制的起始位置 (可选)
                第三个参数：停止复制的索引位置 (默认为 array.length)。如果为负值，表示倒数。(可选)
        let arr = [1, 2, 3, 4, 5, 6];
        let a = arr.copyWithin(2, 0, 3);
        console.log(arr) // [1, 2, 1, 2, 3, 6]

21、 fill()

        数组的填充  改变原数组       ES6
        arr.fill(value, start, end)
        value    必需。填充的值。
        start    可选。开始填充位置。
        end  可选。停止填充位置 (默认为 array.length)
        let arr = new Array(3)
        arr.fill('内容')
        console.log(arr)  [ '内容', '内容', '内容' ]
        let arr1 = new Array(3) 
        arr1.fill('内容', 0, 1)
        console.log(arr1) 	[ '内容', <2 empty items> ]

22、 arr.toString()

	 		把数组转换为字符串，并返回结果。不改变原数组
    		let arr = [1,2,3]
            console.log(arr.toString()) // 1,2,3

23、 arr.indexOf()

			查找数组中某元素的第一个索引值，并返回结果   不改变原数组     ES6
    		第一个参数为查找的值 第二个参数为查找的起始位
            let arr = [1, 2, 3, 4, 5, 6]
            console.log(arr.indexOf(3))//2 
            console.log(arr.indexOf(3, 3))//-1
            console.log(arr.indexOf(8))//-1

24、 arr.lastIndexOf()

		    逆向查找指定元素在数组中的第一个位置，并返回结果   不改变原数组    ES6
    		第一个参数为查找的值 第二个参数为逆向查找的起始位
            let arr = [1, 1, 3, 4, 5, 1];
            console.log(arr.lastIndexOf(1))//5
            console.log(arr.lastIndexOf(1, -2))//1

25、 arr.indludes()

 			查找数组是否包含某个元素    不改变原数组    ES6
    		第一个参数为要查找的值 必填
            第二个为查找的起始位置
            返回值 true或false
            let arr = [1, NaN, 100, '42'];
            console.log(arr.includes(1)); //true
            console.log(arr.includes(NaN)); //true
            console.log(arr.includes(1, 3)); //false

对象方法

1、Object.assign()

		 Describe: 方法用于对象的合并，将源对象（source）的所有可枚举属性，复制到目标对象（target）.
        			Object.assign()方法第一个参数是目标对象，后面的参数都是源对象
        			Object.assign()实现拷贝，如果对象中只有一级属性，没有二级属性，则为深拷贝，若						拷贝对象中仍含有对象，则为浅拷贝，拷贝后的对象仍指向原对象
         eg:
            const target = {a: 1}
            const source1 = {b: 2}
            const source2 = {c: 3}
            Object.assign(target, source1,source2 )
            target	// {a:1, b:2, c:3}

2、Object.create()

		 Describe: 方法创建一个新对象， 使用现有的对象来提供新创建的对象proto
         			第一个参数参数proto : 必须。表示新建对象的原型对象，即该参数会被赋值到目标对象(即新对象，或说是最后返回的对象)的原型上。该参数可以是null， 对象， 函数的prototype属性 （创建空的对象时需传null , 否则会抛出TypeError异常）。
					第二个参数propertiesObject : 可选。 添加到新创建对象的可枚举属性（即其自身的属性，而不是原型链上的枚举属性）对象的属性描述符以及相应的属性名称。
		  eg: 
				//new Object()创建
				var a = {  rep : 'apple' }
                var b = new Object(a)
                console.log(b) // {rep: "apple"}
                console.log(b.__proto__) // {}
                console.log(b.rep) // {rep: "apple"}

                // Object.create() 方式创建
                var a = { rep: 'apple' }
                var b = Object.create(a)
                console.log(b)  // {}
                console.log(b.__proto__) // {rep: "apple"}
                console.log(b.rep) // {rep: "apple"}

3、Object.defineProperty()

 		 Describe: Object.defineProperty(obj, prop, desc)的作用就是直接在一个对象上定义一个新属性，或者修改一个已经存在的属性
 			 obj 需要定义属性的当前对象 , prop 当前需要定义的属性名 , desc 属性描述符
			 一般通过为对象的属性赋值的情况下，对象的属性可以修改也可以删除，但是通过Object.defineProperty()定义属性，通过描述符的设置可以进行更精准的控制对象属性。
			 内容篇幅过长，这里后续补充~

考虑了一下 要是把知识点都写在这一个文件可能有点长 不方便查看 我决定将其拆开放在别的文章里面展示了~