ECMA

作业

作业一

  1. var plan = '做大餐';
  2. var week = window.prompt('请填写星期几');
  4. switch (week) {
  5.   case '星期一':
  6.     document.write(week);
  7.     break;
  8.   case '星期二':
  9.     document.write(week);
  10.     break;
  11.   case '星期三':
  12.     document.write(week);
  13.     break;
  14.   case '星期四':
  15.     document.write(week);
  16.     break;
  17.   case '星期五':
  18.     document.write(week);
  19.     break;
  20.   case '星期六':
  21.     document.write(week);
  22.     break;
  23.   case '星期日':
  24.     document.write(week);
  25.     break;
  26.   default:
  27.     week = false;
  28. }
  30. var day = window.prompt('选择上午或者下午');
  32. switch (day) {
  33.   case '上午':
  34.     document.write(day);
  35.     break;
  36.   case '下午':
  37.     document.write(day);
  38.     break;
  39.   default:
  40.     day = false;
  41. }
  43. if (week && day) {
  44.   document.write('的安排: ' + plan)
  45. } else {
  46.   document.write('没有安排')
  47. }
  1. //日程安排
  2. var weekday = window.prompt('请输入星期几');
  3. var time = window.prompt('请输入上午或下午'); \
  5. switch (weekday) {
  6.   case '星期一':
  7.     if (time == '上午') {
  8.       console.log('看书');
  9.     } else if (time == '下午') {
  10.       console.log('逛街');
  11.     }
  12.     break;
  13. }

作业二

for循环写斐波那契数列(黄金分割数列、兔子数列)，

算出第n位

只知道两位，然后算出后面的值，前两位的和等于后一位

1 1 2 3 5 8…

  1. //循环一： n1 n2 n3
  2. //         1  1  2  3  5  8
  3. //循环二：    n1 n2 n3
  4. //循环三：       n1 n2 n3
  5. //循环四：          n1 n2 n3
  7. //前两位是确定的
  8. //n3 = n1 + n2
  10. var n =parseInt(window.prompt('请输入第几位'));
  11. var n1 = 1,
  12.   n2 = 1,
  13.   n3;
  14. if (n < 0) {
  15.   console.log('输入数字错误');
  16. } else {
  17.   if (n <= 2) {
  18.     n3 = 1;
  19.     }
  20.   for (var i = 2; i < n; i++){
  21.     n3 = n1 + n2;
  22.     n1 = n2;
  23.     n2 = n3;
  24.   }
  25.   console.log(n3);
  26. }

作业三

定义一个函数，从wp接收一个饮料的名称，函数返回对应的价格(switch or if)

  1. function softDrinkPrice(name) {
  2.   switch (name) {
  3.     case '可乐':
  4.       console.log('2.5元');
  5.       break;
  6.     case '雪碧':
  7.       console.log('2.6元');
  8.       break;
  9.     default:
  10.       console.log('请输入饮料名称');
  11.   }
  12. }
  13. softDrinkPrice('可乐'); //2.5元
  14. softDrinkPrice('雪碧'); //2.5元
  15. softDrinkPrice('哈哈哈'); //请输入饮料名称

作业四

定义一个函数，从wp接收第一个数，接收一个运算符号(+,-,*,/,%)，接收第二个数，利用函数做运算并返回运算结果

  1. function Cal(calSign, num1, num2) {
  2.   switch (calSign) {
  3.     case '+':
  4.       console.log(num1 + num2);
  5.       break;
  6.     case '-':
  7.       console.log(num1 - num2);
  8.       break;
  9.     case '*':
  10.       console.log(num1 * num2);
  11.       break;
  12.     case '/':
  13.       console.log(num1 / num2);
  14.       break;
  15.     case '%':
  16.       console.log(num1 % num2);
  17.       break;
  18.     default:
  19.       return console.log('请输入运算符号');
  20.   }
  21. }
  23. // Cal('+', 1, 2); //3
  24. // Cal('-', 1, 2); //-1
  25. // Cal('*', 1, 2); //2
  26. // Cal('/', 1, 2); //0.5
  27. // Cal('%', 1, 2); //1

作业五

定义一个函数，从wp接收一个n，算出n的阶乘，不能用for循环

  1. //result = 1 x 2 x 3 x ... x n
  2. //规律 n = n * (n - 1)
  3. //出口 
  4. function factor(num) {
  5.   if (num < 0) {
  6.     return -1;
  7.   } else if (num === 0 || num === 1) {
  8.     return 1;
  9.   } else {
  10.     return (num * factor(num - 1));
  11.   }
  12. }
  13. console.log(factor(5)); //120
  15. //队列
  16. //fact(5) = 5 * fact(4);
  17. //fact(4) = 4 * fact(3);
  18. //fact(3) = 3 * fact(2);
  19. //fact(2) = 2 * fact(1);
  21. //fact(5) = 5 * 4;
  22. //fact(4) = 4 * 3;
  23. //fact(3) = 3 * 2;
  24. //fact(2) = 2 * 1;

定义一个函数，从wp接收一个n，算出斐波那契数列的第n位，不能用for循环

  1. //1 1 2 3 5 8 ...
  2. //规律：n3 = n2 + n1;
  3. //出口：n <= 2
  4. function fibo(n) {
  5.   if (n == 1 || n == 2) {
  6.     return 1
  7.   };
  8.   return fibo(n - 1) + fibo(n - 2);
  9. };
  10. console.log(fibo(6));
  12. n = 5;
  13. fb(5) = fb(4) + fb(3);
  14. fb(4) = fb(3) + fb(2);
  15. fb(3) = fb(2) + fb(1);
  17. fb(5) = 3 + 2;
  18. fb(4) = 2 + 1;
  19. fb(3) = 1 + 1;
  21. fb(5) = 5

作业六

写闭包累加器，执行一次打印一次

  1. function accumulator(num) {
  2.   var num = arguments[0] || 1;
  3.   function like() {
  4.     num++;
  5.     console.log(num);
  6.   }
  7.   function unlike() {
  8.     num--;
  9.     console.log(num);
  10.   }
  11.   return [like, unlike];
  12. }
  13. var result = accumulator();
  14. result[0]()
  15. result[0]()
  16. result[1]()

写一个缓存区，一个班级，学生名字保存在一个数组里，

两个方法写在函数的一个对象中，第一个方法是加入半接，第二个方法是离开班级，

