JavaScript系列—常见数组编程题

1.数组去重

以下介绍三种写法

    /* ES6去重 */
    var arr = [1, 2, 2, 3];
    var set = new Set(arr);
    var newArr = Array.from(set);

    /* es5去重 */
    function uniq(arr) {
      let temp = [];
      for (var i = 0; i < arr.length; i++) {
        if (temp.indexOf(arr[i]) === -1) {
          temp.push(arr[i]);
        }
      }
      return temp;
    }

    /* reduce去重 */
    let arr = [1,2,3,3]
    arr.reduce((prev,cur) => {
      if(prev.indexOf(cur) === -1){
        prev.push(cur)
      }
      return prev
    },[])

2.数组求和

  <script>
    var arr = [1, 2, 2, 3];

    /* es5求和 */
    function sumArr(arr) {
      let sum = 0;
      for (let i = 0; i < arr.length; i++) {
        sum += arr[i]
      }
      return sum;
    }
    sumArr(arr)

    /* reduce求和 */
    arr.reduce((prev,cur) => {
      return prev + cur;
    },0)
    
  </Script>

3.求数组项最大值

    /* 常规办法 */
    var arr = [1, 2, 2, 3];
    function sumArr(arr) {
      let max = arr[0];
      for (let i = 1; i < arr.length; i++) {
        if (arr[i] > max) {
          max = arr[i]
        }
      }
      return max
    }
    sumArr(arr)
    /* es6扩展运算符 */
    var arr = [1, 2, 2, 3];
    function getMax(arr) {
      return Math.max(...arr)
    }
    getMax(arr)

    /* reduce数组最大值 */
    var arr = [1, 2, 2, 3];
    arr.reduce((prev, cur) => {
      return Math.max(prev, cur);
    })

4.判断一个字符串出现次数最多的字符，并统计这个次数

  <script>
    /* 找到字符串中出现次数最多的字符，并统计这个次数 */
    /* str.charAt() 方法可返回指定位置的字符。 */

    function getJson(str) {
      let json = {}
      for (let i = 0; i < str.length; i++) {
        let key = str.charAt(i);  //当前的字母
        if (!json[key]) {
          // 假如json里面还不存在这个值
          json[key] = 1;
        } else {
          // 假如json里面已经存在这个值
          json[key] += 1;
        }
      }
      return json;
    }

    /* 接下来找出来这个出现次数最多的值以及次数 */
    function getRes(json) {
      let charMax = '';
      let nMax = 0;
      let tmpArr = Object.keys(json);
      for (let i of tmpArr) {
        if (nMax < json[i]) {
          nMax = json[i];
          charMax = i;
        }
      }
      return [charMax, nMax]
    }
    debugger;
    let str = "abbbccccd";
    let json = getJson(str);
    let res = getRes(json)
    console.log(res);

  </Script>

5.求一个字符串的字节长度

    // js获取一个字符串的字节长度
    // 因为中文字占两个字节，英文占一个字节。
    function getLen(str) {
      // 假如有中文字符那么就替换成两个 英文字符（aa）
      str = str.replace(/[\u4e00-\u9fa5]/g,"aa");
      return str.length;
    }
    getLen('我是a');

6.字符串转驼峰

  <script>
    /* 首先用'-'拆成数组，然后首字母大写，截取第二个位置以后的字符，连接起来 
    stringObject.substring(1)  表示从第二个字符开始，包括第二个字符*/

    var str = 'document-redeay-window';
    changeCamel(str);
    function changeCamel(str) {
      let arr = str.split('-');
      for (var i = 0; i < arr.length; i++) {
        arr[i] = arr[i].charAt(0).toUpperCase() + arr[i].substring(1);
      }
      return arr.join('');
    }
  </Script>

7.用js实现trim()方法

