---

一、变量与数据类型

1. 变量

var 声明变量：
s 是 string 字符串的缩写，常用 s 来定义字符串 ”=“ 变量赋值：将右侧的数据赋值给左侧的变量,不是等于的意思。 var 声明 定义多个变量，要用逗号隔开

var s = "hello world";
console.log(s);

变量命名规范：

变量名要见名知意思，即要有语义。

变量名可以是

• 字母、下划线、$，还有数字，但是不能以数字开头；
• 小写字母开头，多个单词，第二个单词首字母大写（驼峰命名，例如 firstName）；
• 不可以用关键字、保留字命名。

2. 数据类型

数据类型就是存储在变量中的数据，是有不同类型的。 六种数据类型：

• 字符串 String : “hello world” ，“你好世界”
• 数值 Number : 100，1，2.8
• 布尔数据类型 Boolean ：true，false。
• 未定义 Undefined : underfined
• 空 Null : null
• 对象 Object ：{}

二、表达式与运算符

1.字面量

"hello world"
100

2.表达式

通过运算符将变量、字面量组合起来，就是表达式；
每一个表达式都有一个固定返回值（表达式的结果）。

let str1 = "hello"  // 将字面量赋值给变量
let str2 = "world"
let result = str1 + str2  // 将表达式赋值给变量，返回值"hello world"
console.log(result)  // "hello world"

3.运算符

3.1 算术运算符

运算符	描述	示例	结果
+	加法	20 + 10	30
-	减法	20 - 10	10
×	乘法	20 * 10	200
/	除法	20 / 10	2
%	求余	11 % 2	1
++	自增1	++7	8
–	自减1	- -7	6

3.2 比较运算符

运算符	描述	示例	结果
＞	大于	20 >10	true
＜	小于	20 <10	false
＞＝	大于等于	20 >=10	true
＜＝	小于等于	20 <=10	false
==	等于	20 == ‘20’	true
!=	不等	20 != ‘20’	false
===	恒等于	20 === ‘20’	false
!==	非恒等于	20 !== ‘20’	true

3.3 逻辑运算符

运算符	描述	示例	结果
&&	逻辑与	true && false	false
‖	逻辑或	true ‖ false	true
!	逻辑非	!true	false

3.4 赋值运算符

运算符	描述	示例	等同于
=	赋值	x = 10	无
+=	加并赋值	x += y	x = x + y
-=	减并赋值	x -= y	x = x - y
*=	乘并赋值	x *= y	x = x * y
/=	除并赋值	x /= y	x = x / y

三、条件语句

1. 控制流程

程序执行流程主要分为三种：

• 按顺序执行；
• 按条件执行；
• 循环执行；

2. 语句块

多条 js 语句组成的语句，用大括号括起来，就是一个语句块。

{let str = "hello world"console.log(str)
}

3. if 语句

根据 if 后面的条件，决定是否执行后面的语句块。

if (boolean) {// 语句块
}if (boolean) {// 语句块1
} else {// 语句块2
}

3. switch 语句

可以实现多重选择，某些情况相对于 if 语句更简洁。

switch (表达式) {case 值1:语句1;break;case 值2:语句2;break;case 值3:语句3;break;  default:语句4;   
}

4. 条件运算符

boolean ? value1 : value2

四、循环语句

1. while

根据条件循环：

while(条件){语句;语句;//根据需要在此放置更多语句
}

示例：计算 100 以内（包括100）所有正整数的加和；

 let total = 0;let i = 1;while (i <= 100) {total += ii++}console.log(total)    // 5050;

2. do…while

先执行一个语句块，然后再根据条件循环。
示例：打印 100 以内（不包括100）所有奇数；

let n = 0;
do {if (n % 2 === 1) {console.log(n);}n++
} while (n < 100)

do…while…与 while 的区别：
前者至少会执行一次，后者可能一次都不执行

3. for

根据条件循环。
大部分情况下，while 与 for 是可以互换的。

for( 初始值; 条件；自加/自减；)

