一、封装myUnshift方法

1.1、利用循环

  1.         // 封装myUnshift方法
  2.         // 方法一
  3.         Array.prototype.myUnshift = function(){
  4.             var pos = 0;
  6.             for(var i = 0; i < arguments.length; i++){
  7.                 this.splice(pos, 0, arguments[i]);
  8.                 pos++;
  9.             }
  11.             return this.length;
  12.         }
  14.         var arr = [3, 4, 5];
  15.         arr.myUnshift(1, 2);
  16.         console.log(arr);

1.2、把类数组转换为数组，然后借用数组拼接的方法

  1.         // 封装myUnshift方法
  2.         // 方法二: 把类数组转换为数组，然后借用数组拼接的方法
  3.         Array.prototype.myUnshift = function(){
  4.             var argArr = Array.prototype.slice.call(arguments);
  5.             var newArr = argArr.concat(this);
  6.             return newArr;
  7.         }
  9.         var arr = [3, 4, 5];
  10.         console.log(arr.myUnshift(1, 2));

二、数组元素按照字节数排序

  • unicode 0~255 是一个字节；255~是两个字节 ```javascript

    1.   // 数组元素按照字节数排序
    2.   // unicode 0~255 是一个字节；255~是两个字节
    3.   function getBytes(str){
    4.       var bytes = str.length;
    6.       for(var i = 0; i < str.length; i++){
    7.           if(str.charCodeAt(i) > 255){
    8.               bytes++;
    9.           }
    10.       }
    12.       return bytes;
    13.   }
    15.   var arr = ['我爱你', 'OK', 'Hello', '你说WHAT'];
    16.   arr.sort(function(a, b){
    17.       return getBytes(a) - getBytes(b);
    18.   });
    20.   console.log(arr)
  1. <a name="FsRhe"></a>
  2. # 三、封装myTypeof方法
  4. - typeof返回的结果：'number' / 'string' / 'boolean' / 'undefined' / 'object' / 'function'
  5. - 万能数据类型检测：Object.prototype.toString.call
  6. ```javascript
  7.         // 封装myTypeof方法
  8.         // typeof返回的结果：'number' / 'string' / 'boolean' / 'undefined' / 'object' / 'function'
  9.         // 万能数据类型检测：Object.prototype.toString.call
  10.         function myTypeof(val){
  11.             var type = typeof(val),
  12.                     toStr = Object.prototype.toString,
  13.                     res = {
  14.                         '[object Array]': 'array',
  15.                         '[object Object]': 'object',
  16.                         '[object Number]': 'object number',
  17.                         '[object String]': 'object string',
  18.                         '[object Boolean]': 'object boolean'
  19.                     }
  21.             if(val === null){
  22.                 return 'null';
  23.             }else if(type === 'object'){
  24.                 var ret = toStr.call(val);
  25.                 return res[ret];
  26.             }else{
  27.                 return type;
  28.             }
  29.         }
  31.         console.log(myTypeof(null));
  32.         console.log(myTypeof(undefined));
  33.         console.log(myTypeof(new Number(1)));
  34.         console.log(myTypeof([]));
  35.         console.log(myTypeof(function(){}));

四、封装一个数组去重的方法

  • 新建一个空对象
  • 新建一个空数组

  • 循环要去重的数组，利用对象属性名不能重复的特性，来实现数组去重

    1.       // 封装一个数组去重的方法
    2.       // 新建一个空对象
    3.       // 新建一个空数组
    4.       // 利用对象属性名不能重复的特性，来实现数组去重
    5.       Array.prototype.unique = function(){
    6.           var temp = {},
    7.                   newArr = [];
    9.           for(var i = 0; i < this.length; i++){
    10.               if(!temp.hasOwnProperty(this[i])){
    11.                   temp[this[i]] = this[i];
    12.                   newArr.push(this[i]);
    13.               }
    14.           }
    16.           return newArr
    17.       }
    19.       var arr = [1,1,1,2,2,3,4];
    20.       var res = arr.unique();
    21.       console.log(res);

    五、封装一个方法实现字符串去重

    1.       // 封装一个方法实现字符串去重
    2.       String.prototype.unique = function(){
    3.           var temp = {},
    4.                   newStr = '';
    6.           for(var i = 0; i < this.length; i++){
    7.               if(!temp.hasOwnProperty(this[i])){
    8.                   temp[this[i]] = this[i];
    9.                   newStr += this[i];
    10.               }
    11.           }
    13.           return newStr
    14.       }
    16.       var str = 'nnnooooolllllltttlyyy';
    17.       console.log(str.unique(str));

    六、百度外卖面试题

  • 找到第一次出现不重复的字母

    1.       // 找到第一次出现不重复的字母
    2.       var str = 'ajahfdjsabljdfbalgfq';
    3.       function firstAppear(str){
    4.           var temp = {};
    6.           for(var i = 0; i < str.length; i++){
    7.           if(temp.hasOwnProperty(str[i])){
    8.               temp[str[i]]++;
    9.           }else{
    10.               temp[str[i]] = 1;
    11.           }    
    12.       }
    14.       for(var key in temp){
    15.           if(temp[key] === 1){
    16.               return key;
    17.           }
    18.       }
    19.   }
    21.   var res = firstAppear(str);
    22.   console.log(res);

    七、优化下面程序

    ```javascript

    1.   // 优化下面程序
    2.   function test(day){
    3.       switch(day){
    4.           case 1:
    5.               console.log('周一');
    6.               break;
    7.           case 2:
    8.               console.log('周二');
    9.               break;
    10.           case 3:
    11.               console.log('周三');
    12.               break;
    13.           case 4:
    14.               console.log('周四');
    15.               break;
    16.           case 5:
    17.               console.log('周五');
    18.               break;
    19.           case 6:
    20.               console.log('周六');
    21.               break;
    22.           case 7:
    23.               console.log('周日');
    24.               break;
    25.           default:
    26.               console.log('我不知道');
    27.       }
    28.   }
    30.   test(1);
    31.   test(9);
    33.   // 数组边界的判断
    34.   var arr = [1,2,3,4];
    35.   console.log(arr[4]);
    37.   // 利用数组来优化
    38.   function week(day){
    39.       var weekArr = ['周一','周二','周三','周四','周五','周六','周日'];
    40.       weekArr[day-1] !== undefined ?
    41.                                                                   console.log(weekArr[day-1])
    42.                                                                   :
    43.                                                                   console.log('我不知道');
    44.   }
    46.   week(1);
    47.   week(6);
    48.   week(9);
    50.   // 现在我不想用day-1的形式，想传入什么就数组星期几，利用数组的特性应该怎么做？
    51.   // 稀松数组：数组不一定每一项都需要值
    52.   function week(day){
    53.       var weekArr = [,'周一','周二','周三','周四','周五','周六','周日'];
    54.       weekArr[day] !== undefined ? 
    55.                                                            console.log(weekArr[day])
    56.                                                            :
    57.                                                            console.log('我不知道');
    58.   }
    60.   week(1);
    61.   week(6);
    62.   week(9);

```