1. 用位运算符提升效率
效果为：
代码为：
<script>
/* 使用位运算符提升效率 */
function main(params) {
// | 取整数
let num1 = 1.7
num1 = num1 | 0 // 1
console.log('| 取整数--num1', num1)
// >> 取半
let num2 = 6
num2 = num2 >> 1 // 3
console.log('>> 取半--num2', num2)
// << 加倍
let num3 = 6
num3 = num3 << 1 // 12
console.log('<< 加倍--num3', num3)
// ^ 交换值
let num4 = 10
let num5 = 20
num4 ^= num5
num5 ^= num4
num4 ^= num5
console.log('^ 交换值', 'num4', num4, 'num5', num5)
// & 判奇数
let num6 = 10
let num7 = 11
// (num6 & 1) === 1 // false
// (num7 & 1) === 1 // true
console.log('& 判奇数--num6', (num6 & 1) === 1, 'num7', (num7 & 1) === 1)
// 双!!转布尔值
console.log('!!(num6 & 1)--判断奇数' ,!!(num6 & 1) , '!!(num6 % 2 )--判断奇数' , !!(num6 % 2) )
// ~ 判断是否存在
const data = '123456'
const key = '3'
const keyIsExist = !!~data.indexOf(key) // true
console.log('~ 判断是否存在', keyIsExist)
// 是否是2的整数幂
const isPowerOf2 = num => (num & (num - 1)) === 0
console.log('是否是2的整数幂', isPowerOf2(8))
console.log('是否是2的整数幂', isPowerOf2(7))
}
main()
</script>
2. 同步阻塞法实现sleep函数
<script>
/* 同步阻塞法实现sleep函数 */
const sleep = delay =>{
const start = new Date().getTime()
while ( (new Date().getTime() < start + delay)) {
continue
}
}
console.log(1)
sleep(3000)
console.log(3)
</script>
3. 利用new URL解析URL
效果为：
<script>
function main() {
/* 利用new URL去解析URL */
const parseURL = (url = '') => {
const res = new URL(url)
res.queryParams = key => {
if (key) {
return res.searchParams.get(key)
}
const params = {}
const paramGroup = res.search.replace(/^\?/, '').split('&');
console.log('paramGroup' ,paramGroup)
paramGroup.forEach(param => {
const [key, val] = param.split('=')
params[key] = val
})
console.log('解析的对象为', params)
return params
}
console.log(res)
return res.queryParams()
}
let params = parseURL('https://www.example.com/a/b?c=1&d=2')
console.log('params' , params)
}
main()
</script>
【补充】序列化参数
效果为：
let data = {
mobile: "15908349526", // 手机号
carNo: '粤B88888', // 车牌号
userName: '李四', // 姓名
passWord: '123456', // 密码
}
// 序列化参数
const convertObj = (data) => {
let str = '?'
let arr = Object.entries(data)
let spec = ''
console.log('arr', arr)
arr.forEach((ele, ind, array) => {
spec = (ind !== array.length - 1) ? '&' : ''
str += ele.join('=') + spec
})
console.log('str', str)
return str
}
convertObj(data)
4. 一行代码实现星级评分
效果为：
<script>
function main() {
const getRate = (rate =0)=> '1111100000'.slice(5-rate , 10-rate)
getRate(3)
console.log('getRate(3)',getRate(3))
}
main()
</script>
5. 判断是否是千分符字符
<script>
function main() {
const numberIsThousand = str => /^-?\d{1,3}(,\d{3})*(\.\d+)?$/.test(str)
numberIsThousand('100,000,000,000')
numberIsThousand('100,000,000,00')
console.log("numberIsThousand('100,000,000,000')",numberIsThousand('100,000,000,000'))
console.log("numberIsThousand('100,000,000,00')",numberIsThousand('100,000,000,00'))
console.log(/[\u5171](-?\d{1,8})[\u6761]/.test('共99条'))
}
main()
</script>
6. 一行代码生成指定长度的数组
<script>
function main() {
const list = len => [...new Array(len).keys()]
const array10 = list(10)
console.log('array10', array10)
}
main()
</script>
7. 实现防抖函数
<script>
/**
* @description: 防抖函数
* @param { 执行的回调函数 } func
* @param { 防抖的时间 } wait
* @param { 是否立即执行 } immediate
* @return {*}
*/
function Debounce(func, wait = 3000, immediate = false) {
let timeout = null // 设置防抖函数的定时器
const bounce = (func, wait, immediate)=> {
// 如果有定时器，那么清除定时器
if (timeout !== null) clearTimeout(timeout)
// 立即执行
if (immediate) {
let callNow = !timeout
timeout = setTimeout(() => {
timeout = null
}, wait);
if (callNow) typeof func === 'function' && func()
} else {
// 设置定时器，当最后一次操作后， timeout不会再被清除，所以在延时wait毫秒后执行func回调函数
timeout = setTimeout(() => {
typeof func === 'function' && func()
}, wait);
}
}
bounce(func, wait, immediate)
}
Debounce(()=>{console.log(1)})
</script>
8. 函数只执行一次
<script>
// 只执行一次的函数， arguments存在浏览器不兼容的情况
function once(fun) {
let called = false
return function () {
if(!called){
called = true
fun.apply(this, arguments)
}
}
}
// 被执行函数
function func() {
console.log('函数' ,1)
}
// 赋值给匿名函数
let onlyOnce = once(func)
// 测试
onlyOnce() // 1
onlyOnce() // 不执行
</script>
9. 复制文本到剪贴板
<body>
<button onclick="copyToClipboard('563245')">复制</button>
<script>
function copyToClipboard(context) {
const clipBoardData = window.clipBoardData
if(clipBoardData){
clipBoardData.clearData()
clipBoardData.setData('text' , context)
return true
}else if(document.execCommand){
const el = document.createElement('textarea')
el.value = context
el.setAttribute('readonly','')
el.style.position = 'absolute'
el.style.left = '-9999px'
document.body.appendChild(el)
el.select()
document.execCommand('copy')
document.body.removeChild(el)
return true
}
return false
}
</script>
</body>
10. 用apply将数组各项添加到另一个数组中
<script>
function main() {
let a = [1, 2, 3]
let b = ['a', 'b']
// 即不改变a,也不改变b
console.log('a.concat(b):', a.concat(b), 'a:', a, 'b:', b)
// 即不改变a,也不改变b
console.log(' [...a, ...b]:', [...a, ...b], 'a:', a, 'b:', b)
}
main()
</script>
11. 使用Boolean构造函数进行一次转换，来快速过滤假值
<script>
const compact = arr => arr.filter(Boolean)
console.log(compact([0, 1, false, '', 3, 'a', 'e' * 23, NaN, 's', 34]))
</script>
12. 函数设置参数强制必传
<script>
const mandatory = () =>{ throw new Error('Missing Parameter!') }
const foo = (parame = mandatory())=>{
return parame
}
foo()
</script>
13. 箭头函数实现隐式返回结果
<script>
function fun() {
return Math.random() * Math.PI
}
const func = () =>( Math.random() * Math.PI )
console.log('fun()', fun() , 'func()' , func())
</script>
14. 创建一个一次性的函数，重新赋值之前的代码相当于运行了一次
<script>
let func = ()=>{
console.log('123')
func = ()=>{
console.log('987')
}
}
func() // 123
func() // 987
func() // 987
</script>
15. 时间大小的比较是按照字符串从左至右的每个字符串的charCode所比较的，所以时间形式补0
<script>
let a = '2020-01-09'
let b = '2020-02-09'
console.log(a>b , b>a)
console.log('21:00' <'09:10')
console.log('21:00' <'9:10')
</script>
16. 深拷贝
/**
* @description: 深拷贝
* @param { 被拷贝对象 } source
* @return {*}
*/
deepClone (source) {
if (!source && typeof source !== 'object') {
throw new Error('error arguments', 'deepClone')
}
const targetObj = source.constructor === Array ? [] : {}
Object.keys(source).forEach(keys => {
if (source[keys] && typeof source[keys] === 'object') {
targetObj[keys] = this.deepClone(source[keys])
} else {
targetObj[keys] = source[keys]
}
})
return targetObj
}
17. 将对象中的null字符串转换为空字符串
/**
* @description: 对象中的null转为空字符串
* @param {对象} data
* @return {清空null字符串}
*/
nullToStr(data) {
for (var x in data) {
if (data[x] == null) { // 如果是null 把直接内容转为 ''
data[x] = '';
} else {
if (Array.isArray(data[x])) { // 是数组遍历数组 递归继续处理
data[x] = data[x].map(z => {
return nullToStr(z);
});
}
if (typeof (data[x]) === 'object') { // 是json 递归继续处理
data[x] = nullToStr(data[x])
}
}
}
return data;
}
18. 对象键值对交换
const reverseObj = Object.fromEntries(Object.entries(obj).map(ele => {
return ele.reverse()
}))
测试代码为：
/**
* @description: 对象键值对交换位置
* @return {*}
*/
function main() {
const obj = {
name: 'John Doe',
email: 'john@doe.com',
phone: '111-111-1111'
}
const reverseObj = Object.fromEntries(Object.entries(obj).map(ele => {
return ele.reverse()
}))
console.log('reverseObj' , reverseObj)
}
效果为：
19. 数组去重
- 第一种方法【最简单，也是最好用的方法】
效果为：
代码为：
function main() {
const arr = [
"123",
"123",
"2",
"2",
"abgh",
"erd",
NaN,
undefined,
"",
"",
"",
"什么",
];
const getArr = Array.from(new Set(arr));
console.log("getArr==========>", getArr);
}
20. 数组对象中的某属性值求和 效果为：
代码为：
function main() {
const obj = [
{
a: 1,
b: "23",
c: "sdf",
d: "2sfd",
},
{
a: 1,
b: "23",
c: "sdf",
d: "2sfd",
},
{
a: 1,
b: "23",
c: "sdf",
d: "2sfd",
},
{
a: 1,
b: "23",
c: "sdf",
d: "2sfd",
},
];
// 第一种方式 【这种方式会增加耗时】
const total = obj
.map((ele) => Number(ele.b))
.reduce(function (sum, currentNum) {
return sum + currentNum;
}, 0);
console.log("total========>", total);
// 第二种方式
let arr = [
{ id: 0, price: 199.88 },
{ id: 1, price: 299.88 },
{ id: 2, price: 399.88 },
];
console.log(countTotal(arr, "price")); //899.64
//计算对象数组中某个属性合计
function countTotal(arr, keyName) {
const sum = arr.reduce(function (
total,
item,
index,
arr
) {
return item[keyName]
? total + item[keyName]
: total;
},
0);
return sum;
}
}
21. 时间戳转时间差值
效果为：
<script>
function timeAgo(timeA, timeB) {
var stamp = new Date(timeA).getTime() - new Date(timeB).getTime();
var time = (stamp / 1000);
if (null != time && "" != time) {
if (time > 60 && time < 60 * 60) {
time = parseInt(time / 60.0) + "m";
} else if (time >= 60 * 60 && time < 60 * 60 * 24) {
time = parseInt(time / 3600.0) + "h" + parseInt((parseFloat(time / 3600.0) -
parseInt(time / 3600.0)) * 60) + "m";
} else if (time >= 60 * 60 * 24) {
time = parseInt(time / 3600.0 / 24) + "d" + parseInt((parseFloat(time / 3600.0 / 24) -
parseInt(time / 3600.0 / 24)) * 24) + "h" + parseInt((parseFloat(time / 3600.0) -
parseInt(time / 3600.0)) * 60) + "m";
} else {
time = parseInt(time) + "s";
}
}
return time;
}
function splitTime(getCalcDate) {
const ind1 = getCalcDate.indexOf('d')
const ind2 = getCalcDate.indexOf('h')
const ind3 = getCalcDate.indexOf('m')
const day = ind1 != -1 ? getCalcDate.slice(0, ind1) : 0
const hour = ind2 != -1 ? getCalcDate.slice(ind1 + 1, ind2) : 0
const minute =ind3 !=-1 ? getCalcDate.slice(ind2 + 1, ind3) : 0
return [day, hour, minute]
}
const time = timeAgo(1659252166285, 1659252166285 - 850000)
console.log('timeAgo()', time)
const timeStr = splitTime(time)
console.log('timeStr',timeStr)
</script>
22. 数据类型强校验
效果为：
/**
* @param value
* @returns {string} 强数据类型校验
* isType({}) === 'Object'
*/
function isType (value) {
return Object.prototype.toString.call(value).slice(8, -1)
}
23. 筛掉对象中键值为空的属性
效果为：
代码为：
<script>
function main(){
const needPayObj = {
otherFee: '123123',
recPayMoney: '',
indemnityMoney: '',
oilcardPay: 'dfsdfsdf',
advancePay: '',
arrivalPay: '',
receiptPay: 'gdfgdfg',
billDetailMoney: '',
}
const filterObj = Object.fromEntries(Object.entries(needPayObj).filter(ele => Boolean(ele[1])))
console.log('筛掉的undefiend的键值对的对象', filterObj)
}
main()
</script>
【补充】提示键值为空的键名
const templateData = {
fileId:'',
fileName:'123123',
waybillNo:'123',
driverPhone1:'',
invoiceMain:''
}
const data = {
fileId: templateData.fileId,
fileName: templateData.fileName,
waybillNo: templateData.waybillNo,
phone: templateData.driverPhone1,
type: templateData.invoiceMain
}
const filterArr = Object.entries(data).filter(ele => !Boolean(ele[1]))
const alertArr = filterArr.map(ele=>ele[0]).join(',')
console.log(`${alertArr}参数缺失！`)
24. 数组操作
- 差集
// 求两个数组之间的差集
const diffArr = (arr1, arr2) => {
return [...arr1, ...arr2].filter((item) => !arr2.includes(item));
};
console.log(diffArr([1, 2, 4, 5, 6, 50, 100], [2, 4, 5, 10, 68, 12, 1]));
-
交集 与上方差集，相反
-
数组合并去重
const a = [1, 2, 3];
const b = [1, 5, 6];
const c = [...new Set([...a, ...b])]; //[1,2,3,5,6]
const obj1 = {
a: 1,
};
const obj2 = {
b: 1,
};
const obj = { ...obj1, ...obj2 }; //{a:1,b:1}
- 数组扁平化
const deps = {
采购部: [1, 2, 3],
人事部: [5, 8, 12],
行政部: [5, 14, 79],
运输部: [3, 64, 105],
};
let member = Object.values(deps).flat(Infinity);
console.log(member)
25. js数组和树结构数据相互转换
参考文档：blog.csdn.net/susuzhe123/…
数组转树结构采取递归和非递归两种方式，树结构转扁平化数组采取深度优先遍历（递归和非递归两种方式）和广度优先遍历实现
效果为：
<!--
* @Author: Null
* @Date: 2022-06-15 10:12:28
* @Description:
-->
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta http-equiv="X-UA-Compatible" content="IE=edge" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Document</title>
</head>
<body>
<script>
// 数组
let arr = [
{ id: 2, name: "部门B", parentId: 0 },
{ id: 3, name: "部门C", parentId: 1 },
{ id: 1, name: "部门A", parentId: 2 },
{ id: 4, name: "部门D", parentId: 1 },
{ id: 5, name: "部门E", parentId: 2 },
{ id: 6, name: "部门F", parentId: 3 },
{ id: 7, name: "部门G", parentId: 2 },
{ id: 8, name: "部门H", parentId: 4 },
];
// 树形结构数据
let tree = [
{
id: 2,
name: "部门B",
parentId: 0,
children: [
{
id: 1,
name: "部门A",
parentId: 2,
children: [
{
id: 3,
name: "部门C",
parentId: 1,
children: [{ id: 6, name: "部门F", parentId: 3 }],
},
{
id: 4,
name: "部门D",
parentId: 1,
children: [{ id: 8, name: "部门H", parentId: 4 }],
},
],
},
{ id: 5, name: "部门E", parentId: 2 },
{ id: 7, name: "部门G", parentId: 2 },
],
},
];
/**
* 数组转树 非递归求解
* 利用数组和对象相互引用 时间复杂度O(n)
* @param {Object} list
*/
function totree(list, parId) {
let obj = {};
let result = [];
//将数组中数据转为键值对结构 (这里的数组和obj会相互引用)
list.map((el) => {
obj[el.id] = el;
});
for (let i = 0, len = list.length; i < len; i++) {
let id = list[i].parentId;
if (id == parId) {
result.push(list[i]);
continue;
}
if (obj[id].children) {
obj[id].children.push(list[i]);
} else {
obj[id].children = [list[i]];
}
}
return result;
}
let result1 = totree(arr, 0);
console.log("数组转树-非递归求解---result1", JSON.stringify(result1));
/**
* 数组转树 递归求解
*/
function toTree(list, parId) {
let len = list.length;
function loop(parId) {
let res = [];
for (let i = 0; i < len; i++) {
let item = list[i];
if (item.parentId === parId) {
item.children = loop(item.id);
res.push(item);
}
}
return res;
}
return loop(parId);
}
let result2 = toTree(arr, 0);
console.log("数组转树-递归求解---result2", result2);
/**
* 树转数组扁平化结构
* 深度优先遍历 堆栈 后进先出
*/
function deepFlat(node) {
let stack = node,
data = [];
while (stack.length != 0) {
let pop = stack.pop();
data.push({
id: pop.id,
name: pop.name,
parentId: pop.parentId,
});
let children = pop.children;
if (children) {
for (let i = children.length - 1; i >= 0; i--) {
stack.push(children[i]);
}
}
}
return data;
}
console.log(
"树转数组扁平化结构-深度优先遍历【更改原数据】-堆栈后进先出----",
deepFlat(deepClone(tree))
);
/**
* 树转数组扁平化结构
* 深度优先遍历 递归
*/
function deepTraversal(data) {
const result = [];
console.log("data", data);
data.forEach((item) => {
const loop = (data) => {
result.push({
id: data.id,
name: data.name,
parentId: data.parentId,
});
let child = data.children;
if (child && child.length) {
for (let i = 0; i < child.length; i++) {
loop(child[i]);
}
}
};
loop(item);
});
return result;
}
console.log(
"树转数组扁平化结构-深度优先遍历【更改原数据】-递归----",
deepTraversal(deepClone(tree))
);
/**
* 广度优先
* 队列 先进先出
*/
function wideTraversal(node) {
let stack = node,
data = [];
while (stack.length != 0) {
let shift = stack.shift();
data.push({
id: shift.id,
name: shift.name,
parentId: shift.parentId,
});
let children = shift.children;
if (children) {
for (let i = 0; i < children.length; i++) {
stack.push(children[i]);
}
}
}
return data;
}
console.log("广度优先-队列-先进先出【更改原数据】----", wideTraversal(deepClone(tree)));
/**
* @description: 深拷贝
* @param { 被拷贝对象 } source
* @return {*}
*/
function deepClone(source) {
if (!source && typeof source !== "object") {
throw new Error("error arguments", "deepClone");
}
const targetObj = source.constructor === Array ? [] : {};
Object.keys(source).forEach((keys) => {
if (source[keys] && typeof source[keys] === "object") {
targetObj[keys] = deepClone(source[keys]);
} else {
targetObj[keys] = source[keys];
}
});
return targetObj;
}
</script>
</body>
</html>
26. 关于输入框非空的判断
if(value !== null && value !== undefined && value !== ''){
//...
}
空值合并运算符，可改写为：
if((value??'') !== ''){
//...
}
27. 异步代码同步请求Promise.all()
const fn1 = () =>{
return new Promise((resolve, reject) => {
setTimeout(() => {
resolve(1);
}, 300);
});
}
const fn2 = () =>{
return new Promise((resolve, reject) => {
setTimeout(() => {
resolve(2);
}, 600);
});
}
const fn = async () =>{
const res1 = await fn1();
const res2 = await fn2();
console.log(res1);// 1
console.log(res2);// 2
Promise.all([res1 , res2]).then(responce=>{
console.log('responce',responce)
})
}
fn()
如果并发请求时，只要其中一个异步函数处理完成，就返回结果，要用到Promise.race()。
27. Object[] 类型数据两元素交换位置
const tempList = this.sortOverList
const [fir, sen] = newVal
const tempVar = tempList.splice(fir, 1)
tempList.splice(sen, 0, ...tempVar)
28. 匹配花括号内的字符串
// 匹配titles
const regTitles = /(?<=\{)[^}]*(?=\})/g; // 匹配花括号内的字符串
(?<={) 匹配以左花括号开头
[^}]* 取得内容
(?=}) 匹配以右花括号结束
29. 删除位于首位的指定长度的字符串
'https://bx.pfr.kim/upload/img/2022-02-23/1645546503vrb4lr.png'.replace(
/(^https:\/\/bx.pfr.kim)|(https:\/\/bx.pfr.kim$)/g,
''
)
【补充】我们也可以通过 String.startWith(string) / String.endWith(string) 来进行判断
30. 常用的正则表达式 参考文档： www.cnblogs.com/Mcy13587817…
数字：^[0-9]*$
n位的数字：^\d{n}$
至少n位的数字：^\d{n,}$
m-n位的数字：^\d{m,n}$
零和非零开头的数字：^(0|[1-9][0-9]*)$
非零开头的最多带两位小数的数字：^([1-9][0-9]*)+(\.[0-9]{1,2})?$
带1-2位小数的正数或负数：^(\-)?\d+(\.\d{1,2})$
正数、负数、和小数：^(\-|\+)?\d+(\.\d+)?$
有两位小数的正实数：^[0-9]+(\.[0-9]{2})?$
有1~3位小数的正实数：^[0-9]+(\.[0-9]{1,3})?$
非零的正整数：^[1-9]\d*$ 或 ^([1-9][0-9]*){1,3}$ 或 ^\+?[1-9][0-9]*$
非零的负整数：^\-[1-9][]0-9"*$ 或 ^-[1-9]\d*$
非负整数：^\d+$ 或 ^[1-9]\d*|0$
非正整数：^-[1-9]\d*|0$ 或 ^((-\d+)|(0+))$
非负浮点数：^\d+(\.\d+)?$ 或 ^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$
非正浮点数：^((-\d+(\.\d+)?)|(0+(\.0+)?))$ 或 ^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$
正浮点数：^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ 或 ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$
负浮点数：^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ 或 ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$
浮点数：^(-?\d+)(\.\d+)?$ 或 ^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$
校验字符的表达式
汉字：^[\u4e00-\u9fa5]{0,}$
英文和数字：^[A-Za-z0-9]+$ 或 ^[A-Za-z0-9]{4,40}$
长度为3-20的所有字符：^.{3,20}$
由26个英文字母组成的字符串：^[A-Za-z]+$
由26个大写英文字母组成的字符串：^[A-Z]+$
由26个小写英文字母组成的字符串：^[a-z]+$
由数字和26个英文字母组成的字符串：^[A-Za-z0-9]+$
由数字、26个英文字母或者下划线组成的字符串：^\w+$ 或 ^\w{3,20}$
中文、英文、数字包括下划线：^[\u4E00-\u9FA5A-Za-z0-9_]+$
中文、英文、数字但不包括下划线等符号：^[\u4E00-\u9FA5A-Za-z0-9]+$ 或 ^[\u4E00-\u9FA5A-Za-z0-9]{2,20}$
可以输入含有^%&',;=?$\"等字符：[^%&',;=?$\x22]+
禁止输入含有~的字符：[^~\x22]+
三、特殊需求表达式
Email地址：^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$
域名：[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(\.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+\.?
InternetURL：[a-zA-z]+://[^\s]* 或 ^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$
手机号码：^(13[0-9]|14[5|7]|15[0|1|2|3|4|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$
电话号码("XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX)：^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$
国内电话号码(0511-4405222、021-87888822)：\d{3}-\d{8}|\d{4}-\d{7}
电话号码正则表达式（支持手机号码，3-4位区号，7-8位直播号码，1－4位分机号）: ((\d{11})|^((\d{7,8})|(\d{4}|\d{3})-(\d{7,8})|(\d{4}|\d{3})-(\d{7,8})-(\d{4}|\d{3}|\d{2}|\d{1})|(\d{7,8})-(\d{4}|\d{3}|\d{2}|\d{1}))$)
身份证号(15位、18位数字)，最后一位是校验位，可能为数字或字符X：(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)
帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
密码(以字母开头，长度在6~18之间，只能包含字母、数字和下划线)：^[a-zA-Z]\w{5,17}$
强密码(必须包含大小写字母和数字的组合，不能使用特殊字符，长度在 8-10 之间)：^(?=.*\d)(?=.*[a-z])(?=.*[A-Z])[a-zA-Z0-9]{8,10}$
强密码(必须包含大小写字母和数字的组合，可以使用特殊字符，长度在8-10之间)：^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$
日期格式：^\d{4}-\d{1,2}-\d{1,2}
一年的12个月(01～09和1～12)：^(0?[1-9]|1[0-2])$
一个月的31天(01～09和1～31)：^((0?[1-9])|((1|2)[0-9])|30|31)$
钱的输入格式：
有四种钱的表示形式我们可以接受:"10000.00" 和 "10,000.00", 和没有 "分" 的 "10000" 和 "10,000"：^[1-9][0-9]*$
这表示任意一个不以0开头的数字,但是,这也意味着一个字符"0"不通过,所以我们采用下面的形式：^(0|[1-9][0-9]*)$
一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号：^(0|-?[1-9][0-9]*)$
这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉,因为钱总不能是负的吧。下面我们要加的是说明可能的小数部分：^[0-9]+(.[0-9]+)?$
必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是 "10" 和 "10.2" 是通过的：^[0-9]+(.[0-9]{2})?$
这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样：^[0-9]+(.[0-9]{1,2})?$
这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样：^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$
1到3个数字,后面跟着任意个 逗号+3个数字,逗号成为可选,而不是必须：^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$
备注：这就是最终结果了,别忘了"+"可以用"*"替代如果你觉得空字符串也可以接受的话(奇怪,为什么?)最后,别忘了在用函数时去掉去掉那个反斜杠,一般的错误都在这里
xml文件：^([a-zA-Z]+-?)+[a-zA-Z0-9]+\\.[x|X][m|M][l|L]$
中文字符的正则表达式：[\u4e00-\u9fa5]
双字节字符：[^\x00-\xff] (包括汉字在内，可以用来计算字符串的长度(一个双字节字符长度计2，ASCII字符计1))
空白行的正则表达式：\n\s*\r (可以用来删除空白行)
HTML标记的正则表达式：<(\S*?)[^>]*>.*?|<.*? /> ( 首尾空白字符的正则表达式：^\s*|\s*$或(^\s*)|(\s*$) (可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式)
腾讯QQ号：[1-9][0-9]{4,} (腾讯QQ号从10000开始)
中国邮政编码：[1-9]\d{5}(?!\d) (中国邮政编码为6位数字)
IP地址：((?:(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d))
/^.{0,200}$/ //匹配任意200个字符
/^(?!_)(?!.*?_$)[a-zA-Z0-9_\u4e00-\u9fa5]{0,200}$/ //匹配0-200个含英文字母、汉字、数字
/^[1-9]\d*$/ //匹配正整数
/^[1-9]\d{0,3}\.\d$/ ; //首位（1-9），中间零到三位数字，接着点号，点号后一位小数（0-9）
/^[1-9]\d{0,2}\.\d{2}$/; //首位（1-9），中间零到二位数字，接着点号，点号后两位小数（0-9）
/^[1-9]\d{1,4}$/; //首位（1-9），中间到结尾一到四位数字，无小数
/^[0]\.\d{2,4}$/; //首位（0），接着点号，点号后二到四位小数（0-9）
/^[\S]{6,12}$/ //匹配数据必须在6到12位，且不能出现空格
^[a-zA-Z0-9_\u4e00-\u9fa5\\s·]+$ //匹配数据不能含有特殊字符
/(^$)|^1\d{10}$/ //匹配手机号格式
/(^$)|^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/ //匹配Email格式
/(^$)|(^#)|(^http(s*):\/\/[^\s]+\.[^\s]+)/ //匹配url链接格式
[/(^$)|^(\d{4})[-\/](\d{1}|0\d{1}|1[0-2])([-\/](\d{1}|0\d{1}|[1-2][0-9]|3[0-1]))*$/ //匹配日期格式
/(^$)|(^\d{15}$)|(^\d{17}(x|X|\d)$)/ //匹配身份证号格式
