问题解决

NaN

  1. 0/0 => NaN
  2. typeof(0) => number
  3. typeof(NaN) => number
  4. typeof(0/0) => NaN => number

typeof ()返回的是字符串

  1. console.log(typeof (a)); //underfined(string)  
  2. console.log(typeof ('undefined')); //string
  3. console.log(typeof (undefined)); //underfined(string)
  1. //'undefined' -> true
  2. //undefined -> false
  3. //typeof (a) -> typeof (undefined) -> 'undefined' -> true
  4. //(-true) -> -1
  5. //(+undefined) -> Number(undefined) -> NaN
  6. //(-1 + NaN + '') -> 'NaN' -> true
  7. //true && true -> true -> console.log('通过了')
  9. if (typeof (a) && (-true) + (+undefined) + '') {
  10.   console.log('通过了');
  11. } else {
  12.   console.log('没通过');
  13. }

实例化之前的prototype和实例化的prototype是有区别的

  1. Car.prototype.name = 'Benz';
  2. function Car() {}
  3. var car = new Car();
  5. //还没实例化
  6. Car.prototype = {
  7.   name: 'Mazda'
  8. }
  9. console.log(car.name); //Benz
  11. //实例化以后
  12. function Car() {
  13.   var this = {
  14.     __proto__: Car.prototype = {
  15.       name: 'Benz'
  16.     }
  17.   }
  18. }

思考：子代赋值是否影响被继承的原型？子代赋值还是父代被赋值？

  1. function Teacher() {
  2.   this.mSkill = 'JS/JQ';
  3.   this.success = {
  4.     alibaba: '28',
  5.     tencent: '30'
  6.   }
  7. }
  8. var teacher = new Teacher();
  9. Student.prototype = teacher;
  11. function Student() {
  12.   this.pSkill = 'HTML/CSS'
  13. }
  14. var student = new Student();
  15. student.success.baidu = '100';
  17. console.log(teacher);
  18. //Professor {mSkill: "JS/JQ", success: {alibaba: "28", tencent: "30", baidu: "100"}}
  20. console.log(student); 
  21. //Student {pSkill: "HTML/CSS"}

