数组1：Array[ ]，创建数组，数组基本操作，冒泡排序，栈内存和堆内存

创建数组：字面量创建，内置构造函数创建：

    <script>
    // 字面量创建数组Array: 简单，规避风险
        var arr = [100,200,300,400,500]
 
        console.log(arr)        //输出数组
        console.log(arr.length)     // 数组长度
        console.log(arr[0].name)        //调用数组 .方法
        console.log(arr[1].name)
        console.log(arr[0]['name'])    //调用数组  []方法


    // 构造函数创建数组 new Array()
            // 创建空数组 
            var arr2 = new Array()
            
            // 创建带有数据的数组 new Array()
            var arr3 = new Array(100,200,300,'hello')
            console.log(arr3)

            //此时100，指的是数组的长度(只有一个数据)
            var arr4 = new Array(100)
            console.log(arr4)


    </script>

数组基本操作:

.length：每个数组自带一个 length属性

下标（索引），

遍历数组

    <script>
            /* 
            数组基本操作：
                1.操作数组的length属性
                    length:这个单词是长度的意思，代表数组的长度，也就是数组中数据的个数
                    关于length属性他是一个读写属性
                    读：可以获取到length的值
                        语法：变量名.length
                    写：可以设置length的值
                        语法：变量名.length  = 值
                        当设置的比原来的长度小：就拥有删除的意思，从数组的末尾删除到符合的个数为止
                        当设置的比原来的长度大：多出来的位置用empty表示
                        当设置的和原来的长度一致：相当于没设置。
                2.操作数组的索引
                    索引也是可读可写的，可以通过索引获取到某一个数据，也可以去设置某一个索引对应的数据
                    读：获取
                        语法：变量名[索引]
                        如果该索引存在会得到该索引对应的数据
                        如果该索引不存在结果是undefined
                    写：设置数据
                        语法：变量名[索引] = 值
                        如果该索引存在就是修改该索引对应的数据
                        如果索引不存在：
                            当你写的索引值刚好和数组的长度一致：就是在数组的末尾添加一条数据
                            当你写的索引值比数组的长度大：中间位置的数据用empty表示
                3.遍历数组
                    从头到尾挨个访问一遍数组中的数据
                    遍历需要借助于循环即可，因为获取数组中的数据核心关键点需要借助于数组的索引
                    索引刚好是一组有过i率的数字，从0开始依次+1
                    刚好循环可以创造一组由规律的数组
                    循环的起始值：0开始
                    循环的结束值：<=数组的长度-1 或者 <数组的长度
                    步长:+1
        */


        // 1
        var arr1 = [100,200,300,400,500]
        console.log(arr1)
        console.log(arr1.length) // 数组长度

        // arr1.length = 3 //将arr1 的长度设置为3
        // console.log(arr1.length) 

        // arr1.length = 8 //将arr1 的长度设置为8，增加3个，empty3个
        // console.log(arr1.length) 
        
        // 2 
        console.log(arr1[0])    // 获取数据 100
        console.log(arr1[4])    // 获取数据 400
        arr1[2] = 'hello' //将索引2的数据设置为hello
        console.log(arr1[2])

        // 3 
        // for(var i = 0; i <= 4; i++){
        //     console.log(arr1[i])
        // }
             //for循环    // arr1.5
        for (var i = 0; i < arr1.length; i++) {
            // i指的就是数组的索引
            console.log(arr1[i]);//arr[4]
        }


                
    </script>

冒泡排序

   <script>
   // ================最终版
        var arr = [10, 9, 6, 7, 5, 3, 100, 2, 1]
        // var arr = [10, 9, 6, 7, 5, 3]//6
        for (var j = 0; j < arr.length-1; j++) {// j<=5    j = 0  1  2   3   4   
            for (var i = 0; i < arr.length - 1 - j; i++) {//i < 5  4  3   2   1
                if (arr[i] > arr[i + 1]) {
                    var temp = arr[i]
                    arr[i] = arr[i + 1]
                    arr[i + 1] = temp
                }
            }
        }
        console.log(arr);
    </script>

基本数据类型和引用数据类型：栈内存（复制），堆内存（给的地址）

                基本（简单）数据类型：是存储在栈内存上面的

                引用（复杂）数据类型：是存储在堆内存上面的

    <script>
        /* 
            数组会存储在内存上，内存上我们针对于不同的数据类型存储的方式是不一样。
            在内存中：我们可以再细分为：栈内存和堆内存
            基本（简单）数据类型：是存储在栈内存上面的
            引用（复杂）数据类型：是存储在堆内存上面的

            变量是存储栈中，变量的数据如果是基本类型，该数据也是再栈中，如果变量的数据是引用类型，该数据会存储到堆当中
        */

        
        var obj1 = { name: '张三', age: 18 }
        var obj2 = obj1
        obj2.name='李四'
        console.log(obj1);
        console.log(obj2);
    </script>