正則（regular expression）描述了一種字符串的匹配式。一般應用在一些方法中，用一些特殊的符號去代表一些特定的內容，對字符串中的信息實現查找，替換，和提取的操作。js中的正則表達式用RegExp對象表示，有兩種寫法：一種是字面量寫法，一種是構造函數寫法。
一、定義正則表達式
字面量創建方式 /正則表達式/[修飾符可寫可不寫]
實例創建方式 new RegExp(字符串，[修飾符])
二者的區別：字面量創建方式特殊含義的字符不需要轉義，實例創建方式需要轉義。
let reg = /\d+/g; reg = new RegExp("\\d+", "g");
字面量定義不能進行字符串拼接，實例創建方式可以。正則表達式中的部分內容是變量存儲的值。如果正則中要包含某個變量的值，那么就不能使用字面量創建方式，因為字面量創建方式，兩個斜杠包起來的都是元字符。要使用構造函數創建，因為它傳遞的規則是字符串，字符串是可以進行拼接的。
let str = "davina"; reg = /^@"+str+"@$/; console.log(reg.test("@davina@")); //false
console.log(reg.test('@"""strrrrr"@')); //true
reg1 = new RegExp("^@" + str + "@$"); console.log(reg1.test("@davina@")); //true
修飾符（放在第二個斜杠的后面）
i: 不區分大小寫，在確定匹配項的時候忽略大小寫
m: 多行模式，在到達一行文本末尾還會繼續查找下一行中是否存在與模式匹配的項
g: 代表全局（global）匹配，模式將用於所有字符串，並非在發現第一個匹配項時就停止
<script> str = 'davina'; var re = /i/; var re1 = new RegExp('davina'); str1 = 'davi/na'; var re2 = '/i\//'; //注意：正則在匹配/時會有問題，需要轉義
console.log(re, re1, re2); // /i/ /davina/ "/i//"
</script>
二、常用的正則字符
<script> 轉義字符 1. \\ 反斜杠 2. \' 單引號 3. \" 雙引號 4. \d 數字（0-9之間的任意一個數字） 5. \D 除數字以外的任意字符 6. \r 回車 7. \n 換行 8. \f 走紙換頁 9. \t 橫向跳格 10.\s 空格 11.\S 非空格 12.\w 數字，字母，下划線0-9 a-z A-Z 13.\W 非數字，非字母，非下划線 14.\b 單詞的邊界，獨立的部分（字符串的開頭結尾，空格的兩邊都是邊界） 15. \B 非邊界的部分 16. . 任意一個字符（代表所有） 17. \. 真正的點 中括號 18.[abc] 查找中括號中的任意字符 19.[^abc] 查找任何不在方括號之間的字符(^表示除掉某個字符) 20.[0-9] 查找任何從0-9的數字 21.[a-z] 查找任何從小寫a到小寫z的字符 22.[A-Z] 查找任何從大寫A到大寫Z的字符 [\u4e00-\u9fa5] 中文區間，包含所有的漢字 量詞：一般用於限制正則的長度 23.{n} 重復n次 （正好n次） 24.{n,m} 至少重復n次，最多重復m次 25.{n,} 至少重復n次，最多不限 （n到多） 26.+ 至少重復1次，最多不限{1,} （1到多） 27.? 至少重復0次，最多重復1次{0,1}（0到1次可有可無） 28.* 至少重復0次，最多不限{0,} （0到多） 29.n$ 匹配任何結尾為n的字符串 30.^n 匹配任何開頭為n的字符串 31.x|y 匹配x或者是y </script>
//元字符：^：以哪一個元字符作為開始 $：以哪一個元字符作為結束 /* let reg1 = /^\d/, reg2 = /\d$/, reg3 = /\d+/, reg4 = /^\d+$/; //^以哪一個元字符作為開始 console.log(reg1.test("2020davina")); //true //$以哪一個元字符作為結束 console.log(reg2.test("2020davina")); //false //兩個都不加，字符串中包含符合規則的內容即可 console.log(reg3.test("2020davina")); //true //兩個都加，字符串只能是和規則一致的內容 console.log(reg4.test("2020davina")); //false */
//元字符：\：轉義 // .不是小數點，是基於\n外的任意字符 /* let reg = /^2.3$/; console.log(reg.test("2.3")); //true console.log(reg.test("2%3")); //true console.log(reg.test("23")); //false //我們可以用轉義符\ 讓其代表小數點 let reg1 = /^2\.3$/; console.log(reg1.test("2.3")); //true */
//元字符：x|y ：x或者y中的一個字符 /* let reg = /^18|29$/; console.log(reg.test("18")); //=>true console.log(reg.test("29")); //=>true console.log(reg.test("182")); //=>true //可以看出直接x|y會存在很亂的優先級問題，一般我們寫的時候都伴隨着小括號進行分組，因為小括號改變處理的優先級 reg1 = /^(18|29)$/; //只能是18或者29中的一個了 console.log(reg1.test("18")); //=>true console.log(reg1.test("29")); //=>true console.log(reg1.test("182")); //=>false */
// 元字符：[]：一般代表本身的含義 //1.中括號中出現的字符一般都代表本身的含義 /* let reg = /^[@+]$/; console.log(reg.test("@")); //=>true console.log(reg.test("+")); //=>true console.log(reg.test("@+")); //=>false reg1 = /^[\d]$/; //=>\d在中括號中還是0-9 console.log(reg1.test("d"));//=>false console.log(reg1.test("9"));//=>true //2.中括號中不存在多位數 reg2 = /^[10-29]$/; //1或者0-2或者9 console.log(reg2.test("1"));//=>true console.log(reg2.test("9"));//=>true console.log(reg2.test("0"));//=>true console.log(reg2.test("10"));//=>false */
三、正則常用的方法
1、RegExp對象相關的方法
test()方法
作用：查看正則表達式與指定字符串是否匹配,用的最多是來做判斷的
語法：正則.test(字符串);
返回值：返回true/false
exec()方法
作用：返回匹配的結果，與match類似
語法：正則.exec(字符串)
返回值：數組或者是null
<script>
var str = '123dvain4553a'; var re = /a/; console.log(re.test(str)); //true
var re1 = /\d/; if (re1.test(str)) { console.log('有數字') //有數字
} else { console.log('沒有數字') } var str2 = 'cat,dog,fish,chicken,duck,bat'; var re2 = /.at/; var re3 = /da/; console.log(re2.exec(str2));//["cat", index: 0, input: "cat,dog,fish,chicken,duck,bat", groups: undefined]
console.log(re3.exec(str2)); //null
</script>
2、String對象相關方法
match()方法
作用：匹配指定的字符串或者是正則，把匹配到的結果放到一個數組中
語法：字符串.match(字符串或者正則)
返回值：找到后把結果放在數組中且返回，沒有找到返回null
注意：如果不帶g修飾符，只會匹配一個結果，且給找到的數組增加兩個屬性：index(找到字符對應的位置)，input(原字符串，從哪個字符串身上找)。
exec()和match()的區別：1. 一個是正則一個是String. 2. exec()只會匹配第一個符合的字符串（g對其並不起作用），match是否返回所有匹配的數組和正則里是否帶g有關。
<script>
var str = 'dav2in34n345av'; var re = /v/; var re1 = /V/; console.log(str.match(re), str.match(re1)); //["v", index: 2, input: "dav2in34n345a", groups: undefined] null
var re2 = /v/g; var re3 = /\d+/g; //有量詞+，所以找到的字符數量不是單個的了
console.log(str.match(re2)); // ["v", "v"]
console.log(str.match(re3));// ["2", "34", "345"]
var str1 = 'dav2in34nda345dav'; var re4 = new RegExp('da', 'g'); var re5 = /da/g; console.log(re4.exec(str1)); //['da']
console.log(str1.match(re5)); //['da','da','da']
</script>
search()方法
作用：找到匹配的字符串首次出現的位置
語法：字符串.search(字符串或者正則)
返回值：找到了返回位置的下標，沒有找到返回-1
注意：search()方法的參數可以是正則，indexOf()的方法參數不可能是正則
<script>
var str = 'davina123Davian'; console.log(str.indexOf('v')); //2
console.log(str.search('v'));//2
var re = /\d/; console.log(str.indexOf(re), str.search(re));//-1 6
</script>
split()方法
作用：按約定字符串或者字符串規則拆分成數組，接受一個字符串或者正則
語法：字符串.split(字符串或者正則)
返回值：數組
<script>
var color = 'red,green,blue,white,yellow'; var color1 = color.split(/[^\,]+/); console.log(color.split(',')); //["red", "green", "blue", "white", "yellow"]
console.log(color1) // ["", ",", ",", ",", ",", ""]
</script>
replace()方法
作用：替換匹配的字符串
語法：字符串.replace(字符串或者正則，字符串或者函數)
參數：在這里參數要說明一下：參數1是字符串或者正則，要匹配的內容，與replace的第一個參數一樣;參數2是要匹配的內容對應的位置下標;參數3是原字符串。
要強調的是這個函數一定要一個返回值，否則會用undefined來替代
返回值：替換后的新字符串，原來的字符串沒有任何的變化
<script>
var str = 'davinadavina'; var re = /d/g; console.log(str.replace('d', 'h'), str); //havinadavina davinadavina
console.log(str.replace(re, 'h'), str); //havinahavina davinadavina
var newStr = str.replace('d', function () { return 'f'; }) console.log(newStr); //favinadavina //1. 把da全部換成*號
var re1 = /da/g; var newStr1 = str.replace(re1, function ($0, $1, $2) { console.log($0, $1, $2); //da 6 davinadavina
var str = ''; for (var i = 0; i < $0.length; i++) { str += '*'; } return str; }) console.log(newStr1) //**vina**vina //2. 去掉字符串兩邊的空格，包括里面的空格
var str = ' davina davina davina '; var str0 = str.replace(/\s+/g, ''); //davinadavinadavina
console.log(str0); //去掉左空格
var str1 = str.replace(/^\s*/, '');//davina davina davina
console.log(str1); //去掉右空格
var str2 = str.replace(/(\s*$)/g, ''); // davina davina davina
console.log(str2); //去掉左右空格
var str3 = str.replace(/(^\s+)|(\s+&)/g, ''); //davina davina davina
console.log(str3); // ^s+表示以空格開頭的連續空白字符，s+$表示以空格結尾的連續空白字符
</script>
四、捕獲
實現正則的捕獲在正則RegExp.prototype上有如下方法：exec(),test();字符串String.prototype上支持正則表達式的方法有：replace(),match(),splite()行等。
正則捕獲具有貪婪性和懶惰性。所謂的貪婪性就是正則在捕獲時，每一次都會盡可能多的去捕獲符合條件的內容。懶惰性指的是正則在成功捕獲一次后不管后邊的字符串有沒有符合條件的都不再捕獲。
貪婪性：默認情況下，正則捕獲的時候，是按照當前正則所匹配的最長結果來獲，如果想要取消，則只需在在量詞元字符后面設置？就可。
let str = "davina2019davina2020", reg = /\d+/g, reg1 = /\d+?/g; console.log(str.match(reg)); //["2019", "2020"]
console.log(str.match(reg1)); //["2", "0", "1", "9", "2", "0", "2", "0"]
懶惰性：exec()方法中就用到了捕獲，它捕獲的結果是null或者是一個數組，每執行一次exec，只能捕獲到一個符合正則規則的結果，但默認情況下，我們執行100遍，獲取到的結果永遠都是第一個匹配到的，這就是正則捕獲的懶惰性引起的，默認只捕獲第一個。我們實在正則捕獲的前提是，當前正則要 字符串匹配，如是不匹配捕獲的結果是null。
/* 第一項：本次捕獲到的內容 * 其余項：對應小分組本次單獨捕獲的內容 * index:當前捕獲內容在字符串中的起始索引 * input:原始字符串 */ let str = "davina2019davina2020", reg = /\d+/g; console.log(reg.exec(str)); //["2019", index: 6, input: "davina2019davina2020", groups: undefined] /* 正則捕獲的懶惰性：默認只捕捕獲第一個 */ console.log(reg.exec(str)); //["2019", index: 6, input: "davina2019davina2020", groups: undefined]
reg1 = /^\d+$/; console.log(reg.exec(str));//null
懶惰性捕獲的原因是因為默認情況下lastIndex(當前正則下一次匹配起始索引位置)的值不會被修改，每一次都是從字符串開始的位置查找，所以找到的永遠只是第一個。我們可以用全局修飾符g來解決這個問題。設置全局匹配修飾符g后，第一次匹配完，lastIndex會自己修改，當全部捕獲完后，再次捕獲的結果為null,lastIndex又回到了被始值，再次捕獲又從第一個開始。
let str = "davina2019davina2020", reg = /\d+/, reg1 = /\d+/g; console.log(reg.lastIndex); //0
console.log(reg.exec(str));//["2019", index: 6, input: "davina2019davina2020", groups: undefined]
console.log(reg.lastIndex); //=>0
console.log(reg1.exec(str)); // ["2019", index: 6, input: "davina2019davina2020", groups: undefined]
console.log(reg1.lastIndex); //10
我們可以編寫一個方法，執行一次可以把所有匹配的結果捕獲到。
!(function () { function execAll(str = "") { //str:要匹配的字符串 //this:RegExp的實例（當前操作的正則） //進來后的第一件事，是驗證當前正則是否設置了G，不設置則不能在進行循環捕獲，不然會導致死循環
if (!this.global) return this.exec(str); // ary存儲最后所有捕獲的信息 res存儲每一次捕獲的內容（數組）
let ary = [], res = this.exec(str); while (res) { // 把每一次捕獲的內容res[0]存放到數組中
ary.push(res[0]); //只要捕獲的內容不為null，就要繼續捕獲下去
res = this.exec(str); } return ary.length === 0 ? null : ary; } RegExp.prototype.execAll = execAll; })(); let reg = /\d+/g, str = "davina2019davina2020"; console.log(reg.execAll(str)); //["2019", "2020"]
分組：量詞控制之前元素的出現次數，這個元素可以是字符也可以是表達式，如果把一個表達式用括號括起來那么，這個表達式可以看成是子項（子表達式）。
如這里的/\d{2}/就表示一個分組，匹配兩位數字；如果希望字符串’ab‘重復出現2次應該加上括號(ab){2}而不是ab{2}
<script>
var re = /\d{2}/; console.log(re.test('12')); //true
var re1 = /(ab){2}/; console.log(re1.test('abab'));//true
var re2 = /ab{2}/; console.log(re2.test('abab'));//false
</script>
下面為正則的分組捕獲
let str = "130828199012040112"; let reg = /^(\d{6})(\d{4})(\d{2})(\d{2})\d{2}(\d)(?:\d|X)$/; console.log(reg.exec(str)); console.log(str.match(reg)); //["130828199012040112", "130828", "1990", "12", "04", "1", index: 0, input: "130828199012040112", groups: undefined] //=>第一項：大正則匹配的結果 //=>其余項：每一個小分組單獨匹配捕獲的結果 //=>如果設置了分組（改變優先級），但是捕獲的時候不需要單獨捕獲，可以基於?:來處理
如果我們即要捕獲到{數字}，也想單獨的把數字獲取到，可以用以下方法：
let str = "{2020}年{11}月{11}日", reg = /\{(\d+)\}/g, Allary = [], Singleary = []; res = reg.exec(str); while (res) { let [All, Single] = res; Allary.push(All); Singleary.push(Single); res = reg.exec(str); } console.log(Allary, Singleary); //(3) ["{2020}", "{11}", "{11}"] (3) ["2020", "11", "11"]
分組引用：正則表達式中也能進行引用，分組引用就是通過“\數字”讓其代表和對應分組出現一模一樣的內容
let str = "book"; let reg = /^[a-zA-Z]([a-zA-Z])\1[a-zA-Z]$/; console.log(reg.test("book")); //=>true
console.log(reg.test("deep")); //=>true
console.log(reg.test("some")); //=>false
五、斷言
在正則表達式中，有些結構並不是真正匹配文本，而只負責判斷在某個位置左/右是否符合要求，這種結構被稱為斷言，也可稱為錨點。強調：斷言只是條件，幫助找到真正需要的字符串，本身是不會匹配的。
1、單詞邊界
單詞邊界是指單詞字符(\w)能匹配的字符串的左右位置。在java和js中，單詞字符(\w)等同於[0-9a-zA-Z]。所以在這些語言中可以用\b\w+\b把所有的單詞提取出來。
單詞邊界是\b（它其實是一個位置匹配符）,它能匹配的位置：一邊是單詞字符\w,一邊是非單詞字符\W.（在\w和\W之間）。
與\b對應的還有\B，表示非單詞的邊界這個用的很少
<script>
var str = 'abc_123,4java=efg漢字'; var reg = /[\d\D]\b/g;["4", ",", "a", "=", "g"] console.log(str.match(reg)); var str1 = 'Wrong cannot afford defeat but right can'; var reg1 = /\b\w+\b/g; console.log(str1.match(reg1)); //["Wrong", "cannot", "afford", "defeat", "but", "right", "can"]
//如有特殊的單詞如e-mail上面的正則就無法匹配要進行修改
</script>
2、^和$
常用的斷言還有^和$,它們分別是匹配字符串的開始和結束位置，可以用來判斷整個字符串能否由表達式匹配。^和$常用功能是刪除字符串首尾多余的空白。
<script>
var str = 'first word\nsecond word\nthird word'; reg = /^\w*/ console.log(reg.exec(str)); /["first"]/
function fn(str) { reg1 = /^\s+|\s+$/
return str.replace(reg1, '') } console.log(fn(' davina ')); //davina
</script>
3、環視
環視是指在某個位置向左向右看，保證其左右位置必須出一某類字符。且環視也中同上面兩個斷言一樣只是做判斷。它在匹配過程中，不占用字符，所以被稱為"零寬"。
零寬度正先行斷言
（?=exp）:字符出現的位置的右邊必須匹配到exp這個表達式
<script>
var str = 'abcdefg'; re = /.*(?=d)/; console.log(re.exec(str)); //["abc"]
var str1 = 'davina6666'; var str2 = 'davina22222'; var reg = /davina(?=6666|4444)/; console.log(str1.match(reg), str2.match(reg));//["davina"] null
</script>
零寬度負先行斷言
(?!exp) : 字符出現的位置的右邊不能是exp這個表達式
<script>
var str = "#www#eee"; var reg = /(?!\#)\w+/g; console.log(str.match(reg)); //["www", "eee"]
</script>
零寬度正后發斷言
(?<=exp)：字符出現的位置的左邊是exp這個表達式（js不支持）
零寬度負后發斷言
(?<!exp)：字符出現的位置的左邊不能是exp這個表達式（js不支持）
總結來說，我們可以看到？號它在正則中有以下幾個作用：
？左邊是非量詞無字符，本身代表量詞元字符，出現0到1次
？左邊是量詞元字符：取消捕獲時候的貪婪性
(?:)：只匹配不捕獲
(?=)：正向預查
(?!)：負向預查
示例：閃亮字體效果
<style> span { transition: 0.5s all ease;} </style> <body> <div id="div"> 你微笑地看着我，不說一句話。而我知道，為了這個，我已經等了很久了。 有一次，我們夢見大家都是不相識的。我們醒了，卻知道我們原是相親相愛的。 有一天，我們夢見我們相親相愛了，我醒了，才知道我們早已經是陌路。 世界上最遙遠的距離，不是生與死，而是我就站在你面前，你卻不知道我愛你。 </div> <script> var val = div.innerHTML; div.innerHTML = val.replace(/./g, function (x) { return '<span>' + x + '</span>' }) setInterval(() => { var span = document.getElementsByTagName('span'); for (var i = 0; i < span.length; i++) { span[i].style.color = 'rgb(' + parseInt(Math.random() * 256) + ',' + parseInt(Math.random() * 256) + ',' + parseInt(Math.random() * 256) + ')'; } }, 500); </script> </body>
改變日期格式
let time = "2019-08-13"; //=>變為"2019年08月13日"
let reg = /^(\d{4})-(\d{1,2})-(\d{1,2})$/; /* 方法一： time = time.replace(reg,"$1年$2月$3日"); console.log(time); //=>2019年08月13日 //=>RegExp.$1~RegExp.$9：獲取當前本次正則匹配后，第一個到第九個分組的信息 */
/*方法二： //=>還可以這樣處理 [str].replace([reg],[function]) time = time.replace(reg,(...arg)=>{ let [,$1,$2,$3]=arg; $2.length<2?$2="0"+$2:null; $3.length<2?$3="0"+$3:null; return $1+"年"+$2+"月"+$3+"日"; }); */
單詞首字母大寫
let str = "keep on going never give up."; let reg = /\b([a-zA-Z])[a-zA-Z]*\b/g; //=>函數被執行了六次，每一次都把正則匹配信息傳遞給函數 //=>每一次arg:["keep","k"] ["on","o"] ...
str = str.replace(reg, (...arg) => { let [content, $1] = arg; $1 = $1.toUpperCase(); content = content.substring(1); return $1 + content; }); console.log(str); //Keep On Going Never Give Up.
六、常用的正則
// 1.驗證是否為有效數字 /* * [-+]? => 可能出現+ -號，也可能不出現 * (\d)|([1-9]\d+) => 一位時0-9都可，多位時，首位不能是0 * \.\d+? => 小數部分可能有可能沒有，一旦有小數點，后面必須要有數字 */ let reg = /^[-+]?(\d|([1-9]\d+))(\.\d+?)$/; // 2.驗證密碼 /* 規則：數字，字母，下划線，6-16位 */ let reg1 = /^\w{6,16}$/; //3.驗證姓名 /* * 漢字：/u4E00-u9FA5/ * 長度2-10位 {2,10} * 可能有譯名：·點 名字（漢譯）(·[\u4E00-u9FA5]{2,10}){0,2} */ let reg2 = /^[\u4E00-u9FA5]{2,10}(·[\u4E00-u9FA5]{2,10}){0,2}$/; // 4.驗證郵箱 /* * 1. 郵箱的名字是由數字，字母，_,-,.這幾個部分組成，但是-/.不能連續的出現也不能作為開始 => \w+((-\w+)|\.\w+) * 2. @后面跟着：數字，字母（1到多位）[A-Za-z0-9]+ * 3. 多@后面跟着的名字的補充 =>((\.|-)[A-Za-z0-9]+)* * 多域名：.com.cn * 企業郵箱：ph.px.office.com * 4. 域名的匹配 => \.[A-Za-z0-9]+ */ let reg3 = /^\w+((-\w+)|\.\w+)*@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/; // 5. 身份證號碼 /* * 1. 一共18位，最后一位可能是x * 2. 前6位是省市縣；中間8位是年月日；最后4位中，最后一位是X或者數字，倒數第二位性別：奇為男，偶為女；其余的算法 */ let reg4 = /^(\d{6})(\d{4})(\d{2})(\d{2})\d{2}(\d)(\d|X)$/; reg4.exec('421181199411039063');//["421181199411039063", "421181", "1994", "11", "03", "6", "3"] //6. 手機號
let reg5 = /^1[34578]\d{9}$/;
~(function () { //1.千分符
/* * thousandMark:實現數字的千分符處理 * @params: * @return * [string] 千分符后的字符串 */ function thousandMark() { return this.replace(/\d{1,3}(?=(\d{3})+$)/g, (content) => content + ","); } // 還有一種方法：把字符串倒過來 // num = num.split('').reverse().join(''); // for (let i = 2; i < num.length - 1; i += 4){ // let prev = num.substring(0, i + 1), // next = num.substring"(i+1); // num = prev + "," + next; // } // num = num.split('').reverse().join(''); //console.log(num); //2.url的處理
/* * queryURLParams:獲取url地址問號后面的參數信息（可能有hash值） * @params * @return * [object] 把所有問號參數信息以鍵值對的方式存儲起來且返回 */ function queryURLParams() { let obj = {}, reg = /([^?=&#]+)=([^?=&#]+)/g; this.replace(reg, (...[, $1, $2]) => (obj[$1] = $2)); this.replace(/#([^?=&#]+)/g, (...[, $1]) => (obj["hash"] = $1)); return obj; } //3.時間字符串的格式化處理
/* * formatTime:時間字符串的格式化處理 * @params * templete:[string] 我們最后希望獲取的日期格式的模板 */ function formatTime(templete = "{0}年{1}月{2}日 {3}時{4}分{5}秒") { let timeAry = this.match(/\d+/g); return templete.replace(/\{(\d+)}/g, (...[, $1]) => { let time = timeAry[$1] || "00"; return time.length < 2 ? "0" + time : time; }); } /* 把所有的方法擴展到內置類String.prototype上 */ ["thousandMark", "queryURLParams", "formatTime"].forEach((item) => { String.prototype[item] = eval(item); }); })(); //進行驗證
let num = "1234553423423"; //1,234,553,423,423
console.log(num.thousandMark()); let url = "http://www.davina.cn/?lx=1&from=qq#video"; console.log(url.queryURLParams()); //{lx: "1", from: "qq", hash: "video"}
let time = "2020-8-13 16:1:39"; console.log(time.formatTime()); //2020年08月13日 16時01分39秒