示例：计算 100 以内（包括100）所有正整数的加和；

let sum = 0;
for (let i = 0; i <= 100; i++) {sum += i;
}
console.log(sum);   // 5050;

4. 中断循环

• break：跳出循环，后面不执行（结束所有循环）；
• continue：结束本次循环，后续还会继续循环 。

break示例：跳出本次循环并且结束后续的循环。

for (var i = 0; i < 10; i++) {if (i === 5) {break;}console.log(i);
}
// 1
// 2
// 3
// 4

continue示例：跳出本次循环但不结束后续的。

for (var i = 0; i < 10; i++) {if (i === 5) {break;}console.log(i);
}
// 1
// 2
// 3
// 4
// 6
// 7
// 8
// 9
// 10

五、函数基础

1.函数概述

函数是一个可执行的语句块（通过 function 关键字声明）。
声明的时候不执行语句块，调用函数时执行。
优点：声明之后可以反复调用，提高代码的复用能力。

//声明函数 function fun(){//语句...} //调用函数fun();

2.传递参数

通过参数可以让函数的功能更具扩展性。

• 形参：声明函数的时候可以定义；
• 实参：调用函数的时候传递实参。

//函数声明的语法
function fun(x) {var result = 3 * x + 4;console.log(result);
}
//调用函数
fun(5);

示例： 定义一个计算四则运算的函数。

function calc(x, y, operator) {switch (operator) {case '+':return x + y;break;case '-':return x - y;break;case '*':return x * y;break;case '/':return x / y;break;default:return '';}
}console.log(calc(1, 4, '+'));
console.log(calc(6, 4, '-'));
console.log(calc(3, 4, '*'));
console.log(calc(12, 4, '/'));

3.返回值

返回值表示函数运作之后的结果。
将返回值赋值给变量。
关键字 return。
示例： 用return改写上面的fun函数。

function fun(x) {return 3 * x + 4;
}console.log(fun(5));

六、对象

1.对象的定义

六种数据类型中的一种，对象可以重新设置属性。
属性的无序集合。

// 创建一个对象
let cat = {name: "miaomiao", //注意是逗号age: 2,
};
// 获取对象的属性
console.log(cat.name);
console.log(cat["name"]);

2.方法

属性的值是一个函数，则称为方法。可以传递参数，也可以不传递参数，还可以return 返回值。

// 创建一个对象
let cat = {name: "mm", age: 2,sayName: function(){console.log("我是mm");}
};
// 调用对象的方法
cat.sayName();

3.this 关键字

