对象内存结构

对象内存结构

<script>
            // 字面量方式创建对象obj
			var obj = {
				name: 'jack',
				age: 18,
			}

            var obj1 = obj
            obj1.age = 20

            console.log('obj.age ',obj.age)

            var arr = [10,20,30]
            var arr1 = arr
            arr1[1] = 200

            console.log(arr[1])

		</script>

练习

<script>
        var obj = {
            name:'jack',
            age:18
        }

        function fun(obj){ //obj = 0x0001
            obj.age = 20
            console.log('fun age ',obj.age); // 20
        }

        fun(obj)

        console.log('age ',obj.age) // 20

        // ===================
        var m = 100
        function fun1(m){
            m = 200
            console.log('fun1 m ',m)
        }
        fun1(m)
        console.log('m ',m);

    </script>

数组的常用方法

Object对象

        数组对象

           属性和方法

           var arr = [10,20,30]

           arr.length 属性

方法

           1. push

               => arr.push(40)  //push方法

               => 向数组追加元素

           2. pop

               => arr.pop() // 删除数组后面元素

           3. unshift

                =>arr.unsift()  //数组前面添加元素

            4. shift

                =>arr.shift  //删除数组最前面元素

            5. splice(下标,元素个数)

                 => arr.splice(1,2)

            6. reverse()

                 =>反转数组元素  [1,2,3] -> [3,2,1]

练习

<script>
			/*
                1.创建一个学生成绩数组 [98,78,86,59,94]
                2.向数组中追加一个成绩100分
                3. 删除第1个不及格的成绩
                    提示: 1. 删除数组元素，使用splice(索引号,1) 
                          2. 遍历数组,查找不及格元素索引号
                4. 数组成绩由低到高排序输出
        
        */
		</script>

数组遍历方法

- forEach

            匿名函数

            function(){}

            arr.forEach(function(item,index){

                // 第一个形参： 数组元素

                // 第二个形参: index  索引号(下标)

            })

        - map

           var newArr = arr.map(function(item,index){

               return 新元素

           })

           [新元素1,新元素2,...]

        - filter

           var newArr = arr.filter(function(item,index){

               return 条件

           })

           查找数组满足条件的元素，返回新数组

        - find

           查找第一个满足条件的元素

        - every

           遍历数组，查找数组元素是否全部满足条件，全部满足返回真

        - some

            遍历数组，查找数组是否有一个满足条件，有一个满足条件返回真

数组遍历reduce方法

 [98, 57, 78, 95, 89, 99]

            reduct(callFun, [initValue])

               callFun:  function(previousValue,currentValue,currentIndex,arr){

                         }

            forEach(function(currentValue,currentindex,arr){

            })

<script>
			var arr = [98, 57, 78, 95, 89, 99]
            function test1(){
                arr.reduce(function(previousValue,currentValue,currentIndex,arr){
                    //previousValue 上一个值,如果initValue存在，第一遍历时previousValue就是initValue
                    // currentValue 当前数组元素
                    // currentIndex 当前数组下标
                    // arr 原数组
                    console.log('previousValue',previousValue, ' currentValue :',currentValue, ' currentIndex :',currentIndex);

                    return 100
                },0)
                
            }
            function test2(){
                arr.reduce(function(previousValue,currentValue,currentIndex,arr){
                    //previousValue 上一个值,如果initValue存在，第一遍历时previousValue就是initValue
                    // currentValue 当前数组元素
                    // currentIndex 当前数组下标
                    // arr 原数组
                    console.log('previousValue',previousValue, ' currentValue :',currentValue, ' currentIndex :',currentIndex);
                    return 10
                })
            }
            // test2()

            // 应用累加求和
            function test3(){
                //  [98, 57, 78, 95, 89, 99]
                // currentValue: 98: 57 , 78
                var sum = arr.reduce(function(previousValue,currentValue){ //previousValue: 0, 98 (98 + 57)
                    return previousValue + currentValue//previousValue: 0 + 98 + 57 +78
                },0)
                console.log('sum ',sum)
            }
            test3()

            function test4(){
                var sum = 0
                for(var i =0; i < arr.length; i++){
                    var item = arr[i] // 累加项
                    sum = sum + item 
                }
                console.log("sum >> ",sum);
            }
            test4()
            

		</script>

冒泡排序

相邻两个数，两两比较，如果前面的数大于后面的数，交换位置, 第一轮比较完，最大数到最后面

              第二轮重复上述操作，找到第2大数

var arr = [89, 98, 78, 68, 76]
			// 外层循环冒泡轮数
			for (var j = 0; j < arr.length - 1; j++) {
				//内层循环,两两比较交换位置
				for (var i = 0; i < arr.length - 1 - j; i++) {
					//1.相邻两个数，两两比较
					if (arr[i] > arr[i + 1]) {
						// 2.交换位置
						var temp = arr[i]
						arr[i] = arr[i + 1]
						arr[i + 1] = temp
					}
				}
				console.log(arr)
			}
			console.log('排序后 ：', arr)

练习

var arr = [89, 98, 78, 68, 76]
			// 1. n个数进行n-1轮冒泡排序
			var n = arr.length
			// 外层循环
			for (var i = 0; i < n - 1; i++) {
				//内层循环
				for (var j = 0; j < n - 1 - i; j++) {
					// 2.相邻两个数，两两比较，前一个比后一个大，交换位置
					if (arr[j] > arr[j + 1]) {
						var temp = arr[j]
						arr[j] = arr[j + 1]
						arr[j + 1] = temp
					}
				}
			}