js 数组去重
//数组去重
let arr=['12','32','89','12','12','78','12','32'];
//最简单数组去重
function unique1(arr){
let newArr = []
for(i = 0; i <arr.length; i++){
if(newArr.indexOf(arr[i]) === -1){
newArr.push(arr[i])
}
}
return newArr
}
arr = unique1(arr)
console.log(arr)
//数组下标判断法
let arr=['12','32','89','12','12','78','12','32'];
function unique2(array){
var n = [array[0]]; //结果数组
for(var i = 1; i < array.length; i++) { //从第二项开始遍历
if (array.indexOf(array[i]) == i)
n.push(array[i]);
}
return n;
}
arr = unique2(arr)
console.log(arr)
//es6方法数组去重
arr = [...new Set(arr)];
console.log(arr)
//es6方法数组去重，第二种方法
arr = Array.from(new Set(arr)); //Array.from()能把set结构转换为数组
console.log(arr)
//通过filter去重
function unique3(arr){
return arr.filter((item, index, self) => {
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<arr.length; i++){
arr[i] = arr[i].charAt(0).toUpperCase() + arr[i].substr(1, arr[i].length-1)
}
return arr.join('')
}
console.log(toStr2("get-element-by-id"))
冒泡排序
冒泡排序
var arr = [5,4,3,2,1]
for(var i = 0; i<arr.length-1; i++){
for(var j = 0; j<arr.length-1-i; j++){
if(arr[j] > 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<arr.length/2; i++){
var j = arr.length-1-i
var temp = arr[i]
arr[i] = arr[j]
arr[j] = temp
}
console.log(arr)
实现一个防抖函数
//防抖函数：一个需要频繁触发的函数，在规定时间内，只让最后一次生效，前面的不生效
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))
