/**
 * @author:水痕
 * @timer:2016-07-28
 * @email:[email protected]
 * @version:1.0
 * @title:封裝一個自己常用的工具類js
 * @note:
 */
;
(function(window, document, $) {
    window.utils = {
            /////////////////////////////關於陣列操作js開始/////////////////////////////////////
            tmArray: {
                /*each和map的功能是一樣的*/
                each: function(arr, fn) {
                    fn = fn || Function
 
;
                    var a = [];
                    var args = Array.prototype.slice.call(arguments, 1);
                    for(var i = 0; i < arr.length; i++) {
                        var res = fn.apply(arr, [arr[i], i].concat(args));
                        if(res != null) a.push(res);
                    }
                    return
 
 a;
                },
                /*each和map的功能是一樣的*/
                map: function(arr, fn, thisObj) {
                    var scope = thisObj || window;
                    var a = [];
                    for(var i = 0, j = arr.length; i < j; ++i) {
                        var res = fn.call(scope, arr[i], i, this
 
);
                        if(res != null) a.push(res);
                    }
                    return a;
                },
                /**
                 * 陣列的排序
                 * @param array
                 * @param sortFlag
                 * @returns {*}
                 */
                orderBy: function(array, sortFlag) {
                    var $arr = array;
                    if(sortFlag == 'asc') {
                        $arr.sort(this._numAscSort);
                    } else if(sortFlag == 'desc') {
                        $arr.sort(this._numDescSort);
                    } else {
                        $arr.sort(this._numAscSort);
                    }
                    return $arr;
                },
                // 求兩個集合的並集
                union: function(a, b) {
                    var newArr = a.concat(b);
                    return this.unique2(newArr);
                },
                // 求兩個集合的補集
                complement: function(a, b) {
                    return this.minus(this.union(a, b), this.intersect(a, b));
                },
                // 求兩個集合的交集
                intersect: function(a, b) {
                    a = this.unique(a);
                    return this.each(a, function(o) {
                        return b.contains(o) ? o : null;
                    });
                },
                //求兩個集合的差集
                minus: function(a, b) {
                    a = this.unique(a);
                    return this.each(a, function(o) {
                        return b.contains(o) ? null : o;
                    });
                },
                /**
                 * 陣列的去重
                 * @param arr
                 * @returns {Array}
                 */
                unique: function(arr) {
                    var ra = new Array();
                    for(var i = 0; i < arr.length; i++) {
                        if(!ra.contains(arr[i])) {
                            //if(this.contains(ra,arr[i])){
                            ra.push(arr[i]);
                        }
                    }
                    return ra;
                },
                /**
                 * 陣列的去重複
                 * @param arr
                 * @returns {*}
                 */
                unique2: function(arr) {
                    for(var i = 0; i < arr.length; i++) {
                        for(var j = i + 1; j < arr.length;) {
                            if(arr[j] == arr[i]) {
                                arr.splice(j, 1);
                            } else {
                                j++;
                            }
                        }
                    }
                    return arr;
                },
                /**
                 * 陣列去除重複的(根據物件來)
                 * @param {Object} ary
                 */
                unique3: function(ary) {
                    var result = [],
                        hash = {};
                    for(var i = 0, elem;
                        (elem = arr[i]) != null; i++) {
                        if(!hash[elem]) {
                            result.push(elem);
                            hash[elem] = true;
                        }
                    }
                    return result;
                },
                /**
                 * 獲取陣列的下標
                 * @param arr
                 * @param val
                 * @returns {number}
                 */
                indexOf: function(arr, val) {
                    for(var i = 0; i < arr.length; i++) {
                        if(arr[i] == val) {
                            return i;
                        }
                    }
                    return -1;
                },
                /**
                 * 判斷一個元素是否在一個數組中
                 * @param arr
                 * @param val
                 * @returns {boolean}
                 */
                contains: function(arr, val) {
                    return this.indexOf(arr, val) != -1 ? true : false;
                },
                /**
                 * 陣列中刪除一個元素
                 * @param arr
                 * @param indexs
                 * @returns {*}
                 */
                remove: function(arr, indexs) {
                    var index = this.indexOf(arr, indexs);
                    if(index > -1) {
                        arr.splice(index, 1);
                    }
                    return arr;
                },
                removeObject: function(arr, item) {
                    for(var i = 0; i < arr.length; i++) {
                        var jsonData = arr[i];
                        for(var key in jsonData) {
                            if(jsonData[key] == item) {
                                arr.splice(i, 1);
                            }
                        }
                    }
                    return arr;
                },
                /**
                 * 求陣列中最大值
                 * @param arr
                 * @returns {number|Number}
                 */
                arrMax: function(arr) {
                    return Math.max.apply(null, arr);
                },
                /**
                 * 求陣列中最小值
                 * @param arr
                 * @returns {number|Number}
                 */
                arrMin: function(arr) {
                    return Math.min.apply(null, arr);
                },
                /**
                 * 刪除陣列元素的方法
                 */
                removeAry: function(ary, ele) {
                    ary.splice(ary.indexOf(ele), 1);
                },
                /**
                 * 將類陣列轉換為陣列的方法
                 * @param ary
                 * @returns {Array}
                 */
                formArray: function(ary) {
                    var arr = [];
                    if(Array.isArray(ary)) {
                        arr = ary;
                    } else {
                        arr = Array.prototype.slice.call(ary);
                    };
                    return arr;
                },
                /**
                 * 定義一個數組排序的方法
                 * 預設為升序排序asc,
                 * 如果傳遞是引數是一個的話，那麼就是是升序，如果傳遞的引數是兩個的話，如果第一個引數不能轉換為陣列的話，也直接退出
                 * 引數:acs:表示升序
                 * 引數:desc:表示降序
                 * @returns {*}
                 */
                arrySort: function() {
                    var arg = arguments;
                    var len = arg.length;
                    var ary = this.arryList(arg[0]);
                    //如果沒傳遞引數，或者傳遞的不能轉換為陣列的話就直接返回
                    if(!len || Array.isArray(ary) == false) {
                        return false;
                    };
                    if(len == 1) {
                        return ary.sort(function(a, b) {
                            return a - b;
                        });
                    } else {
                        return ary.sort(function(a, b) {
                            if(arg[1] == "desc") {
                                return b - a;
                            } else if(arg[1] == "asc") {
                                return a - b;
                            } else {
                                return a - b;
                            };
                        });
                    };
                },
                /**
                 * 求和函式
                 * @param arr
                 * @returns {number}
                 */
                arySum: function(arr) {
                    var ary = [];
                    var result = 0;
                    if(arr instanceof Array) {
                        ary = arr;
                    } else {
                        ary = this.formArray(arr);
                    };
                    for(var i = 0; i < ary.length; i++) {
                        result += parseFloat(ary[i]);
                    };
                    return result;
                },

                /**
                 * 陣列隨機排列
                 * @param {Object} ary
                 */
                shuffle: function(ary) {
                    var input = this;
                    for(var i = input.length - 1; i >= 0; i--) {
                        var randomIndex = Math.floor(Math.random() * (i + 1));
                        var itemAtIndex = input[randomIndex];
                        input[randomIndex] = input[i];
                        input[i] = itemAtIndex;
                    }
                    return input;
                },
                /**
                 * 陣列隨機排序
                 * @param {Object} target
                 */
                shuffle1: function(target) {
                    function randomsort(a, b) {
                        return Math.random() > .5 ? -1 : 1;
                        //用Math.random()函式生成0~1之間的隨機數與0.5比較，返回-1或1  
                    }

                    return target.sort(randomsort);
                },
                /**
                 * 判斷是不是陣列
                 * @param {Object} ary
                 */
                isArray: function(ary) {
                    var objectToStringFn = Object.prototype.toString;
                    var arrayToStringResult = objectToStringFn.call([]);
                    return function(subject) {
                        return objectToStringFn.call(subject) === arrayToStringResult;
                    };
                },
                /**
                 * 隨機返回陣列中一個元素
                 * @param {Object} ary
                 */
                randomItem: function(ary) {
                    return ary[Math.ceil(Math.random() * ary.length)];
                },
                /**
                 * 判斷陣列中是否包含某一項
                 * @param arr
                 * @returns {number|Number}
                 * 呼叫方法：var max = utils.arrContains([],"",false)  flag 如果為true，則判斷字串    false則判斷字元
                 */
                arrContains: function(arr, str, flag) {
                    if(flag) {
                        if(arr.length > 0 && this.isNotEmpty(str)) {
                            for(var i = 0; i < arr.length; i++) {
                                if(arr[i] == str) {
                                    return true;
                                } else {
                                    return false;
                                }
                            }
                        }
                    } else {
                        for(var i = 0; i < arr.length; i++) {
                            for(var j = 0; j < arr[i].length; j++) {
                                if(arr[i].charAt(j) == str) {
                                    return true;
                                } else {
                                    false;
                                }
                            }
                        }
                    }
                },
                /**
                 * 判斷陣列是否有重複的項
                 * @param {Object} arr
                 */
                isRepeat: function(arr) { //arr是否有重複元素
                    var hash = {};
                    for(var i in arr) {
                        if(hash[arr[i]]) return true;
                        hash[arr[i]] = true;
                    }
                    return false;
                },

                _numAscSort: function(a, b) {
                    return a - b;
                },
                _numDescSort: function(a, b) {
                    return b - a;
                },
                _sortAsc: function(x, y) {
                    if(x > y) {
                        return 1;
                    } else {
                        return -1;
                    }
                },
                _sortDesc: function(x, y) {
                    if(x > y) {
                        return -1;
                    } else {
                        return 1;
                    }
                }
            },
            /////////////////////////////關於陣列操作js結束/////////////////////////////////////

            /////////////////////////////關於日期操作js開始/////////////////////////////////////
            tmDate: {
                /*轉換日期*/
                _transferDate: function(date) {
                    if(typeof date == "string") {
                        return new Date(date.replace(/-/ig, "/"));
                    } else {
                        return date;
                    }
                },
                /*格式化日期*/
                _toString: function(date, pattern) {
                    var d = this._transferDate(date);
                    return d.format(pattern);
                },

                /*獲取兩個時間相減的時間*/
                _Date: function(date1, date2) {
                    var dateTime = this._numMillSecond(date1, date2);
                    return new Date(dateTime).format("yyyy-MM-dd");
                },

                //間隔年份
                _numYear: function(date1, date2) {
                    var times = this._numDay(date1, date2);
                    return Math.floor(times / 365);
                },

                //間隔月份
                _numMonth: function(date1, date2) {
                    var times = this._numDay(date1, date2);
                    return Math.floor(times / 30);
                },

                //間隔天數
                _numDay: function(date1, date2) {
                    var times = this._numSecond(date1, date2);
                    var hour = this._var().hour;
                    var mills = this._var().mills;
                    return Math.ceil(times / (mills * hour));
                },

                //間隔時
                _numHour: function(date1, date2) {
                    return Math.floor(this._numMillSecond(date1, date2) / (1000 * 60 * 60));
                },

                //間隔分
                _numMinute: function(date1, date2) {
                    return Math.floor(this._numMillSecond(date1, date2) / (1000 * 60));
                },

                //間隔秒數
                _numSecond: function(date1, date2) {
                    return Math.floor(this._numMillSecond(date1, date2) / 1000);
                },

                //間隔毫秒
                _numMillSecond: function(date1, date2) {
                    var stimes = this._getTime(this._transferDate(date1));
                    var etimes = this._getTime(this._transferDate(date2));
                    return etimes - stimes;
                },

                _var: function() {
                    return {
                        hour: 24,
                        second: 60,
                        mills: 3600,
                        format: "yyyy-MM-dd",
                        dateFormat: "yyyy-MM-dd HH:mm:ss"
                    };
                },

                /*某個日期加上多少毫秒*/
                _plusMillisSeconds: function(date, millisSeconds) {
                    var dateTime = this._getTime(date);
                    var mintimes = millisSeconds;
                    var rdate = dateTime * 1 + mintimes * 1;
                    return this._format(new Date(rdate));
                },
                /*某個日期加上多少秒*/
                _plusSeconds: function(date, seconds) {
                    var dateTime = this._getTime(date);
                    var mintimes = seconds * 1000;
                    var rdate = dateTime * 1 + mintimes * 1;
                    return this._format(new Date(rdate));
                },
                /*某個日期加上多少分鐘*/
                _plusMinutes: function(date, minutes) {
                    var dateTime = this._getTime(date);
                    var mintimes = minutes * 60 * 1000;
                    var rdate = dateTime * 1 + mintimes * 1;
                    return this._format(new Date(rdate));
                },
                /*某個日期加上小時數*/
                _plusHours: function(date, hours) {
                    var dateTime = this._getTime(date);
                    var mintimes = hours * 60 * 60 * 1000;
                    var rdate = dateTime + mintimes;
                    return this._format(new Date(rdate));
                },
                /*某個日期加上天數*/
                _plusDays: function(date, days) {
                    var dateTime = this._getTime(date);
                    var mintimes = days * 60 * 60 * 1000 * 24;
                    var rdate = dateTime * 1 + mintimes * 1;
                    return this._format(new Date(rdate));
                },

                /*某個日期加上多少個月,這裡是按照一個月30天來計算天數的*/
                _plusMonths: function(date, months) {
                    var dateTime = this._getTime(date);
                    var mintimes = months * 30 * 60 * 60 * 1000 * 24;
                    var rdate = dateTime + mintimes * 1;
                    return this._format(new Date(rdate));
                },

                /*某個日期加上多少個年,這裡是按照一個月365天來計算天數的，如果loop為true則按閏年計算*/
                _plusYears: function(date, years, isLoop) {
                    var dateTime = this._getTime(date);
                    var day = 365;
                    if(isLoop) day = 366;
                    var mintimes = years * day * 60 * 60 * 1000 * 24;
                    var rdate = dateTime + mintimes;
                    return this._format(new Date(rdate));
                },

                /*某個日期加上某個日期，這樣的操作視乎沒什麼意義*/
                _plusDate: function(date1, date2) {
                    var dateTime = this._getTime(date1);
                    var dateTime2 = this._getTime(date2);;
                    var rdate = dateTime + dateTime2;
                    return this._format(new Date(rdate));
                },

                /*某個日期減去多少毫秒秒*/
                _minusMillisSeconds: function(date, millisSeconds) {
                    var dateTime = this._getTime(date);
                    var mintimes = millisSeconds * 1;
                    var rdate = dateTime - mintimes;
                    return this._format(new Date(rdate));
                },
                /*某個日期減去多少秒*/
                _minusSeconds: function(date, seconds) {
                    var dateTime = this._getTime(date);
                    var mintimes = seconds * 1000;
                    var rdate = dateTime - mintimes;
                    return this._format(new Date(rdate));
                },
                /*某個日期減去多少分鐘*/
                _minusMinutes: function(date, minutes) {
                    var dateTime = this._getTime(date);
                    var mintimes = minutes * 60 * 1000;
                    var rdate = dateTime - mintimes;
                    return this._format(new Date(rdate));
                },
                /*某個日期減去小時數*/
                _minusHours: function(date, hours) {
                    var dateTime = this._getTime(date);
                    var mintimes = hours * 60 * 60 * 1000;
                    var rdate = dateTime - mintimes;
                    return this._format(new Date(rdate));
                },
                /*某個日期減去天數*/
                _minusDays: function(date, days) {
                    var dateTime = this._getTime(date);
                    var mintimes = days * 60 * 60 * 1000 * 24;
                    var rdate = dateTime - mintimes;
                    return this._format(new Date(rdate));
                },

                /*某個日期減去多少個月,這裡是按照一個月30天來計算天數的*/
                _minusMonths: function(date, months) {
                    var dateTime = this._getTime(date);
                    var mintimes = months * 30 * 60 * 60 * 1000 * 24;
                    var rdate = dateTime - mintimes;
                    return this._format(new Date(rdate));
                },

                /*某個日期減去多少個年,這裡是按照一個月365天來計算天數的*/
                _minusYears: function(date, years, isLoop) {
                    var dateTime = this._getTime(date);
                    var day = 365;
                    if(isLoop) day = 366;
                    var mintimes = years * day * 60 * 60 * 1000 * 24;
                    var rdate = dateTime - mintimes;
                    return this._format(new Date(rdate));
                },

                /*某個日期減去某個日期，這樣的操作視乎沒什麼意義*/
                _minusDate: function(date1, date2) {
                    var dateTime = this._getTime(date1);
                    var dateTime2 = this._getTime(date2);;
                    var rdate = dateTime - dateTime2;
                    return this._format(new Date(rdate));
                },

                /*獲取一個月有多少天*/
                _getMonthOfDay: function(date1) {
                    var currentMonth = this._getFirstDayOfMonth(date1);
                    var nextMonth = this._getNextDayOfMonth(date1);
                    return this._numDay(currentMonth, nextMonth);
                },

                /*獲取一年又多少天*/
                _getYearOfDay: function(date) {
                    var firstDayYear = this._getFirstDayOfYear(date);
                    var lastDayYear = this._getLastDayOfYear(date);
                    return Math.ceil(this._numDay(firstDayYear, lastDayYear));
                },

                /*某個日期是當年中的第幾天*/
                _getDayOfYear: function(date1) {
                    return Math.ceil(this._numDay(this._getFirstDayOfYear(date1), date1));
                },

                /*某個日期是在當月中的第幾天*/
                _getDayOfMonth: function(date1) {
                    return Math.ceil(this._numDay(this._getFirstDayOfMonth(date1), date1));
                },

                /*獲取某個日期在這一年的第幾周*/
                _getDayOfYearWeek: function(date) {
                    var numdays = this._getDayOfYear(date);
                    return Math.ceil(numdays / 7);
                },

                /*某個日期是在當月中的星期幾*/
                _getDayOfWeek: function(date1) {
                    return this._getWeek(date1);
                },

                /*獲取在當前日期中的時間*/
                _getHourOfDay: function(date) {
                    return this._getHour(date);
                },
                _eq: function(date1, date2) {
                    var stime = this._getTime(this._transferDate(date1));
                    var etime = this._getTime(this._transferDate(date2));
                    return stime == etime ? true : false;
                },
                /*某個日期是否晚於某個日期*/
                _after: function(date1, date2) {
                    var stime = this._getTime(this._transferDate(date1));
                    var etime = this._getTime(this._transferDate(date2));
                    return stime < etime ? true : false;
                },

                /*某個日期是否早於某個日期*/
                _before: function(date1, date2) {
                    var stime = this._getTime(this._transferDate(date1));
                    var etime = this._getTime(this._transferDate(date2));
                    return stime > etime ? true : false;
                },

                /*獲取某年的第一天*/
                _getFirstDayOfYear: function(date) {
                    var year = this._getYear(date);
                    var dateString = year + "-01-01 00:00:00";
                    return dateString;
                },

                /*獲取某年的最後一天*/
                _getLastDayOfYear: function(date) {
                    var year = this._getYear(date);
                    var dateString = year + "-12-01 00:00:00";
                    var endDay = this._getMonthOfDay(dateString);
                    return year + "-12-" + endDay + " 23:59:59";
                },

                /*獲取某月的第一天*/
                _getFirstDayOfMonth: function(date) {
                    var year = this._getYear(date);
                    var month = this._getMonth(date);
                    var dateString = year + "-" + month + "-01 00:00:00";
                    return dateString;
                },

                /*獲取某月最後一天*/
                _getLastDayOfMonth: function(date) {
                    var endDay = this._getMonthOfDay(date);
                    var year = this._getYear(date);
                    var month = this._getMonth(date);
                    return year + "-" + month + "-" + endDay + " 23:59:59";
                },
                /*一天的開始時間*/
                _getFirstOfDay: function(date) {
                    var year = this._getYear(date);
                    var month = this._getMonth(date);
                    var dates = this._getDay(date);
                    return year + "-" + month + "-" + dates + " 00:00:00";
                },

                /*一天的結束時間*/
                _getLastOfDay: function(date) {
                    var year = this._getYear(date);
                    var month = this._getMonth(date);
                    var dates = this._getDay(date);
                    return year + "-" + month + "-" + dates + " 23:59:59";
                },

                /*獲取下個月的第一天*/
                _getNextDayOfMonth: function(date) {
                    var year = this._getYear(date);
                    var month = this._getMonth(date);
                    month = month * 1 + 1;
                    if(month > 12) {
                        year = year + 1;
                        month = month - 12;
                    }
                    month = month > 9 ? month : "0" + month;
                    var dateString = year + "-" + month + "-01 00:00:00";
                    return dateString;
                },

                _getFirstOfWeek: function(date1) {
                    var week = this._getWeek(date1);
                    var date = this._minusDays(date1, week);
                    var year = this._getYear(date);
                    var month = this._getMonth(date);
                    var dates = this._getDay(date);
                    return year + "-" + month + "-" + dates + " 00:00:00";
                },

                _getLastOfWeek: function(date1) {
                    var week = 6 - this._getWeek(date1);
                    var date = this._minusDays(date1, week);
                    var year = this._getYear(date);
                    var month = this._getMonth(date);
                    var dates = this._getDay(date);
                    return year + "-" + month + "-" + dates + " 23:59:59";
                },

                _getNow: function() {
                    return new Date();
                },
                _format: function(date) {
                    return this._getYear(date) + "-" + this._getMonth(date) + "-" + this._getDay(date) + " " + this._getHour(date) + ":" + this._getMinute(date) + ":" + this._getSecond(date);
                },
                _getDate: function() {
                    return this._getNow();
                },
                /*年*/
                _getYear: function(date) {
                    return this._transferDate(date).getFullYear();
                },

                /*月*/
                _getMonth: function(date) {
                    var month = this._transferDate(date).getMonth() + 1;
                    return month > 9 ? month : "0" + month;
                },

                /*日*/
                _getDay: function(date) {
                    var day = this._transferDate(date).getDate();
                    return day > 9 ? day : "0" + day;
                },

                /*獲取今天星期幾,如果為0代表星期日*/
                _getWeek: function(date) {
                    return this._transferDate(date).getDay();
                },

                /*時*/
                _getHour: function(date) {
                    var hour = this._transferDate(date).getHours();
                    return hour > 
            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
封裝一個常用的js工具類
     
 
							
							
							/**
 * @author:水痕
 * @timer:2016-07-28
 * @email:[email protected]
 * @version:1.0
 * @title:封裝一個自己常用的工具類js
 * @note:
 */
;
(f 

  
 

    

    
    
通用JS工具類封裝——網路資料請求功能、獲取服務端介面 url、引數功能
     
  
 
  
  
 程式碼片段 
 'use strict';
var conf = {
    serverHost = ''
};

var _mm = {
    //網路請求功能
    request : function(param){
        var _this = this;
    

  
 

    

    
    
簡單封裝了一個OKHttp的工具類 非同步get請求和post請求
     
  
  
  
 package com.example.okhttp.OkHttp; 
 import android.os.Handler; import android.os.Looper; import android.util.Log; 
 import com.example.okhttp.Con 

  
 

    

    
    
常用JSON工具類JsonUtil封裝
     
 
							
							
							前言


  專案中經常會有String轉Object以及Object轉Json字串的需求，故封裝一個常用Json工具類




Maven依賴



    <dependency>
      <groupId>org.codehau 

  
 

    

    
    
分享一下常用的工具類ES6封裝
     
 
                分享一下目前專案中用到的工具類,僅供參考,直接引用可能會報錯,用到的第三方外掛需要引入對應的包和模組才行 

/**
 * 公有方法類
 */

import Chinese from '../../../static/js/i18n/zh-cn.js';
import En 

  
 

    

    
    
Java常用工具類封裝——連線資料庫的工具類
     
 
                
資料庫操作工具類，供大家參考。
package com.itjh.javaUtil;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement 

  
 

    

    
    
web開發一些常用的工具類的網站
     
 項目目錄   圖標   nbsp   菜鳥   rip   icons   power   html css   som   持續更新中..........
 
1.  網頁圖標網站:
http://fontawesome.io
下面的鏈接瀏覽其提供的圖標:
http://fontawesome.io/ico 

  
 

    

    
    
java使用Calendar類獲取常用簡單工具類
     
 凱哥java前言：在工作中，我們經常會用到時間相關的。比如月初、月末、年初、年末、指定月份所在季度的季末、當前時間加X天、x月、x年等這些常用的雖說不難，但是如果要用到，立馬又想不起來。這裏凱哥歸納了一些常用的放在一個工具類中。有需要的朋友可以拿去或是收藏。如果大家有更好的，歡迎留言。如果凱哥哪裏不對，歡迎大 

  
 

    

    
    
Python之自定義封裝一個簡單的Log類
     
 實例對象   級別   port   detail   問題   文件夾   相對   alt   腳本   參考：http://www.jb51.net/article/42626.htm
參考：http://blog.csdn.net/u011541946/article/details/70198676 

  
 

    

    
    
C# 中那些常用的工具類(Utility Class)(三)
     
 asp   call   ast   eba   order   com   引用   creat   信息   　　今天就平常用到的非常多的反射這個技術來做一個總結，當然關於反射需要講解的東西實在是太多的內容，在一片文章中想要講解清楚是非常難的，本篇博客也是就自己本人對這些內容學習後的一個總結，當然包括看書 

  
 

    

    
    
自己封裝的data日期工具類
     
 tar   gets   back   rtt   負數   tint   inner   clear   obj   HTML頁面的調用

<!DOCTYPE html>
<html>

    <head>
        <meta charset= 

  
 

    

    
    
創建一個node.js express類型的app
     
 node.js   bst   pro   一個   project   gen   storm   sta   創建   

npm install -g express-generator


express <project_name>


cd <project_name>,  

  
 

    

    
    
兩個常用的工具類（經常使用）
     
 persist   iter   per   pan   src   edi   cnblogs   n)   ali   一.首先創建一個可以進行序列化的類 創建類的時候前面加上[Serializable](需要註意的是想要打出序列化需要引入的命名空間為 using System;)
二.然後寫入一些類的基 

  
 

    

    
    
Apache最常用的工具類
     
  
 
 本博內容摘自部落格大神一杯甜酒，部落格地址https://blog.csdn.net/u012562943/article/details/82664692 
 1. org.apache.commons.io.IOUtils 
 
  closeQuietly() 
  toString() 
  

  
 

    

    
    
Android 常用開發工具類
     
  
 
 
 Android 好用的框架與UI效果demo收集 
 1.AndroidCommon 
 裡面幾乎包含你所有想要的工具類，如： 
 網路工具、SharedPreferences工具、時間工具、日誌工具、字串工具、Json工具、裝置資訊工具、APP工具類、bitmap的工具類等等 
 github 

  
 

    

    
    
使用計算類BigDecimal寫一個精確計算工具類
     
  
 
 在日常開放當中需要我們計算數字，利率。通常Java的做法是使用Math相關的API。但是，這樣做是不夠精確的，由於float和double不能進行計算，如果強行進行計算會使得計算不準確。造成難以挽回的損失。為了彌補這一個缺點Java提供了BigDecimal這個類來解決。在使用這個類的時候需要將do 

  
 

    

    
    
commons.lang中常用的工具類
     
  
 
 
  
   
    
     
      
       
       
        
         
          
           
            
             
              
               
         

  
 

    

    
    
常用的工具類DBUtil/ServiceFactory/TransactionInvocationHandler/UUIDUtil等等
     
  
  
  
 常用的工具類DBUtil/ServiceFactory/TransactionInvocationHandler/UUIDUtil 
 package com.yy.crud.util; 
 import java.sql.Connection; import java.sql.Driver 

  
 

    

    
    
Java 常用的工具類—判斷Excel版本&讀取Excel/CSV檔案
     
 
                以下內容均來自實際專案需求，記錄下，網上找的讀取Excel會出現不少問題，下面程式碼是經過好多次測試改進的符合現在專案的程式碼，如有不同要求，請自行修改，程式碼均只去掉了包名。
注：我們的Excel 第一行是表頭，其他行是資料1、第一行遇到空列，後面的內容自動忽略掉，
2、如 

  
 

    

    
    
自己封裝的Log優化工具類
     
 
							
							
							/**
 * Log方法優化工具類
 * 只在Debug模式下列印log並新增 log程式碼定位
 */

public class L {

    private L() {
        /* cannot be instantiated */