前端题—数组去重、冒泡排序、防抖节流

js 数组去重

//数组去重
let arr=['12','32','89','12','12','78','12','32'];

//最简单数组去重
function unique1(arr){
    let newArr = []
    for(i = 0; i  {
      return self.indexOf(item) === index
  })
}

用js递归的方式写1到100求和

function add(num1,num2){
let num = num1+num2
if(num2+1 >100){
return num
}else{
return add(num,num2+1)
}
}
let sum = add(1,2)
console.log(sum)

JS找字符串中出现最多的字符

//forEach
var mystring= 'gudigudigggudi';
var arr = mystring.split('')
var maxNum = 0;
var maxName = ''
const obj = {}
console.log(arr)
arr.forEach(function(el){
    obj[el] ? obj[el]++ : obj[el] = 1
})
console.log(obj)
for(num in obj){
    if(obj[num] > maxNum){
        maxNum = obj[num]
        maxName = num
    }
}
console.log(maxName,maxNum)

//ES6 reduce
var mystring= 'gudigudigggudi';
var maxNum = 0;
var maxName = ''
let obj = mystring.split('').reduce(function(res, cur) {
res[cur] ? res[cur] ++ : res[cur] = 1
return res;
}, {})
console.log(obj)
for(num in obj){
if(obj[num] > maxNum){
maxNum = obj[num]
maxName = num
}
}
console.log(maxName,maxNum)

封装函数将字符串进行驼峰命名

function toStr1(str){
var arr = str.split('')
arr.forEach(function (el,index) {
if(arr[index] === "-"){
arr[index+1] = arr[index+1].toUpperCase()
}
})

return arr.toString().split('-').join('')
}
console.log(toStr1("get-element-by-id"))

function toStr2(str){
var arr = str.split('-')
for(i = 1; i

冒泡排序

冒泡排序

var arr = [5,4,3,2,1]
for(var i = 0; i arr[j+1]){
var temp = arr[j]
arr[j] = arr[j+1]
arr[j+1] = temp
}
}
}
console.log(arr);



arr.sort(function(a,b){
return a-b
})
console.log(arr)

反转数组

反转数组

var arr = [1,2,3,4,5,6,7,8]
for(var i = 0; i

实现一个防抖函数

//防抖函数：一个需要频繁触发的函数，在规定时间内，只让最后一次生效，前面的不生效
function debounce(fn,delay) {
var timer = null;
//清除上一次延时器
return function(){
clearTimeout(timer);
//重新设置新的延时器
timer = setTimeout(function(){
fn.apply(this)
},delay)
}
}
function ff2() {
console.log('防抖')
}
document.getElementById('box2').onclick = debounce(ff2,500)

实现一个节流函数

有个需要频繁触发的函数，出于优化性能角度，在规定时间内，只让函数触发的第一次生效，后面不生效

*/

/* 节流函数
@param fn 要被节流的函数
@param delay 规定的时间
*/
function throttle(fn,delay){
//记录上一次函数触发的时间
var lastTime = 0;
//记录当前函数触发的时间
return function(){
var nowTime = Date.now();
if(nowTime - lastTime > delay){
//修正this指向问题
fn.call(this);
lastTime = nowTime
}
}
}
function ff() {
console.log('节流')
}
document.getElementById('box').onclick = throttle(ff,1000)
addEventListener('scroll', throttle(ff, 1000))


// 进阶版：开始执行、结束执行
function throttle(fn, delay) {
var timer = null
var prev = Date.now()
return function(...args) {
var that = this
var remaining = delay - (Date.now() - prev) // 剩余时间
if (remaining <= 0) { // 第 1 次触发
fn.apply(that, args)
prev = Date.now()
} else { // 第 1 次之后触发
timer && clearTimeout(timer)
timer = setTimeout(function() {
fn.apply(that, args)
}, remaining)
}
}
}

function fn () {
console.log('节流')
}
addEventListener('scroll', throttle(fn, 1000))