这几个小方法每一个都含有一种不同的思维方式，或者含有经常用不要的点，罗列一下，如果谁有更好的方式，欢迎交流。

 

　　　　　//序列化url，把后面的参数变成键值对的方式
        //思路：用正则匹配到，然后利用replace的第二个参数传递function的方法实现
        //注：在正则没有分组的情况下function会有三个参数传递，第一个是匹配到的部分，第二个是索引位置，第三个是整个的匹配内容
        //另：如果不用这方式，用字符串分割，然后循环也可以实现
        function parseUrl(){
            var link = window.location.href;
            var result = {};
            link.replace(/[^=&?]+=[^=&?]+/g,function(){
                var arr = arguments[0].split('=');
                result[arr[0]] = arr[1];
            });
            return result;
        }
        console.log(parseUrl());

        //取不重复的随机数
        //这种方式比用splice去掉一项的好处是，他不会引起所有项的移动
        function random(oldArr){
            var randomNum = null;
            var newArr = [];
            for(var i = 0; i < 5; i++){
                randomNum = Math.round(Math.random() * (oldArr.length-1) + 1);
                newArr.push(oldArr[randomNum]);
                oldArr[randomNum] = oldArr[oldArr.length -1];
                oldArr.length = oldArr.length - 1;
            }
            return newArr;
        }
        console.log(random([1,2,3,4,5,6,7,8,9,10]));

        //加千分符
        //主要用到把字符串倒过来数的思想，同样是字符串的替换
        function thousandSplit(str){
            var newStr = str.replace(/(?!^)\d/g,function(){
                var index = arguments[1];
                if((str.length - index)%3 === 0){
                    return ',' + arguments[0];
                }else {
                    return arguments[0];
                }
            });
            return newStr;
        }
        console.log(thousandSplit('8316733827648235'));

        //以下一个方法是实现一个对象的深拷贝和浅拷贝
        //深拷贝利用递归实现，两种拷贝方式的差异主要是因为引用类型的存储方式
        function isType(obj,type){
            var tostring = Object.prototype.toString;
            return(type === 'Null' && obj === 'null') || (type === 'Undefined' && obj === 'undefined') ||
                    (tostring.call(obj).slice(8,-1) === type);
        }
        function copy(result,obj,deep){
            if(!deep) {
                for(var key in obj) {
                    result[key] = obj[key];
                }
            }else {
                for(var key in obj){
                    var temp = obj[key];
                    if(isType(temp,'Object') || isType(temp,'Array')) {
                        result[key] = arguments.callee(result[key] || {}, copy, true);
                    }else {
                        result[key] = temp;
                    }
                }
            }
            return result;
        }
        var obj = {
            name : 'a',
            age : 18,
            skill : {
                'eat' : 'fruit',
                'drink' : 'milk',
                'sleeping' : 24
            }
        };
        var deepObj = copy({},obj,true);
        deepObj.skill.eat = 'vegetable';
        console.log(obj.skill.eat);

        var copyObj = copy({},obj,false);
        copyObj.skill.drink = 'coke';
        console.log(obj.skill.drink);

        //去掉前后的空格
        function trim(str){
            var result = str.replace(/^\s*|s*$/g,'');
        }

        //计算offset的值
        //这里就主要是找父元素，然后叠加
        function offset(ele){
            var left = ele.offsetLeft;
            var top = ele.offsetTop;
            var parent = ele.offsetParent;

            while(parent){
                if(document.body.currentStyle){ //如果是ie8及以下的浏览器
                    left += ele.offsetLeft;
                    top += ele.offsetTop;
                }else {
                    left += ele.offsetLeft + ele.clientLeft; //clientLeft是左面的边框
                    top += ele.offsetTop + ele.clientTop;
                }
                parent = parent.offsetParent;
            }
            return {"left":left,"top":top};
        }

本人的QQ：185986288,如果有更好的思想欢迎交流