js中简单算法

1、删除数组中所有的假值，

false,null,0,'',undefined,NaN
let falseValue =function(arr){
    let newArr=[];
    arr.forEach((item)=>{
        if(Boolean(item)){
           newArr.push(item)
        }
    })
    return newArr
}
console.log('去掉假值',falseValue([1,'',null,5,undefined,NaN]))

删除数组中指定对象
delete(record) {
      let key = record.key
      let index
      for (let i = 0; i < this.loadData.length; i++) {
        if (this.loadData[i].key == key) {
          index = i
          this.loadData.splice(index, 1)
        }
      }
    },

2、 如果数组的第一个字符串元素包含了第二个字符串元素的所有字符，返回true

let contain = function(arr){
            let astr= arr[0].toLowerCase();    //忽略大小写
            let bstr=arr[1].toLowerCase();
            for(let i=0;i<bstr.length;i++){   //遍历第二个字符串中的元素
                if(astr.indexOf(bstr[i])==-1){   //indexOf()区分大小写
                    return false
                }
                // else{
                //     return true   //如果bstr中字符在astr中，直接返回true,不往后执行
                // }
            }
            return true
        }
        console.log('11',contain(['sdgra','Ast']))

3、返回一个数组被截断n个元素后还剩余的元素，截断从索引0开始
//splice(a,b)(b包含)返回一个数组，该数组包含从原数组中删除的项

let jieduan=function(arr,size){   //size是删除的元素个数
         let len=arr.length;
         if(size == 0){
             return arr;
         }else{
             return arr.splice(size,len)
         }
     }
     console.log(jieduan([1,2,3,4,5,6,7,8],0))

4、把一个数组arr按照指定的数组大小size分割成若干个数组块

let segmentation=function(arr,size){
     let newArr=[];
     for(let i=0;i<arr.length;i+=size){
         newArr.push(arr.slice(i,i+size));
     }
     return newArr;
 }
 console.log(segmentation([1,2,3,4,5,6,7],2))

5、截断字符串，如果字符串长度比指定参数num长，把多余部分用…来表示
//slice(a,b)(b不包含)提取字符串的一部分，并返回这个新的字符串

let interception=function(str,num){
       let len=str.length;
       let astr = str.slice(0,num-3);
       let bstr = str.slice(0,num);
       if(len >num){
           if(num<3){
               return bstr +'...'
           }else{
               return astr +'...'
           }
       }else{
           return str;
       }
   }
   console.log(interception('1562486vfgmkmn',3))

6、重复一个字符串n次，n为负数返回一个空字符串

let repeat =function(str,num){
    let astr= str;
    if(num<0){
        return ''
    }else{
        for(let i=0;i<num-1;i++){   //str自身相当于实现了一次循环
            str += astr
        }
        return str;
    }
}
console.log(repeat('axd',3))

7、整数的阶乘

let jiecheng = function(num){
      if(num<1){
          return 1;
      }else{
          return num*jiecheng(num-1)   //递归
      }                                
  }
  console.log(jiecheng(5))

8、随机生成指定长度的字符串

let randomString = function(n){
  let str ='12jg5g24y5t24y5ergthyjyjgg454hggh';
  let temp='',
  l=str.length;
  for(let i=0;i< n;i++){   //每次获取一个字符，循环n次
      temp += str.charAt(Math.floor(Math.random()*l))
  }
  return temp;
}
console.log(randomString(6))

9、 找出正整数的最大差值(也可以先给数组排序，用最大值-最小值)

let differenceValue=function(arr){
    let min=arr[0];  //最小值
    let maxDiffrernce=0;   //最大差值
    for(let i=0;i<arr.length;i++){
        let temp=arr[i];
        min=Math.min(min,temp);
        let potential = temp -min;   //差值
        maxDiffrernce=Math.max(potential,maxDiffrernce)
    }
    return maxDiffrernce;
}
console.log(differenceValue([1,5,2,3,6,9]))

10、不借助临时变量，进行两个整数的交换

let palindrome=function(a,b){
       a=a-b;
       b=a+b;
       a=b-a;
       return [a,b]
   }
   console.log(palindrome(5,9))

11、数组去重

quchong(){
    /**
     * indexof()检索该值在数组中是否存在，不存在返回-1
     */
    let arr=[];
    this.arr1.forEach((item)=>{
        if(arr.indexOf(item)=== -1){
            arr.push(item)
        }
    })
    return arr;
}

