1、三目运算

    1. let str = '';
    2. str = 89 > 9 ? ('89' > '9' ? '通过' : '内层未通过') //字符串比较=>对位的ASCII码比较
    3.                          : ('外层未通过')
    4. console.log(str) // => '内层未通过'

    2、浅拷贝
    创建一个新对象，遍历要复制的对象，给新对象增加每个复制对象的箭名以及其箭值。

    1. Object.prototype.num = 1
    2. //遍历对象时，原型链上自定义的属于都会被遍历到。
    3. let obj1 = {
    4.     name: 'obj1',
    5.   age: 16
    6. }
    7. let obj2 = clone(obj1)
    8. function clone(orig,targ){
    9.   //考虑没有传targ空对象的情况
    10.   var tar = targ || {}
    11.   for(key in orig){
    12.     //避免赋值原型链上的属性
    13.     if(orig.hasOwnProperty(key)){
    14.         tar[key] = orig[key]
    15.     }
    16.   }
    17.   return tar
    18. }

    3、深拷贝
    核心：
    （1）判断是否为自身属性
    （2）判断属性值是否为原始值，原始值就直接赋值
    （3）引用类型，判断是数组还是对象，然后调用自身函数，递归赋值

    1. function deepClone(origin){
    2.     var toString = Object.prototype.toString,
    3.       isOriginObj = toString.call(origin) === '[object Object]',
    4.           target = isOriginObj ? {} : [];
    5.   for(key in origin){
    6.       //判断是否为自身属性
    7.     if(origin.hasOwnProperty(key)){
    8.         //判断是否为原始值
    9.       if(typeof(origin[key]) === 'object' && typeof(origin[key]) + '' !== 'null'){
    10.           //判断是数组还是对象
    11.         if(toString.call(origin[key]) === '[object Array]' ){
    12.             target[key] = []
    13.         }else{
    14.             target[key] = {}
    15.         }
    17.         //调用函数本身，递归克隆该引用值
    18.         target[key] = deepClone(origin[key])
    19.       }else{
    20.           //原始值，直接赋值，也是递归的出口
    21.         target[key] = origin[key]
    22.       }
    23.     }
    24.   }
    25.   return target
    26. }

    4、Json方法也可以完成深拷贝
    先将原对象转换为json字符串，再解析成对象（不推荐）
    Json.stringify
    Json.parse
    5、一些面试题
    (1) 查找未声明的变量报错，访问对象没有的属性返回undefined

    1. fucntion test(){
    2.     console.log(foo) => undefined
    3.   var foo = 2
    4.   console.log(foo) => 2
    5.   console.log(a) // => 报错
    6. }
    7. test()

    (2) this指向问题

    1. var name = '222'
    2. var a = {
    3.     name: '111',
    4.   say:function(){console.log(this.name)}
    5. }
    6. var fun = a.say
    7. fun() // => 调用者为window，指向window window.a => '222'
    8. a.say() // => 调用者为a,this指向a this.a
    10. var b = {
    11.     name: '333',
    12.   say:function(fun){fun()}
    13. }
    14. b.say(a.say) 
    15. // function(fun){
    16. //    console.log(this) 这个地方this指向b
    17. //    fun() 而传进来的函数，前面没有调用者，所以fun内部this默认指向window
    18. //}
    19. b.say = a.say
    20. b.say() // => 调用者为b，函数内部this指向b 打印333