1. 三目运算符/三元运算符

  1. var a = 5,
  2.     str = '';
  3. str = a > 0 ? '大于0'   //return 自带return的功能
  4.                         : '小于0';  //return
  5. console.log(str);

2. 拷贝/复制/克隆

  1. var penson1 = {
  2.   name: '张三',
  3.   sex: 'male',
  4.   age: 18,
  5. }
  7. var penson2 = penson1;
  8. penson2.name = '李四';
  9. console.log(penson1, penson2);//{name: '李四', sex: 'male', age: 18}打印出两个相同的对象，name值都变成了李四，因为两个值都是指向同样的引用地址，改一个，另外一个也会变，因为指向的是同一个存储空间

3. 浅拷贝

  1. var penson1 = {
  2.   name: '张三',
  3.   sex: 'male',
  4.   age: 18,
  5. }
  7. var penson3 = {};
  8. for(var key in penson1){
  9.   penson3[key] = penson1[key];
  10. }
  11. penson3.name = '王五';
  12. console.log(penson1, penson3);//打印出来两个数组，但name不同，说明penson3是独立的存储空间

再给penson1加上属性son添加三项键值对

  1. var penson1 = {
  2.   name: '张三',
  3.   sex: 'male',
  4.   age: 18,
  5.   son: {
  6.     first: 'jenney',
  7.     second: 'Lucy',
  8.     third: 'jone'
  9.   }
  10. }
  12.  //然后再到penson3添加一个son
  13. var penson3 = {};
  14. for(var key in penson1){
  15.   penson3[key] = penson1[key];
  16. }
  17. penson3.name = '王五';
  18. penson3.son.forth = 'Ben';
  19. console.log(penson1, penson3);//打印的结果两个Array都有了forth: Ben属性

说明penson3改，pensen1也会改。所以说并没有处理掉对象中的引用值，这种现象就叫做浅拷贝
#_#封装一下浅拷贝

  1. function clone(origin, target){
  2.  var tar = target || {};
  3.   for(var key in origin){
  4.     if(origin.hasOwnProperty(key)){//剔除非本身原型上的属性
  5.       tar[key] = origin[key];
  6.     }
  7.   }
  8. }

4. 深拷贝

  1. Object.prototype.num = 1;
  2. var penson1 = {
  3.   name: '张三',
  4.   sex: 'male',
  5.   age: 38,
  6.   children: {
  7.     first: {
  8.       name: 'jenney',
  9.       age: 18
  10.     },
  11.     second:{
  12.       name:  'Lucy',
  13.       age: 12
  14.     },
  15.     third: {
  16.       name: 'jone',
  17.       age: 7
  18.     }
  19.   },
  20.   car: ['Banz', 'Mazda']
  21. }
  22. var penson2 = deepClone(penson1);
  23. penson2.name = '李四';
  24. penson2.children.forth = {
  25.   name: 'Ben',
  26.   age: 1
  27. }
  28. penson2.car.push('BYD');
  30. function deepClone(origin, target){
  31.   var target = target || {},
  32.       toStr = Object.prototype.toString,//判断值的类型，后面加上call直接能用
  33.       arrType = '[object Array]';
  35.   for(var key in origin){
  36.     if(origin.hasOwnProperty(key)){
  37.       if(typeof(origin[key]) === 'object' && origin[key] !== null){//判断是引用值且不为null
  38.         if(toStr.call(origin[key]) === arrType){//判断是不是数组类型
  39.           target[key] = [];
  40.         }else{
  41.           target[key] = {};
  42.         }
  44.         deepClone(origin[key], target[key]);//如果数据还有一层，就递归再循环出来
  45.       }else{
  46.         target[key] = origin[key];
  47.       }
  48.     }
  49.   }
  50.   return target;
  51. }
  52. console.log(penson1, penson2);

//结果返回的值name不同，penson2增加对象children里的值和增加数组car里的值并不会改变penson1

深拷贝的第二种方法

利用JSON的方法，也能达到深拷贝的目的，因为先转成字符串，然后再转对象，就已经不是原先的存储空间了。但是有缺陷，例如clone方法的时候就没用。

  1.  var str = JSON.stringify(penson1),//转成字符串
  2.      person2 = JSON.parse(str);//转成对象

深拷贝还有第三种方法，jquery的一种。

面试题/笔试题

1. 壹

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

2. 贰

  1. function a(){
  2.   var test;
  3.   test();
  4.   function test(){
  5.     console.log(1);//1
  6.   }
  7. }
  8. a();
  10. // AO = {
  11. //     test: undefined; -> function
  12. // }

3. 叁

  1. var name = '222';
  2. var a = {
  3.   name: '111',
  4.   say: function(){
  5.     console.log(this.name);
  6.   }
  7. }
  8. var fun = a.say;
  9. //这一步也就相当于var fun = function(){console.log(this.name)}this还是指向window
  11. fun();//222
  12. a.say();//111
  13. var b = {
  14.   name: '333',
  15.   say: function(fun){
  16.     fun();
  17.   }
  18. }
  19. b.say(a.say);//222
  20. //这一步相当于在b.say函数里面放了一个fun()方法，因为是fun函数调用的，这个时候执行的this是指向window的，又所以仍然是222
  21. b.say = a.say;
  22. b.say();//333，a.say赋给了b.say,b调用的，所以是333

4. 肆

  1. function test(){
  2.   var marty = {
  3.     name: 'marty',
  4.     printName: function(){
  5.       console.log(this.name);
  6.     }
  7.   }
  9.   var test1 = {
  10.     name: 'test1'
  11.   }
  12.   var test2 = {
  13.     name: 'test2'
  14.   }
  15.   var test3 = {
  16.     name: 'test3'
  17.   }
  19.   test3.printName = marty.printName;
  20.   marty.printName.call(test1);//test1
  21.   marty.printName.apply(test2);//test2
  22.   marty.printName();//marty  
  23.   test3.printName();//test3
  24. }
  25. test();

5. 伍

  1. var bar = {
  2.   a: '1'
  3. };
  5. function test(){
  6.   bar.a = 'a';
  7.   Object.prototype.b = 'b';
  8.   return function inner(){
  9.     console.log(bar.a);//a
  10.     console.log(bar.b);//b
  11.   }
  12. }
  13. test()();//这一句实际上就是var test = test(); test();

作业

模块化开发

  1. window.onload = function(){
  2.   init();
  3. }
  4. function init(){
  5.   console.log(initFb(10));
  6.   console.log(initDiv(100));
  7. }
  9. //     1. 斐波那契数列
  10. var initFb = (function(){
  11.   function fb(n){
  12.     if(n <= 0){
  13.       return 0;
  14.     }
  15.     if(n <= 2){
  16.       return 1;
  17.     }
  18.     return fb(n - 1) + fb(n - 2);
  19.   }
  20.   return fb;
  21. })();
  23. //     2. 能被3、5、7整数的数
  24. var initDiv = (function(){
  25.   function div(n){
  26.     var arr = [];
  27.     for(var i = 0;i <= n;i++){
  28.       if(i % 3 === 0 || i % 5 === 0 || i % 7 ===0){
  29.         arr.push(i);
  30.       }
  31.     }
  32.     return arr
  33.   }
  34.   return div;
  35. })();