每次加入或离开，都需要打印新的学生名单

  1. function classOne(name) {
  2.   var sList = [];
  3.   var operate = {
  4.     enter: function () {
  5.       console.log(name + '加入班级');
  6.       sList += name;
  7.     },
  8.     leave: function () {
  9.       console.log(name + '离开班级');
  10.       sList -= name;
  11.     }
  12.   }
  13.   return operate;
  14. }
  15. classOne('大田').enter();
  16. classOne('大田').leave();
  1. function myClass() {
  2.   var sList = [];
  3.   var operation = {
  4.     join: function (name) {
  5.       sList.push(name);
  6.       console.log(sList);
  7.     },
  8.     leave: function (name) {
  9.       for (var i = 0; i < sList.length; i++) {
  10.         var item = sList[i];
  11.         if (item === name) {
  12.           sList.splice(i, 1);
  13.         }
  14.       }
  15.     }
  16.   }
  17.   return operation;
  18. }
  20. var obj = myClass();
  21. obj.join('zhangsan');
  22. obj.join('lisi');
  23. obj.join('wangwu');
  24. obj.leave('lisi');

作业七

写一个构造函数，接收数字类型的参数，参数数量不定，完成参数相加和相乘的功能

  1. function MyMath(option) {
  2.   this.number1 = option.number1;
  3.   this.number2 = option.number2;
  5.   this.add = function () {
  6.     console.log(this.number1 + this.number2);
  7.   }
  8.   this.mul = function () {
  9.     console.log(this.number1 * this.number2);
  10.   }
  11. }
  13. var test = new MyMath({
  14.   number1: 2,
  15.   number2: 10
  16. });
  17. test.add();
  18. test.mul();
  1. function Compute() {
  2.   var args = arguments,
  3.     res;
  4.   this.plus = function () {
  5.     res = 0;
  6.     loop('add', res);
  7.   }
  8.   this.times = function () {
  9.     res = 1;
  10.     loop('mul', res);
  11.   }
  12.   function loop(method, res) {
  13.     for (var i = 0; i < args.length; i++) {
  14.       var item = args[i];
  15.       if (method === 'add') {
  16.         res += item;
  17.       } else if (method === 'mul') {
  18.         res *= item;
  19.       }
  20.     }
  21.     console.log(res);
  22.   }
  23. }
  24. var compute = new Compute(2, 4, 6);
  25. compute.plus(); //12 
  26. compute.times(); //48
  1. function Compute() {
  2.   var res = 0;
  3.   this.plus = function (args) {
  4.     // console.log(arguments);
  5.     loop(arguments, 'add', res);
  6.   }
  7.   this.times = function (args) {
  8.     res = 1;
  9.     loop(arguments, 'mul', res);
  10.   }
  12.   function loop(args, method, res) {
  13.     for (var i = 0; i < args.length; i++) {
  14.       var item = args[i];
  15.       if (method === 'add') {
  16.         res += item;
  17.       } else if (method === 'mul') {
  18.         res *= item;
  19.       }
  20.     }
  21.     console.log(res);
  22.   }
  23. }
  24. var compute = new Compute();
  25. compute.plus(2, 4, 6); //12 
  26. compute.times(3, 5, 7); //48

作业八

写一个构造车的函数，可设置车的品牌，颜色，排量，再写一个构造消费者的函数，设置用户的名字，年龄，收入，通过选择的方法实例化该用户喜欢的车，再设置车的属性

  1. function Car(option) {
  2.   this.brand = option.brand;
  3.   this.color = option.color;
  4.   this.displacement = option.displacement;
  5. }
  7. function User(option) {
  8.   this.name = option.name;
  9.   this.age = option.age;
  10.   this.incoming = option.incoming;
  11.   this.carSelect = option.carSelect;
  13. }
  15. var test = new MyMath({
  16.   number1: 2,
  17.   number2: 10
  18. });
  19. test.add();
  20. test.mul();
  1. function Car(color, brand, displacement) {
  2.   this.brand = brand;
  3.   this.color = color;
  4.   this.displacement = displacement;
  5.   this.drive = function () {
  6.     console.log('I am driving');
  7.   }
  8. }
  10. var car = new Car('red', 'mazda');
  11. console.log(car.color);
  12. console.log(car.brand);
  13. car.drive();
  1. function Car(opt) {
  2.   this.brand = opt.brand;
  3.   this.color = opt.color;
  4.   this.displacement = opt.displacement;
  5. }
  7. function Person(opt) {
  8.   this.name = opt.name;
  9.   this.age = opt.age;
  10.   this.income = opt.income;
  11.   this.selectCar = function () {
  12.     var myCar = new Car(opt.carOpt);
  13.     console.log(this.name + '挑选了一辆排量为: ' + myCar.displacement + '的' + myCar.color + '的' + myCar.brand);
  14.   }
  15. }
  16. var james = new Person({
  17.   name: 'james',
  18.   age: 18,
  19.   income: '15k',
  20.   carOpt: {
  21.     brand: 'Mazda',
  22.     color: '红色',
  23.     displacement: '2.5L'
  24.   }
  25. });
  26. james.selectCar();

作业九

写一个函数，接收任意一个字符串，算出这个字符串的总字节数

  1. function seachASCII(str) {
  2.   var byte = 0;
  3.   var result = 0;
  4.   for (var i = 0; i < str.length; i++) {
  5.     var pos = str.charCodeAt(i);
  6.     if (pos < 255) {
  7.       byte = 1;
  8.     } else {
  9.       byte = 2;
  10.     }
  11.     result += byte;
  12.   }
  13.   console.log(result);
  14. }
  15. seachASCII('abcdefa'); //7

