JavaScript(JS) 常用判斷式 + [ 正規表示式 / 正規表達式]

JavaScript(JS) 常用判斷式 + [ 正規表示式 / 正規表達式]

JavaScript(JS) 常用判斷式 + [ 正規表示式 / 正規表達式]


資料來源: https://github.com/hangjob/vue-admin/blob/master/src/utils/util.js


 /**
  * 郵箱
  * @param {*} s
  */
 export const isEmail = (s) => {
     return /^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+((.[a-zA-Z0-9_-]{2,3}){1,2})$/.test(s)
 }
 
 /**
  * 手機號碼(大陸)
  * @param {*} s
  */
 export const isMobile = (s) => {
     return /^1[0-9]{10}$/.test(s)
 }
 
 /**
  * 電話號碼(對岸)
  * @param {*} s
  */
 export const isPhone = (s) => {
     return /^([0-9]{3,4}-)?[0-9]{7,8}$/.test(s)
 }
 
 /**
  * URL地址
  * @param {*} s
  */
 export const isURL = (s) => {
     return /^http[s]?:\/\/.*/.test(s)
 }
 
 /**
  * 是否字串
  */
 export const isString = (o) => {
     return Object.prototype.toString.call(o).slice(8, -1) === 'String'
 }
 
 /**
  * 是否數字
  */
 export const isNumber = (o) => {
     return Object.prototype.toString.call(o).slice(8, -1) === 'Number'
 }
 
 /**
  * 是否boolean
  */
 export const isBoolean = (o) => {
     return Object.prototype.toString.call(o).slice(8, -1) === 'Boolean'
 }
 
 /**
  * 是否函數
  */
 export const isFunction = (o) => {
     return Object.prototype.toString.call(o).slice(8, -1) === 'Function'
 }
 
 /**
  * 是否為null
  */
 export const isNull = (o) => {
     return Object.prototype.toString.call(o).slice(8, -1) === 'Null'
 }
 
 /**
  * 是否undefined
  */
 export const isUndefined = (o) => {
     return Object.prototype.toString.call(o).slice(8, -1) === 'Undefined'
 }
 
 /**
  * 是否物件
  */
 export const isObj = (o) => {
     return Object.prototype.toString.call(o).slice(8, -1) === 'Object'
 }
 
 /**
  * /是否陣列
  */
 export const isArray = (o) => {
     return Object.prototype.toString.call(o).slice(8, -1) === 'Array'
 }
 
 /**
  * 是否時間
  */
 export const isDate = (o) => {
     return Object.prototype.toString.call(o).slice(8, -1) === 'Date'
 }
 
 /**
  * 是否正則
  */
 export const isRegExp = (o) => {
     return Object.prototype.toString.call(o).slice(8, -1) === 'RegExp'
 }
 
 /**
  * 是否錯誤物件
  */
 export const isError = (o) => {
     return Object.prototype.toString.call(o).slice(8, -1) === 'Error'
 }
 
 /**
  * 是否Symbol函數
  */
 export const isSymbol = (o) => {
     return Object.prototype.toString.call(o).slice(8, -1) === 'Symbol'
 }
 
 /**
  * 是否Promise物件
  */
 export const isPromise = (o) => {
     return Object.prototype.toString.call(o).slice(8, -1) === 'Promise'
 }
 
 /**
  * 是否Set物件
  */
 export const isSet = (o) => {
     return Object.prototype.toString.call(o).slice(8, -1) === 'Set'
 }
 
 export const ua = navigator.userAgent.toLowerCase();
 
 /**
  * 是否是微信流覽器
  */
 export const isWeiXin = () => {
     return ua.match(/microMessenger/i) == 'micromessenger'
 }
 
 /**
  * 是否是移動端
  */
 export const isDeviceMobile = () => {
     return /android|webos|iphone|ipod|balckberry/i.test(ua)
 }
 
 /**
  * 是否是QQ流覽器
  */
 export const isQQBrowser = () => {
     return !!ua.match(/mqqbrowser|qzone|qqbrowser|qbwebviewtype/i)
 }
 
 
 /**
  * 是否是爬蟲
  */
 export const isSpider = () => {
     return /adsbot|googlebot|bingbot|msnbot|yandexbot|baidubot|robot|careerbot|seznambot|bot|baiduspider|jikespider|symantecspider|scannerlwebcrawler|crawler|360spider|sosospider|sogou web sprider|sogou orion spider/.test(ua)
 }
 
 
 /**
  * 是否ios
  */
 export const isIos = () => {
     var u = navigator.userAgent;
     if (u.indexOf('Android') > -1 || u.indexOf('Linux') > -1) {  //安卓手機
         return false
     } else if (u.indexOf('iPhone') > -1) {//蘋果手機
         return true
     } else if (u.indexOf('iPad') > -1) {//iPad
         return false
     } else if (u.indexOf('Windows Phone') > -1) {//winphone手機
         return false
     } else {
         return false
     }
 }
 
 /**
  * 是否為PC端
  */
 export const isPC = () => {
     var userAgentInfo = navigator.userAgent;
     var Agents = ["Android", "iPhone",
         "SymbianOS", "Windows Phone",
         "iPad", "iPod"];
     var flag = true;
     for (var v = 0; v < Agents.length; v++) {
         if (userAgentInfo.indexOf(Agents[v]) > 0) {
             flag = false;
             break;
         }
     }
     return flag;
 }
 
 
 
 /**
  * 去除html標籤
  * @param {*} str 
  */
 export const removeHtmltag = (str) => {
     return str.replace(/<[^>]+>/g, '')
 }
 
 /**
  * 獲取url參數
  * @param {*} name 
  */
 export const getQueryString = (name) => {
     const reg = new RegExp('(^|&)' + name + '=([^&]*)(&|$)', 'i');
     const search = window.location.search.split('?')[1] || '';
     const r = search.match(reg) || [];
     return r[2];
 }
 
 
 /**
  * 動態引入js
  * @param {*} src 
  */
 export const injectScript = (src) => {
     const s = document.createElement('script');
     s.type = 'text/javascript';
     s.async = true;
     s.src = src;
     const t = document.getElementsByTagName('script')[0];
     t.parentNode.insertBefore(s, t);
 }
 
 /**
  * 根據url位址下載
  * @param {*} url 
  */
 export const download = (url) => {
     var isChrome = navigator.userAgent.toLowerCase().indexOf('chrome') > -1;
     var isSafari = navigator.userAgent.toLowerCase().indexOf('safari') > -1;
     if (isChrome || isSafari) {
         var link = document.createElement('a');
         link.href = url;
         if (link.download !== undefined) {
             var fileName = url.substring(url.lastIndexOf('/') + 1, url.length);
             link.download = fileName;
         }
         if (document.createEvent) {
             var e = document.createEvent('MouseEvents');
             e.initEvent('click', true, true);
             link.dispatchEvent(e);
             return true;
         }
     }
     if (url.indexOf('?') === -1) {
         url += '?download';
     }
     window.open(url, '_self');
     return true;
 }
 
 /**
  * el是否包含某個class
  * @param {*} el 
  * @param {*} className 
  */
 export const hasClass = (el, className) => {
     let reg = new RegExp('(^|\\s)' + className + '(\\s|$)')
     return reg.test(el.className)
 }
 
 /**
  * el添加某個class
  * @param {*} el 
  * @param {*} className 
  */
 export const addClass = (el, className) => {
     if (hasClass(el, className)) {
         return
     }
     let newClass = el.className.split(' ')
     newClass.push(className)
     el.className = newClass.join(' ')
 }
 
 /**
  * el去除某個class
  * @param {*} el 
  * @param {*} className 
  */
 export const removeClass = (el, className) => {
     if (!hasClass(el, className)) {
         return
     }
     let reg = new RegExp('(^|\\s)' + className + '(\\s|$)', 'g')
     el.className = el.className.replace(reg, ' ')
 }
 
 /**
  * 獲取滾動的座標
  * @param {*} el 
  */
 export const getScrollPosition = (el = window) => ({
     x: el.pageXOffset !== undefined ? el.pageXOffset : el.scrollLeft,
     y: el.pageYOffset !== undefined ? el.pageYOffset : el.scrollTop
 });
 
 /**
  * 滾動到頂部
  */
 export const scrollToTop = () => {
     const c = document.documentElement.scrollTop || document.body.scrollTop;
     if (c > 0) {
         window.requestAnimationFrame(scrollToTop);
         window.scrollTo(0, c - c / 8);
     }
 }
 
 /**
  * el是否在視口範圍內
  * @param {*} el 
  * @param {*} partiallyVisible 
  */
 export const elementIsVisibleInViewport = (el, partiallyVisible = false) => {
     const { top, left, bottom, right } = el.getBoundingClientRect();
     const { innerHeight, innerWidth } = window;
     return partiallyVisible
         ? ((top > 0 && top < innerHeight) || (bottom > 0 && bottom < innerHeight)) &&
         ((left > 0 && left < innerWidth) || (right > 0 && right < innerWidth))
         : top >= 0 && left >= 0 && bottom <= innerHeight && right <= innerWidth;
 }
 
 /**
  * 洗牌演算法隨機
  * @param {*} arr 
  */
 export const shuffle = (arr) => {
     var result = [],
         random;
     while (arr.length > 0) {
         random = Math.floor(Math.random() * arr.length);
         result.push(arr[random])
         arr.splice(random, 1)
     }
     return result;
 }
 
 /**
  * 劫持粘貼板
  * @param {*} value 
  */
 export const copyTextToClipboard = (value) => {
     var textArea = document.createElement("textarea");
     textArea.style.background = 'transparent';
     textArea.value = value;
     document.body.appendChild(textArea);
     textArea.select();
     try {
         var successful = document.execCommand('copy');
     } catch (err) {
         console.log('Oops, unable to copy');
     }
     document.body.removeChild(textArea);
 }
 
 
 /**
  * 判斷類型集合
  * @param {*} str 
  * @param {*} type 
  */
 export const checkStr = (str, type) => {
     switch (type) {
         case 'phone':   //手機號碼
             return /^1[3|4|5|6|7|8|9][0-9]{9}$/.test(str);
         case 'tel':     //座機
             return /^(0\d{2,3}-\d{7,8})(-\d{1,4})?$/.test(str);
         case 'card':    //身份證
             return /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/.test(str);
         case 'pwd':     //密碼以字母開頭,長度在6~18之間,只能包含字母、數位和底線
             return /^[a-zA-Z]\w{5,17}$/.test(str)
         case 'postal':  //郵遞區號
             return /[1-9]\d{5}(?!\d)/.test(str);
         case 'QQ':      //QQ號
             return /^[1-9][0-9]{4,9}$/.test(str);
         case 'email':   //郵箱
             return /^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/.test(str);
         case 'money':   //金額(小數點2位)
             return /^\d*(?:\.\d{0,2})?$/.test(str);
         case 'URL':     //網址
             return /(http|ftp|https):\/\/[\w\-_]+(\.[\w\-_]+)+([\w\-\.,@?^=%&:/~\+#]*[\w\-\@?^=%&/~\+#])?/.test(str)
         case 'IP':      //IP
             return /((?:(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d))/.test(str);
         case 'date':    //日期時間
             return /^(\d{4})\-(\d{2})\-(\d{2}) (\d{2})(?:\:\d{2}|:(\d{2}):(\d{2}))$/.test(str) || /^(\d{4})\-(\d{2})\-(\d{2})$/.test(str)
         case 'number':  //數字
             return /^[0-9]$/.test(str);
         case 'english': //英文
             return /^[a-zA-Z]+$/.test(str);
         case 'chinese': //中文
             return /^[\\u4E00-\\u9FA5]+$/.test(str);
         case 'lower':   //小寫
             return /^[a-z]+$/.test(str);
         case 'upper':   //大寫
             return /^[A-Z]+$/.test(str);
         case 'HTML':    //HTML標記
             return /<("[^"]*"|'[^']*'|[^'">])*>/.test(str);
         default:
             return true;
     }
 }
 
 /**
  * 嚴格的身份證校驗
  * @param {*} sId 
  */
 export const isCardID = (sId) => {
     if (!/(^\d{15}$)|(^\d{17}(\d|X|x)$)/.test(sId)) {
         console.log('你輸入的身份證長度或格式錯誤')
         return false
     }
     //身份證城市
     var aCity = { 11: "北京", 12: "天津", 13: "河北", 14: "山西", 15: "內蒙古", 21: "遼寧", 22: "吉林", 23: "黑龍江", 31: "上海", 32: "江蘇", 33: "浙江", 34: "安徽", 35: "福建", 36: "江西", 37: "山東", 41: "河南", 42: "湖北", 43: "湖南", 44: "廣東", 45: "廣西", 46: "海南", 50: "重慶", 51: "四川", 52: "貴州", 53: "雲南", 54: "西藏", 61: "陝西", 62: "甘肅", 63: "青海", 64: "寧夏", 65: "新疆", 71: "臺灣", 81: "香港", 82: "澳門", 91: "國外" };
     if (!aCity[parseInt(sId.substr(0, 2))]) {
         console.log('你的身份證地區非法')
         return false
     }
 
     // 出生日期驗證
     var sBirthday = (sId.substr(6, 4) + "-" + Number(sId.substr(10, 2)) + "-" + Number(sId.substr(12, 2))).replace(/-/g, "/"),
         d = new Date(sBirthday)
     if (sBirthday != (d.getFullYear() + "/" + (d.getMonth() + 1) + "/" + d.getDate())) {
         console.log('身份證上的出生日期非法')
         return false
     }
 
     // 身份證號碼校驗
     var sum = 0,
         weights = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2],
         codes = "10X98765432"
     for (var i = 0; i < sId.length - 1; i++) {
         sum += sId[i] * weights[i];
     }
     var last = codes[sum % 11]; //計算出來的最後一位身份證號碼
     if (sId[sId.length - 1] != last) {
         console.log('你輸入的身份證號非法')
         return false
     }
 
     return true
 }
 
 
 
 
 /********************************************* 數位轉換 ******************************/
 
 
 /**
  * 亂數範圍
  */
 export const random = (min, max) => {
     if (arguments.length === 2) {
         return Math.floor(min + Math.random() * ((max + 1) - min))
     } else {
         return null;
     }
 
 }
 
 /**
  * 將阿拉伯數字翻譯成中文的大寫數位
  */
 export const numberToChinese = (num) => {
     var AA = new Array("零", "一", "二", "三", "四", "五", "六", "七", "八", "九", "十");
     var BB = new Array("", "十", "百", "仟", "萬", "億", "點", "");
     var a = ("" + num).replace(/(^0*)/g, "").split("."),
         k = 0,
         re = "";
     for (var i = a[0].length - 1; i >= 0; i--) {
         switch (k) {
             case 0:
                 re = BB[7] + re;
                 break;
             case 4:
                 if (!new RegExp("0{4}//d{" + (a[0].length - i - 1) + "}$")
                     .test(a[0]))
                     re = BB[4] + re;
                 break;
             case 8:
                 re = BB[5] + re;
                 BB[7] = BB[5];
                 k = 0;
                 break;
         }
         if (k % 4 == 2 && a[0].charAt(i + 2) != 0 && a[0].charAt(i + 1) == 0)
             re = AA[0] + re;
         if (a[0].charAt(i) != 0)
             re = AA[a[0].charAt(i)] + BB[k % 4] + re;
         k++;
     }
 
     if (a.length > 1) // 加上小數部分(如果有小數部分)
     {
         re += BB[6];
         for (var i = 0; i < a[1].length; i++)
             re += AA[a[1].charAt(i)];
     }
     if (re == '一十')
         re = "十";
     if (re.match(/^一/) && re.length == 3)
         re = re.replace("一", "");
     return re;
 }
 
 /**
  * 將數位轉換為大寫金額
  */
 export const changeToChinese = (Num) => {
     //判斷如果傳遞進來的不是字元的話轉換為字元
     if (typeof Num == "number") {
         Num = new String(Num);
     };
     Num = Num.replace(/,/g, "") //替換tomoney()中的“,”
     Num = Num.replace(/ /g, "") //替換tomoney()中的空格
     Num = Num.replace(/¥/g, "") //替換掉可能出現的¥字元
     if (isNaN(Num)) { //驗證輸入的字元是否為數位
         //alert("請檢查小寫金額是否正確");
         return "";
     };
     //字元處理完畢後開始轉換,採用前後兩部分分別轉換
     var part = String(Num).split(".");
     var newchar = "";
     //小數點前進行轉化
     for (var i = part[0].length - 1; i >= 0; i--) {
         if (part[0].length > 10) {
             return "";
             //若數量超過拾億單位,提示
         }
         var tmpnewchar = ""
         var perchar = part[0].charAt(i);
         switch (perchar) {
             case "0":
                 tmpnewchar = "零" + tmpnewchar;
                 break;
             case "1":
                 tmpnewchar = "壹" + tmpnewchar;
                 break;
             case "2":
                 tmpnewchar = "貳" + tmpnewchar;
                 break;
             case "3":
                 tmpnewchar = "三" + tmpnewchar;
                 break;
             case "4":
                 tmpnewchar = "肆" + tmpnewchar;
                 break;
             case "5":
                 tmpnewchar = "伍" + tmpnewchar;
                 break;
             case "6":
                 tmpnewchar = "陸" + tmpnewchar;
                 break;
             case "7":
                 tmpnewchar = "柒" + tmpnewchar;
                 break;
             case "8":
                 tmpnewchar = "捌" + tmpnewchar;
                 break;
             case "9":
                 tmpnewchar = "玖" + tmpnewchar;
                 break;
         }
         switch (part[0].length - i - 1) {
             case 0:
                 tmpnewchar = tmpnewchar + "元";
                 break;
             case 1:
                 if (perchar != 0) tmpnewchar = tmpnewchar + "拾";
                 break;
             case 2:
                 if (perchar != 0) tmpnewchar = tmpnewchar + "佰";
                 break;
             case 3:
                 if (perchar != 0) tmpnewchar = tmpnewchar + "仟";
                 break;
             case 4:
                 tmpnewchar = tmpnewchar + "萬";
                 break;
             case 5:
                 if (perchar != 0) tmpnewchar = tmpnewchar + "拾";
                 break;
             case 6:
                 if (perchar != 0) tmpnewchar = tmpnewchar + "佰";
                 break;
             case 7:
                 if (perchar != 0) tmpnewchar = tmpnewchar + "仟";
                 break;
             case 8:
                 tmpnewchar = tmpnewchar + "億";
                 break;
             case 9:
                 tmpnewchar = tmpnewchar + "拾";
                 break;
         }
         var newchar = tmpnewchar + newchar;
     }
     //小數點之後進行轉化
     if (Num.indexOf(".") != -1) {
         if (part[1].length > 2) {
             // alert("小數點之後只能保留兩位元,系統將自動截斷");
             part[1] = part[1].substr(0, 2)
         }
         for (i = 0; i < part[1].length; i++) {
             tmpnewchar = ""
             perchar = part[1].charAt(i)
             switch (perchar) {
                 case "0":
                     tmpnewchar = "零" + tmpnewchar;
                     break;
                 case "1":
                     tmpnewchar = "壹" + tmpnewchar;
                     break;
                 case "2":
                     tmpnewchar = "貳" + tmpnewchar;
                     break;
                 case "3":
                     tmpnewchar = "三" + tmpnewchar;
                     break;
                 case "4":
                     tmpnewchar = "肆" + tmpnewchar;
                     break;
                 case "5":
                     tmpnewchar = "伍" + tmpnewchar;
                     break;
                 case "6":
                     tmpnewchar = "陸" + tmpnewchar;
                     break;
                 case "7":
                     tmpnewchar = "柒" + tmpnewchar;
                     break;
                 case "8":
                     tmpnewchar = "捌" + tmpnewchar;
                     break;
                 case "9":
                     tmpnewchar = "玖" + tmpnewchar;
                     break;
             }
             if (i == 0) tmpnewchar = tmpnewchar + "角";
             if (i == 1) tmpnewchar = tmpnewchar + "分";
             newchar = newchar + tmpnewchar;
         }
     }
     //替換所有無用漢字
     while (newchar.search("零零") != -1)
         newchar = newchar.replace("零零", "零");
     newchar = newchar.replace("零億", "億");
     newchar = newchar.replace("億萬", "億");
     newchar = newchar.replace("零萬", "萬");
     newchar = newchar.replace("零元", "元");
     newchar = newchar.replace("零角", "");
     newchar = newchar.replace("零分", "");
     if (newchar.charAt(newchar.length - 1) == "元") {
         newchar = newchar + "整"
     }
     return newchar;
 }
 
 
 
 /********************************************* 關於陣列 ******************************/
 
 /**
  * 判斷一個元素是否在陣列中
  */
 export const contains = (arr, val) => {
     return arr.indexOf(val) != -1 ? true : false;
 }
 
 
 /**
  * @param  {arr} 陣列
  * @param  {fn} 回呼函數
  * @return {undefined}
  */
 export const each = (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);
     }
 }
 
 /**
  * @param  {arr} 陣列
  * @param  {fn} 回呼函數
  * @param  {thisObj} this指向
  * @return {Array} 
  */
 export const map = (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  {arr} 陣列
  * @param  {type} 1:從小到大   2:從大到小   3:隨機
  * @return {Array}
  */
 export const sort = (arr, type = 1) => {
     return arr.sort((a, b) => {
         switch (type) {
             case 1:
                 return a - b;
             case 2:
                 return b - a;
             case 3:
                 return Math.random() - 0.5;
             default:
                 return arr;
         }
     })
 }
 
 /**
  * 去重
  */
 export const unique = (arr) => {
     if (Array.hasOwnProperty('from')) {
         return Array.from(new Set(arr));
     } else {
         var n = {}, r = [];
         for (var i = 0; i < arr.length; i++) {
             if (!n[arr[i]]) {
                 n[arr[i]] = true;
                 r.push(arr[i]);
             }
         }
         return r;
     }
 }
 
 
 /**
  * 求兩個集合的並集
  */
 export const union = (a, b) => {
     var newArr = a.concat(b);
     return this.unique(newArr);
 }
 
 /**
  * 求兩個集合的交集
  */
 export const intersect = (a, b) => {
     var _this = this;
     a = this.unique(a);
     return this.map(a, function (o) {
         return _this.contains(b, o) ? o : null;
     });
 }
 
 /**
  * 刪除其中一個元素
  */
 export const remove = (arr, ele) => {
     var index = arr.indexOf(ele);
     if (index > -1) {
         arr.splice(index, 1);
     }
     return arr;
 }
 
 /**
  * 將類陣列轉換為陣列的方法
  */
 export const formArray = (ary) => {
     var arr = [];
     if (Array.isArray(ary)) {
         arr = ary;
     } else {
         arr = Array.prototype.slice.call(ary);
     };
     return arr;
 }
 
 /**
  * 最大值
  */
 export const max = (arr) => {
     return Math.max.apply(null, arr);
 }
 
 /**
  * 最小值
  */
 export const min = (arr) => {
     return Math.min.apply(null, arr);
 }
 
 /**
  * 求和
  */
 export const sum = (arr) => {
     return arr.reduce((pre, cur) => {
         return pre + cur
     })
 }
 
 /**
  * 平均值
  */
 export const average = (arr) => {
     return this.sum(arr) / arr.length
 }
 
 
 
 /********************************************* String 字串操作 ******************************/
 
 
 /**
  * 去除空格
  * @param  {str}
  * @param  {type} 
  * type:  1-所有空格  2-前後空格  3-前空格 4-後空格
  * @return {String}
  */
 export const trim = (str, type) => {
     type = type || 1
     switch (type) {
         case 1:
             return str.replace(/\s+/g, "");
         case 2:
             return str.replace(/(^\s*)|(\s*$)/g, "");
         case 3:
             return str.replace(/(^\s*)/g, "");
         case 4:
             return str.replace(/(\s*$)/g, "");
         default:
             return str;
     }
 }
 
 /**
  * @param  {str} 
  * @param  {type}
  *       type:  1:首字母大寫  2:首字母小寫  3:大小寫轉換  4:全部大寫  5:全部小寫
  * @return {String}
  */
 export const changeCase = (str, type) => {
     type = type || 4
     switch (type) {
         case 1:
             return str.replace(/\b\w+\b/g, function (word) {
                 return word.substring(0, 1).toUpperCase() + word.substring(1).toLowerCase();
 
             });
         case 2:
             return str.replace(/\b\w+\b/g, function (word) {
                 return word.substring(0, 1).toLowerCase() + word.substring(1).toUpperCase();
             });
         case 3:
             return str.split('').map(function (word) {
                 if (/[a-z]/.test(word)) {
                     return word.toUpperCase();
                 } else {
                     return word.toLowerCase()
                 }
             }).join('')
         case 4:
             return str.toUpperCase();
         case 5:
             return str.toLowerCase();
         default:
             return str;
     }
 }
 
 
 /*
 *  檢測密碼強度
 */
 export const checkPwd = (str) => {
     var Lv = 0;
     if (str.length < 6) {
         return Lv
     }
     if (/[0-9]/.test(str)) {
         Lv++
     }
     if (/[a-z]/.test(str)) {
         Lv++
     }
     if (/[A-Z]/.test(str)) {
         Lv++
     }
     if (/[\.|-|_]/.test(str)) {
         Lv++
     }
     return Lv;
 }
 
 /**
  * 函數節流器
  * @param  {Function} fn 需要執行性的函數
  * @param  {number} time 時間戳記
  * @param  {number} interval 間隔時間
  */
 export const debouncer = (fn, time, interval = 200) => {
     if (time - (window.debounceTimestamp || 0) > interval) {
         fn && fn();
         window.debounceTimestamp = time;
     }
 }
 
 /**
  * 在字串中插入新字串
  * @param {string} soure 源字元
  * @param {string} index 插入字元的位置
  * @param {string} newStr 需要插入的字元
  * @returns {string} 返回新生成的字元
  */
 export const insertStr = (soure, index, newStr) => {
     var str = soure.slice(0, index) + newStr + soure.slice(index);
     return str;
 }
 
 /**
 * 判斷兩個物件是否鍵值相同
 * @param  {Object}  a 第一個對象
 * @param  {Object}  b 第一個對象
 * @return {Boolean}   相同返回true,否則返回false
 */
 export const isObjectEqual = (a, b) => {
     var aProps = Object.getOwnPropertyNames(a);
     var bProps = Object.getOwnPropertyNames(b);
 
     if (aProps.length !== bProps.length) {
         return false;
     }
 
     for (var i = 0; i < aProps.length; i++) {
         var propName = aProps[i];
 
         if (a[propName] !== b[propName]) {
             return false;
         }
     }
     return true;
 }
 
 /**
  * 16進制顏色轉RGB\RGBA字串
  * @param  {String} val 16進制顏色值
  * @param  {Number} opa 不透明度,取值0~1
  * @return {String}     轉換後的RGB或RGBA顏色值
  */
 export const colorToRGB = (val, opa) => {
 
     var pattern = /^(#?)[a-fA-F0-9]{6}$/; //16進制顏色值校驗規則
     var isOpa = typeof opa == 'number'; //判斷是否有設置不透明度
 
     if (!pattern.test(val)) { //如果值不符合規則返回空字元
         return '';
     }
 
     var v = val.replace(/#/, ''); //如果有#號先去除#號
     var rgbArr = [];
     var rgbStr = '';
 
     for (var i = 0; i < 3; i++) {
         var item = v.substring(i * 2, i * 2 + 2);
         var num = parseInt(item, 16);
         rgbArr.push(num);
     }
 
     rgbStr = rgbArr.join();
     rgbStr = 'rgb' + (isOpa ? 'a' : '') + '(' + rgbStr + (isOpa ? ',' + opa : '') + ')';
     return rgbStr;
 }
 
 /**
  * 追加url參數
  * @param {string} url url參數
  * @param {string|object} key 名字或者物件
  * @param {string} value 值
  * @return {string} 返回新的url
  * @example
  * appendQuery('lechebang.com', 'id', 3);
  * appendQuery('lechebang.com?key=value', { cityId: 2, cityName: '北京'});
  */
 export const appendQuery = (url, key, value) => {
     var options = key;
     if (typeof options == 'string') {
         options = {};
         options[key] = value;
     }
     options = $.param(options);
     if (url.includes('?')) {
         url += '&' + options
     } else {
         url += '?' + options
     }
     return url;
 }
 
 
 /**
  * 判斷a陣列是否包含b陣列中
  */
 export const getArrRepeat = (arr1,arr2) =>{
     return arr1.filter((item,index) =>{
         return arr2.includes(item)
     })
 } 
 
 
 
 /**
  * 將陣列分片
  * 列子[1,2,3,4,5,6,7,8] [[1,2,3],[4,5,6],[7,8]]
  */
 export const arrChunk = (data=[],space=5) => {
     var result = [];
     for (var i = 0, len = data.length; i < len; i += space) {
         result.push(data.slice(i, i + space));
     }
     return {data:result,total:data.length,space};
 }
 
 /**
  * 複製內容
  */
 export const copyToClip = (content) => {
     var aux = document.createElement("input");
     aux.setAttribute("value", content);
     document.body.appendChild(aux);
     aux.select();
     document.execCommand("copy");
     document.body.removeChild(aux);
     console.log('複製成功');
 }
 
 /**
  * 生成uuid
  */
 export const generateUUID = () => {
     let d = new Date().getTime();
     let uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
         let r = (d + Math.random() * 16) % 16 | 0;
         d = Math.floor(d / 16);
         return (c == 'x' ? r : (r & 0x7 | 0x8)).toString(16);
     });
     return uuid;
 }

發表迴響

你的電子郵件位址並不會被公開。 必要欄位標記為 *