一、JavaScript对象
1 对象是什么?
描述一个具体事务的代码
2.对象中的元素?
属性【变量】和方法【函数】
3.java中对象的分类
3.1 自定义对象 -- javascript没有提供，需要我们自己创建的对象自定义对象
1.通过字面量的方式创建对象
2.通过构造函数方式创建对象
例如：
3.2内置对象
3.2.1内建对象
Number对象 、字符串（String）对象 、Date（日期） 对象、Array（数组） 对象
、Boolean（布尔） 对象 、Math（算数） 对象、RegExp 对象
3.2.1.1Number对象
JavaScript 只有一种数字类型。可以使用也可以不使用小数点来书写数字。
JavaScript 数字
JavaScript 数字可以使用也可以不使用小数点来书写：
var pi=3.14; // 使用小数点
var x=34; // 不使用小数点极大或极小的数字可通过科学（指数）计数法来写：
var y=123e5; // 12300000
var z=123e-5; // 0.00123所有 JavaScript 数字均为 64 位
JavaScript 不是类型语言。与许多其他编程语言不同，JavaScript 不定义不同类型的数字，比如整数、短整数、长整数、浮点等等。
在JavaScript中，数字不分为整数类型和浮点型类型，所有的数字都是由浮点型类型。JavaScript 采用 IEEE754 标准定义的 64 位浮点格式表示数字，它能表示最大值（Number.MAX_VALUE）为 ±1.7976931348623157e+308，最小值（Number.MIN_VALUE）为 ±5e-324。
此格式用 64 位存储数值，其中 0 到 51 存储数字（片段），52 到 62 存储指数，63 位存储符号：
值 (aka Fraction/Mantissa)
指数（Exponent）
符号（Sign）
52 bits (0 - 51)
11 bits (52 - 62)
1 bit (63)
精度
整数（不使用小数点或指数计数法）最多为 15 位。
var x = 999999999999999; // x 为 999999999999999
var y = 9999999999999999; // y 为 10000000000000000
小数的最大位数是 17，但是浮点运算并不总是 100% 准确：
var x = 0.2+0.1; // 输出结果为 0.30000000000000004
八进制和十六进制
如果前缀为 0，则 JavaScript 会把数值常量解释为八进制数，如果前缀为 0 和 "x"，则解释为十六进制数。
var y = 0377;
var z = 0xFF;绝不要在数字前面写零，除非您需要进行八进制转换。
默认情况下，JavaScript 数字为十进制显示。
但是你可以使用 toString() 方法 输出16进制、8进制、2进制。
var myNumber=128;
myNumber.toString(16); // 返回 80
myNumber.toString(8); // 返回 200
myNumber.toString(2); // 返回 10000000无穷大（Infinity）
当数字运算结果超过了JavaScript所能表示的数字上限（溢出），结果为一个特殊的无穷大（infinity）值，在JavaScript中以Infinity表示。同样地，当负数的值超过了JavaScript所能表示的负数范围，结果为负无穷大，在JavaScript中以-Infinity表示。无穷大值的行为特性和我们所期望的是一致的：基于它们的加、减、乘和除运算结果还是无穷大（当然还保留它们的正负号）。
myNumber=2;
while (myNumber!=Infinity){
myNumber=myNumber*myNumber; // 重复计算直到 myNumber 等于 Infinity
}除以0也产生了无限:
var x = 2/0;
var y = -2/0;NaN - 非数字值
NaN 属性是代表非数字值的特殊值。该属性用于指示某个值不是数字。可以把 Number 对象设置为该值，来指示其不是数字值。
你可以使用 isNaN() 全局函数来判断一个值是否是 NaN 值。
var x = 1000 / "Apple";
isNaN(x); // 返回 true
var y = 100 / "1000";
isNaN(y); // 返回 false除以0是无穷大，无穷大是一个数字:
var x = 1000 / 0;
isNaN(x); // 返回 false数字可以是数字或者对象
数字可以私有数据进行初始化，就像 x = 123;
JavaScript 数字对象初始化数据， var y = new Number(123);
var x = 123;
var y = new Number(123);
typeof(x) // 返回 Number
typeof(y) // 返回 Object实例
var x = 123;
var y = new Number(123);
(x === y) // 为 false，因为 x 是一个数字，y 是一个对象Number 属性
属性
描述
Number.MAX_VALUE
最大值
Number.MIN_VALUE
最小值
Number.NaN
非数字
Number.NEGATIVE_INFINITY
负无穷，在溢出时返回
Number.POSITIVE_INFINITY
正无穷，在溢出时返回
Number.EPSILON
表示 1 和比最接近 1 且大于 1 的最小 Number 之间的差别
Number.MIN_SAFE_INTEGER
最小安全整数。
Number.MAX_SAFE_INTEGER
最大安全整数。
数字方法
方法
描述
Number.parseFloat()
将字符串转换成浮点数，和全局方法 parseFloat() 作用一致。
Number.parseInt()
将字符串转换成整型数字，和全局方法 parseInt() 作用一致。
Number.isFinite()
判断传递的参数是否为有限数字。
Number.isInteger()
判断传递的参数是否为整数。
Number.isNaN()
判断传递的参数是否为 isNaN()。
Number.isSafeInteger()
判断传递的参数是否为安全整数。
数字类型原型上的一些方法
方法
描述
toExponential()
返回一个数字的指数形式的字符串，如：1.23e+2
toFixed()
返回指定小数位数的表示形式。
var a=123;
b=a.toFixed(2); // b="123.00"
toPrecision()
返回一个指定精度的数字。如下例子中，a=123 中，3会由于精度限制消失:
var a=123;
b=a.toPrecision(2); // b="1.2e+2"
例如：
<!DOCTYPE html>
<html>
<head>
<title>Number对象</title>
<meta charset="utf-8">
</head>
<body>
<script>
//Number对象
//封装关于数字操作的对象
//通过字面量的方式创建对象 -- 字面量=变量
var num1=100;
//alert(typeof num1); //number
//变量就是对象，数据类型为number
//通过构造函数方式创建对象-- 数据类型为object
var num2=new Number(100);
//alert(typeof num2); //object
//number转换成object-----new Number()
var num3=new Number(num1);
//alert(typeof num3); //object
//object转换成number-----parseInt(num2)/parseFloat(num2)
var num4=Number.parseInt(num2);
//alert(typeof num4); //number
//常用的属性
//Number.MAX_VALUE 最大值
//Number.MIN_VALUE 最小值
//alert(Number.MAX_VALUE); // 1.7976931348623157e+308
//alert(Number.MIN_VALUE); // 5e-324
//常用方法
//Number.parseFloat() 将字符串转换成浮点数，和全局方法 parseFloat() 作用一致。
//Number.parseInt() 将字符串转换成整型数字，和全局方法 parseInt() 作用一致。
var str1="100";
var number1 = Number.parseFloat(str1);
//alert(typeof number1);//number
//alert(number1+1); //101
//全局方法isNaN()判断传递的参数是否不是一个数字。
//当是一个数字是结果为false
//当不是一个数字是结果为true
//isNaN---is Not a Number? 是否不是一个数字
var age="ssssds";
//alert(isNaN(age));
//toFixed() 返回指定小数位数的表示形式。[主意正负值]
var shuzi=-3.145;
//alert(shuzi.toFixed(2)); //-3.15
//JavaScript 不是类型语言
//所有的数字都是由浮点型类型.
//JavaScript 采用 IEEE754 标准定义的 64 位浮点格式表示数字，它能表示最大值（Number.MAX_VALUE）为 ±1.7976931348623157e+308，最小值（Number.MIN_VALUE）为 ±5e-324。
//此格式用 64 位存储数值，其中 0 到 51 存储数字（片段），52 到 62 存储指数，63 位存储符号
//浮点运算并不总是 100% 准确
//alert(10/3); //3.3333333333333335
//整数（不使用小数点或指数计数法）最多为 15 位。
//小数的最大位数是 17，
//如果前缀为 0，则 JavaScript 会把数值常量解释为八进制数，如果前缀为 0 和 "x"，则解释为十六进制数。
//toString(2/8/16)转换数字成字符串【指定进制】
//无穷大（Infinity） / 无穷小（-Infinity）
//当数字运算结果超过了JavaScript所能表示的数字上限（溢出），结果为一个特殊的无穷大（infinity）值，在JavaScript中以Infinity表示。
//当负数的值超过了JavaScript所能表示的负数范围，结果为负无穷大，在JavaScript中以-Infinity表示。
/*var mynumber=2;
while(mynumber!=Infinity){
mynumber=mynumber*mynumber;
document.write(mynumber+"<br>");
};*/
//除以0也产生了无穷大（Infinity）
</script>
</body>
</html>3.2.1.2 String对象
String 对象用于处理已有的字符块。
特殊字符
Javascript 中可以使用反斜线（\）插入特殊符号，如：撇号,引号等其他特殊符号。
查看如下 JavaScript 代码:
var txt="We are the so-called "Vikings" from the north.";
document.write(txt);在JavaScript中，字符串的开始和停止使用单引号或双引号。这意味着，上面的字符串将被切成： We are the so-called
解决以上的问题可以使用反斜线来转义引号：
var txt="We are the so-called \"Vikings\" from the north.";
document.write(txt);JavaScript将输出正确的文本字符串：We are the so-called "Vikings" from the north.
下表列出其他特殊字符，可以使用反斜线转义特殊字符：
代码
输出
\'
单引号
\"
双引号
\\
斜杆
\n
换行
\r
回车
\t
tab
\b
空格
\f
换页
String 对象属性
属性
描述
对创建该对象的函数的引用
字符串的长度
允许您向对象添加属性和方法
String 对象方法
方法
描述
返回在指定位置的字符。
连接两个或更多字符串，并返回新的字符串。+
返回某个指定的字符串值在字符串中首次出现的位置。
从后向前搜索字符串，并从起始位置（0）开始计算返回字符串最后出现的位置。
查找找到一个或多个正则表达式的匹配。
在字符串中查找匹配的子串， 并替换与正则表达式匹配的子串。
把字符串分割为字符串数组。
查看字符串是否以指定的子字符串开头。
从起始索引号提取字符串中指定数目的字符。
提取字符串中两个指定的索引号之间的字符。
把字符串转换为小写。
把字符串转换为大写。
去除字符串两边的空白
根据本地主机的语言环境把字符串转换为小写。
根据本地主机的语言环境把字符串转换为大写。
返回某个字符串对象的原始值。
返回一个字符串。
String HTML 包装方法
HTML 返回包含在相对应的 HTML 标签中的内容。
以下方法并非标准方法，所以可能在某些浏览器下不支持。
方法
描述
创建 HTML 锚。
用大号字体显示字符串。<b></b>
显示闪动字符串。
使用粗体显示字符串。
以打字机文本显示字符串。
使用指定的颜色来显示字符串。
使用指定的尺寸来显示字符串。
使用斜体显示字符串。
将字符串显示为链接。
使用小字号来显示字符串。
用于显示加删除线的字符串。
把字符串显示为下标。
把字符串显示为上标。
例如;
<!DOCTYPE html>
<html>
<head>
<title>String对象</title>
<meta charset="utf-8">
</head>
<body>
<script>
//String对象
//1.创建方式
//1.1 直接赋值【可以使用"" / ''】
var str1="hello"; //string
var str2='world'; //string
//一般使用""表示字符串，当""中出现""时可以用''代替
//1.2 new String(字符串值)
var str3=new String("hello,world"); //object
//string和object之间的转换
//string--->object--- new String("");
//object---->String--- toString() / valueof()返回某个字符串对象的原始值。
//var str4=str3.valueOf();//string
//alert(typeof str4)
//一般使用""表示字符串，当""中出现""时可以用''代替
//也可以使用转义字符
// \' 单引号 \" 双引号 \\ 斜杆 \r\n 回车换行 \t tab \b 空格 \f换页
//document.write("F:\\lianxi\\86498149");
//alert("hello\r\nworld");
// alert("hello\tworld");
//alert("hello\bworld");
//2.字符串的常用属性和方法
var str5=new String("hello,world");
//length 字符串的长度
//alert(str5.length);//11
//charAt() 返回在指定位置的字符,从零开始。返回o的位置
//alert(str5.charAt(4));
//concat() 连接两个或更多字符串，并返回新的字符串。+
var st1="hello";
var st2="fxt";
//alert(st1.concat(st2));
//indexOf() 返回某个指定的字符串值在字符串中首次出现的位置。
//alert(str5.indexOf("l"));//2
//lastIndexOf() 从后向前搜索字符串，并从起始位置（0）开始计算返回字符串最后出现的位置。
//alert(str5.lastIndexOf("l"));//9
//replace() 在字符串中查找匹配的子串， 并替换与正则表达式匹配的子串。
//alert(str5.replace("l","A"));//heAlo,world
//split() 把字符串分割为字符串数组。
/*var strrra=str5.split(",");
for(x in strrra){
alert(strrra[x]);
}*///得到hello 和 world
//startsWith() 查看字符串是否以指定的子字符串开头。
//endsWith()查看字符串是否以指定的子字符串结尾。
//alert(str5.startsWith("h"));//true
/*var arr=["张三","李四","王五"];
for(s in arr){
if((arr[s].startsWith("李"))){
alert(arr[s])
} }//李四
for(s in arr){
if((arr[s].endsWith("五"))){
alert(arr[s])
} }//王五
*/
//substr() 从起始索引号提取字符串中指定数目的字符。
//alert(str5.substr(","+1,5))//wrold
//substring(startindex，endindex) 提取字符串中两个指定的索引号之间的字符。
//alert(str5.substring(6,10));//world
//toLowerCase() 把字符串转换为小写。
//toUpperCase() 把字符串转换为大写。
//alert(str5.toUpperCase());//HELLO,WORLD
//trim() 去除字符串两边的空白
var st3=" hello fxt ";
alert(st3.length);//16
var st4=st3.trim();
alert(st4.length);//10
//toLocaleLowerCase() 根据本地主机的语言环境把字符串转换为小写。
//toLocaleUpperCase() 根据本地主机的语言环境把字符串转换为大写。
</script>
</body>
</html>3.2.1.3 Date（日期） 对象
日期对象用于处理日期和时间。
Date 对象属性
属性
描述
返回对创建此对象的 Date 函数的引用。
使您有能力向对象添加属性和方法。
Date 对象方法
方法
描述
从 Date 对象返回一个月中的某一天 (1 ~ 31)。
从 Date 对象返回一周中的某一天 (0 ~ 6)。
从 Date 对象以四位数字返回年份。
返回 Date 对象的小时 (0 ~ 23)。
返回 Date 对象的毫秒(0 ~ 999)。
返回 Date 对象的分钟 (0 ~ 59)。
从 Date 对象返回月份 (0 ~ 11)。
返回 Date 对象的秒数 (0 ~ 59)。
返回 1970 年 1 月 1 日至今的毫秒数。
返回本地时间与格林威治标准时间 (GMT) 的分钟差。
根据世界时从 Date 对象返回月中的一天 (1 ~ 31)。
根据世界时从 Date 对象返回周中的一天 (0 ~ 6)。
根据世界时从 Date 对象返回四位数的年份。
根据世界时返回 Date 对象的小时 (0 ~ 23)。
根据世界时返回 Date 对象的毫秒(0 ~ 999)。
根据世界时返回 Date 对象的分钟 (0 ~ 59)。
根据世界时从 Date 对象返回月份 (0 ~ 11)。
根据世界时返回 Date 对象的秒钟 (0 ~ 59)。
getYear()
已废弃。 请使用 getFullYear() 方法代替。
返回1970年1月1日午夜到指定日期（字符串）的毫秒数。
设置 Date 对象中月的某一天 (1 ~ 31)。
设置 Date 对象中的年份（四位数字）。
设置 Date 对象中的小时 (0 ~ 23)。
设置 Date 对象中的毫秒 (0 ~ 999)。
设置 Date 对象中的分钟 (0 ~ 59)。
设置 Date 对象中月份 (0 ~ 11)。
设置 Date 对象中的秒钟 (0 ~ 59)。
setTime() 方法以毫秒设置 Date 对象。
根据世界时设置 Date 对象中月份的一天 (1 ~ 31)。
根据世界时设置 Date 对象中的年份（四位数字）。
根据世界时设置 Date 对象中的小时 (0 ~ 23)。
根据世界时设置 Date 对象中的毫秒 (0 ~ 999)。
根据世界时设置 Date 对象中的分钟 (0 ~ 59)。
根据世界时设置 Date 对象中的月份 (0 ~ 11)。
setUTCSeconds() 方法用于根据世界时 (UTC) 设置指定时间的秒字段。
setYear()
已废弃。请使用 setFullYear() 方法代替。
把 Date 对象的日期部分转换为字符串。
toGMTString()
已废弃。请使用 toUTCString() 方法代替。
使用 ISO 标准返回字符串的日期格式。
以 JSON 数据格式返回日期字符串。
根据本地时间格式，把 Date 对象的日期部分转换为字符串。
根据本地时间格式，把 Date 对象的时间部分转换为字符串。
根据本地时间格式，把 Date 对象转换为字符串。
把 Date 对象转换为字符串。
把 Date 对象的时间部分转换为字符串。
根据世界时，把 Date 对象转换为字符串。
实例：
var today = new Date();var UTCstring = today.toUTCString();
根据世界时返回 1970 年 1 月 1 日 到指定日期的毫秒数。
返回 Date 对象的原始值。
例如：
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Date（日期） 对象</title>
<script>
//Date（日期） 对象
//1.创建方式
//1.1 new Date(); //得到当前系统时间
var date1=new Date(); //Fri Oct 08 2021 15:13:48 GMT+0800 (GMT+08:00)
//1.2 new Date(毫秒数); //从1970年1月1日0点是时间纪元向后推算毫秒数得到新的时间
var date2=new Date(1000); //Thu Jan 01 1970 08:00:01 GMT+0800 (GMT+08:00)
//alert(date2);
//1.3 new Date(dateString); //dateString--具体的时间日期注意它的格式
//2021-10-01 12:30:30
//2021/10/01 12:30:30
//2021年10月01日 12:30:30 Invalid Date
var date3=new Date("2021年10月01日 12:30:30"); //Fri Oct 01 2021 12:30:30 GMT+0800 (GMT+08:00)
//1.4 new Date(year, monthIndex [, day [, hours [, minutes [, seconds [, milliseconds]]]]]);
//月份的表示是一个索引值从0开始计数的，所用我们在设置月份的时候要减1
var date4=new Date(2021,9,30,15,20,30); //Sat Oct 30 2021 15:20:30 GMT+0800 (GMT+08:00)
//2.常用的属性和方法
//setXXXX()设置某一个具体时间值
//setFullYear()/setMonth()/setDate()/setHours()/setMinutes()/setSeconds()
date1.setFullYear(2021);
date1.setMonth(10);
date1.setDate(20);
date1.setHours(12);
date1.setMinutes(30);
date1.setSeconds(30);
//getXXXXX() 得到某一个具体时间值
//getFullYear()/getMonth()/getDate()/getHours()/getMinutes()/getSeconds()/getDay()
var y=date1.getFullYear();
var m=date1.getMonth();
var d=date1.getDate();
var h=date1.getHours();
var mi=date1.getMinutes();
var s=date1.getSeconds();
var day=date1.getDay();
var datetimestr=y+"年"+(m+1)+"月"+d+"日 "+h+":"+mi+":"+s+" 星期"+day;
alert(datetimestr);
//getTime() 返回 1970 年 1 月 1 日至今的毫秒数。 //1633678810194
//alert(date1.getTime());//1606703430053
</script>
</head>
<body>
</body>
</html>3.2.1.4 Array（数组） 对象
数组对象的作用是：使用单独的变量名来存储一系列的值。
数组属性
属性
描述
返回创建数组对象的原型函数。
设置或返回数组元素的个数。
允许你向数组对象添加属性或方法。
Array 对象方法
方法
描述
连接两个或更多的数组，并返回结果。
数组每个元素都执行一次回调函数。
搜索数组中的元素，并返回它所在的位置。
把数组的所有元素放入一个字符串。
搜索数组中的元素，并返回它最后出现的位置。
删除数组的最后一个元素并返回删除的元素。
向数组的末尾添加一个或更多元素，并返回新的长度。
反转数组的元素顺序。
删除并返回数组的第一个元素。
选取数组的一部分，并返回一个新数组。
对数组的元素进行排序。
从数组中添加或删除元素。
把数组转换为字符串，并返回结果。
向数组的开头添加一个或更多元素，并返回新的长度。
返回数组对象的原始值。
例如：
<!DOCTYPE html>
<html>
<head>
<title>Array（数组） 对象</title>
<meta charset="utf-8">
</head>
<body>
<script>
//JavaScript Array（数组） 对象
//1.数组创建
var shuzu=new Array();//声明一个空数组
var shuzu1=new Array(3);//声明一个有三个位置的空数组
var shuzu2=[];//使用 []创建空数组
//2.数组的赋值
//2.1通过小标逐个赋值
shuzu[0]=1001;
shuzu[1]="fxt";
shuzu[2]=22;
shuzu2[0]=1002;
shuzu2[1]="ch";
shuzu2[2]=22;
//2.2创建时直接赋值
var arr1=new Array(1003,"htt",22);
var arr2=[1004,"gyq",21,1004];
//3.数组的取值
//3.1利用小标取出对应数据
//alert(arr1[0]);
//4.遍历数组
for(x in arr2){
document.write("<p>"+arr2[x]+"</p>");
}
//5.数组中常用的属性和方法
//length 设置或返回数组元素的个数
//alert(arr1.length);//3
//concat() 连接两个或更多的数组，并返回结果
var newarr=shuzu.concat(shuzu2);
document.write(newarr);
//forEach() 数组每个元素都执行一次回调函数。
shuzu.forEach(function(res){
document.write("<h4>"+res+"</h4>")
});
//indexOf() 搜索数组中的元素，并返回它所在的位置[第一次]。
shuju=new Array("zhangsan","lisi","wangwu","zhangsan")
//alert(shuju.indexof("zhangsan"));//0
//lastIndexOf() 搜索数组中的元素，并返回它最后出现的位置。
//alert(shuju.lastIndexOf("zhangsan")); //3
//join() 把数组的所有元素放入一个字符串。
//alert(typeof (arr2.join()));//1004,gyq,21,1004 string
//pop() 删除数组的最后一个元素并返回删除的元素。
//arr2.pop();
var newarr2=arr2.join();
//alert(newarr2);//1004,gyq,21
//shift() //shift()删除第一个元素。
//arr2.shift();
var newarr23=arr2.join();
//alert(newarr23);//gyq,21,1004
//push()向数组的末尾添加一个或更多元素，并返回新的长度。
//alert(arr1.length);//3
//var newarr1=arr1.push("test");
//alert(newarr1)//4
//unshift() 向数组的开头添加一个或更多元素，并返回新的长度。
//arr1.unshift("test");
//var sstr= arr1.join();
//alert(sstr);//test,1003,htt,22
//reverse() 反转数组的元素顺序。
//arr1.reverse();
//var arrstr=arr1.join();
//alert(arrstr);//22,htt,1003
//slice(startindex,endindex)选取数组的一部分，并返回一个新数组。
var username=["fxt","ch","gyq","htt"];
//alert(username.slice(0,3))//fxt,ch,gyq //不包括最后一个索引值
//splice() 从数组中删除元素。
//username.splice(0,1)
var arrstr=username.join()
alert(arrstr)//ch,gyq,htt 当从开始索引开始删除时不包括结束索引，从中间位置开始包括末尾
username.splice(1,2)//
var arrstr=username.join()
alert(arrstr)//fxt,htt
//sort()对数组的元素进行排序。
var nums=[120,23,348,11];
/*nums.sort(function(a,b){
//return b-a;//降序排列
return a-b; //升序排列
})*/
//var arrstr=nums.join();
//alert(arrstr)//348,120,23,11
nums.sort(); //字符串默认升序
nums.reverse();//使用reverse将圣墟排列好的数组反转就是降序
var arrstr=nums.join();
alert(arrstr);//348,23,120,11
</script>
</body>
</html>3.2.1.5 Boolean（布尔） 对象
Boolean（布尔）对象用于将非布尔值转换为布尔值（true 或者 false）。
Boolean 对象属性
属性
描述
返回对创建此对象的 Boolean 函数的引用
使您有能力向对象添加属性和方法。
Boolean 对象方法
描述
把布尔值转换为字符串，并返回结果。
返回 Boolean 对象的原始值。
<!DOCTYPE html>
<html>
<head>
<title>Boolean（布尔） 对象</title>
<meta charset="utf-8">
</head>
<body>
<script>
//JavaScript Boolean（布尔） 对象
//Boolean（布尔） 对象
//1.创建方式
var boo1=true; //boolean
var boo2=new Boolean(false); //object
//boolean--->object---new Boolean()
//object----->boolean----valueOf()
var boo3=boo2.valueOf();
//alert(typeof boo3); //boolean
//toString() 把布尔值转换为字符串，并返回结果。
//valueOf() 返回 Boolean 对象的原始值。
//数字0---false 非0数字---true
//空字符""---false 非空字符---true
//null---false
//undefined---false
var test1;
alert(test1);
var boo4=new Boolean(test1);
alert(boo4);
</script>
</body>
</html>3.2.1.6 Math（算数） 对象
Math（算数）对象的作用是：执行常见的算数任务。
Math 对象提供多种算数值类型和函数。无需在使用这个对象之前对它进行定义。
Math 对象属性
属性
描述
返回算术常量 e，即自然对数的底数（约等于2.718）。
返回 2 的自然对数（约等于0.693）。
返回 10 的自然对数（约等于2.302）。
返回以 2 为底的 e 的对数（约等于 1.4426950408889634）。
返回以 10 为底的 e 的对数（约等于0.434）。
返回圆周率（约等于3.14159）。
返回 2 的平方根的倒数（约等于 0.707）。
返回 2 的平方根（约等于 1.414）。
Math 对象方法
方法
描述
返回 x 的绝对值。
返回 x 的反余弦值。
返回 x 的反正弦值。
以介于 -PI/2 与 PI/2 弧度之间的数值来返回 x 的反正切值。
返回从 x 轴到点 (x,y) 的角度（介于 -PI/2 与 PI/2 弧度之间）。
对数进行上舍入。
返回数的余弦。
返回 Ex 的指数。
对 x 进行下舍入。
返回数的自然对数（底为e）。
返回 x,y,z,...,n 中的最高值。
返回 x,y,z,...,n中的最低值。
返回 x 的 y 次幂。
返回 0 ~ 1 之间的随机数。
四舍五入。
返回数的正弦。
返回数的平方根。
返回角的正切。
例如：
<!DOCTYPE html>
<html>
<head>
<title>Math（算数） 对象</title>
<meta charset="utf-8">
</head>
<body>
<script>
//JavaScript Math（算数） 对象
//Math（算数）对象的作用是：执行常见的算数任务。
//Math（算数）对象不需要创建【Math就是对象】
//常见的属性
//E 返回算术常量 e，即自然对数的底数（约等于2.718）。
//PI 返回圆周率（约等于3.14159）。
//alert(Math.E); //2.718281828459045
//alert(Math.PI); //3.141592653589793
//max(x,y,z,...,n) 返回 x,y,z,...,n 中的最高值。
//min(x,y,z,...,n) 返回 x,y,z,...,n中的最低值。
//pow(x,y) 返回 x 的 y 次幂。
//sqrt(x) 返回数的平方根。
//alert(Math.sqrt(0)); 0
//alert(Math.sqrt(1)); 1
//random() 返回 0 ~ 1 之间的随机数。
//alert(Math.random());
//得到1-10 / 1-100 之间的随机数
//var num1= Number.parseInt(Math.random()*100);
//alert(num1)
//round(x) 四舍五入。
//alert(Math.round(11.5)); //12
//alert(Math.round(-11.5)); //-11
alert(Math.round(-11.8)); //-12
</script>
</body>
</html>3.2.1.7 RegExp 对象
RegExp：是正则表达式（regular expression）的简写
什么是 RegExp？
正则表达式描述了字符的模式对象。
元字符
描述
\
将下一个字符标记符、或一个向后引用、或一个八进制转义符。例如，“\\n”匹配\n。“\n”匹配换行符。序列“\\”匹配“\”而“\(”则匹配“(”。即相当于多种编程语言中都有的“转义字符”的概念。
^
匹配输入字行首。如果设置了RegExp对象的Multiline属性，^也匹配“\n”或“\r”之后的位置。
$
匹配输入行尾。如果设置了RegExp对象的Multiline属性，$也匹配“\n”或“\r”之前的位置。
*
匹配前面的子表达式任意次。例如，zo*能匹配“z”，也能匹配“zo”以及“zoo”。*等价于{0,}。
+
匹配前面的子表达式一次或多次(大于等于1次）。例如，“zo+”能匹配“zo”以及“zoo”，但不能匹配“z”。+等价于{1,}。
?
匹配前面的子表达式零次或一次。例如，“do(es)?”可以匹配“do”或“does”。?等价于{0,1}。
{n}
n是一个非负整数。匹配确定的n次。例如，“o{2}”不能匹配“Bob”中的“o”，但是能匹配“food”中的两个o。
{n,}
n是一个非负整数。至少匹配n次。例如，“o{2,}”不能匹配“Bob”中的“o”，但能匹配“foooood”中的所有o。“o{1,}”等价于“o+”。“o{0,}”则等价于“o*”。
{n,m}
m和n均为非负整数，其中n<=m。最少匹配n次且最多匹配m次。例如，“o{1,3}”将匹配“fooooood”中的前三个o为一组，后三个o为一组。“o{0,1}”等价于“o?”。请注意在逗号和两个数之间不能有空格。
?
当该字符紧跟在任何一个其他限制符（*,+,?，{n}，{n,}，{n,m}）后面时，匹配模式是非贪婪的。非贪婪模式尽可能少地匹配所搜索的字符串，而默认的贪婪模式则尽可能多地匹配所搜索的字符串。例如，对于字符串“oooo”，“o+”将尽可能多地匹配“o”，得到结果[“oooo”]，而“o+?”将尽可能少地匹配“o”，得到结果 ['o', 'o', 'o', 'o']
.点
匹配除“\n”和"\r"之外的任何单个字符。要匹配包括“\n”和"\r"在内的任何字符，请使用像“[\s\S]”的模式。
(pattern)
匹配pattern并获取这一匹配。所获取的匹配可以从产生的Matches集合得到，在VBScript中使用SubMatches集合，在JScript中则使用$0…$9属性。要匹配圆括号字符，请使用“\(”或“\)”。
(?:pattern)
非获取匹配，匹配pattern但不获取匹配结果，不进行存储供以后使用。这在使用或字符“(|)”来组合一个模式的各个部分时很有用。例如“industr(?:y|ies)”就是一个比“industry|industries”更简略的表达式。
(?=pattern)
非获取匹配，正向肯定预查，在任何匹配pattern的字符串开始处匹配查找字符串，该匹配不需要获取供以后使用。例如，“Windows(?=95|98|NT|2000)”能匹配“Windows2000”中的“Windows”，但不能匹配“Windows3.1”中的“Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?!pattern)
非获取匹配，正向否定预查，在任何不匹配pattern的字符串开始处匹配查找字符串，该匹配不需要获取供以后使用。例如“Windows(?!95|98|NT|2000)”能匹配“Windows3.1”中的“Windows”，但不能匹配“Windows2000”中的“Windows”。
(?<=pattern)
非获取匹配，反向肯定预查，与正向肯定预查类似，只是方向相反。例如，“(?<=95|98|NT|2000)Windows”能匹配“2000Windows”中的“Windows”，但不能匹配“3.1Windows”中的“Windows”。
*python的正则表达式没有完全按照正则表达式规范实现，所以一些高级特性建议使用其他语言如java、scala等
(?<!pattern)
非获取匹配，反向否定预查，与正向否定预查类似，只是方向相反。例如“(?<!95|98|NT|2000)Windows”能匹配“3.1Windows”中的“Windows”，但不能匹配“2000Windows”中的“Windows”。
*python的正则表达式没有完全按照正则表达式规范实现，所以一些高级特性建议使用其他语言如java、scala等
x|y
匹配x或y。例如，“z|food”能匹配“z”或“food”(此处请谨慎)。“[z|f]ood”则匹配“zood”或“food”。
[xyz]
字符集合。匹配所包含的任意一个字符。例如，“[abc]”可以匹配“plain”中的“a”。
[^xyz]
负值字符集合。匹配未包含的任意字符。例如，“[^abc]”可以匹配“plain”中的“plin”任一字符。
[a-z]
字符范围。匹配指定范围内的任意字符。例如，“[a-z]”可以匹配“a”到“z”范围内的任意小写字母字符。
注意:只有连字符在字符组内部时,并且出现在两个字符之间时,才能表示字符的范围; 如果出字符组的开头,则只能表示连字符本身.
[^a-z]
负值字符范围。匹配任何不在指定范围内的任意字符。例如，“[^a-z]”可以匹配任何不在“a”到“z”范围内的任意字符。
\b
匹配一个单词的边界，也就是指单词和空格间的位置（即正则表达式的“匹配”有两种概念，一种是匹配字符，一种是匹配位置，这里的\b就是匹配位置的）。例如，“er\b”可以匹配“never”中的“er”，但不能匹配“verb”中的“er”；“\b1_”可以匹配“1_23”中的“1_”，但不能匹配“21_3”中的“1_”。
\B
匹配非单词边界。“er\B”能匹配“verb”中的“er”，但不能匹配“never”中的“er”。
\cx
匹配由x指明的控制字符。例如，\cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。否则，将c视为一个原义的“c”字符。
\d
匹配一个数字字符。等价于[0-9]。grep 要加上-P，perl正则支持
\D
匹配一个非数字字符。等价于[^0-9]。grep要加上-P，perl正则支持
\f
匹配一个换页符。等价于\x0c和\cL。
\n
匹配一个换行符。等价于\x0a和\cJ。
\r
匹配一个回车符。等价于\x0d和\cM。
\s
匹配任何不可见字符，包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。
\S
匹配任何可见字符。等价于[^ \f\n\r\t\v]。
\t
匹配一个制表符。等价于\x09和\cI。
\v
匹配一个垂直制表符。等价于\x0b和\cK。
\w
匹配包括下划线的任何单词字符。类似但不等价于“[A-Za-z0-9_]”，这里的"单词"字符使用Unicode字符集。
\W
匹配任何非单词字符。等价于“[^A-Za-z0-9_]”。
\xn
匹配n，其中n为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，“\x41”匹配“A”。“\x041”则等价于“\x04&1”。正则表达式中可以使用ASCII编码。
\num
匹配num，其中num是一个正整数。对所获取的匹配的引用。例如，“(.)\1”匹配两个连续的相同字符。
\n
标识一个八进制转义值或一个向后引用。如果\n之前至少n个获取的子表达式，则n为向后引用。否则，如果n为八进制数字（0-7），则n为一个八进制转义值。
\nm
标识一个八进制转义值或一个向后引用。如果\nm之前至少有nm个获得子表达式，则nm为向后引用。如果\nm之前至少有n个获取，则n为一个后跟文字m的向后引用。如果前面的条件都不满足，若n和m均为八进制数字（0-7），则\nm将匹配八进制转义值nm。
\nml
如果n为八进制数字（0-7），且m和l均为八进制数字（0-7），则匹配八进制转义值nml。
\un
匹配n，其中n是一个用四个十六进制数字表示的Unicode字符。例如，\u00A9匹配版权符号（©）。
\p{P}
小写 p 是 property 的意思，表示 Unicode 属性，用于 Unicode 正表达式的前缀。中括号内的“P”表示Unicode 字符集七个字符属性之一：标点字符。
其他六个属性：
L：字母；
M：标记符号（一般不会单独出现）；
Z：分隔符（比如空格、换行等）；
S：符号（比如数学符号、货币符号等）；
N：数字（比如阿拉伯数字、罗马数字等）；
C：其他字符。
*注：此语法部分语言不支持，例：javascript。
\<
\>
匹配词（word）的开始（\<）和结束（\>）。例如正则表达式\<the\>能够匹配字符串"for the wise"中的"the"，但是不能匹配字符串"otherwise"中的"the"。注意：这个元字符不是所有的软件都支持的。
( )
将( 和 ) 之间的表达式定义为“组”（group），并且将匹配这个表达式的字符保存到一个临时区域（一个正则表达式中最多可以保存9个），它们可以用 \1 到\9 的符号来引用。
|
将两个匹配条件进行逻辑“或”（or）运算。例如正则表达式(him|her) 匹配"it belongs to him"和"it belongs to her"，但是不能匹配"it belongs to them."。注意：这个元字符不是所有的软件都支持的。
一、校验数字的表达式
1. 数字：^[0-9]*$
2. n位的数字：^\d{n}$
3. 至少n位的数字：^\d{n,}$
4. m-n位的数字：^\d{m,n}$
5. 零和非零开头的数字：^(0|[1-9][0-9]*)$
6. 非零开头的最多带两位小数的数字：^([1-9][0-9]*)+(.[0-9]{1,2})?$
7. 带1-2位小数的正数或负数：^(\-)?\d+(\.\d{1,2})?$
8. 正数、负数、和小数：^(\-|\+)?\d+(\.\d+)?$
9. 有两位小数的正实数：^[0-9]+(.[0-9]{2})?$
10. 有1~3位小数的正实数：^[0-9]+(.[0-9]{1,3})?$
11. 非零的正整数：^[1-9]\d*$ 或 ^([1-9][0-9]*){1,3}$ 或 ^\+?[1-9][0-9]*$
12. 非零的负整数：^\-[1-9][]0-9"*$ 或 ^-[1-9]\d*$
13. 非负整数：^\d+$ 或 ^[1-9]\d*|0$
14. 非正整数：^-[1-9]\d*|0$ 或 ^((-\d+)|(0+))$
15. 非负浮点数：^\d+(\.\d+)?$ 或 ^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$
16. 非正浮点数：^((-\d+(\.\d+)?)|(0+(\.0+)?))$ 或 ^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$
17. 正浮点数：^[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]*))$
18. 负浮点数：^-([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]*)))$
19. 浮点数：^(-?\d+)(\.\d+)?$ 或 ^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$
二、校验字符的表达式
1. 汉字：^[\u4e00-\u9fa5]{0,}$
2. 英文和数字：^[A-Za-z0-9]+$ 或 ^[A-Za-z0-9]{4,40}$
3. 长度为3-20的所有字符：^.{3,20}$
4. 由26个英文字母组成的字符串：^[A-Za-z]+$
5. 由26个大写英文字母组成的字符串：^[A-Z]+$
6. 由26个小写英文字母组成的字符串：^[a-z]+$
7. 由数字和26个英文字母组成的字符串：^[A-Za-z0-9]+$
8. 由数字、26个英文字母或者下划线组成的字符串：^\w+$ 或 ^\w{3,20}$
9. 中文、英文、数字包括下划线：^[\u4E00-\u9FA5A-Za-z0-9_]+$
10. 中文、英文、数字但不包括下划线等符号：^[\u4E00-\u9FA5A-Za-z0-9]+$ 或 ^[\u4E00-\u9FA5A-Za-z0-9]{2,20}$
11. 可以输入含有^%&',;=?$\"等字符：[^%&',;=?$\x22]+ 12 禁止输入含有~的字符：[^~\x22]+
三、特殊需求表达式
1. Email地址：^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$
2. 域名：[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?
3. InternetURL：[a-zA-z]+://[^\s]* 或 ^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$
4. 手机号码：^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$
5. 电话号码("XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX)：^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$
6. 国内电话号码(0511-4405222、021-87888822)：\d{3}-\d{8}|\d{4}-\d{7}
7. 身份证号(15位、18位数字)：^\d{15}|\d{18}$
8. 短身份证号码(数字、字母x结尾)：^([0-9]){7,18}(x|X)?$ 或 ^\d{8,18}|[0-9x]{8,18}|[0-9X]{8,18}?$
9. 帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
10. 密码(以字母开头，长度在6~18之间，只能包含字母、数字和下划线)：^[a-zA-Z]\w{5,17}$
11. 强密码(必须包含大小写字母和数字的组合，不能使用特殊字符，长度在8-10之间)：^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$
12. 日期格式：^\d{4}-\d{1,2}-\d{1,2}
13. 一年的12个月(01～09和1～12)：^(0?[1-9]|1[0-2])$
14. 一个月的31天(01～09和1～31)：^((0?[1-9])|((1|2)[0-9])|30|31)$
15. 钱的输入格式：
16. 1.有四种钱的表示形式我们可以接受:"10000.00" 和 "10,000.00", 和没有 "分" 的 "10000" 和 "10,000"：^[1-9][0-9]*$
17. 2.这表示任意一个不以0开头的数字,但是,这也意味着一个字符"0"不通过,所以我们采用下面的形式：^(0|[1-9][0-9]*)$
18. 3.一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号：^(0|-?[1-9][0-9]*)$
19. 4.这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉,因为钱总不能是负的吧.下面我们要加的是说明可能的小数部分：^[0-9]+(.[0-9]+)?$
20. 5.必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是 "10" 和 "10.2" 是通过的：^[0-9]+(.[0-9]{2})?$
21. 6.这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样：^[0-9]+(.[0-9]{1,2})?$
22. 7.这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样：^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$
23 8.1到3个数字,后面跟着任意个 逗号+3个数字,逗号成为可选,而不是必须：^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$
24. 备注：这就是最终结果了,别忘了"+"可以用"*"替代如果你觉得空字符串也可以接受的话(奇怪,为什么?)最后,别忘了在用函数时去掉去掉那个反斜杠,一般的错误都在这里
25. xml文件：^([a-zA-Z]+-?)+[a-zA-Z0-9]+\\.[x|X][m|M][l|L]$
26. 中文字符的正则表达式：[\u4e00-\u9fa5]
27. 双字节字符：[^\x00-\xff] (包括汉字在内，可以用来计算字符串的长度(一个双字节字符长度计2，ASCII字符计1))
28. 空白行的正则表达式：\n\s*\r (可以用来删除空白行)
29. HTML标记的正则表达式：<(\S*?)[^>]*>.*?</\1>|<.*? /> (网上流传的版本太糟糕，上面这个也仅仅能部分，对于复杂的嵌套标记依旧无能为力)
30. 首尾空白字符的正则表达式：^\s*|\s*$或(^\s*)|(\s*$) (可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式)
31. 腾讯QQ号：[1-9][0-9]{4,} (腾讯QQ号从10000开始)
32. 中国邮政编码：[1-9]\d{5}(?!\d) (中国邮政编码为6位数字)
33. IP地址：\d+\.\d+\.\d+\.\d+ (提取IP地址时有用)
34. IP地址：((?:(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d))
当您检索某个文本时，可以使用一种模式来描述要检索的内容。RegExp 就是这种模式。
简单的模式可以是一个单独的字符。
更复杂的模式包括了更多的字符，并可用于解析、格式检查、替换等等。
您可以规定字符串中的检索位置，以及要检索的字符类型，等等。
语法
var patt=new RegExp(pattern,modifiers);
或更简单的方法
var patt=/pattern/modifiers;模式描述了一个表达式模型。
修饰符(modifiers)描述了检索是否是全局，区分大小写等。
注意：当使用构造函数创造正则对象时，需要常规的字符转义规则（在前面加反斜杠 \）。比如，以下是等价的：
var re = new RegExp("\\w+");
var re = /\w+/;
RegExp 修饰符
修饰符用于执行不区分大小写和全文的搜索。
i - 修饰符是用来执行不区分大小写的匹配。
g - 修饰符是用于执行全文的搜索（而不是在找到第一个就停止查找,而是找到所有的匹配）。
实例 1:在字符串中不区分大小写找"runoob"
var str = "Visit RUnoob";
var patt1 = /runoob/i;
以下标记的文本是获得的匹配的表达式：
Visit RUnoob
实例 2:全文查找 "is"
var str="Is this all there is?";
var patt1=/is/g;
以下标记的文本是获得的匹配的表达式：
Is this all there is?
实例 3:全文查找和不区分大小写搜索 "is"
var str="Is this all there is?";
var patt1=/is/gi;
以下 标记的文本是获得的匹配的表达式：
Is this all there is?
test()
test()方法搜索字符串指定的值，根据结果并返回真或假。
下面的示例是从字符串中搜索字符 "e" ：
实例
var patt1=new RegExp("e");
document.write(patt1.test("The best things in life are free"));
由于该字符串中存在字母 "e"，以上代码的输出将是：
true
当使用构造函数创造正则对象时，需要常规的字符转义规则（在前面加反斜杠 \）
实例
var re = new RegExp("\\w+");
exec()
exec() 方法检索字符串中的指定值。返回值是被找到的值。如果没有发现匹配，则返回 null。
下面的示例是从字符串中搜索字符 "e" ：
实例 1
var patt1=new RegExp("e");
document.write(patt1.exec("The best things in life are free"));
由于该字符串中存在字母 "e"，以上代码的输出将是：e
662
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