写插件，任意传两个数字，调用插件内部方法可进行加减乘除功能

  1. var compute = (function () {
  2.   function Compute() {
  3.     var result = 0;
  4.     switch (arguments[0].method) {
  5.       case 'add':
  6.         add(arguments[0]);
  7.         break;
  8.       case 'reduce':
  9.         reduce(arguments[0]);
  10.         break;
  11.       case 'mul':
  12.         mul(arguments[0]);
  13.         break;
  14.       case 'div':
  15.         div(arguments[0]);
  16.         break;
  17.       default:
  18.         console.log('请输入正确的运算符');
  19.     }
  20.     function add(arg) {
  21.       result = arguments[0].a + arguments[0].b;
  22.       console.log(result);
  23.     }
  24.     function reduce(arg) {
  25.       result = arguments[0].a - arguments[0].b;
  26.       console.log(result);
  27.     }
  28.     function mul(arg) {
  29.       result = arguments[0].a * arguments[0].b;
  30.       console.log(result);
  31.     }
  32.     function div(arg) {
  33.       result = arguments[0].a / arguments[0].b;
  34.       console.log(result);
  35.     }
  36.   }
  37.   return Compute;
  38. })();
  40. compute({
  41.   a: 1,
  42.   b: 2,
  43.   method: 'mul'
  44. });
  1. var compute = (function () {
  2.   function Compute(opt) {
  3.     this.a = opt.a || 0;
  4.     this.b = opt.b || 0;
  5.     this.method = opt.method;
  6.     switch (this.method) {
  7.       case 'add':
  8.         Compute.prototype.add(this.a, this.b);
  9.         break;
  10.       case 'reduce':
  11.         Compute.prototype.reduce(this.a, this.b);
  12.         break;
  13.       case 'mul':
  14.         Compute.prototype.mul(this.a, this.b);
  15.         break;
  16.       case 'div':
  17.         Compute.prototype.div(this.a, this.b);
  18.         break;
  19.     }
  20.   }
  22.   Compute.prototype = {
  23.     add: function (a, b) {
  24.       console.log(a + b);
  25.     },
  26.     reduce: function (a, b) {
  27.       console.log(a - b);
  28.     },
  29.     mul: function (a, b) {
  30.       console.log(a * b);
  31.     },
  32.     div: function (a, b) {
  33.       console.log(a / b);
  34.     }
  35.   }
  36.   return Compute;
  37. })();
  39. new compute({
  40.   a: 1,
  41.   b: 2,
  42.   method: 'div'
  43. });

作业十

年龄为多少岁姓名为XX买了一辆排量为XX的XX颜色的XX牌子的车

  1. //硬性规定两个构造函数Car和Person合并
  2. function Car(displacement, color, brand) {
  3.   this.displacement = displacement;
  4.   this.color = color;
  5.   this.brand = brand;
  6. }
  8. function Person(args) {
  9.   var carLike = args.carLike;
  10.   Car.apply(this, carLike);
  11.   this.name = args.name;
  12.   this.age = args.age;
  13.   this.carSelect = function () {
  14.     console.log('年龄为' + this.age + '岁' + '姓名为' + this.name + '买了一辆排量为' + this.displacement + '的' + this.color + '颜色的' + this.brand + '牌子的车');
  15.   }
  16. }
  18. var person = new Person({
  19.   name: 'kevin',
  20.   age: 30,
  21.   carLike: ['2.5L', 'grey', 'Mazda']
  22. });
  23. person.carSelect();

写模块化：

  • 功能一：打印一个参数值以内能被3或5或7整除的数值
  • 功能二：打印斐波那契数列的第N位
  • 功能三：打印从0到100的累加值
  1. window.onload = function () {
  2.   init();
  3. }
  5. function init() {
  6.   initComputeDiv(10);
  7.   initComputeFibo(10);
  8.   initComputeAcc(10);
  9. }
  11. var initComputeDiv = (function () {
  12.   //打印一个参数值以内能被3或5或7整除的数值
  13.   function div(num) {
  14.     var arr = [];
  15.     for (var i = 0; i < num; i++) {
  16.       if (i % 3 == 0 || i % 5 == 0 || i % 7 == 0) {
  17.         arr.push(i);
  18.       }
  19.     }
  20.     console.log(arr);
  21.     return this;
  22.   }
  23.   return div;
  24. })();
  26. var initComputeFibo = (function () {
  27.   //打印斐波那契数列的第N位
  28.   function fibo(n) {
  29.     var n1 = 1,
  30.       n2 = 1,
  31.       n3;
  32.     if (n < 0) {
  33.       console.log('数字错误');
  34.     } else {
  35.       if (n <= 2) {
  36.         n3 = 1;
  37.       }
  38.       for (var i = 2; i < n; i++) {
  39.         n3 = n1 + n2;
  40.         n1 = n2;
  41.         n2 = n3;
  42.       }
  43.       console.log(n3);
  44.     }
  45.   }
  47.   return fibo;
  48. })();
  50. var initComputeAcc = (function () {
  51.   //打印从0到100的累加值
  52.   function sum(num) {
  53.     var result = 0;
  54.     for (var i = 0; i <= num; i++) {
  55.       result += i;
  56.     }
  57.     console.log(result);
  58.   }
  60.   return sum;
  61. })();
  1. //请用window.prompt接收用户输入的年份，判断是否是闰年？(三目运算符)
  2. //整除4 并且不能整除100
  3. //整除400
  4. var year = window.prompt('请输入年份');
  5. (year % 4 == 0 && year % 100 !== 0) || year % 400 === 0 ? console.log('是闰年') : console.log('不是闰年');

作业十一

用splice()重写原型数组的原型上的unshift()方法myUnshift()

  1. var arr = ['d', 'e', 'f'];
  2. //['a', 'b', 'c', 'd', 'e', 'f']
  4. Array.prototype.myUnshift = function () {
  5.   //unshift 在第一位前面加
  6.   //返回值都为执行了方法以后数组长度
  7.   //传入实参列表
  9.   for (var i = arguments.length - 1; i >= 0; i--) {
  10.     // console.log(arguments[i]); //c b a
  11.     //arr.splice(开始项的下标，剪切长度，剪切以后最后一位开始添加数据)
  12.     this.splice(0, 0, arguments[i]);
  13.   }
  15.   //功能2：返回执行方法以后数组长度
  16.   return this.length;
  17. }
  19. arr.myUnshift('a', 'b', 'c');
  20. console.log(arr);
  1. Array.prototype.myUnshift = function () {
  2.   var pos = 0;
  3.   for (var i = 0; i < arguments.length; i++){
  4.     // console.log(arguments[i]);//a b c
  5.     this.splice(pos, 0, arguments[i]);
  6.     pos++;
  7.   }
  8.   return this.length;
  9. }
  10. arr.myUnshift('a', 'b', 'c');
  11. console.log(arr);
  1. //利用concat()数组拼接
  2. Array.prototype.myUnshift = function () {
  3.   //先让类数组转为数组
  4.   var argArr = Array.prototype.slice.call(arguments);
  5.   // console.log(argArr); //["a", "b", "c"]
  6.   //返回值：修改原数组
  7.   arr = argArr.concat(this);
  8.   return arr.length;
  9. }
  10. arr.myUnshift('a', 'b', 'c'); //["a", "b", "c", "d", "e", "f"]
  11. // arr.myUnshift(1); //[1, "d", "e", "f"]
  12. console.log(arr);

请按照字节数排序下列数组，charCodeAt() > 255