结果看出没有赋值到实例对象里而是赋值到实例对象的原型上

  1. //alibaba
  2. function b(x, y, a) {
  3.   // arguments[2] = 10;
  4.   // alert(a); //10
  6.   //形参和实参具有映射关系，谁被改都会更改
  7.   a = 10;
  8.   alert(arguments[2]); //10
  10. }
  11. b(1, 2, 3);
  12. //b(1, 2, 3) => b(1, 2, 10)
  1. //undefined > 0 -> false
  2. //undefined < 0 -> false
  3. //undefined = 0 -> false
  4. //null > 0 -> false
  5. //null < 0 -> false
  6. //null = 0 -> false
  7. //undefined == null -> true
  8. //undefined === null -> false
  10. //isNaN('100') -> false
  11. //isNaN('abc') -> true
  12. //var num = Number('100') -> isNaN(num) -> false
  14. //parseInt('123a') -> 123
  15. //parseInt('1a') -> 1
  17. console.log(undefined == null); //true
  18. console.log(undefined === null); //false
  19. console.log(isNaN('100')); //false
  20. console.log(parseInt('1a') == 1); //true
  1. var a = 5;
  3. function test() {
  4.   a = 0;
  5.   console.log(a);
  6.   console.log(this.a);
  7.   var a;
  8.   console.log(a);
  9. }
  10. test(); //0 5 0
  11. new test(); //0 undefined 0
  1. //alibaba
  2. var name = '222';
  3. var a = {
  4.   name: '111',
  5.   say: function () {
  6.     console.log(this.name);
  7.   }
  8. }
  9. var fun = a.say;
  10. /**
  11.  * var fun = function(){
  12.  *   console.log(this.name); //this -> window
  13.  * }
  14.  */
  15. fun(); //222
  17. a.say(); //111 this-> a
  19. var b = {
  20.   name: '333',
  21.   say: function (fun) {
  22.     fun();
  23.     /**
  24.      * function(){
  25.      *   console.log(this.name); //this -> window
  26.      * }()
  27.      */
  28.   }
  29. }
  30. b.say(a.say); //222
  31. b.say = a.say;
  32. b.say(); //333
  33. //b.say = function(){
  34. //  console.log(this.name); this -> b
  35. //}
  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()();
  14. //此处test()() -> var test = test(); -> test();
  1. //总结知识点
  2. //1.函数也是一个对象
  3. //2.变量提升
  4. //3.函数内部没有var就会提升到全局
  5. //4.构造函数实例化内部没有的属性和方法会去访问原型
  6. //5.预编译过程：变量，函数声明，函数表达式之间的赋值先后
  7. //6.优先级：执行符号()/new + 执行符号() > .调用 > new
  8. //7.new + 数字结果 没有输出
  10. /**
  11.  * GO = {
  12.  *   getName: undefined 
  13.  *            -> function getName(){console.log(5)}(提升) 
  14.  *            -> function(){console.log(4)}(被赋值)
  15.  *            -> function(){console.log(1)}(被没有var声明的getName函数覆盖)
  16.  * }
  17.  * 
  18.  */
  20. //构造函数
  21. //3.Foo().getName()
  22. //
  23. function Foo() {
  24.   //这里AO需要调用Foo()才能进来
  25.   //这里getName没有var声明会直接提升到全局
  26.   getName = function(){
  27.     console.log(1);
  28.   }
  29.   return this;
  30. }
  32. //Foo函数底下声明getName属性，值为函数
  33. //1.Foo.getName();
  34. //分析Foo.getName() 只是借用Foo对象里面的方法 如 .length 跟Foo函数本身没有任何关系 JS中函数是一种特殊的对象
  35. Foo.getName = function () {
  36.   console.log(2);
  37. }
  39. //Foo函数底下原型上声明getName属性，值为函数
  40. //(这里需要实例化构造函数Foo()才能访问)
  41. Foo.prototype.getName = function () {
  42.   console.log(3);
  43. }
  45. //全局声明变量getName接收匿名函数
  46. //2.getName()
  47. //这里预编译时保持变量getName
  48. var getName = function () {
  49.   console.log(4);
  50. }
  52. //函数声明
  53. function getName() {
  54.   console.log(5);
  55. }
  57. Foo.getName(); //2
  58. //直接访问Foo对象下的getName方法
  59. getName(); //4
  60. //getName函数提升然后被全局变量getName接收赋值覆盖
  61. Foo().getName(); //1
  62. //Foo()执行，内部没有var声明的getName函数提升到全局并覆盖之前的值所以打印1
  63. getName(); //1
  64. //这里执行的是全局的getName 打印1
  65. new Foo.getName(); //2
  66. //这里.运算 是比new的优先级高的
  67. //先执行Foo.getName() 打印2 然后 new 数字2 是没意义的 没有输出结果
  68. new Foo().getName(); //3
  69. //规律这里执行符号()的优先级比 .大 且执行的同时包含了new
  70. //实例化的时候构造函数Foo内部没有this.getName属性，但是原型上有 所以打印原型上的3
  71. new new Foo().getName(); //3
  72. //情况跟new Foo().getName()一样，然后再new 数字3 没意义没输出
  74. //我写的答案： 1 4 1 5 2 1 1
  75. //答案：2 4 1 1 2 3 3
  1. //封装myTypeof方法
  2. //Object.prototype.toString.call();
  4. //原始值:
  5. //typeof('123') -> 'string'; 
  6. //toString.call('123') -> '[object String]'
  7. //typeof(123) -> 'number'; 
  8. //toString.call(123) -> '[object Number]'
  9. //typeof(null) -> 'object'; 
  10. //toString.call(null) -> '[object Null]'
  11. //typeof(NaN) -> 'number';
  12. //toString.call(NaN) -> '[object Number]'
  13. //typeof(undefined) -> 'undefined';
  14. //toString.call(undefined) -> '[object Undefined]'
  15. //typeof(true) -> 'boolean';
  16. //toString.call(true) -> '[object Boolean]'
  18. //引用值
  19. //typeof({}) -> 'object';
  20. //toString.call({}) -> '[object Object]'
  21. //typeof([]) -> 'object';
  22. //toString.call([]) -> '[object Array]'
  23. //typeof(function(){}) -> 'function';
  24. //toString.call(function(){}) -> '[object Function]'
  26. //包装类
  27. //typeof(new Number(1)) -> 'object';
  28. //toString.call(new Number(1)) -> '[object Number]'
  29. //typeof(new String('1')) -> 'object';
  30. //toString.call(new String('123')) -> '[object String]'
  31. //typeof(new Boolean(true)) -> 'object';
  32. //toString.call(new Boolean(true)) -> '[object Boolean]'
  34. function myTypeof(val) {
  35.   var toStr = Object.prototype.toString,
  36.     type=typeof(val),
  37.     res = toStr.call(val);
  39.     //包装类和 引用值 null {} [] 
  40.   if (type === 'object') {
  41.     switch (res) {
  42.       case '[object Null]':
  43.         type = 'null';
  44.         break;
  45.       case '[object Object]':
  46.         type = 'object';
  47.         break;
  48.       case '[object Array]':
  49.         type = 'array';
  50.         break;
  51.         case '[object Number]':
  52.           type = 'object number';
  53.         break;
  54.         case '[object String]':
  55.           type = 'object string';
  56.         break;
  57.         case '[object Boolean]':
  58.           type = 'object boolean';
  59.         break;
  60.     }
  61.   }
  62.   return type;
  63. }
  65. //原始值
  66. console.log(myTypeof('123')); //'string'
  67. console.log(myTypeof(123)); //'number'
  68. console.log(myTypeof(null)); //'null'
  69. console.log(myTypeof(NaN)); //'number'
  70. console.log(myTypeof(undefined)); //'undefined'
  71. console.log(myTypeof(true)); //'boolean'
  72. //引用值
  73. console.log(myTypeof({})); //'object'
  74. console.log(myTypeof([])); //'array'
  75. console.log(myTypeof(function () { })); //'function'
  76. //包装类
  77. console.log(myTypeof(new Number(1))); //object number
  78. console.log(myTypeof(new String('123'))); //object string
  79. console.log(myTypeof(new Boolean(true))); //object boolean
  1. var test = function a() {
  2.   a();
  3. }
  5. //typeof() 加没有声明的变量永远返回undefined 
  6. console.log(test.name); //a
  7. console.log(typeof (a)); //undefined 函数表达式忽略函数名称

包装类

  1. console.log(new String('123'));
  2. //转为123
  3. console.log(new Number(456));
  4. //转为456

参数

  1. //在方法中参数不填写值为undefined
  2. console.log(arr, arr.slice(undefined, undefined));
  3. //["a", "b", "c"] ["a", "b", "c"]