对象数组去重
unique(arr) {
const res = new Map()
return arr.filter((arr) => !res.has(arr.specialColumnCourseId) && res.set(arr.specialColumnCourseId, 1));
},
12、将xiaoshuo-ss-sfff-fe转化XiaoshuoSsSfffFe

toTuofeng(){
     let arr=[];
     let str = '';
     this.str1.split('-').forEach((item)=>{
         //charAt() 方法用于返回指定索引处的字符，从0到length-1
         //item.charAt(0).toUpperCase()每个单词的首字母（大写）
         return arr.push(item.charAt(0).toUpperCase() +item.slice(1))   
     })
     arr.forEach((item)=>{
         str += item;
     })
    return str;
 }

13、求出字符串中出现次数最多的字符

frequent (){
    let temp=this.str2.split('').reduce((pre,item)=>{
        if(item in pre){
            pre[item] ++
        }else{
            pre[item] = 1
        }
        return pre   //统计每个字符出现的次数
    },{})
    let maxNum=0;
    let maxChar ='';
   for(let key in temp){
      if(temp[key] > maxNum){
          maxChar = key;
          maxNum = temp[key]
        }
    }
    return maxChar;
}

14、 字符串反转

reverse(){
   //join() 字符件逗号隔开  join('')字符间没有特殊字符隔开
   return this.str2.split('').reverse().join('')   
}

15、 深拷贝

deepCopy(){
   if(typeof this.arr2 !== 'object'){
       return ''
   }else{
       let objString = JSON.stringify(this.arr2);
       return JSON.parse(objString)
   }
}

深复制和浅复制最根本的区别在于是否是真正获取了一个对象的复制实体，而不是引用。
深拷贝和浅拷贝是只针对Object和Array这样的引用数据类型的。
浅复制 —-只是拷贝了基本类型的数据，而引用类型数据，复制后也是会发生引用，我们把这种拷贝叫做“（浅复制）浅拷贝”，换句话说，浅复制仅仅是指向被复制的内存地址，如果原地址中对象被改变了，那么浅复制出来的对象也会相应改变。
深复制 —-在计算机中开辟了一块新的内存地址用于存放复制的对象。
通俗一点理解就是浅拷贝出来的数据并不独立，如果被复制的对象改变了，那么浅拷贝的对象也会改变，深拷贝之后就会完全独立，与浅拷贝断绝关系。
16、浅拷贝

copy(){
    return Object.assign(this.arr2);
}

17、合并多个有序数组（将二维数组转化为一维数组）

 concat(){
      //不考虑去重
      let newArr = this.arr3.reduce((pre,item)=>{
          return pre.concat(item)
      },[])
      //考虑去重
      let temp = newArr.reduce((pre,item)=>{
          if(!pre.includes(item)){
             return pre.concat(item)
          }else{
              return pre
          }
      },[])
      return temp;
      // return newArr
  }

18、 数组排序(从小到大)

sor1(){
     let arrs =this.arr2.sort((m,n)=>{
         if(m.value>n.value){  //数组中对象的排序
             //当判断的条件为m>n时，返回m-n是从小到大排序，返回n-m是从大到小排序
             return (n.value-m.value)
         }
     })
     return arrs;
 }

19、判断单词是不是回文

palindrome(){
   let str ='mamam';
   return str == str.split('').reverse().join('');
}

20、数组的filter()方法

let shaixuan = function(arr,num){
      return arr.filter((item)=>{
          return item > num
      })
  }
  console.log(shaixuan([1,5,6,2,6,8,8,5],4))

21、数组的map()方法

let pingfang = function(arr){
      return arr.map((item)=>{
          return item*item
      })
  }
  console.log(pingfang([1,5,6,2,6,8,8,5]))

22、将数组（对象数组）倒序

var achearr=[1,2,3,4];
var bchearr=[];
//方法1：
for (var i = 0; i <=achearr.length;i++) {
bchearr.push(achearr.pop());
}
bchearr.push(achearr[0]);
console.log(bchearr)
 

 //方法2：
for (var i = 0; i <= achearr.length; i++) {
var a=i;
var b=i+1;
bchearr.sort(function (a, b) {
return a- b
})
}
console.log(bchearr)