let student = {name: 'Lisa',age: 22,sayName(){// this.xxxx 可以指向调用方法的对象console.log('我是' + this.name);}
}
student.name = 'Jacky'
student.sayName()    // 我是Jacky

4.对象的分类

• 自定义对象：作用:封装
• 内置对象（例如 Date，获取当前时间）
• 宿主对象（document）
• 第三方库的对象（jQuery、Vue 等）

七、数组

1.数组概述

数组是一个特殊的对象，可以按顺序存储数据。

创建数值类型的数组：

let list = [1, 2, 3, 4, 5];

创建字符串类型的数组：

var list = ["a", "b", "c"];

2.获取数组中的元素

通过下标获取数组中的元素：list[0]、list[1]、…

获取数组元素的个数：list.length

3.遍历数组

• while 循环遍历：

var list = ["a", "b", "c", "d", "e"];
//下标索引
var i = 0;
while (i < list.length) {console.log(list[i]);i++;
}

• for 循环遍历数组：

let list = ["a", "b", "c", "d", "e"];
for (let i = 0; i < list.length; i++) {console.log(list[i]);
}

• for in 遍历（ i 为索引）：

let list = ["a", "b", "c", "d", "e"];
for (var i in list) {console.log(list[i]);
}

• for of 遍历（ i 为值）：

let list = ["a", "b", "c", "d", "e"];
for (var i of list) {console.log(i);
}

• map 方法遍历：

数组自带的，map() 方法的参数是函数。
map 有两个参数： 值 、索引。

let list = ["a", "b", "c", "d", "e"];
list.map(function (item, i) {console.log(item);    //item是list的元素console.log(i);     //i就是list的索引
});

4.数组的常用方法

• map()：遍历数组；

let list = ["a", "b", "c", "d", "e"];
list.map(function (item, i) {console.log("第" + (i + 1) + "个元素是" + item);
});

• push()：在结尾追加元素；

let list = ["a", "b", "c", "d", "e"];
list.push("f");
console.log(list);  // ["a", "b", "c", "d", "e", "f"];

• sort()：排序；
  数组中的值为数值：从小到大排序；
  数组中的值为字符串：按首字母从 a~z 来排序。

let list = [1, 3, 6, 5, 2];
// sort 排序，从小到大
list.sort();
console.log(list);   // [1, 2, 3, 5, 6]

• filter()：过滤器；

与 map() 遍历很像，但是需要返回 符合要求的值 或 true。

// 将数组中大于等于 3 的元素放到新的数组
let list = [1, 3, 6, 5, 2];let resList = list.filter((item) => {if (item >= 3) {return item;// 或者返回true 和 return item效果一样// return true;}
});
console.log(resList); // [3, 6, 5]

• join()：连接数组；

不传入参数时，默认为逗号。

let list = ["a", "b", "c"];
let str = list.join();
console.log(str);   // "a,b,c"

• split()：拆分字符串；

split 是字符串的拆分成数组的方法。
split 不传入参数时，会默认生成一个数组。

let str = "banana";
// 不传参数，会生成一个数组
let list1 = str.split();
console.log(list1);    // ["banana"]// 传入空字符串，会将每项进行切割，然后生成一个数组
let list2 = str.split("");
console.log(list2);    // ["b", "a", "n", "a", "n", "a"]// 传入指定字符，会按照传入字符进行切割，生成一个数组
let list3 = str.split("n");
console.log(list3);    // ["ba", "a", "a"]

5.结合数组与对象

let list = [{ name: "小明", age: 2, sex: "男" },{ name: "小红", age: 2, sex: "女" },{ name: "小亮", age: 2, sex: "男" },
];//获取数组里第一个对象的年龄
console.log(list[0].age);
//获取数组里第一个对象的名字
console.log(list[0].name);

八、内置对象

1.内置对象概述

JavaScript 语言中提供了一些对象，让开发人员可以使用一些现成的功能。

2.常用的内置对象

• Array - 数组
• Math - 数学
• Date - 日期
• RegExp - 正则表达式

3.Math对象

常用的方法：

• Math.floor()：向下取整；

去掉数值类型数据的小数部分，只保留整数部分。

let num = 5.99;
console.log(Math.floor(num));     // 5 取整数部分，不是四舍五入

负数情况时需要特殊注意，因为负数和正数相反。

let num = -5.99;
console.log(Math.floor(num));     // -6 去掉小数部分，然后在整数部分减 1

• Math.random()：获取 0~1 之间的随机数；

console.log(Math.random());      // 0.5472628534867743

• Math.abs()：绝对值；

let num= -1.99;
console.log(Math.abs(num));     // 1.99

• Math.sqrt：开方；

let num = 9;
console.log(Math.sqrt(num));      // 3

• Math.pow()：乘方；

Math.pow(m, n)中 m 底数，n 次方

console.log(Math.pow(2, 3)); // 8 2^3

获取指定范围的随机数：

示例：如何获取 1-10 的随机数？

思路：

1. 首先获取一个 0 ~ 1 的随机数，Math.random()；
2. 然后乘以 10，即 0 ~ 10的随机数，Math.random() * 10；
3. 又因为要从 1 开始，所以要再加 1，即 1~11之间的随机数（不包括11），Math.random() * 10 + 1；
4. 但因为要的是整数，所以要向下取整，这样就不用担心会出现大于 10 的整数，Math.floor(Math.random() * 10 + 1)。

let rdm = Math.floor(Math.random() * 10 + 1);
console.log(rdm);      //  2  3  8  7  1

扩展成一个公式：
获取 y ~ x 之间的随机数： Math.floor(Math.random() * x + y)
x：指的是取到几的随机数；
y ：指的是从几开始，如果想从0开始，这个参数可以省略，即：Math.floor(Math.random() * x。

示例 - 针对下面的成员列表，随机选择一个人在控制台输出。

// 5 个超级英雄，他们的索引分别为：0，1，2，3，4，即要生成 0 ~ 5 之间的随机数(因为要向下取整）
// 因为数组的长度可能会变，所以要生成 0 ~ list.length 之间的随机数
let list = ["钢铁侠", "绿巨人", "美国队长", "蜘蛛侠", "雷神"];
let index = Math.floor(Math.random() * list.length);
console.log(list[index]);

4.Date对象

（1）语法：new Date();
Date() 不设参数时就是显示当前的星期 月 日 年 时：分：秒 时区

var d = new Date();
console.log(d);     // Thu Aug 03 2023 11:40:03 GMT+0800 (中国标准时间)

传入时间参数时：

let d_target = new Date('2023-08-03');
console.log(d_target);     // Thu Aug 03 2023 08:00:00 GMT+0800 (中国标准时间)

（2）关于日期的一些方法：

• d.getFullYear()：获取年份；
• d.getMonth()：获取月份（从0开始的，使用是要+1）；
• d.getDate()：获取日期；
• d.getHours()：获取小时；
• d.getMinutes()：获取分钟；
• d.getSeconds()：获取秒数；
• d.getTime()：获取时间戳(时间戳是指格林威治时间1970-01-01 00:00:00 起至现在的总毫秒数)，可用于计算时间的差值。

示例1：计算两个日期的时间差值。

let date1 = new Date();
let date2 = new Date('2023-01-01');
console.log(date1 - date2);                // 18517071915

示例2：打印显示当前时间。

let date = new Date();let y = date.getFullYear();
let m = date.getMonth();
let d = date.getDay();
let h = date.getHours();
let mm = date.getMinutes();
let s = date.getSeconds();//打印显示当前时间
console.log(y + '-' + (m + 1) + '-' + d + ' ' + h + ':' + mm + ':' + s);    // 2023-8-4 14:42:34

5.计时器方法 setInterval

语法：setInterval(callback, ms);

• callback：执行的回调函数；
• ms：间隔时间，每隔 m 毫秒数调用一次函数，单位为毫秒。

// 每隔1s在控制台打印 hello world
setInterval(() => {console.log('hello world');
}, 1000)

九、正则表达式

正则表达式可以用来匹配字符串。
通过正则表达式，可以实现字符串的截取或按规则替换和验证字符串内容。
正则表达式独立于语言，很多语言都支持正则表达式。（并非 JavaScript 特性）。

1. 创建正则表达式对象

//第一种方法
let reg = new RegExp("123");
//第二种方法 简写
let reg = /123/;

类似于数组：

let list = new Array();
let list = [];

2. 正则表达式的方法

• reg.test()：检测一个字符串是否匹配某个模式，返回值为布尔值；
• reg.exec()：检索字符串中的正则表达式的匹配，如果字符串中有匹配的值返回该匹配值，否则返回 null。

3. 正则表达式的语法

• ^：开头
• $：结尾

规定字符串的开头和结尾：

let str1 = "a";
let str2 = "1a";
let reg = /^[a-z]$/;
console.log(reg.test(str1));  // true
console.log(reg.test(str2));  // false

• [ ]：范围

规定字符串的范围：[a-z]：小写字母，[0-9]：数字，[A-Z]：大写字母。

let str1 = "s";
let str2 = "S";
let reg = /^[a-z]$/;
console.log(reg.test(str1));   // true
console.log(reg.test(str3));   // false

• { }：位数

规定字符串的有几位：{3}表示需要三位，多了不行，少了也不行。

let str = "abc";
let reg = /^[a-z]{3}$/;
console.log(reg.test(str));     // truelet str = "abcde";
// {3,} 表示需要3个或3个以上的字母
let reg = /^[a-z]{3,}$/;
console.log(reg.test(str));     // true

• ( )：分组
  将字符串分组，通常与 exec() 搭配使用来 截取字符串。

let timeStr = "2023-08-07";
// 将 匹配2023的 \d{4}，匹配08的 \d{2}，匹配07的 \d{2} 分别用三个小括号括起来
let arr = /^(\d{4})-(\d{2})-(\d{2})$/.exec(str);
console.log(arr); // ["2023-08-07", "2023", "08", "07", index: 0, input: "2023-08-07", groups: undefined]
console.log(result[1]); // 2023
console.log(result[2]); // 08
console.log(result[3]); // 07

• +：匹配 1 位或多位，同 {1,}

let str1 = "test"; 
let str2 = ""; 
// 相当于 /^[a-z]{1,}$/;
let reg = /^[a-z]+$/
console.log(reg.test(str1));   // true
console.log(reg.test(str2));   // false

• ?：匹配 0 位或 1 位，同 {0,1}

let str1 = "1";
let str2 = "";
let str3 = "123";
// 相当于 /^[0-9]{0,1}$/
let reg = /^[0-9]?$/;
console.log(reg.test(str1));   // true
console.log(reg.test(str2));   // true
console.log(reg.test(str3));   // false

• .：匹配所有

匹配所有，随便写什么都可以，空字符串除外。

let str1 = "_123Abc";
let str2 = "";
let reg = /^.+$/;
console.log(reg.test(str1));   // true
console.log(reg.test(str2));   // false

• \ ：转义

由于一些符号在正则表达式中是有特殊含义的，例如：“.”，“+”，“?” 等等，我们需要通过 \ 转义符，将想要匹配的特殊符号先进行转义。

示例1：匹配字符串 ‘1+’

let str1 = "1+";
let str2 = "11111";
// 由于+有特殊的含义，所以需要在前面添加转义符\
let reg = /^1\+$/;
console.log(reg.test(str1));   // true
console.log(reg.test(str2));   // false

示例2：匹配邮箱

let str = "xiaolu@163.com";
// 由于.有特殊的含义，所以需要在前面添加转义符\
let reg = /^\w{5,12}@163\.com$/;
console.log(reg.test(str1));   // true

• \d：代表数字，相当于 [0-9] 的简写

let str1 = "123abc";
let str2 = "456789";
// 相当于 /^[0-9]{6}$/
let reg = /^\d{6}$/;
console.log(reg.test(str1));   // false
console.log(reg.test(str2));   // true

• \w：代表数字、大小写字母以及下划线，相当于 [0-9a-zA-Z_] 的简写

let str1 = "_123Abc";
let str2 = "";
// 相当于 /^[0-9a-zA-Z_]+$/
let reg = /^\w+$/;
console.log(reg.test(str1));   // true
console.log(reg.test(str2));   // false

• \s：空格或换行

let str1 = "hello";
let str2 = "";
let reg = /^\s?$/;
console.log(reg.test(str1));   // false
console.log(reg.test(str2));   // true

• \g：全局匹配

全局匹配，找到所有能匹配到的内容。
通常和字符串的 replace() 搭配使用，来帮我们完成字符串的替换。

let str = "123abc456def";
let result = str.replace(/[a-zA-z]/g, "");
console.log(result);     // 123456

4. 实际开发中

大部分情况下，是不需要我们自己写正则表达式的。
例如常见的邮箱或电话的验证方式，有很多现成的解决方案。
所以我们只要可以读懂即可。

5. 常用正则表达式整理

• 校验数字：

数字：^[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 位数字)
IPv4 地址：((2(5[0-5]|[0-4]\d))|[0-1]?\d{1,2})(\.((2(5[0-5]|[0-4]\d))|[0-1]?\d{1,2})){3}

---

总结

以上就是我所总结的JavaScript基础知识内容，希望可以帮助初学的同学入门，帮助入门的同学巩固。