// 在JS中, 用正则来移除所有的标签, 只留下innerText:
var html = "<p><a href='http://www.cnblogs.com'>JS</a>by<em>M27</em></p>";
var text = html.replace(/<(.|\s)*?>/g, "-");
console.log(text);   // --JS-by-M27--

console.log( /^((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)$/.exec("192.168.1.0") ); 
// 得到的结果为: ["192.168.1.0", "1.", "1", "0", index: 0, input: "192.168.1.0"]
console.log(RegExp.$1) // 1.
console.log(RegExp.$2) // 1
console.log(RegExp.$3) // 0

// (?:exp)不会改变正则表达式的处理方式, 只是这样的组匹配的内容不会被捕获到某个组里面, 也不会拥有组号.
const color = "#990000";
const arr = /#(?:\d+)/.exec(color);
console.log(RegExp.$1);  // ""
console.log(arr);  // ["#990000", index: 0, input: "#990000"]

const str1 = "bedroom";
const str2 = "bedding";
const pattern1 = /(bed(?=room))/;
const pattern2 = /(bed(?!room))/; 
console.log(pattern1.test(str1));   // true
console.log(RegExp.$1);             // bed
console.log(RegExp.$2 === "");      // true
console.log(pattern1.test(str2));   // false
console.log(pattern2.test(str2));   // true 

// 在JS中, 用正则来移除hr以外的所有标签, 只留下innerText: 
const html = "<p><a href='#'>JS</a></p><hr/><p>by<em>M27</em></p>";
const text = html.replace(/<(?!hr)(.|\s)*?>/ig, "-");
console.log(text);   // --JS--<hr/>-by-M27—

// 在JS中, 假如你想要给一个很长的数字中每三位间加一个逗号, 可以如下操作:
const html = "123456780123456789";
const reg = /(\d{3})(?=\d)/g;
console.log(html.replace(reg, str => str + ","));
// console.log(html.replace(reg, "$1,"));

// 在JS中, 假如需要匹配密码必须有至少一个大写字母, 一个小写字母, 一个数字, 并且长度至少6位而且只能是数字字母组合, 可以如下操作:
/^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)[A-Za-z0-9]{6,}$/.test("123Abc");  // true

const pattern = new RegExp("\\[bc\\]at", "ig");

const str = "cat, bat, sat, fat";
const pattern = /(.)at/;
let matchs = pattern.exec(str);
console.log(matchs);    // ["cat", "c", index: 0, input: "cat, bat, sat, fat"]
console.log(matchs[0]); // "cat"   第一个匹配项
console.log(matchs[1]); // "c"     捕获组匹配的字符串
console.log(pattern.lastIndex);   // 0 表示开始搜索下一个匹配项的字符位置

matchs = pattern.exec(str);
console.log(matchs);    // ["cat", "c", index: 0, input: "cat, bat, sat, fat"]
console.log(matchs[0]); // "cat"   第一个匹配项
console.log(matchs[1]); // "c"     捕获组匹配的字符串
console.log(pattern.lastIndex);   // 0 表示开始搜索下一个匹配项的字符位置
/*
** 在不设置全局标志(g)的情况下, 在同一个字符串上多次调用 exec() 将始终返回第一个匹配项的信息.
** 而在设置了全局标志(g)的情况下, 每次调用 exec() 则都会在字符串中继续查找新匹配项. 如下:
*/
const str = "cat, bat, sat, fat";
const pattern = /(.)at/g;
let matchs = pattern.exec(str);
console.log(matchs);    // ["cat", "c", index: 0, input: "cat, bat, sat, fat"]
console.log(matchs[0]); // "cat"   第一个匹配项
console.log(matchs[1]); // "c"     捕获组匹配的字符串
console.log(pattern.lastIndex);   // 3 表示开始搜索下一个匹配项的字符位置     

