对象/复合对象/新增，修改，删除对象/内部对象 this/[]/增加，新增属性名字

01-对象

    <script>

        // 有属性数据的对象
        let pig = {
            name: '猪八戒',
            // 属性组成：名字 : 值
            height: 180,
            weight: 178,
            age: 165
        }
        console.log(aser, pig)
        // 对象数据类型：比数组的描述性更强
        // 访问更方便

        // 属性访问：专用语法， .语法  对象.属性名
        console.log(pig.name)

        // .语法：console.log代表 console对象下的log，log()代表log是一个函数

        // 属性访问：数组语法 对象['属性名']  数字可以不加引号（数组访问的时候就没加）
        console.log(pig['height'])

        // 如果属性名不存在：undefined
        console.log(pig.gun, pig['gun'])

        // 数组的元素下标：其实也是字符串，可以通过数字来访问：原因是因为系统会自动转换
        console.log(aser[0], aser['0'])

    </script>

访问方法：
1.属性访问：专用语法， .语法 对象.属性名console.log(属性名.属性值)
2.属性访问：数组语法 对象[‘属性名’] 数字可以不加引号（数组访问的时候就没加）console.log(属性名['属性值'])
3.数组的元素下标：其实也是字符串，可以通过数字来访问：原因是因为系统会自动转换

02-新增(属性名上一级).(属性名下一级)=(属性值)，修改(同新增)，删除对象delete (属性名上一级)(属性名下一级)

    <script>
        // 对象的增查改删（CRUD）

        let obj = { name: '妲己' }

        // 1. 新增：给一个不存在的属性赋值（怎么访问就怎么赋值）
        obj.age = 18
        obj['gender'] = '女'

        // 2. 修改：给一个已存在的属性赋值
        obj.age = 19
        obj['age'] = 20

        // 3. 删除：给一个存在的属性干掉
        // delete 对象.属性名 || 对象['属性名']
        delete obj.age
        delete obj['gender']

        console.log(obj)
    </script>

访问方法：

1.新增：给一个不存在的属性赋值（怎么访问就怎么赋值）
2.修改：给一个已存在的属性赋值
3. 删除：给一个存在的属性干掉。 delete 对象.属性名 || 对象[‘属性名’]

03-关于 对象 的一些补充

    <script>
        // 对象属性名：没有严格规定，数字也可以当做属性名
        let obj1 = { 0: '黑马', 1: '前端', 2: '64' }
        console.log(obj1)
        // 可以存在：如果是数字的话，为什么不直接使用数组？因此不会这么使用

        // 扩展一下：如果对象属性名是数字：点语法失效
        // console.log(obj1.0)  // 不能使用
        // console.log(obj1.'0')

        console.log(obj1[0], obj1['0'])

        // 对象属性名：没有严格规定，可以使用引号
        let obj2 = { name: '张飞', 'skill': '吼一个', "subject": '坦克' }
        console.log(obj2)
        // 增加引号：增加程序员的工作量（实际开发布会这么写）

        // 对象的完整声明方式：new Object()
        // {}：语法糖
        let obj3 = new Object()
        console.log(obj3)

        // 带数据写法
        let obj4 = new Object({ name: '妲己' })
        console.log(obj4)
    </script>

04-复杂对象

    <script>
        // 复合对象：对象的属性值不限定任意数据类型

        let obj = {
            name: '张三',
            age: 18,
            isMarried: false,
            // 复合数据类型：数组、函数、对象
            hobby: ['篮球', '足球', '羽毛球'],
            girlFriend: {
                name: '迪丽热巴',
                age: 20,
                boyFriend: {
                    name: '小马哥'
                }
            },
            eat: function () {
                console.log('张三正在吃饭')
            }
            // 名词：数据
            // 动词：函数
        }

        console.log(obj)
        // 访问：层层深入
        console.log(obj.name)
        console.log(obj.hobby)
        // 访问第一个爱好
        console.log(obj.hobby[0])
        console.log(obj.girlFriend.name)
        console.log(obj.girlFriend.boyFriend.name)
        console.log(obj['girlFriend']['boyFriend']['name'])
        // 函数访问
        console.log(obj.eat)
        // 调用：+()
        obj.eat()
    </script>

注意：

1.复合对象：对象的属性值不限定任意数据类型
2.复合数据类型：数组、函数、对象
3.名词：数据 。 动词：函数
4.访问一定是层层深入

05-对象 遍历

    <script>
        // 对象遍历：for-in
        let hero = {
            name: '蔡文姬',
            gender: '女',
            age: 8,
            skill: '弹弹乐'
        }
        console.log(hero)
        // 对象的属性名：没有规律，for循环无法实现

        // for-in
        /*
            for(let 变量名 in 对象变量){
                变量名：取得对象的属性名
            }
        */
        for (let key in hero) {
            console.log(key)    // 属性名
            // 取值
            // console.log(hero.key)
            // console.log(hero['key'])
            // 对象.属性名 || 对象['属性名']本质是一样的：代表去对象中，找名字叫做属性名的值
            // hero.key  去对象hero中，找一个属性名叫做key的属性（没有）：undefined
            console.log(hero[key])
            // 1. 系统发现key没有引号：当做变量，找变量代表的值：name age gender skill
            // 2. 将变量的值替换key所在的位置：hero['name'] hero['age'] hero['gender'] hero['skill']

            // 对象的遍历：只能使用[]语法
        }
    </script>

注意：
1.对象的遍历 用 for(let key in hero）{}

06-对象 内部对象（this）

    <script>
        // 只要有函数：内部就有this
        function fn() {
            console.log(this)
        }

        // fn()
        // fn() ==== window.fn()

        // 对象的属性访问：任何时候任何地点，都需要对象才能调用

        let obj = {
            name: '兰陵王',
            type: '刺客',
            skill: '隐身',

            // 抓人
            gank: function () {
                // 刺客 兰陵王 隐身 来抓人了
                // console.log(`${type} ${name} ${skill} 抓人了`)

                // 任何时候，任何地点：访问对象的属性都需要对象才能访问
                // console.log(`${obj.type} ${obj.name} ${obj.skill} 抓人了`)

                // 是函数：就有this
                // console.log(this)
                console.log(`${this.type} ${this.name} ${this.skill} 抓人了`)

                // this可以减少维护的成本：函数内部的代码不需要做任何修改（不依赖任何外部名字）
            }
        }

        // 调用gank
        obj.gank()

        // 扩展：外部也可以使用this：this永远执行window对象（所有我们所写的代码都是在window对象内部写的）
        console.log(this)       // 一定不会在函数外部使用this
    </script>

注意：

1.只要有函数：内部就有this
2.tthis可以减少维护的成本：函数内部的代码不需要做任何修改（不依赖任何外部名字）
3.任何时候，任何地点：访问对象的属性都需要对象才能访问