javascript常用方法整理；(不断更新)

以下是在项目中遇到的常用的javascript方法整理；

---

1.判断传入参数的类型，以字符串的形式返回

/**
 *  判断传入参数的类型，以字符串的形式返回
 *  @obj：数据
 **/
function dataType(obj){
    if (obj===null) return "Null";
    if (obj===undefined) return "Undefined";
    return Object.prototype.toString.call(obj).slice(8,-1);
};

2.判断对象是否存在

/*
* 判断传入的对象是否存在
* @obj:对象值
*/
function isObj(obj){
    if( obj === null || typeof(obj) === 'undefined' ) return false;
    return true;
}

3.去除字符串中的空格

/*
* 去除字符串中的空格符；
* @str:字符串参数值
*/
function strTrim(str){
    if( !isObj(str) ) return 'undefined';
    str=str.replace(/^/s+|/s+$/g,'');
    return str;
}

4.去掉html的标签

/**
 * 去掉html的标签
 * @str str:标签字符串
 */
function removeHTMLTag (str ) {
    str = str. replace(/<\/?[^>]*>/g ,''); //去除HTML tag
    str = str. replace(/[ | ]*\n/g ,'\n'); //去除行尾空白
    str = str.replace(/\n[\s| | ]*\r/g,'\n'); //去除多余空行
    str =str. replace(/&nbsp;/ig ,''); //去掉&nbsp;
    return str ;
}

5.删除数组中某个元素，并且修改下标，返回新数组

/**
 * 删除数组中某个元素，并且修改下标，返回新数组
 * array数组扩展方法
 */
Array.prototype .del = function( n){
     if ( n<0 ){
         return this ;
     }else{
         return this.slice (0, n).concat (this. slice(n +1, this.length ));
     }
};

6.去除数组中重复元素，返回新数组

/**
 * 去除数组中重复元素，返回新数组
 * array数组扩展方法
 */
Array.prototype .distinct = function(){
     var result = [], hash = {};
     for( var i = 0, elem ;(elem = this[ i]) != null; i ++ ){
         if( !hash[ elem] ){
            result .push( elem);
            hash [elem] = true;
         }
     }
     return result;
};

7.禁用鼠标右键，禁止复制粘贴等操作

/**
 *  禁用鼠标右键，禁止复制粘贴等操作
 */
banCopyAndPaste:function(){
    // 禁止复制
    document.oncopy = function(){event.returnValue = false;};
    // 禁止右键菜单
    document.oncontextmenu = function(){event.returnValue = false;};
    // 禁止网页上选取内容
    document.onselectstart = function(){event.returnValue = false;};
    // 键盘事件
    document.onkeydown = function(){
        if( event.ctrlKey ){
            return false;
        }
    };
}

8.处理对象参数值，排除对象参数值为”“、null、undefined，并返回一个新对象

function dealObjectValue(obj){
    var param = {};
    if ( obj === null || obj === undefined || obj === "" ) return param;
    for ( var key in obj ){
        if ( dataType(obj[key]) === "object" ){
            param[key] = dealObjectValue(obj[key]);
        }else if(  obj[key] !== null && obj[key] !== undefined && obj[key] !== ""  ){
            param[key] = obj[key];
        }
    }
    return param;
};

9.对象复制（克隆）方法，改变对原对象的引用，生成新对象

/**
 *  对象复制（克隆）方法，改变对原对象的引用，生成新对象
 *  复制时包括对象中的属性，方法；
 *  @obj：数据
 **/
function clone(obj){
    var result = {},objClass=dataType(obj);
    if (objClass==="Object") {
        result = {};
    }else if (objClass==="Array"){
        result = [];
    }else{
        return obj;
    }
    // 遍历obj对象的每一个属性
    for ( var key in obj ){
        var = obj[key];
        if (dataType(val)==="Object"){
            result[key] = arguments.callee(val);
        }else if(dataType(val)==="Array"){
            result[key] = arguments.callee(val);
        }else{
            result[key] = obj[key];
        }
    }
    return result;
};

10.将数组中的元素相加，求和

/*
 * 将数组中的元素相加，求和
 * 注意：1.参数必须是数组或者类似数组的对象
 *       2.数组中的元素必须是数字
 */
function arrayElementSum(a){
    var total = 0;
    if ( dataType(a) === "Array" ){
        for ( var i=0;i<a.length;i++ ){
            var element = a[i];
            if ( !element ) continue;
            if ( dataType(element) == "Number" ){
                total += element;
            }else {
                alert("数组中的元素必须是数字");
            }
        }
    }else {
        alert("参数必须是数组或者类似数组的对象");
    }
    return total;
}

11.获取浏览器信息

