走进js面向对象

Smbol

利用Symbol的唯一创建变量 下面再重新赋值也不会被改变 Symbol识别字符串

/* let car = Symbol('car');
    let obj = {
       [car]:'bmw'
    }
    obj.car = 'audi'
    console.log(obj[car]);
    console.log(obj.car); */

    /* 引用数据类型 会开辟一个内存（栈内存（内存地址）和堆内存（内存的值）） */
    let obj1 = {name:'zhangsan',age:20}
    let obj2 = {};
    /* obj1的栈内存的地址给了obj2 */
    obj2 = obj1;

    /* obj2把obj1的堆内存的name值 改为了lili */
    obj2.name = 'lili';
    console.log('obj1',obj1);
    console.log('obj2',obj2);
    

const

const用来定义常量 ,用它声明的变量值不能重复定义 定义对象 引用数据类型,会开辟一个堆内存,内存地址不会变,地址不会被改变也就不会报错

 const obj = {
        name:'zhangsan'
    }
    obj.name = 'lili'
    obj.age = 20
    console.log(obj);
    

面向对象

1.利用new Object()创建对象

let obj =  new Object();
    obj.name = 'sss';
    obj.age = '20';
    obj.kaiche = function(){
        document.write(`${obj.name}---年纪 ${obj.age}---会开车`)
    }
    obj.kaiche();
    

2.利用 对象字面量创建对象

  let obj = {
        "name":"ssss",
        "age":30,
        "kaiche":function(){
            document.write(`${this.name}---年纪 ${this.age}---会开车`)
        }
    }
    obj.kaiche();
    

3.利用构造函数创建对象

  <script>
    function getPerson(name, age, address, job) {
        let person = new Object();
        person.name = name
        person.age = age
        person.address = address
        person.job = job
        person.intro = function () {
            document.write(
                `姓名：${this.name}<br><br>
                年龄：${this.age}<br><br>
                工作：${this.job}<br><br>
                住址：${this.address}<br><br><hr>
                `)
        }
        return person
    }
   let person1 =  getPerson('张三', 30, '南京江宁', '工人');
   person1.intro();
   let person2 = getPerson('李四',22,'北京定海','程序员');
   person2.intro();
  

构造函数方法很好用，但是存在浪费内存的问题，构造函数原型 prototype 构造函数通过原型分配的函数时所有对象所共享的 作用就是共享方法