JS部分面试题和重要知识点汇总（更新中……）（一）

1. 10个常用的数组方法   

      push()       接受参数                       pop()     移除最后项                    shift() 删除第一项

       unshift()    返回数组的长度            reverse()   反转顺序                    slice()   指定下标数

       splice()   删除、插入和替换       indexOf()    查找下标              some()  一些元素

       lastIndexOf()  末尾开始向前查找         join()   分隔符        every()   每个元素

 

2. 10个常用的字符串方法

concat()           将两个或多个字符的文本组合起来，返回一个新的字符串。

charAt()           返回指定位置的字符。

indexOf()         返回字符串中一个子串第一处出现的索引。如果没有匹配项，返回 -1 。

match()            检查一个字符串是否匹配一个正则表达式。

substring()      返回字符串的一个子串。传入参数是起始位置和结束位置。

replace()          用来查找匹配一个正则表达式的字符串，然后使用新字符串代替匹配的字符串。

slice()               提取字符串的一部分，并返回一个新字符串。

split()               通过将字符串划分成子串，将一个字符串做成一个字符串数组。

toLowerCase()将整个字符串转成小写字母。

toUpperCase()将整个字符串转成大写字母。

search()           执行一个正则表达式匹配查找。如果查找成功，返回字符串中匹配的索引值。否则返回 -1 。

 

3. 存一个有效期为7天的cookie，key=nickname,val=Ace 并删除

 

// 设置cookie封装
function setCookie(key, value, expires){
	let now = new Date();
    now.setDate(now.getDate()+expires);
    document.cookie = `${key} = ${value}; expires= ${now.toUTCString()}`;
}


// 提取cookie封装

function getCookie(){
    let obj = {};
    let cookies = document.cookie.split('; ');
    cookies.forEach(r => {
        let kv = r.split('=');
        let key = kv[0];
        let val = kv[1];
        obj[key] = val;
    });
    if(key){return obj[key]}
    return obj
}

//删除cookie封装

function removeCookie(key){
    setCookie(key, null, -1)
}

方法2：

    
        // 创建cookie
        function createCookie(key,value,days) {
            let t = new Date();
            t.setDate(t.getDate() + days)
            document.cookie = `${key}=${value};expires=${t}`
        }


        // 获取cookie
        function getCookie(key) { 
            
            let arr = document.cookie.split("; ")
           
            for (let i = 0; i < arr.length; i++) {
                let arr2 = arr[i].split("=")
                if (arr2[0] == key) {
                    return arr2[1]
                } 
            }
        }

        // 删除cookie
        function removeCookie(key) { 
            let t = new Date();
            t.setDate(t.getDate() - 1)
            document.cookie = `${key}=;expires=${t}`
        }

4.获取地址栏 age=20&pirce=30&keywords=lv&cc=1 中的keywords参数的值

let obj={}
let str='age=20&pirce=30&keywords=lv&cc=1'
let keys=str.split('&')    //["age=20","pirce=30","keywords=lv","cc=1"]
keys.forEach(r=>{
    let kv=r.split('=')
    let key=kv[0];
    let val=kv[1];
    obj[key]=val;
})
conlose.log(obj.keywords)    //lv

 

5.获取30~40之间的一个随机数

 

Math.round(Math.random() *(40- 30 ) + 30)

 

6.如何获取当前是星期几，汉字

<script>
    
     //获取当前星期几
    function getWeekDate() {
       var now = new Date();
       var day = now.getDay();
       var weeks = new Array("星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六");
       var week = weeks[day];
       return week;
    }
    alert(getWeekDate());
  </script>

 

7.递归方式获取10以内数字的和