['我爱你', 'OK', 'Hello', '你说WHAT', '可以']

  1. // //请按照字节数排序下列数组
  2. var arr = ['我爱你', 'OK', 'Hello', '你说WHAT', '可以'];
  3. var newArr = [];
  5. for (var i = 0; i < arr.length; i++) {
  6.   // console.log(i); // console.log(i); 0 1 2 3 4
  7.   // console.log(arr[i]); //我爱你 OK Hello 你说WHAT 可以
  8.   // console.log(arr[0]); //我爱你
  9.   var res = seachASCII(arr[i]); //6 2 5 8 4
  11.   //{
  12.   //  6: '我爱你',
  13.   //  2: 'OK'
  14.   //}
  16.   var obj = {};
  17.   //对象键名 = 对象键值
  18.   obj[res] = arr[i];
  19.   // console.log(obj);
  21.   /**
  22.    * {6: "我爱你"}
  23.    * {2: "OK"}
  24.    * {5: "Hello"}
  25.    * {8: "你说WHAT"}
  26.    * {4: "可以"}
  27.    */
  29.   newArr.push(obj);
  30. }
  32. newArr.sort(function (a, b) {
  33.   if (a[res] > b[res]) {
  34.     return 1;
  35.   } else {
  36.     return -1;
  37.   }
  38. })
  40. console.log(newArr);
  42. function seachASCII(str) {
  43.   var byte = 0;
  44.   var result = 0;
  45.   for (var i = 0; i < str.length; i++) {
  46.     var pos = str.charCodeAt(i);
  47.     if (pos < 255) {
  48.       byte = 1;
  49.     } else {
  50.       byte = 2;
  51.     }
  52.     result += byte;
  53.   }
  54.   return result;
  55. }
  57. // var arr = [];
  58. // for (var i = 0; i < 5; i++) {
  59. //   arr.push(i);
  60. // };
  61. // console.log(arr);
  1. //数组按照元素的字节数排序
  2. var arr = ['我爱你', 'OK', 'Hello', '你说WHAT', '可以'];
  4. arr.sort(function (a, b) {
  5.   //比较函数获取到的字符即可
  6.   return getBytes(a) - getBytes(b);
  7. })
  9. //unicode 0-255 -> 1个字节
  10. //unicode > 255 -> 2个字节
  11. function getBytes(str) {
  12.   //我爱你 -> bytes = 3
  13.   //不管中文还是英文都当成一个字节
  14.   //让下面判断的时候再决定是否加一个字节
  15.   var bytes = str.length;
  17.   for (var i = 0; i < str.length; i++){
  18.     //逐个查询字符遇到>255的加一个字节
  19.     if (str.charCodeAt(i) > 255) {
  20.       bytes++;
  21.     }
  22.   }
  23.   return bytes;
  24. }
  25. console.log(getBytes('我爱你')); //6
  26. console.log(arr); //["OK", "可以", "Hello", "我爱你", "你说WHAT"]
  1. //数组去重
  2. //Array.protype原型上写unique方法
  3. //实现数据去重 返回新的数组
  4. //重复的项目剔除
  5. //可以用对象属性的方式
  6. //把属性或者值拿出来重新做一个数组
  8. var arr = [0, 0, 1, 1, 1, 1, 2, 2, 2, 3, 3, 3, 'a', 'a'];
  10. Array.prototype.unique = function () {
  11.   var temp = {},
  12.     newArr = [];
  13.   for (var i = 0; i < this.length; i++) {
  14.     // console.log(this[i]); //0, 0, 1, 1, 1, 1, 2, 2, 2, 3, 3, 3, 'a', 'a'
  16.     //写法一：
  17.     // if (!temp[this[i]]) {
  18.     //   //temp对象属性 = arr对象属性
  19.     //   // temp[this[i]] = this[i];
  20.     //   //过滤0改写为'1111'
  21.     //   temp[this[i]] = '1111';
  22.     //   // console.log(temp);
  23.     //   //{0: "1111", 1: "1111", 2: "1111", 3: "1111", a: "1111"}
  24.     //   newArr.push(this[i]);
  25.     // }
  27.     //写法二：
  28.     if (!temp.hasOwnProperty(this[i])) {
  29.       //temp对象属性 = arr对象属性
  30.       temp[this[i]] = this[i];
  31.       console.log(temp);
  32.       //{0: 0, 1: 1, 2: 2, 3: 3, a: "a"}
  33.       newArr.push(this[i]);
  34.     }
  35.   }
  36.   return newArr;
  37. }
  38. //这里发现0没过滤掉 因为!temp[this[i] -> !0 -> true
  39. console.log(arr.unique()); //[0, 0, 1, 2, 3, "a"] 
  40. console.log(arr.unique()); //[0, 1, 2, 3, "a"]
  42. //原理分析：
  44. // //借用对象不重复性的属性
  45. // //根据数组判断自身有没有该属性
  46. // //如果没有就给该对象添加属性
  48. // var obj = {
  49. //   0: 0,
  50. //   1: 1,
  51. //   2: 2
  52. // }
  54. // //给对象放属性的同时给数组也添加元素
  55. // var newArr = [];
  1. //字符串去重
  3. var str = '111222000aabb';
  5. String.prototype.unique = function () {
  6.   var temp = {},
  7.     newStr = '';
  9.   for (var i = 0; i < this.length; i++) {
  10.     if (!temp.hasOwnProperty(this[i])) {
  11.       temp[this[i]] = this[i];
  12.       newStr += this[i];
  13.     }
  14.   }
  15.   return newStr;
  16. }
  18. console.log(str.unique()); //120ab
  1. //找出不重复的字符串并返回次数
  2. var str = 'truaiwrtruibowrtpoiwrcutwopirut';
  4. function test(str) {
  5.   var temp = {};
  7.   for (var i = 0; i < str.length; i++) {
  8.     if (temp.hasOwnProperty(str[i])) {
  9.       // console.log(temp[str[i]]);
  10.       temp[str[i]]++;
  11.     } else {
  12.       temp[str[i]] = 1;
  13.     }
  14.   }
  15.   return temp;
  16. }
  17. console.log(test(str));
  18. /**
  19.  * {t: 5, r: 6, u: 4, a: 1, i: 4, …}
  20.      a: 1
  21.      b: 1
  22.      c: 1
  23.      i: 4
  24.      o: 3
  25.      p: 2
  26.      r: 6
  27.      t: 5
  28.      u: 4
  29.      w: 4
  30.      __proto__: Object
  31.  */
  1. //封装myTypeof方法
  2. //Object.prototype.toString.call();
  4. //原始值:
  5. //typeof('123') -> 'string'; 
  6. //typeof(123) -> 'number'; 
  7. //typeof(null) -> 'object'; 
  8. //typeof(NaN) -> 'number';
  9. //typeof(undefined) -> 'undefined';
  10. //typeof(true) -> 'boolean';
  11. //toString.call('123') -> '[object String]'
  12. //toString.call(123) -> '[object Number]'
  13. //toString.call(null) -> '[object Null]'
  14. //toString.call(NaN) -> '[object Number]'
  15. //toString.call(undefined) -> '[object Undefined]'
  16. //toString.call(true) -> '[object Boolean]'
  18. //引用值
  19. //typeof({}) -> 'object';
  20. //typeof([]) -> 'object';
  21. //typeof(function(){}) -> 'function';
  22. //toString.call({}) -> '[object Object]'
  23. //toString.call([]) -> '[object Array]'
  24. //toString.call(function(){}) -> '[object Function]'
  26. //包装类
  27. //typeof(new Number(1)) -> 'object';
  28. //typeof(new String('1')) -> 'object';
  29. //typeof(new Boolean(true)) -> 'object';
  30. //toString.call(new Number(1)) -> '[object Number]'
  31. //toString.call(new String('123')) -> '[object String]'
  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. //封装myTypeof()
  2. function myTypeof(val) {
  3.   var type = typeof (val),
  4.     toStr = Object.prototype.toString,
  5.     res = {
  6.       '[object Array]': 'array',
  7.       '[object Object]': 'object',
  8.       '[object Number]': 'object number',
  9.       '[object String]': 'object string',
  10.       '[object Boolean]': 'object boolean'
  11.     }
  12.   if (val === null){
  13.     return 'null';
  14.     //object: null {} []
  15.     //这里返回包括包装类Number, String, Boolean
  16.   } else if (type === 'object') {
  17.     var ret = toStr.call(val);
  18.     return res[ret];
  19.     //返回原始值
  20.     //
  21.   } else {
  22.     return type;
  23.   }
  24. }