matchs = pattern.exec(str);
console.log(matchs);    // ["bat", "b", index: 5, input: "cat, bat, sat, fat"]
console.log(matchs[0]); // "bat"   第一个新的匹配项
console.log(matchs[1]); // "b"     捕获组匹配的字符串
console.log(pattern.lastIndex);   // 8 表示开始搜索下一个匹配项的字符位置
/*
** 因为模式 pattern 是全局模式, 因此每次调用 exec() 都会返回字符串中的下一个匹配项, 直到搜索到字符串末尾为止.
** 注意模式的 lastIndex 属性的变化, 在全局模式匹配下, lastIndex的值在每次调用exec()后都会增加, 而在非全局模式下则始终保持不变. 
** 对于exec()方法, 即使在模式匹配中设置了全局标志(g), 它每次也只会返回一个匹配项!
** -----------------------------------------------
** lastIndex 表示匹配成功时候, 匹配内容最后一个字符所在原字符串中的位置+1.
** 也就是匹配内容的下一个字符的index(如果匹配内容在字符串的结尾, 同样返回原字符串中的位置+1, 也就是字符串的length, 如果匹配失败则重置 lastIndex 的值为0).
** 如果未带参数g, lastIndex始终为0.
*/

// 注: match()不管是否带g(全局匹配), 连续多次匹配获取的结果都一样. 如下:
const str = "cat, bat, sat, fat";
const patternOne = /(.)at/;
let matchs = str.match(patternOne);
console.log(matchs);    // ["cat", "c", index: 0, input: "cat, bat, sat, fat"]
console.log(matchs[0]); // "cat"   第一个匹配项
console.log(matchs[1]); // "c"     捕获组匹配的字符串

matchs = str.match(patternOne);
console.log(matchs);    // ["cat", "c", index: 0, input: "cat, bat, sat, fat"]
console.log(matchs[0]); // "cat"   第一个匹配项
console.log(matchs[1]); // "c"     捕获组匹配的字符串
--------------------------------------------------------------------
const patternTwo = /(.)at/g;
matchs = str.match(patternTwo);
console.log(matchs);    // ["cat", "bat", "sat", "fat"]
console.log(matchs[0]); // "cat"
console.log(matchs[1]); // "bat"

matchs = str.match(patternTwo);
console.log(matchs);    // ["cat", "bat", "sat", "fat"]
console.log(matchs[0]); // "cat"
console.log(matchs[1]); // "bat"

const str = "M27 is stupid!";
const pos = str.search(/M27/i);  // 0

function changeVarStyle(str) {
   return str.replace(/\_([a-zA-Z0-9])+/g, match => match.charAt(1).toUpperCase() + match.slice(2).toLowerCase());
}

const text = "this is a short summer";
const pattern = /(.)hort/g;
if (pattern.test(text)) {
  console.log(RegExp.input);         // this is a short summer
  console.log(RegExp.lastMatch);     // short
  console.log(RegExp.lastParen);     // s
  console.log(RegExp.leftContext);   // this is a 
  console.log(RegExp.rightContext);  // summer
}
/*
** 上面的长属性名都可以使用相应的短属性名来访问.
** 由于这些短属性名大多都不是有效的 ECMAScript 标识符, 因此必须通过方括号语法来访问它们, 即:
   RegExp.lastMatch         →  RegExp["$&"]
   RegExp.lastParen         →  RegExp["$+"]
   RegExp.leftContext       →  RegExp["$`"]
   RegExp.rightContext      →  RegExp["$'"]
*/

// 1. 获取 url 中的查询参数.
function getParam(name) {
  const reg = new RegExp(`\\b${name}=([^&#?]*)`);
  const m = window.location.href.match(reg);
  return m ? m[1] || '' : '';
}

// 2. 获取 url 中的 Hash 值.
function getHashString() {
  const s = window.location.href;
  const m = s.match(/#([^&#?]*)/);
  return m ? m[1] || '' : '';
}

// 3. 设置 url 中的查询参数.
function setUrlParam(link, name, value) {
  let currentUrl = link.split('#')[0];
  const reg = new RegExp(`${name}=([^&]*)`);
  if (/\?/g.test(currentUrl)) {
    if (reg.test(currentUrl)) {
      currentUrl = currentUrl.replace(reg, `${name}=${value}`);
    } else {
      currentUrl += `&${name}=${value}`;
    }
  } else {
    currentUrl += `?${name}=${value}`;
  }
  if (link.split('#')[1]) {
    currentUrl += `#${link.split('#')[1]}`;
  }
  return currentUrl;
}
function setUrlParams(link, obj){
  for (let i in obj) {
    link = setUrlParam(link, i, obj[i]);
  }
  return link;
}

// 4. 驼峰命名转下划线/连接符命名 ( componentMapModelRegistry )
function changeVarStyleOne(str) {
  return str.match(/^([a-z][a-z0-9]+)|([A-Z][a-z0-9]*)/g).join('_').toLowerCase();
}