回顾对象

对象：一种无序的数据集合，由若干个“键值对”（key-value）构成。

开门见山，不想说话直接抛出一道经典题，复习下js中的引用类型

var o1 = {};
var o2 = o1;
o1.a = 1;
o2.a  //输出结果为1

var o1 = {};
var o2 = o1;
o1 = 1;
o2 // 输出结果为{}

分析：例一中，o1和o2均为引用类型，指向同一个内存地址，为其中任何一个变量添加属性，另一个变量都可以读写该属性。
例二中，o1和o2均为引用类型，指向同一个内存地址，之后对o1赋值，o1为基本类型，值为1，o2为引用类型。

---

继续复习对象

Object.keys可以查看一个对象本身的所有属性(key值)，返回数组。

var obj = {
  a:1,
  b:2
}
Object.keys(obj) //["a","b"]
Object.keys(obj).length// 2,可计算对象key-value的对数

hasOwnProperty() 方法会返回一个布尔值，指示对象是否具有指定的属性作为自身（不继承）属性。

var obj = {
    a:1,
    b:2
}
obj.hasOwnProperty('a')   //输出结果为true
// obj.hasOwnProperty('c')  输出结果为false

delete命令用于删除对象的属性，删除成功后返回true。

var obj = {a:1}
Object.keys(obj) //["a"]
delete obj.a //true
obj.a //undefined
Object.keys(obj) // []

for...in循环用来遍历一个对象的全部属性。

var obj = {
  a:1,
  b:2
}
for (var i in obj){
console.log(i)  // a,b
} 

常见面试题之浅拷贝、深拷贝

拷贝的定义就是复制，怎么复制对象么，利用给对象添加key、value值的方式。

var a = {}
a.b = 1
console.log(a)

好，方法已经确定，那我们就新建一个空对象，遍历添加就好。

var oldObj = {
    a:1,
    b:2
}
function shallowCopy(oldObj){
    var newObj = {}
    for(var key in oldObj){
        if(oldObj.hasOwnProperty(key)){
          newObj[key] = oldObj[key]            
        }
    }
    return newObj
}
shallowCopy(oldObj)  //{a:1, b:2}

结果出来，符合预期。但好像有点不对，万一oldObj中存在值为对象，结果还会一样么，控制台输入试一下，无效.....结果的办法就是将对象的值再进行拷贝，递归

    function deepCopy(oldObj) {
        var newObj = {};
        for(var key in oldObj) {
            if(typeof oldObj[key] === 'object' & typeof oldObj[key] != null) {
                newObj[key] = deepCopy(oldObj[key]);
            }else{
                newObj[key] = oldObj[key];
            }
        }
        return newObj;
    }

常见面试题
将数组中的值遍历，记录出现的次数

function count(arr) {
    var count = {}
    for(var i = 0; i<arr.length; i++){
        if(count[arr[i]]){
          count[arr[i]]++  
        }else{
            count[arr[i]] = 1
        }
    }
    console.log(count)
}
count([1, 2, 4, 4, 3, 4, 3])  //{1: 1, 2: 1, 3: 2, 4: 3}