dom:

作业一：

  1. //作业1 
  2. //在原型上编程
  3. //遍历任意一个父元素，找到他的子元素节点
  4. //有数字参数 返回 某一个对应子元素
  5. //没有数字参数 返回 子元素节点的集合
  7. Document.prototype.findChildEleNode = function (fNode, num) {
  8.   var fNode = arguments[0],
  9.     sNode = fNode.childNodes,
  10.     childEleSet = [],
  11.     typeNum = arguments[1] || 0;
  12.   // console.log(sNode);
  14.   for (var i = 0; i < sNode.length; i++) {
  15.     var nodeType = sNode[i].nodeType,
  16.       childItem = sNode[i];
  17.     // 有参数
  18.     if (nodeType === typeNum) {
  19.       childEleSet.push(childItem);
  20.     } else {
  21.       //没有参数
  22.       // console.log(sNode);
  23.       // childEleSet = sNode;
  24.     }
  25.   }
  26.   return childEleSet;
  27. }
  28. console.log(document.findChildEleNode(div, 9));;

作业二

  1. //作业2 
  2. //在原型上编程
  3. //找出一个元素的第n层父级元素 
  5. var a = document.getElementsByTagName('a')[0];
  7. Document.prototype.findFatherTagName = function (ele, n) {
  8.   console.log(ele.parentNode.parentNode);
  9.   var fatherEle = ele;
  10.   for (var i = 1; i <= n; i++) {
  11.     fatherEle = ele.parentNode;
  12.   }
  13.   return fatherEle;
  15. }
  16. document.findFatherTagName(a, 1)

作业三

  1. //作业3：原型上编程hasChildren
  2. //判断是否有子节点(包括文本节点)
  3. //判断父元素有没有子元素节点
  4. // parent.hasChildNodes
  5. // console.log(div.hasChildNodes()); //true
  7. Node.prototype.hasChildNodes = function () {
  8.   var children = this.childNodes,
  9.     eleNode = [],
  10.     result = false;
  12.   for (var i = 0; i < children.length; i++) {
  13.     var item = children[i];
  14.     if (item.nodeType === 1) {
  15.       eleNode.push(item);
  16.       // console.log(eleNode);
  17.       if (eleNode) {
  18.         result = true;
  19.       } else {
  20.         result = false;
  21.       }
  22.     }
  23.   }
  24.   return result;
  25. }
  26. console.log(div.hasChildNodes());

作业四

  1. //作业4：原型上编程(未做完)
  2. //寻找兄弟元素节点
  3. //参数为正：找之后的第N个
  4. //参数为负：找之前的第N个
  5. Node.prototype.findEleSibling = function (num) {
  6.   // console.log(this.nodeType);
  8.   //拿到同级所有的节点
  9.   var elem = this.parentNode.childNodes,
  10.     elemList = [];
  11.   //过滤除元素节点之外的节点
  12.   for (var i = 0; i < elem.length; i++) {
  13.     var item = elem[i];
  14.     if (elem[i].nodeType === 1) {
  15.       elemList.push(item);
  16.     }
  17.   }
  19.   //找回原来位置 ????
  21.   console.log(elemList[0]);
  22.   // if (num > 0) {
  23.   // } else if (num < 0) {
  24.   //   num = Math.abs(num);
  25.   //   // console.log(num);
  26.   // }
  29.   //负数
  30.   //参数1： console.log(this.previousSibling.previousSibling);
  31.   //参数2： console.log(this.previousSibling.previousSibling.previousSibling.previousSibling);
  33.   //正数
  34.   //参数1： 
  35.   // console.log(this.nextSibling.nextSibling);
  36.   //参数2： console.log(this.nextSibling.nextSibling.nextSibling.nextSibling)
  37. }
  38. div.findEleSibling(1);
  1. //作业5： JS创建HTML结构
  2. //div > ul > li class="list item" x 5
  3. var div = document.createElement('div'),
  4.   oList = document.createElement('ul'),
  5.   oFrag = document.createDocumentFragment();
  7. for (var i = 1; i <= 5; i++) {
  8.   var oLi = document.createElement('li');
  9.   oLi.innerHTML = i;
  10.   oLi.className = 'list-item';
  11.   oFrag.appendChild(oLi);
  12. }
  13. oList.appendChild(oFrag);
  14. div.appendChild(oList);
  16. console.log(div);
  1. //作业6：遍历一个父级元素下面所有的子元素节点(未完成)
  2. //递归
  3. Node.prototype.findAllElem = function () {
  4.   console.log(this);
  5.   // console.log(this.childNodes[1].childNodes[1]);
  6.   var elemList = [];
  8.   for (var i = 0; i < this.childNodes.length; i++) {
  9.     if (this.childNodes[i].nodeType === 1) {
  10.       elemList.push(this.childNodes[i]);
  11.       console.log(elemList);
  12.     }
  13.   }
  14. }
  16. div.findAllElem();
  1. function elemChildren(node) {
  2.   var temp = {
  3.     'length': 0,
  4.     'push': Array.prototype.push,
  5.     'splice': Array.prototype.splice
  6.   };
  8.   var children = node.childNodes,
  9.     len = children.length,
  10.     item;
  12.   for (var i = 0; i < len; i++) {
  13.     item = children[i];
  14.     if (item.nodeType === 1) {
  15.       temp.push(item);
  16.     }
  17.   }
  18.   return temp;
  19. }
  21. console.log(elemChildren(box)[1]);