trim()去除字符串的头尾空格:

  <script>
    /* 
    arrayObject.slice(start,end)  返回一个新的数组，包含从 start 到 end （不包括该元素）的 arrayObject 中的元素。
     */

    let str1 = "   jjsun   ";
    console.log(custTrim(str1));
    function custTrim(str){
      let start = 0;
      let end = 0;

      for (let i = 0; i < str.length; i++) {
        if (str[i] != ' ') {
          start = i;
          break;//跳出循环
        }
      }

      for (let i = str.length-1; i > 0; i--) {
        if (str[i] != ' ') {
          end = i+1;
          break;
        }
      }

      return str.slice(start, end);
    }
  </script>

8.add(1)(2)(3)()

首先实现一个定制版的

    function add(a){
      let sum = 0;
      sum += a;
      return (b)=>{
        sum+=b
        return (c) => {
          sum+=c;
          return sum
        }
      }
    }

    add(1)(2)(3)

-------------------------------------------------------------------------------------------
    function add(a){
      let sum = 0;
      sum += a;
      return (b)=>{
        sum+=b
        return (c) => {
          sum+=c;
          return () => {
            return sum
          }
        }
      }
    }


    add(1)(2)(3)()

输出为6

add(1)(2)(3)()做成扩展性的

    function add(a){
      let sum = 0;
      sum += a
      return function tmp(b){
        if(arguments.length === 0){
          return sum
        }else{
          sum += b;
          return tmp;
        }
      }
    }

    add(1)(2)(3)()

9.实现一个深拷贝

    var obj = {
      a:1,
      c:{
        c1:1,
        c2:2
      }
    };

    /* 
    hasOwnProperty
    用法：obj.hasOwnProperty(key) //obj为对象 key为所要判断的字符串
    判断一个对象属性里是否包含某个key，key为字符串,此方法不会去判断原型
     */


    function deepCopy(obj){
      let newObj = Array.isArray(obj)?[]:{};
      for(let i in obj){
        // if(obj.hasOwnProperty(i)){
        if(Object.prototype.hasOwnProperty.call(obj,i)){
          if(typeof(obj[i]) === 'object'){
            newObj[i] = deepCopy(obj[i])
          }else{
            newObj[i] = obj[i]
          }
        }
      }
      return newObj
    }

    let c = deepCopy(obj);
    console.log(c)

上面为什么要这么判断呢，因为

注意4：存在性

如何在不访问属性值的情况下判断对象中是否存在某个属性呢，看下面的代码。

// 木易杨
var anotherObject = {
    a: 1
};

// 创建一个关联到 anotherObject 的对象
var myObject = Object.create( anotherObject );
myObject.b = 2;

("a" in myObject); // true
("b" in myObject); // true

myObject.hasOwnProperty( "a" ); // false
myObject.hasOwnProperty( "b" ); // true

这边使用了 in 操作符和 hasOwnProperty 方法，区别如下（你不知道的JS上卷 P119）：

1、in 操作符会检查属性是否在对象及其 [[Prototype]] 原型链中。

2、hasOwnProperty(..) 只会检查属性是否在 myObject 对象中，不会检查  [[Prototype]] 原型链。

Object.assign 方法肯定不会拷贝原型链上的属性，所以模拟实现时需要用hasOwnProperty(..) 判断处理下，但是直接使用 myObject.hasOwnProperty(..)是有问题的，因为有的对象可能没有连接到 Object.prototype 上（比如通过Object.create(null) 来创建），这种情况下，使用myObject.hasOwnProperty(..) 就会失败。

// 木易杨
var myObject = Object.create( null );
myObject.b = 2;

("b" in myObject); 
// true

myObject.hasOwnProperty( "b" );
// TypeError: myObject.hasOwnProperty is not a function

解决方法也很简单，使用我们在【进阶3-3期】中介绍的 call 就可以了，使用如下。

// 木易杨
var myObject = Object.create( null );
myObject.b = 2;

Object.prototype.hasOwnProperty.call(myObject, "b");
// true