var s = navigator.userAgent.toLowerCase();
var BrowserInfo = {
    IsIE: /*@on_on!@*/false,
    IsIE8Under: /*@on_on!@*/false && (parseInt(s.match(/msie (\d+)/)[1], 10) <=8 ),
    IsIE7: /*@on_on!@*/false && (parseInt(s.match(/msie (\d+)/)[1], 10) >= 7),
    IsIE6: /*@on_on!@*/false && (parseInt(s.match(/msie (\d+)/)[1], 10) >= 6),
    IsSafari: s.indexOf("applewebkit") > -1,
    IsOpera: !!window.opera,
    IsAIR: s.indexOf('adobeair') > -1,
    IsMac: s.indexOf('macintosh') > -1
};
(function(A) {
    A.IsGecko = (navigator.product == 'Gecko') && !A.IsSafari && !A.IsOpera;
    A.IsGeckoLike = (A.IsGecko || A.IsSafari || A.IsOpera);
    if (A.IsGecko) {
        var B = s.match(/rv:(\d+\.\d+)/);
        var C = B && parseFloat(B[1]);
        A.IsIERV = true;
        if (C) {
            A.IsGecko10 = (C < 1.8);
            A.IsGecko19 = (C > 1.8);
        }
    }
})(BrowserInfo);

12.比较两个日期字符串（YYYY/MM型）

/**
* 比较两个日期字符串（YYYY/MM型）
* date1=date2则返回0 , date1>date2则返回1 , date1<date2则返回-1
* @date1:日期
* @date2:日期
* auth:JYX8 time:2017.06.26
**/
function compareData(date1,date2){
  var strValue1=date1.split("/");
  var date1Temp=new Date(strValue1[0],parseInt(strValue1[1],10)-1,1);

  var strValue2=date2.split("/");
  var date2Temp=new Date(strValue2[0],parseInt(strValue2[1],10)-1,1);

  if(date1Temp.getTime()==date2Temp.getTime())
    return 0;
  else if(date1Temp.getTime()>date2Temp.getTime())
    return 1;
  else
    return -1;
}

13.批量移除某个样式

/**
 * 批量移除某个样式
 * obj:jquery对象
 * className:样式名称
 * auth:JYX8 time:2016.02.15
 */
function removeClassName(obj,className){
    if ( obj && obj.length>0 && className && className != "" ){
        $.each(obj,function(n,val){
            var $val = $(val);
            if ( $val.hasClass(className) ){
                $val.removeClass(className);
            }
        });
    }
}

14.按id(或某个参数名称)对数组中的元素进行归类，参数值相同的对象放在一起，以数组第一个元素为准

/**
 * 按id(或某个参数名称)对数组中的元素进行归类，参数值相同的对象放在一起，以数组第一个元素为准
 * array:数组
 * auth:JYX8 time:2016.07.13
 * */
function questionTypeSort(array){
    var temp_array = array,return_array = [];
    if( dataType(array) === "Array" ){
        for( var i=0;i<array.length;i++ ){
            for ( var j=0;j<temp_array.length; ){
                if( temp_array[j].id == array[i].id ){
                    return_array.push(temp_array[j]);
                    temp_array = temp_array.del(j);
                    j=0;
                }else{
                    j++;
                }
            }
        }
    }
    return return_array;
};

15.回到页面顶部位置

//回到页面顶部位置
// auth:JYX8 time:2015.03.20
$(".go-top").click(function(){
    $('body,html').animate({scrollTop:0},1000);
    return false;
}); 

16.通过sessionStorage、localStorage将数据保存到浏览器中存储；

/**
 * 通过sessionStorage、localStorage将数据保存到浏览器中存储；
 * @param data：保存的参数value值
 * @param name：保存到浏览器中的key值，获取时候用
 * @param type：保存方式sessionStorage、localStorage
 * @returns {Boolean}：是否保存成功
 * auth:JYX8 time:2016.07.20
 */
function setDataToBrowser(name, data, type){if ( data === undefined ) return false;
    if ( data === null ) return false;
    if ( type === "sessionStorage" && window.sessionStorage ){
        if ( dataType(data) === "Object" || dataType(data) === "Array" ){
            window.sessionStorage.setItem(name,JSON.stringify(data));
        }else{
            window.sessionStorage.setItem(name,data);
        }
    }else if ( type === "localStorage" && window.localStorage ){
        if ( dataType(data) === "Object" || dataType(data) === "Array" ){
            window.localStorage.setItem(name,JSON.stringify(data));
        }else{
            window.localStorage.setItem(name,data);
        }
    }
    return true;
}

17.获取浏览器sessionStorage、localStorage中存储的数据

