es6+css选择器

1.简述css3选择器的优先级机制

        ID选择器》class，属性，伪类》标签

        行内1000 id选择器100 类选择器10 标签选择器1

        如果权重相同，那么以定义顺序靠近的选择器优先，或者有!importent标记的优先

     （0，0，0，0）（行内样式，ID选择器数量，（class，属性，伪类数量），（标签，伪元素数量））

2.symbol

        Symbol('key')生成的变量并不在它的全局注册表中

        Symbol.for('key')生成的才在全局注册表中

3.继承
      ES5继承
        借用构造函数继承
          function Animal() {}
          function Dog() {
            Animal.call(this)
          }
        原型链继承h
          子构造函数的原型指向父构造函数的实例
          Dog.prototype = new Anmimal()
          Dog.prototype = Anmimal.prototype
      ES6继承
        用法
          class Dog extends Anmimal {
            constructor(name,age,weight) {
              super(name,age);
            }
          }
          let dog = new Dog('二狗',1,'10KG')
        子类继承父类(构造函数继承，继承静态方法、属性)
          子类的构造函数继承父类的构造函数
          子类构造函数的原型对象指向父类构造函数
          Dog.__proto__ === Animal
        子类原型对象继承父类原型对象（方法继承，继承实例方法、属性）
          Dog.prototype.__proto__ === Animal.prototype
          dog.__proto__.__proto__ === Animal.prototype

4.如何实现一个对象的深拷贝？

        1.JSON.parse(JSON.stringify)

缺点：不能拷贝函数，正则，undefined
优点：可以深拷贝二层对象
let obj1={
    a:1,
    say(){
        console.log(1)
    },
    reg:/\d/,
    data:undefined,
    person:{
        name:"张三"
    }
}
let obj2=JSON.parse(JSON.stringify(obj1));
console.log(obj2);
obj1.a=2;
obj1.person.name="lsi";
console.log(obj2);



{ a: 1, reg: {}, person: { name: '张三' } }
{ a: 1, reg: {}, person: { name: '张三' } }

        2.Object.assign()

// 优点：可以拷贝函数 ,正则，undefine
// Object.assign()不能深拷贝第二层对象
let obj1={
    a:1,
    say(){
        console.log(1)
    },
    reg:/\d/,
    data:undefined,
    person:{
        name:"张三"
    }
}
let obj2={};
Object.assign(obj2,obj1);
obj1.a=2;
obj1.person.name="lisi";
console.log(obj2);


{
  a: 1,
  say: [Function: say],
  reg: /\d/,
  data: undefined,
  person: { name: 'lisi' }
}

        3.递归调用

var person={
            name:'wang',
            hobby:['看电影',['学习','跑步']]
        }
function deepClone(obj){
            var cloneObj=new obj.constructor();
            if(obj===null) return obj;
            if(obj instanceof Date) return new Date(obj);
            if(obj instanceof RegExp) return new RegExp(obj);
            if(typeof obj!=='object') return obj;
            for(var i in obj){
                if(obj.hasOwnProperty(i)){
                    cloneObj[i]=deepClone(obj[i]);
                }
                // cloneObj[i]=obj[i];
            }
            return cloneObj;
        }
        var person1=deepClone(person);
        // console.log(person);
        // console.log(person1);
        person1.name='ling';
        person1.hobby[0]='王';
        console.log(person);
        console.log(person1);

        4.对象拷贝
            $.extend([true],targent,obj,[objs]);
            true是深拷贝，默认为false浅拷贝 objs代表多个obj时合并并拷贝 []可选参数

        深拷贝不会覆盖原来冲突的属性

        浅拷贝会覆盖原来冲突的属性

<script>
        var targentobj={
            a:1,
            msg:{
                b:1,
                c:2
            }
        }
        var obj={
            id:1,
            name:'zhang',
            msg:{
                io:2
            }
        }
        
        $.extend(targentobj,obj);
        console.log(targentobj);
</script>

<script>
        var targentobj={
            a:1,
            msg:{
                b:1,
                c:2
            }
        }
        var obj={
            id:1,
            name:'zhang',
            msg:{
                io:2
            }
        }
        
        $.extend(true,targentobj,obj);
        console.log(targentobj);
</script>