三目运算符

判断?表达式：表达式

  1. var str = '89'>'9'?'you are right':'you wrong';//字符串比较大小会从左到右一位一位比较。
  2. console.log(str);//you are wrong;

浅拷贝

  1. var person = {
  2.     name:'张三',
  3.   age:10,
  4.   sex:'male',
  5.   height:180,
  6.   weight:120
  7. }
  8. var person2 = {};
  9. for(var k in person){
  10.     person2[k]= person[k];
  11. }
  12. console.log(person,person2)//此时是浅拷贝，虽然值都拷贝过来了。如果person里有一个数组或者对象。
  13. //那么修改person2的值，person的值也会发生改变。因为person2复制过来的是引用地址。
  1. Object.prototype.num = 1;
  2. var person = {
  3.     name:'张三',
  4.   age:10,
  5.   sex:'male',
  6.   bro:{
  7.       first:'张一',
  8.     second:'张er'
  9.   }
  10. }
  11. var person2 ={};
  12. for(var k in person){
  13.  person2[k] = person[k];//此时因为bro这个属性是对象,bro里存着的是这个对象的引用地址.
  14. }
  15. person2.bro.third = '李四';
  16. console.log(person ,person2);

image.png

深拷贝

  1. // hasOwnProperty 自身有该属性则返回true 否则返回false;
  2. function deepClone(origin, target) {
  3.     var tar = target || {},//如果不传target就赋值为{};
  4.         toStr = Object.prototype.toString,
  5.         arrType = '[object Array]';
  6.     for (var k in origin) {//遍历
  7.         if (origin.hasOwnProperty(k)) {//是否是自身属性
  8.             if (typeof origin[k] === 'object' && origin[k] != null) {//是对象且不是null
  9.                 if (toStr.call(origin[k]) === arrType) {//是否是数组
  10.                     tar[k] = [];
  11.                 } else {
  12.                     tar[k] = {};
  13.                 }
  14.                 deepClone(origin[k], tar[k]);//如果是这样。递归实现
  15.             } else {
  16.                 tar[k] = origin[k];//原始值。直接赋值。
  17.             }
  18.         }
  19.     }
  20.     return tar;
  21. }
  23. /**
  24.  * 1 判断是否自身有这个属性 hasOwnProperty
  25.  * 2 有 就判断这个属性值是否是对象（需要排除null） 是就判断是数组还是 对象。
  26.  * 3 是数组或者对象都要 调用自身。
  27.  * 4 返回tar
  28.  */
  29. var person = {
  30.     name: '123',
  31.     age: 122,
  32.     son: {
  33.         name: 'lucy',
  34.         son: {
  35.             name:'John'
  36.         }
  37.     },
  38.     cars: ['Mazda', 'Benz'],
  39.     eat:function () {
  40.         console.log('i am eating an apple');
  41.     }
  42. }
  43. var person2 = deepClone(person);
  44. person2.eat = function () {
  45.     console.log('i am eating an orange');
  46. }
  47. person2.cars.push('XiaoPeng');
  48. console.log(person,person2);

image.png

笔试题

题目一

  1. /**
  2.  * AO {
  3.  *  foo:undefined->2
  4.  * }
  5.  * 
  6.  */
  8. function test(){
  9.     console.log(foo);//undefined
  10.     var foo = 2;
  11.     console.log(foo);//2
  12.     console.log(a);//a 并未在作用域内申明 a.is not defined
  13. }
  14. test();

题目二

  1. var name = '222';
  2. var a = {
  3.     name: '111',
  4.     say:function () {
  5.         console.log(this);
  6.         console.log(this.name);
  7.     }
  8. }
  9. var fun = a.say;
  10. fun();//222 将a.say 赋值给fun fun在全局。this指向window.
  11. a.say();//111 对象中调用this 指向该对象。
  12. var b = {
  13.     name: '333',
  14.     say:function (fun) {
  15.         fun();
  16.     }
  17. }
  18. b.say(a.say);//222 此时相当于 b.say(function(){console.log(this);console.log(this.name)});相当于fun 变量。
  19. b.say = a.say;//将a.say赋值给b.say;
  20. b.say();//333  对象中调用this this指向该对象。

题目三

  1. function test() {
  2.     var marty = {
  3.         name: 'marty',
  4.         print:function () {
  5.             console.log(this.name);
  6.         }
  7.     }
  8.     var test1 = {
  9.         name: 'test1'
  10.     }
  11.     var test2 = {
  12.         name:'test2'
  13.     }
  14.     var test3 = {
  15.         name:'test3'
  16.     }
  17.     test3.print = marty.print;
  18.     marty.print.call(test1);//test1 this的指向改变成了 test1
  19.     marty.print.apply(test2);//test2 this的指向改变成了test2
  20.     marty.print();//marty
  21.     test3.print();//test3 this的指向改变成了test3
  22. }
  23. test();

题目四

  1. var bar = {
  2.     a:'1'
  3. }
  5. function test() {
  6.     bar.a = 'a';
  7.     Object.prototype.b = 'b';//函数终极原型链 b
  8.     return function () {
  9.         console.log(bar.a);
  10.         console.log(bar.b);
  11.     }
  12.     /**
  13.      * 相当于 声明了一个函数。并且将这个函数return 出去。此时形成了闭包
  14.      */
  15. }
  16. test()();

作业

  1. function Foo() {
  2.     getName = function () {
  3.         console.log(1);
  4.     }
  5.     return this;//构造函数会隐式返回this 如果不是构造函数这个this 指向就是window
  6. }
  7. //给Foo函数新增一个静态属性。Function也是对象。类似于var obj = {}; obj.getName = function(){.....}
  8. Foo.getName = function () {
  9.     console.log(2);
  10. }
  11. //Foo原型上添加一个getName属性
  12. Foo.prototype.getName = function () {
  13.     console.log(3);
  14. }
  15. //函数表达式
  16. var getName = function (params) {
  17.     console.log(4);
  18. }
  19. //函数申明
  20. function getName(params) {
  21.     console.log(5)
  22. }
  24. //对象调用自身的方法
  25. Foo.getName();//2
  27. //全局调用 因为函数声明提前了。函数表达式又把函数重新赋值
  28. getName();//4
  30. //()的优先级比.高 Foo()执行的时候把getName 重新赋值了。
  31. Foo().getName();//1
  33. // .的优先级比new高所以先执行Foo.getName();->new 2 new 一个数字没有含义。
  34. new Foo.getName();//2 
  36. // new+一个函数()这个组合。new Foo()返回一个新的实例化对象。实例化对象没有getName().所以就往原型上找.
  37. new Foo().getName();//3
  39. //相当于new (new Foo()).getName(); new this.getName()//原型链上找getName; new 3是没有意义的。
  40. new new Foo().getName();// 3