/**
 * 获取浏览器sessionStorage、localStorage中存储的数据
 * @param name：保存到浏览器中的名称key值
 * @param type：保存方式sessionStorage、localStorage
 * @returns {String}：返回数据；
 * auth:JYX8 time:2016.07.20
 */
function getDataFromBrowser(name,type){
    var param = "";
    if ( name === undefined ) return param;
    if ( name === null ) return param;
    if ( type === "sessionStorage" && window.sessionStorage ){
        param = window.sessionStorage.getItem(name);
    }else if ( type === "localStorage" && window.localStorage ){
        param = window.localStorage.getItem(name);
    }
    return param;
}

18.动态替换css主题样式文件

/**
 * 动态替换css主题样式文件；
 * @param title：替换的css样式文件名称及路径
 * auth:JYX8 time:2016.07.28
 */
function setStyleSheet(title){
    // 找到head
    var doc_head = document.head;
    // 找到所有的link标签
    var link_list = document.getElementsByTagName("link");
    if ( link_list ){
        for ( var i=0;i<link_list.length;i++ ){
            // 找到我们需要替换的link，
            // 一般情况下有些样式是公共样式，我们可以写到功能样式文件中，不用来做替换；
            // 这样可以避免每次替换的时候样式文件都很大；可以节省加载速度；
            // ty="theme"，用来做标示，标示我要替换掉的css文件
            if ( link_list[i].getAttribute("ty") === "theme" ){
                // 找到后将这个link标签重head中移除
                doc_head.removeChild(link_list[i]);
            }
        }
    }
    // 创建一个新link标签
    var link_style = document.createElement("link");
    // 对link标签中的属性赋值
    link_style.setAttribute("rel","stylesheet");
    link_style.setAttribute("type","text/css");
    link_style.setAttribute("href",title);
    link_style.setAttribute("ty","theme");
    // 加载到head中最后的位置
    doc_head.appendChild(link_style);
};

19.处理对象参数值，排除对象参数值为”“、null、undefined，并返回一个新对象

/**
* 处理对象参数值，排除对象参数值为”“、null、undefined，并返回一个新对象
* @obj：需要处理的参数值
**/
function dealObjectValue(obj){
    var param = {};
    if ( obj === null || obj === undefined || obj === "" ) return param;
    for ( var key in obj ){
    // 判断是否是Object对象 
        if ( dataType(obj[key]) === "Object" ){
            param[key] = dealObjectValue(obj[key]);
        }else if(  obj[key] !== null && obj[key] !== undefined && obj[key] !== ""  ){
            param[key] = obj[key];
        }
    }
    return param;
};

20.获取url的参数

//获取url的参数
function getUrlParameter() {
    var url_search = window.location.search;
    var param = {};
    //获取路径“?”后的参数列表部分
    if ( url_search.indexOf("?") != -1 ) {
        var str = url_search.substr(1);
        strs = str.split("&");
        for(var i = 0; i < strs.length; i ++) {
            // 将URL参数名称和值以对象形式保存
            param[strs[i].split("=")[0]]=unescape(strs[i].split("=")[1]);
        }
    }
    return param;
}

21.array数组扩展方法：在数组的指定位置添加新元素

/**
 * 在数组的指定位置添加新元素
 * array数组扩展方法
 * auth:JYX8 time:2016.08.26
 */
Array.prototype.insert = function(index, stem){
    this.splice(index, 0, stem);
};

22.处理多层级结构数据，通过关联参数字段将有关联关系的数据整合起来，返回多层级关系型数据结构；

    /**
     * 处理树形结构数据，通过关联参数字段将有关联关系的数据整合起来，返回父子关系型数据结构；
     * 
     * @param data:数据集合，改数据类型为数组，包含对象数据
     * @param pcode:父节点名称，用关联当前对象的父级，字符串类型（例如："parentCode"）
     * @param code:当前对象的节点名称，字符串类型（例如："code"）
     * @param children:关联关系整合后，父级包含子级对象集合的名称，用来存放当前对象的所有子级，
     *                 字符串类型（例如："children"）
     */
    function dealTreeData(data, pcode, code, children){
        var tree = [],tempMap = [];
        if ( dataType(data) === "Array" ){
            for ( var i=0; i<data.length;i++ ){
                tempMap[data[i][code]] = data[i];
            }
            for ( var j=0; j<data.length; j++ ){
                if ( tempMap[data[j][pcode]] && data[j][code] != data[j][pcode] ){
                    if( !tempMap[data[j][pcode]][children] ){
                        tempMap[data[j][pcode]][children] = [];
                    }
                    tempMap[data[j][pcode]][children].push(data[j]);
                }else{
                    tree.push(data[j]);
                }
            }
        }
        return tree;
    }