事件流

作业1：

做列表 点击增加li 按钮

  1. 清空input框内容
  2. list列表后增加项
  1. <div>
  2.   <input type="text" id="add" />
  3.   <button class="addBtn">增加li</button>
  4.   <ul class="list">
  5.   </ul>
  6. </div>
  1. var oList = document.getElementsByClassName('list')[0],
  2.   oInput = document.getElementById('add'),
  3.   oBtn = document.getElementsByClassName('addBtn')[0];
  5. oBtn.addEventListener('click', function (e) {
  6.   var e = e || window.event,
  7.     tar = e.target || e.srcElement,
  8.     li = document.createElement('li');
  10.   li.innerHTML = oInput.value;
  11.   oList.appendChild(li);
  12.   oInput.value = '';
  13. }, false);

作业2：todolist

  1.   <div>
  2.     <input type="text" id="add" />
  3.     <button class="addBtn">增加li</button>
  4.     <ul class="list">
  6.     </ul>
  7.   </div>
  1. // 作业1
  2. // 做列表 点击增加li 按钮 
  3. //新增：
  4. //1.清空input框内容
  5. //2.list列表后增加项
  6. //编辑：
  7. //1.点击某一项把某项数据填到输入框文本域
  8. //2.点击按钮文本内容改为 编辑到第几项
  9. //3.点击按钮成功修改该项信息
  11. var oList = document.getElementsByClassName('list')[0],
  12.   oInput = document.getElementById('add'),
  13.   oBtn = document.getElementsByClassName('addBtn')[0],
  14.   isEdit = false,
  15.   inputValue = '',
  16.   idx;
  18. //动态创建的ul
  19. var oItems = document.getElementsByClassName('item');
  21. function init() {
  22.   bindEvent();
  23. }
  25. //事件绑定
  26. function bindEvent() {
  27.   //按钮事件
  28.   addEvent(oBtn, 'click', btnClick);
  29.   //列表事件：修改
  30.   addEvent(oList, 'click', edit);
  31.   //列表事件：删除
  32.   addEvent(oList, 'click', del);
  33. }
  35. function btnClick(e) {
  36.   //情况1：输入框为空不能点按钮
  37.   if (oInput.value.length === 0) {
  38.     return;
  39.   }
  41.   //去重
  42.   var _item;
  43.   //遍历对比li里面的text
  44.   for (var i = 0; i < oItems.length; i++) {
  45.     _item = oItems[i].innerText.split(' ')[0];
  46.     if (oInput.value === _item) {
  47.       alert('已存在该项目');
  48.       return;
  49.     }
  50.   }
  52.   // 新增/编辑
  53.   if (isEdit) {
  54.     //编辑
  55.     oItems[idx].innerHTML = tpl(oInput.value);
  56.     reset();
  57.     isEdit = false;
  58.   } else {
  59.     //新增
  60.     add();
  61.   }
  62. }
  64. // 新增操作
  65. function add() {
  66.   //增加操作: 1.获取输入框的文本值并保存至全局
  67.   inputValue = oInput.value;
  68.   //增加操作: 2.创建新的li节点并新增类名
  69.   var oLi = document.createElement('li');
  70.   oLi.className = 'item';
  71.   //增加操作: 3.把处理好的字符串赋值到Li的文本里
  72.   oLi.innerHTML = tpl(inputValue);
  73.   //增加操作: 4.将处理好的li逐条加入到ul里
  74.   oList.appendChild(oLi);
  75.   //重置输入框内容
  76.   reset();
  77.   isEdit = false;
  78. }
  80. //修改操作
  81. function edit(e) {
  82.   var e = e || window.event,
  83.     tar = e.target || e.srcElemnt;
  85.   //点击到编辑时才能进行下面操作：
  86.   if (tar.innerText === ' 编辑') {
  87.     //修改操作: 1.拿到被点击的当前li项
  88.     var oLi = elemParent(tar, 1),
  89.       //修改操作: 2.拿到被点击的当前li项里面的文本内容
  90.       text = oLi.innerText.split(' ')[0];
  91.     //修改操作: 3.将文本内容放到文本输入框里
  92.     oInput.value = text;
  94.     //修改操作: 4.找到该项索引值并修改按钮文本信息
  95.     idx = Array.prototype.indexOf.call(oItems, oLi);
  96.     oBtn.innerText = '修改第' + (idx + 1) + '项';
  98.     //激活可编辑状态
  99.     isEdit = true;
  100.     console.log('编辑状态：启用');
  101.   }
  102. }
  104. function del(e) {
  105.   var e = e || window.event,
  106.     tar = e.target || e.srcElemnt;
  108.   //点击到编辑时才能进行下面操作：
  109.   if (tar.innerText === ' 删除') {
  110.     //找到当前项
  111.     var oLi = elemParent(tar, 1);
  112.     //删除当前项
  113.     elemParent(oLi, 1).removeChild(oLi);
  114.   }
  115. }
  117. function tpl(text) {
  118.   return (
  119.     text +
  120.     '<a href="javascript:;" style="text-decoration: none;"> 编辑</a>' +
  121.     '<a href="javascript:;" style="text-decoration: none;"> 删除</a>'
  122.   )
  123. }
  125. function reset() {
  126.   oInput.value = '';
  127.   oBtn.innerText = '增加li'
  128. }
  130. function findNodeElem(elem, type) {
  131.   var _arrLike = {
  132.       'length': 0,
  133.       'push': Array.prototype.push,
  134.       'slice': Array.prototype.slice
  135.     },
  136.     children = elem.childNodes,
  137.     item;
  139.   for (var i = 0; i < children.length; i++) {
  140.     item = children[i];
  141.     if (item.nodeType === 1) {
  142.       _arrLike.push(item);
  143.     }
  144.   }
  145.   return _arrLike;
  146. }
  148. /**
  149.  * 封装兼容低版本的事件绑定处理函数
  150.  * @el 元素
  151.  * @type 事件类型
  152.  * @fn 事件处理函数
  153.  */
  154. function addEvent(el, type, fn) {
  155.   if (el.addEventListener) {
  156.     el.addEventListener(type, fn, false);
  157.   } else if (el.attachEvent) {
  158.     el.attachEvent('on' + type, function () {
  159.       fn.call(el);
  160.     })
  161.   } else {
  162.     el['on' + type] = fn;
  163.   }
  164. }
  166. /**
  167.  * 封装找父级元素的函数
  168.  * @node 子元素节点
  169.  * @n 寻找第几个父级元素
  170.  * @返回值 返回父级元素
  171.  */
  172. function elemParent(node, n) {
  173.   var type = typeof (n);
  175.   if (type === 'undefined') {
  176.     return node.parentNode;
  177.   } else if (n <= 0 || type !== 'number') {
  178.     return undefined;
  179.   }
  181.   while (n) {
  182.     node = node.parentNode;
  183.     n--;
  184.   }
  185.   return node;
  186. }
  188. init();

