web前端总结面试问题<经常遇到的手写代码>

冒泡排序

var arr = [5,8,3,6,9]
	for(var i=0;i<arr.length;i++){
	 for(var j=i+1;j<arr.length;j++){
	 	 if(arr[i]>arr[j]){
	 	 	var temp
	 	 	temp=arr[i];
	 	 	arr[i]=arr[j];
	 	 	arr[j]=temp;
		 	 }

		 }
	}
	 console.log(arr)

//temp是中间变量，把要交换的第一个元素arr[j]赋值给中间变量，也是把第一个元素存储起来

//第二个元素赋值给第一个元素，因为第一个元素我们已经存储在中间变量中了，所以我们不用担心它的值会被覆盖掉

//temp存储了第一个元素的值，把它赋值给第二个元素，就是把第一个元素赋值给第二个元素了，到这一步，两个元素已经交换位置了

编程实现IndexOf方法

	var brr=[5,9,6,3,2,5];
		function indexfun(arr,val){
			for(var i=0;i<arr.length;i++){
				if(arr[i]==val){
					return i;
				}
			}
			return -1;
		}
		console.log(indexfun(brr,13));

写一个方法实现parseInt函数 将字符串转化成整型

function _parseInt(str, radix) {
        let str_type = typeof str;
        let res = 0;
        if (str_type !== 'string' && str_type !== 'number') {
        // 如果类型不是 string 或 number 类型返回NaN
            return NaN
        }
        // 字符串处理
        str = String(str).trim().split('.')[0]
        let length = str.length;
        if (!length) {
            // 如果为空则返回 NaN
            return NaN
        }
        if (!radix) {
            // 如果 radix 为0 null undefined
            // 则转化为 10
            radix = 10;
        }
        if (typeof radix !== 'number' || radix < 2 || radix > 36) {
            return NaN
        }
        for (let i = 0; i < length; i++) {
            let arr = str.split('').reverse().join('');
            res += Math.floor(arr[i]) * Math.pow(radix, i)
        }
        return res;
    }

编写一个函数，将url后的参数串解析成hash形式的对象、

var url = "http://www.taobao.com/index.php?key0=0&key1=1&key2=2...";
        var obj = parseQueryString(url);
        console.log(obj)
        function parseQueryString(argu){
        　　var str = argu.split('?')[1];
        　　var result = {};
        　　var temp = str.split('&');
       　　 for(var i=0; i<temp.length; i++){
            var temp2 = temp[i].split('=');
            result[temp2[0]] = temp2[1];
        　　}
       　　 return result;
        }

将首字母大写

function titleCase(str){
            var a = str.toLowerCase().split(' ');
            var b = a.map(function(val){return val.replace(val.charAt(0),val.charAt(0).toUpperCase())})
            return b.join(' ');
        }

　　

求二维数组所有数的和(封装函数)

function sum(arr){
　　var total=0;
　　for(var i=0;i<arr.length;i++){
　　　　for(var j=0;j<arr[i].length;j++){
　　　　　　total+=arr[i][j]
　　　　}
　　}
　　return total;
}

编写一个方法 求一个字符串的字节长度

假设： 

一个英文字符占用一个字节，一个中文字符占用两个字节 

function GetBytes(str){
    var len = str.length;
    var bytes = len;
    for(var i=0; i<len; i++){
        if (str.charCodeAt(i) > 255) bytes++;
    }
    return bytes;
}
alert(GetBytes("你好,as"));

编写一个方法 去掉一个数组的重复元素 

var arr = [1 ,1 ,2, 3, 3, 2, 1];
Array.prototype.unique = function(){
    var ret = [];
    var o = {};
    var len = this.length;
    for (var i=0; i<len; i++){
        var v = this[i];
        if (!o[v]){
            o[v] = 1;
            ret.push(v);
        }
    }
    return ret;
};
alert(arr.unique());

千分符

var str2=46548978911;
        function qianff(str){
            var strn=str.toString(),
                len=strn.length,
                ind=len%3,
                //console.log(strn)
                newstr=strn.substr(0,ind);
                console.log(newstr);
                if(ind==0){
                   newstr=strn.substr(0,3);
                    ind=3;
                    //console.log(newstr);
                }
                for(i=ind;i<len;i=i+3){
                  newstr+=","+strn.substr(i,3);
                }
                return newstr;
        }
        console.log(qianff(str2))

快速排序

        function quickSort(arr){
            //如果数组<=1,则直接返回
            if(arr.length<=1){return arr;}
            var pIndex=Math.floor(arr.length/2);
            //找基准，并把基准从原数组删除
            var result=arr.splice(pIndex,1);
            //定义左右数组
            var left=[];
            var right=[];

            //比基准小的放在left，比基准大的放在right
            for(var i=0;i<arr.length;i++){
                if(arr[i]<=result){
                    left.push(arr[i]);
                }
                else{
                    right.push(arr[i]);
                }
            }
            //递归
            return quickSort(left).concat(result,quickSort(right));
        }
        console.log(quickSort([1,89,56,4,2,2]))

输出执行顺序：

Promise代码then之前的代码会立即执行。

then之后会放入微任务执行
then里边的代码是回调
交给异步模块处理

　　未完待续>>>

温故而知新~