// for 求10以内数字的和
var sum=0
for ( var i =0; i < 10 ; i++ ) {
    sum = sum + i;
}
console.log(sum );  // 45
// 递归实现n个数字的和
function getSum (x) {
    if ( x ==1 ) {
       return 1;
    }
    return x + getSum ( x - 1 );
}
console.log(getSum( 10 - 1 ));  // 45

 方法二 

     <script > 
            function fun(num){ 
                if(num<0){ 
                    return 0; 
                }else{ 
                    return fun(num-1)+num; 
                } 
            } 
 alert("10以内的和的结果为："+fun(10)); 
        </script> 
  

 

8. 写一个补零函数，如 repairZero(8) 变成 “08”

 function repairZero(num) {
            num = num.toString()
            return num[1] ? num : ('0' + num)
        }
        console.log(repairZero(8));

 

9.写一个节流函数

  function throttle(func, wait) {

    let previous = 0;

    return function() {
        let now = +new Date();
        let context = this;

        if (now - previous >= wait) {
            func.apply(context, arguments);
            previous = now; // 执行后更新 previous 值
        }
    }
}


//实例
container.onmousemove = throttle(doSomething, 1000);

函数节流是什么

对于持续触发的事件，规定一个间隔时间（n秒），每隔一段只能执行一次。。

函数防抖一般是指对于在事件被触发n秒后再执行的回调，如果在这n秒内又重新被触发，则重新开始计时。

二者都能防止函数过于频繁的调用。

区别在于，当事件持续被触发，如果触发时间间隔短于规定的等待时间（n秒），那么

• 函数防抖的情况下，函数将一直推迟执行，造成不会被执行的效果；
• 函数节流的情况下，函数将每个 n 秒执行一次。

10.写一个防抖函数

// 思路:在规定时间内未触发第二次，则执行
function debounce (fn, delay) {
  // 利用闭包保存定时器
  let timer = null
  return function () {
    let context = this
    let arg = arguments
    // 在规定时间内再次触发会先清除定时器后再重设定时器
    clearTimeout(timer)
    timer = setTimeout(function () {
      fn.apply(context, arg)
    }, delay)
  }
}
 
function fn () {
  console.log('防抖')
}
addEventListener('scroll', debounce(fn, 1000))

 

11. 写一个函数，将{a:1,b:2}转换成a=1&b=2的字符串

 let zz = {a: 1,b: 2}
        //for- in 获取对象的属性
        function stringify(obj) {
            let arr = []
            for (let key in obj) {
                let val = obj[key]
                let str = key + '=' + val
                arr.push(str);
            }
            return arr.join('&')
        }

 

12.写一个函数，得到字符串 aabcdcacd中每个字符串的出现次数

<script>
 
	/*这个字符串中的每个字每出现了多少次*/
	var ary1 = "aabcdcacd";
	var obj = {};
	var i = 0;
 
 
	for(i = 0; i < ary1.length; i++)
	{
		key = ary1[i];
 
		if(obj[key])
		{
			//对象中有这个字母
			obj[key]++;
		}
		else
		{
			//对象中没有这个字母,把字母加到对象中
			obj[key] = 1;
		}
	}
 
	for(var key in obj) //遍历这个对象
	{
		console.log(key + "这个字母出现了" + obj[key] + "次");
	}
</script>

 

13.写一个函数，将数组中[11,22,11,32,22,4]去除重复

function noRepeat(arr){
	var newArr = [11,22,11,32,22,4]; //定义空的新数组
	for(var i=0; i<arr.length; i++){
		if(!has(newArr,arr[i])){ //如果不存在新数组中，将该元素追加到新数组中
			newArr.push(arr[i]);
		}
	}
	return newArr;
}

noRepert()

 

14.写一个函数，实现数组的join功能，如 _.join([1,2,3],'&')得到 1&2&3

          let arr = [1,2,3]

        // console.log(arr.join('---'));

        function join(code = '&') {
            let res = ''
            for (let i = 0; i < arr.length; i++) {
                res += arr[i]
                //如果不是最后一个元素，则拼接Code
                if (i < arr.length - 1) res += code
            }
            return res
        }

        let str = join()
        console.log(str);//1&2&3