面试题

  1. var a = false + 1;
  2. console.log(a); //1
  1. var b = false == 1;
  2. console.log(b); //false
  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. }
  1. //1 + 15 = 16 == 16 -> true
  2. if (1 + 5 * '3' == 16) {
  3.   console.log('通过了');
  4. } else {
  5.   console.log('未通过');
  6. }
  8. //16(number) => true
  9. if (1 + 5 * '3' === 16) {
  10.   console.log('通过了');
  11. } else {
  12.   console.log('未通过');
  13. }
  1. //' ' = false -> !! -> true
  2. //'' = false -> !! -> flase
  3. //!!false -> false
  4. //true + false - false = 1 
  5. // 1 || '通过了' -> 1 
  6. console.log(!!' ' + !!'' - !!false || '通过了'); //1
  1. //(a, b) 只返回逗号后面
  2. var fn = (
  3.   function test1() {
  4.     return 1;
  5.   },
  6.   function test1() {
  7.     return '2';
  8.   }
  9. )();
  10. console.log(typeof (fn)); //string
  1. //(function b() {})为表达式忽略b所以没有b，所以为undefined
  2. //console.log(b)报错，但console.log(typeof (b))报undefined
  3. //typeof (undefined) => undefined
  5. var a = 10;
  6. if (function b() {}) {
  7.   a += typeof (b);
  8. }
  9. console.log(a); //10undefined
  1. //面试题
  2. function Foo() {
  3.   getName = function () {
  4.     console.log('111');
  5.   }
  6.   return this;
  7. }
  8. Foo.getName = function () {
  9.   console.log('222');
  10. }
  11. Foo.prototype.getName = function () {
  12.   console.log('333');
  13. }
  14. var getName = function () {
  15.   console.log('444');
  16. }
  18. function getName() {
  19.   console.log('555');
  20. }
  22. //输出结果
  23. Foo.getName(); //222
  24. getName(); //function getName(){console.log(444);}
  25. Foo().getName(); //111
  26. getName(); //111
  27. new Foo.getName(); //222
  28. new Foo().getName(); //333
  29. new new Foo().getName(); //333
  31. //解题过程
  32. /**
  33.  * GO = {
  34.  *   getName: undefined 
  35.  *            -> function getName(){console.log(555);}
  36.  *            -> function getName(){console.log(444);}
  37.  *            //执行Foo()
  38.  *            -> function getName(){console.log(111);}
  39.  * }
  40.  */
  1. //最先想到的办法:for循环
  2. function uniqueArr(array) {
  3.   //数组容器
  4.   var _arr = [],
  5.     isReapeat;
  6.   for (var i = 0; i < array.length; i++) {
  7.     //默认为false
  8.     isReapeat = false;
  9.     //遍历数组容器
  10.     for (var j = 0; j < _arr.length; j++) {
  11.       //证明重复了
  12.       if (_arr[j] == array[i]) {
  13.         //并定义为true
  14.         isReapeat = true;
  15.         //不能往_arr容器里增加元素
  16.         break;
  17.       }
  18.     }
  19.     //这里外层for循环仍会继续循环
  20.     //如需终止循环,声明变量isReapeat枷锁
  21.     if (!isReapeat) {
  22.       //在循环外push元素
  23.       _arr.push(array[i]);
  24.     }
  25.   }
  26.   return _arr;
  27. }
  29. console.log(uniqueArr(arr).sort());;
  30. //[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

笔试题

  1. /**
  2.  * 
  3.    AO = {
  4.      a: undefined -> function a() {}
  5.    }
  6.  */
  7. function test() {
  8.   return a;
  9.   a = 1;
  11.   function a() {}
  12.   var a = 2;
  13. }
  14. console.log(test()); //function a() {}
  1. /**
  2.  * GO = {
  3.  *   a: 1,
  4.  *   test: function test(){...}
  5.    }
  6.    AO = {
  7.      a: undefined -> function a() {} -> 2
  8.    }
  9.  */
  10. console.log(test()); //2
  11. function test() {
  12.   a = 1;
  14.   function a() {}
  15.   var a = 2;
  16.   return a;
  17. }
  1. /**
  2.  * GO = {
  3.  *   a: undefined -> 1,
  4.      test: function test(e){...},
  5.      f: 5
  6.    }
  7.    AO = {
  8.      a: undefined -> 4,
  9.      b: undefined,
  10.      c: undefined,
  11.      e: undefined -> 1 -> function e() {} -> 2
  12.    }
  13.  */
  14. a = 1;
  16. function test(e) {
  17.   function e() {}
  18.   arguments[0] = 2;
  19.   console.log(e); //2
  20.   //a: undefined -> false
  21.   if (a) {
  22.     var b = 3;
  23.     console.log(b); //不打印
  24.   }
  25.   var c;
  26.   a = 4;
  27.   var a;
  28.   console.log(b); //undefined
  29.   f = 5;
  30.   console.log(c); //undefined
  31.   console.log(a); //4
  32. }
  33. var a;
  34. test(1);
  35. console.log(a); //1
  36. console.log(f); //5
  1. function Test(a, b, c) {
  2.   var d = 1;
  3.   this.a = a;
  4.   this.b = b;
  5.   this.c = c;
  7.   function f() {
  8.     d++;
  9.     console.log(d);
  10.   }
  11.   this.g = f;
  12. }
  13. var test1 = new Test();
  14. test1.g(); //2
  15. test1.g(); //3
  16. var test2 = new Test();
  17. test2.g(); //2
  1. //x = 1
  2. //y = 0 
  3. //z = 0 
  4. /**
  5.  * GO = {
  6.  *   x: undefined -> 1,
  7.  *   y: undefined -> 0,
  8.  *   z: undefined -> 0,
  9.  *   add: function add(n){return n = n + 1;} 
  10.  *        -> function add(n){return n = n + 3;}
  11.  * }
  12.  */
  14. var x = 1,
  15.   y = z = 0;
  17. function add(n) {
  18.   return n = n + 1;
  19. }
  20. y = add(x); //y = 4
  22. function add(n) {
  23.   return n = n + 3;
  24. }
  25. z = add(x); //z = 4
  26. console.log(x, y, z); //1 4 4
  1. function foo1(x) {
  2.   console.log(arguments);
  3.   return x;
  4. }
  5. foo1(1, 2, 3, 4, 5); //可输出
  7. function foo2(x) {
  8.   console.log(arguments);
  9.   return x;
  10. }(1, 2, 3, 4, 5); //不可输出
  12. (function foo3(x) {
  13.   console.log(arguments);
  14.   return x;
  15. })(1, 2, 3, 4, 5); //可输出
  1. function b(x, y, a) {
  2.   a = 10;
  3.   console.log(arguments[2]); //10
  4. }
  5. b(1, 2, 3);
  6. //映射关系
  7. function b(x, y, a) {
  8.   arguments[2] = 10;
  9.   console.log(a); //10
  10. }
  11. b(1, 2, 3);
  1. //alibaba
  2. //console.log(arguments) => 空数组
  3. //bar() -> bar.call() -> bar(arguments)
  5. function foo() {
  6.   bar.apply(null, arguments);
  7.   //bar.call(arguments) -> bar(arguments) -> [1,2,3,4,5]
  8. }
  10. function bar() {
  11.   console.log(arguments); //1,2,3,4,5
  12. }
  13. foo(1, 2, 3, 4, 5);
  1. //alibaba
  2. function b(x, y, a) {
  3.   arguments[2] = 10;
  4.   alert(a); //10
  5. }
  6. b(1, 2, 3);
  1. var f = (function f() {
  2.   return '1';
  3. }, function g() {
  4.   return 2;
  5. })
  6. console.log(typeof f); //function
  8. var f = (function f() {
  9.   return '1';
  10. }, function g() {
  11.   return 2;
  12. })()
  13. console.log(typeof f); //number
  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
  22. //写一个isNaN()方法
  23. function isNaN1(num) {
  24.   //由于NaN谁也不等于所有把它变为'NaN'
  25.   var res = Number(num) + '';
  26.   if (res == 'NaN') {
  27.     return true;
  28.   } else {
  29.     return false;
  30.   }
  31. }
  33. isNaN1('abc'); //NaN
  34. console.log(isNaN1('abc')); //true
  35. console.log(isNaN1(123)); //false
  1. {} = {} ?
  2. //为什么不等于？
  3. //因为引用值地址不一样
  4. //如何相等？
  5. var obj = {}
  6. obj1 = obj;
  7. console.log(obj == obj1); //true
  1. var a = '1';
  3. function test() {
  4.   var a = '2';
  5.   this.a = '3';
  6.   console.log(a); //2 //2
  7. }
  8. test();
  9. new test();
  10. console.log(a); //3
  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. function test() {
  2.   console.log(foo); //undefined
  3.   var foo = 2;
  4.   console.log(foo); //2
  5.   console.log(a); //报错
  6. }
  7. test();
  1. function a() {
  2.   var test;
  3.   test();
  5.   function test() {
  6.     console.log(1); //1
  7.   }
  8. }
  9. a();
  10. //test: undefined -> fuction test(){}
  1. //alibaba
  2. function test() {
  3.   var marty = {
  4.     name: 'marty',
  5.     printName: function () {
  6.       console.log(this.name);
  7.     }
  8.   }
  10.   var test1 = {
  11.     name: 'test1'
  12.   }
  13.   var test2 = {
  14.     name: 'test2'
  15.   }
  16.   var test3 = {
  17.     name: 'test3'
  18.   }
  20.   test3.printName = marty.printName;
  22.   marty.printName.call(test1); //test1
  23.   marty.printName.apply(test2); //test2
  24.   marty.printName(); //marty
  25.   test3.printName(); //test3
  26. }
  27. test()
  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. function test(day) {
  3.   switch (day) {
  4.     case 1:
  5.       console.log('Mon');
  6.       break;
  7.     case 2:
  8.       console.log('Tue');
  9.       break;
  10.     case 3:
  11.       console.log('Wed');
  12.       break;
  13.     case 4:
  14.       console.log('Thur');
  15.       break;
  16.     case 5:
  17.       console.log('Fri');
  18.       break;
  19.     case 6:
  20.       console.log('Sat');
  21.       break;
  22.     case 7:
  23.       console.log('Sun');
  24.       break;
  25.     default:
  26.       console.log('I dont know');
  27.   }
  28. }
  30. // 写法一
  32. function test(day) {
  33.   var weekday = ['Mon', 'Tue', 'Wed', 'Thur', 'Fri', 'Sat', 'Sun'];
  35.   weekday[day - 1] !== undefined ? console.log(weekday[day - 1]) : console.log('i dont know')
  36. }
  37. test(-1)
  39. //写法二
  40. function test(day) {
  41.   var weekday = [, 'Mon', 'Tue', 'Wed', 'Thur', 'Fri', 'Sat', 'Sun'];
  43.   weekday[day] !== undefined ? console.log(weekday[day]) : console.log('i dont know')
  44. }
  45. test(2);
  1. //考点：预编译作用域闭包
  2. function Test(a, b, c) {
  3.   var d = 0;
  4.   this.a = a;
  5.   this.b = b;
  6.   this.c = c;
  8.   function e() {
  9.     d++;
  10.     console.log(d);
  11.   }
  12.   this.f = e;
  13. }
  14. var test1 = new Test();
  15. test1.f(); //1
  16. test1.f(); //2
  17. var test2 = new Test();
  18. test2.f(); //1
  1. //考点：类数组也是对象的一种形式
  2. function test() {
  3.   console.log(typeof (arguments)); //object
  4. }
  5. test();
  1. //考点：函数表达式忽略函数名
  2. var test = function a() {
  3.   return 'a';
  4. }
  5. test();
  7. console.log(typeof (a)); //undefined
  1. //考点：typeof(未声明变量) -> undefined 
  2. var test = function a() {}
  3. test();
  4. console.log(typeof (a)); //'undefined'