JavaScript 中的所有事物都是对象:字符串、数值、数组、函数...
此外,JavaScript 允许自定义对象
JavaScript 对象
对象只是一种特殊的数据。对象拥有属性和方法
访问对象的属性
属性是与对象相关的值。访问对象属性的语法是:
objectName.propertyName
下面这个例子使用了 String 对象的 length 属性来获得字符串的长度:
var message="Hello World!";
var x=message.length;
访问对象的方法
方法是能够在对象上执行的动作。可以通过以下语法来调用方法:
objectName.methodName()
下面这个例子使用了 String 对象的 toUpperCase() 方法来将文本转换为大写:
var message="Hello world!";
var x=message.toUpperCase();
创建 JavaScript 对象
通过 JavaScript,您能够定义并创建自己的对象
创建新对象有两种不同的方法:
1.定义并创建对象的实例
下面这个例子创建了对象的一个新实例,并向其添加了三个属性:
person=new Object();
person.firstname="John";
person.age=50;
person.eyecolor="blue";
替代语法(使用对象 literals):
person={firstname:"John",age:50,eyecolor:"blue"};
2.使用函数来定义对象,然后创建新的对象实例
下面的例子使用函数来构造对象:
function person(firstname,age,eyecolor){
this.firstname=firstname;
this.age=age;
this.eyecolor=eyecolor;
}
在JavaScript中,this通常指向的是我们正在执行的函数本身,或者是指向该函数所属的对象(运行时)
创建 JavaScript 对象实例
一旦您有了对象构造器,就可以创建新的对象实例,就像这样:
var myFather=new person("John",50,"blue");
var myMother=new person("Sally",48,"green");
把属性添加到 JavaScript 对象
您可以通过为对象赋值,向已有对象添加新属性:
假设 personObj 已存在 - 您可以为其添加这些新属性:firstname、age 以及 eyecolor:
person.firstname="John";
person.age=30;
person.eyecolor="blue";
把方法添加到 JavaScript 对象
方法只不过是附加在对象上的函数。在构造器函数内部定义对象的方法:
function person(firstname,age,eyecolor)
{
this.firstname=firstname;
this.age=age;
this.eyecolor=eyecolor;
this.changeName=changeName;
function changeName(name)
{
this.firstname=name;
}
}
myMother=new person("Sally",48,"green");
myMother.changeName("Doe");
document.write(myMother.firstname);
JavaScript 类
JavaScript是面向对象的语言,但JavaScript不使用类
在 JavaScript 中,不会创建类,也不会通过类来创建对象(就像在其他面向对象的语言中那样)
JavaScript 基于 prototype,而不是基于类的
JavaScript for...in 循环
JavaScript for...in 语句循环遍历对象的属性
for (variable in object){
code to be executed
}
注意: for...in 循环中的代码块将针对每个属性执行一次
JavaScript Number 对象
JavaScript 数字
JavaScript 只有一种数字类型。可以使用也可以不使用小数点来书写数字
var pi=3.14; // 使用小数点
var x=34; // 不使用小数点
极大或极小的数字可通过科学(指数)计数法来写:
var y=123e5; // 12300000
var z=123e-5; // 0.00123
所有 JavaScript 数字均为 64 位
所有 JavaScript 数字均为 64 位
在JavaScript中,数字不分为整数类型和浮点型类型,所有的数字都是由浮点型类型。JavaScript采用IEEE754标准定义的64位浮点格式表示数字,它能表示最大值为±1.7976931348623157 x 10308,最小值为±5 x 10 -324
精度
整数(不使用小数点或指数计数法)最多为 15 位。小数的最大位数是 17,但是浮点运算并不总是 100% 准确:
var x = 0.2+0.1; // result will be 0.30000000000000004
八进制和十六进制
如果前缀为 0,则 JavaScript 会把数值常量解释为八进制数,如果前缀为 0 和 "x",则解释为十六进制数
var y = 0377; //255
var z = 0xFF;//255
绝不要在数字前面写零,除非您需要进行八进制转换
默认情况下,JavaScript 数字为十进制显示。但是你可以用toString()方法 输出16进制、8进制、2进制
var myNumber=128;
myNumber.toString(16); // returns 80
myNumber.toString(8); // returns 200
myNumber.toString(2); // returns 10000000
无穷大(Infinity)
当数字运算结果超过了JavaScript所能表示的数字上限(溢出),结果为一个特殊的无穷大(infinity)值,在JavaScript中以Infinity表示。同样地,当负数的值超过了JavaScript所能表示的负数范围,结果为负无穷大,在JavaScript中以-Infinity表示。无穷大值的行为特性和我们所期望的是一致的:基于它们的加、减、乘和除运算结果还是无穷大(当然还保留它们的正负号)。
myNumber=2;
while (myNumber!=Infinity){
myNumber=myNumber*myNumber;
document.write(myNumber +'<BR>');
}//4 16 256 65536 4294967296 18446744073709552000 3.402823669209385e+38 1.157920892373162e+77 1.3407807929942597e+154 Infinity
除以0也产生了无限:
var x = 2/0; //Infinity
var y = -2/0; //-Infinity
NaN - 非数字值
NaN 属性是代表非数字值的特殊值。该属性用于指示某个值不是数字。可以把Number对象设置为该值来指示其不是数字值。
可以使用 isNaN() 全局函数来判断一个值是否是 NaN 值
var x = 1000 / "Apple";
isNaN(x); // returns true
var y = 100 / "1000";
isNaN(y); // returns false
除以0是无穷大,无穷大也是一个数字
数字可以是数字或者对象
数字可以私有数据进行初始化,就像 x = 123;
JavaScript 数字对象初始化数据, var y = new Number(123);
var x = 123;
var y = new Number(123);
typeof(x) // returns Number
typeof(y) // returns Object
数字属性
MAX_VALUE - 最大值
MIN_VALUE - 最小值
NEGATIVE_INFINITY - 负无穷大
POSITIVE_INFINITY - 正无穷大
NaN - 非数字
Number.prototype - 运行您向对象添加属性和方法。当构造一个属性 所有Number对象将被添加上该属性及值。当构造一个方法所有Number对象都会有这个方法。Number.prototype不允许引用一个单独的Number对象但是可以使用Number()对象。prototype 型是一个全局对象的构造函数,可用于所有的JavaScript对象
object.prototype.name=value // 语法
//例子
Number.prototype.myMet=function(){
this.myProp=this.valueOf()/2;
}
var n = new Number(55);
n.myMet();
var x = n.myProp;
object.constructor - 返回对创建此对象的数组函数的引用
function employee(name,job,born){
this.name=name;
this.job=job;
this.born=born;
}
var bill=new employee("Bill Gates","Engineer",1985);
document.write(bill.constructor); //function employee(name,job,born) { this.name=name; this.job=job; this.born=born; }
数字方法
NumberObject.toExponential(num):把Number转换成指数计数法,num表示小数点后保留几位
NumberObject.toFixed(num):把Number四舍五入为指定小数位数的数字
NumberObject.toPrecision(num):在对象的值超出指定位数时将其转换为指数计数法,num指定有效数字的位数。如果没有提供precision参数或其值为undefined,则将转而调用toString()方法进行处理。如果提供了参数,则参数precision必须介于 [1, 21] 之间,否则将报错。如果数字的有效位数大于precision,将会根据第precision + 1位的有效数字进行四舍五入
NumberObject.toString():不加参数表示把数字转化为字符串,也可以加上几进制的参数进行转化
NumberObject.valueOf():可以把字符串转化为数字
JavaScript 字符串
String 对象用于处理已有的字符块。
JavaScript 字符串
一个字符串可以使用单引号或双引号:
var carname="Volvo XC60";
var carname='Volvo XC60';
使用位置(索引)可以访问字符串中任何的字符:
var character=carname[7];
字符串的索引从零开始, 所以字符串第一字符为 [0],第二个字符为 [1]
可以在字符串中使用引号
var answer="It's alright";
var answer="He is called 'Johnny'";
var answer='He is called "Johnny"';
或者可以在字符串中使用转义字符使用“\”:
var answer='It\'s alright';
var answer="He is called \"Johnny\"";
字符串(String)
字符串(String)使用长度属性length来计算字符串的长度:
var txt="Hello World!";
document.write(txt.length);
在字符串中查找字符串
字符串使用 indexOf() 来定位字符串中某一个指定的字符首次出现的位置:
var str="Click the button to locate where "locate" first occurs.";
var n=str.indexOf("locate"); //20
如果没找到对应的字符函数返回-1
lastIndexOf() 方法在字符串末尾开始查找字符串出现的位置
内容匹配
match()函数用来查找字符串中特定的字符,并且如果找到的话,则返回这个字符
var str="Hello world!";
document.write(str.match("world") + "<br>"); //world
document.write(str.match("World") + "<br>"); //null
document.write(str.match("world!")); //world!
替换内容
replace() 方法在字符串中用某些字符替换另一些字符
str="Please visit Microsoft!"
var n=str.replace("Microsoft","w3cschool"); //Please visit w3cschool!"
字符串大小写转换
字符串大小写转换使用函数 toUpperCase() / toLowerCase():
var txt="Hello World!"; // String
var txt1=txt.toUpperCase(); // txt1 is txt converted to upper
var txt2=txt.toLowerCase(); // txt2 is txt converted to lower
字符串转为数组
字符串使用strong>split()函数转为数组:
txt="a,b,c,d,e" // String
txt.split(","); // Split on commas
txt.split(" "); // Split on spaces
特殊字符
Javascript 中可以使用反斜线(\)插入特殊符号,如:撇号,引号等其他特殊符号
var txt="We are the so-called "Vikings" from the north.";
在JavaScript中,字符串的开始和停止使用单引号或双引号。这意味着,上面的字符串将被切成: We are the so-called。解决以上的问题可以使用反斜线来转义引号:
var txt="We are the so-called \"Vikings\" from the north.";
JavaScript将输出正确的文本字符串:We are the so-called "Vikings" from the north.
下表列出其他特殊字符,可以使用反斜线转义特殊字符:
代码 | 输出 |
---|---|
\' | 单引号 |
\" | 双引号 |
\ | 斜杆 |
\n | 换行 |
\r | 回车 |
\t | tab |
\b | 空格 |
\f | 换页 |
字符串属性和方法
属性:
length - 计算字符串的长度
prototype - 同number
constructor - 同number
方法:
charAt() - 返回指定位置的字符
charCodeAt() - 返回指定位置的字符的 Unicode 编码
concat() - 多个字符串的连接
fromCharCode() - 根据Unicode编码返回一个字符串
indexOf() - 定位字符串中某一个指定的字符首次出现的位置
lastIndexOf() - 在字符串末尾开始查找字符串出现的位置
match() - 查找字符串中特定的字符,并且如果找到的话,则返回这个字符
replace() - 在字符串中用某些字符替换另一些字符
search() - 检索字符串中指定的子字符串,或检索与正则表达式相匹配的子字符串,查到后返回字符串首字母位置
stringObject.slice(start,end) - 可提取字符串的某个部分,并以新的字符串返回被提取的部分,允许使用负数作为参数
split() - 字符串以某标志分割转为数组
stringObject.substr(start,length) - 在字符串中抽取从start下标开始的指定数目的字符
stringObject.substring(start,stop) - 提取字符串中介于两个指定下标之间的字符,不接受负的参数
toLowerCase() - 字符串转为小写
toUpperCase() - 字符串转为大写
stringObject.valueOf() - 返回 Object 参数的字符串形式,如果参数为 “null”,返回“null”,否则返回objtoString()的值
JavaScript Date(日期)对象
日期对象用于处理日期和时间
Date() 方法 - 返回当日的日期和时间
var d=new Date();
document.write(d); //Fri Jun 02 2017 11:39:29 GMT+0800
getFullYear() - 获取年份
var d = new Date().getFullYear(); //2017
getTime() - 返回从 1970 年 1 月 1 日至今的毫秒数
var d = new Date().getTime(); //1496374883302
setFullYear() - 设置具体的日期
var d = new Date().setFullYear(2020,10,3); //Tue Nov 03 2020 11:42:29 GMT+0800
toUTCString() - 将当日的日期(根据 UTC)转换为字符串
var d = new Date().toUTCString(); //Fri, 02 Jun 2017 03:42:39 GMT
getDay() - 显示星期
var d = new Date().getDay(); //5
Date 对象属性
属性 | 描述 |
---|---|
constructor | 返回对创建此对象的 Date 函数的引用 |
prototype | 使您有能力向对象添加属性和方法 |
JavaScript constructor 属性
返回创建Date对象的函数原型:
myDate.constructor;
constructor 属性返回对创建此对象的 Date 函数的引用
function myFunction(){
var d = new Date();
document.write(d.constructor);
} //function Date() { [native code] }
JavaScript Date prototype 属性
prototype 属性使您有能力向对象添加属性和方法。当构造一个原型,所有的日期对象都会默认添加属性和方法。
注意: 可将属性和方法添加到原型中,但不能为对象分配其他原型。 但是可以向用户定义的对象分配新的原型。Prototype是一个全局属性,这对于几乎全部的JavaScript对象
Date.prototype.myMet=function(){
if (this.getMonth()==3){this.myProp="四月"};
if (this.getMonth()==4){this.myProp="五月"};
if (this.getMonth()==5){this.myProp="六月"};
}
function myFunction(){
var d = new Date();
d.myMet();
document.write(d.myProp);
} //function Date() { [native code] }
Date 对象方法
方法 | 描述 |
---|---|
getDate() | 从 Date 对象返回一个月中的某一天 (1 ~ 31) |
getDay() | 从 Date 对象返回一周中的某一天 (0 ~ 6) |
getFullYear() | 从 Date 对象以四位数字返回年份 |
getHours() | 返回 Date 对象的小时 (0 ~ 23) |
getMilliseconds() | 返回 Date 对象的毫秒(0 ~ 999) |
getMinutes() | 返回 Date 对象的分钟 (0 ~ 59) |
getMonth() | 从 Date 对象返回月份 (0 ~ 11) |
getSeconds() | 返回 Date 对象的秒数 (0 ~ 59) |
getTime() | 返回 1970 年 1 月 1 日至今的毫秒数 |
getTimezoneOffset() | 返回本地时间与格林威治标准时间 (GMT) 的分钟差 |
getUTCDate() | 根据世界时从 Date 对象返回月中的一天 (1 ~ 31) |
getUTCDay() | 根据世界时从 Date 对象返回周中的一天 (0 ~ 6) |
getUTCFullYear() | 根据世界时从 Date 对象返回四位数的年份 |
getUTCHours() | 根据世界时返回 Date 对象的小时 (0 ~ 23) |
getUTCMilliseconds() | 根据世界时返回 Date 对象的毫秒(0 ~ 999) |
getUTCMinutes() | 根据世界时返回 Date 对象的分钟 (0 ~ 59) |
getUTCMonth() | 根据世界时从 Date 对象返回月份 (0 ~ 11) |
getUTCSeconds() | 根据世界时返回 Date 对象的秒钟 (0 ~ 59) |
getYear() | 已废弃。 请使用 getFullYear() 方法代替 |
parse() | 返回1970年1月1日午夜到指定日期(字符串)的毫秒数 |
setDate() | 设置 Date 对象中月的某一天 (1 ~ 31) |
setFullYear() | 设置 Date 对象中的年份(四位数字) |
setHours() | 设置 Date 对象中的小时 (0 ~ 23) |
setMilliseconds() | 设置 Date 对象中的毫秒 (0 ~ 999) |
setMinutes() | 设置 Date 对象中的分钟 (0 ~ 59) |
setMonth() | 设置 Date 对象中月份 (0 ~ 11) |
setSeconds() | 设置 Date 对象中的秒钟 (0 ~ 59) |
setTime() | setTime() 方法以毫秒设置 Date 对象 |
setUTCDate() | 根据世界时设置 Date 对象中月份的一天 (1 ~ 31) |
setUTCFullYear() | 根据世界时设置 Date 对象中的年份(四位数字) |
setUTCHours() | 根据世界时设置 Date 对象中的小时 (0 ~ 23) |
setUTCMilliseconds() | 根据世界时设置 Date 对象中的毫秒 (0 ~ 999) |
setUTCMinutes() | 根据世界时设置 Date 对象中的分钟 (0 ~ 59) |
setMilliseconds() | 设置 Date 对象中的毫秒 (0 ~ 999) |
setUTCMonth() | 根据世界时设置 Date 对象中的月份 (0 ~ 11) |
setUTCSeconds() | 根据世界时 (UTC) 设置指定时间的秒字段 |
setYear() | 已废弃。请使用 setFullYear() 方法代替 |
toDateString() | 把 Date 对象的日期部分转换为字符串 |
toGMTString() | 已废弃。请使用 toUTCString() 方法代替 |
toISOString() | 使用 ISO 标准返回字符串的日期格式 |
toJSON() | 以 JSON 数据格式返回日期字符串 |
toLocaleDateString() | 根据本地时间格式,把 Date 对象的日期部分转换为字符串 |
toLocaleTimeString() | 根据本地时间格式,把 Date 对象的时间部分转换为字符串 |
toLocaleString() | 据本地时间格式,把 Date 对象转换为字符串 |
toString() | 把 Date 对象转换为字符串 |
toTimeString() | 把 Date 对象的时间部分转换为字符串。 |
toUTCString() | 根据世界时,把 Date 对象转换为字符串 |
UTC() | 根据世界时返回 1970 年 1 月 1 日 到指定日期的毫秒数 |
valueOf() | 返回 Date 对象的原始值 |
JavaScript Array(数组)对象
数组对象是使用单独的变量名来存储一系列的值
什么是数组?
数组可以用一个变量名存储所有的值,并且可以用变量名访问任何一个值
数组中的每个元素都有自己的的ID以便它可以很容易地被访问到
创建一个数组
创建一个数组,有三种方法。下面的代码定义了一个名为 myCars的数组对象:
1: 常规方式:
var myCars=new Array();
myCars[0]="Saab";
myCars[1]="Volvo";
myCars[2]="BMW";
2: 简洁方式:
var myCars=new Array("Saab","Volvo","BMW");
3: 字面:
var myCars=["Saab","Volvo","BMW"];
访问数组
通过指定数组名以及索引号码,可以访问某个特定的元素。
以下实例可以访问myCars数组的第一个值:
var name=myCars[0];
以下实例修改了数组 myCars 的第一个元素:
myCars[0]="Opel";
在一个数组中你可以有不同的对象
所有的JavaScript变量都是对象。数组元素是对象。函数是对象。因此,你可以在数组中有不同的变量类型。可以在一个数组中包含对象元素、函数、数组:
myArray[0]=Date.now;
myArray[1]=myFunction;
myArray[2]=myCars;
数组方法和属性
使用数组对象预定义属性和方法:
var x=myCars.length // the number of elements in myCars
var y=myCars.indexOf("Volvo") // the index position of "Volvo"
创建新方法 - prototype
Array.prototype.myUcase=function(){
for (i=0;i<this.length;i++){
this[i]=this[i].toUpperCase();
}
}
function myFunction(){
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.myUcase();
document.write(fruits);
}
Array 对象方法
方法 | 描述 |
---|---|
concat() | 连接两个或更多的数组,并返回结果 |
every() | 检测数组元素的每个元素是否都符合条件 |
filter() | 检测数组元素,并返回符合条件所有元素的数组 |
indexOf() | 搜索数组中的元素,并返回它第一次出现的位置 |
join() | 把数组的所有元素放入一个字符串 |
lastIndexOf() | 返回一个指定字符串值最后出现的位置 |
map() | 通过指定函数处理数组的每个元素,并返回处理后的数组 |
pop() | 删除数组的最后一个元素并返回删除的元素 |
push() | 向数组的末尾添加一个或更多元素,并返回新的长度 |
reverse() | 反转数组的元素顺序 |
shift() | 删除并返回数组的第一个元素 |
slice(start,end) | 选取数组的的一部分,并返回一个新数组,可以为负数 |
some() | 检测数组元素中是否有元素符合指定条件 |
sort() | 对数组的元素进行排序 |
splice() | 从数组中添加或删除元素 |
toString() | 把数组转换为字符串,并返回结果 |
unshift() | 向数组的开头添加一个或更多元素,并返回新的长度 |
valueOf() | 返回数组对象的原始值 |
every() 方法
every()方法用于检测数组所有元素是否都符合指定条件(通过函数提供)。如果数组中检测到有一个元素不满足,则整个表达式返回 false ,且剩余的元素不会再进行检测。如果所有元素都满足条件,则返回 true。
注意: every() 不会对空数组进行检测。every() 不会改变原始数组
var ages = [32, 33, 16, 40];
function checkAdult(age) {
return age >= 18;
}
document.write(ages.every(checkAdult)); //false
filter() 方法
filter()方法创建一个新的数组,新数组中元素是通过检查指定数组中符合条件的所有元素
注意: filter() 不会对空数组进行检测。filter() 不会改变原始数组
var ages = [32, 33, 16, 40];
function checkAdult(age) {
return age >= 18;
}
document.write(ages.filter(checkAdult)); //32,33,40
map() 方法
map() 方法返回一个新数组,数组中的元素为原始数组元素调用函数处理后的值。map() 方法按照原始数组元素顺序依次处理元素
注意:map() 不会对空数组进行检测。map() 不会改变原始数组
var numbers = [4, 9, 16, 25];
function myFunction() {
document.write(numbers.map(Math.sqrt));
} //2,3,4,5
var numbers = [65, 44, 12, 4];
function multiplyArrayElement(num) {
return num * 10;
}
function myFunction() {
document.getElementById("demo").innerHTML = numbers.map(multiplyArrayElement);
} //650, 440, 120, 40
valueOf()
valueOf() 是数组对象的默认方法,返回 Array 对象的原始值。该原始值由 Array 对象派生的所有对象继承。
valueOf() 方法通常由 JavaScript 在后台自动调用,并不显式地出现在代码中。valueOf() 方法不会改变原数组
function myFunction(){
var fruits = ["Banana", "Orange", "Apple", "Mango"];
document.write(fruits.valueOf());
} //Banana,Orange,Apple,Mango
JavaScript Boolean(布尔)对象
Boolean 对象用于转换一个不是 Boolean 类型的值转换为 Boolean 类型值 (true 或者false)
Boolean 对象代表两个值:"true" 或者 "false"
如果布尔对象无初始值或者其值为:0 -0 null "" false undefined NaN 那么对象的值为 false。否则其值为 true(即使当自变量为字符串 "false" 时)
Boolean 对象属性
属性 | 描述 |
---|---|
constructor | 返回对创建此对象的 Boolean 函数的引用 |
prototype | 使您有能力向对象添加属性和方法 |
Boolean 对象方法
方法 | 描述 |
---|---|
toString() | 把布尔值转换为字符串,并返回结果 |
valueOf() | 返回 Boolean 对象的原始值 |
JavaScript Math(算数)对象
Math(算数)对象的作用是:执行常见的算数任务。Math对象提供多种算数值类型和函数。无需在使用这个对象之前对它进行定义
Math 对象并不像 Date 和 String 那样是对象的类,因此没有构造函数 Math()。
使用Math的属性/方法的语法:
var x=Math.PI; // 返回PI
var y=Math.sqrt(16); // 返回16的平方根4
注意: Math对象无需在使用这个对象之前对它进行定义
算数值
JavaScript 提供 8 种可被Math对象访问的算数值:
算数方法
除了可被 Math 对象访问的算数值以外,还有几个函数(方法)可以使用。
使用 Math 对象的 round 方法对一个数进行四舍五入。
document.write(Math.round(4.7)); //5
使用 Math 对象的 random() 方法来返回一个介于 0 和 1 之间的随机数:
document.write(Math.random());
使用 Math 对象的 floor() 方法和 random() 来返回一个介于 0 和 11 之间的随机数:
document.write(Math.floor(Math.random()*11));
Math 对象属性
属性 | 描述 |
---|---|
E | 返回算术常量 e,即自然对数的底数(约等于2.718) |
LN2 | 返回 2 的自然对数(约等于0.693) |
LN10 | 返回 10 的自然对数(约等于2.302) |
LOG2E | 返回以 2 为底的 e 的对数(约等于 1.414) |
LOG10E | 返回以 10 为底的 e 的对数(约等于0.434) |
PI | 返回圆周率(约等于3.14159) |
SQRT1_2 | 返回返回 2 的平方根的倒数(约等于 0.707) |
SQRT2 | 返回 2 的平方根(约等于 1.414) |
Math 对象方法
方法 | 描述 |
---|---|
abs(x) | 返回 x 的绝对值 |
acos(x) | 返回 x 的反余弦值 |
asin(x) | 返回 x 的反正弦值 |
atan(x) | 以介于 -PI/2 与 PI/2 弧度之间的数值来返回 x 的反正切值 |
atan2(y,x) | 返回从x轴到点 (x,y) 的角度(介于 -PI/2 与 PI/2 弧度之间) |
ceil(x) | 对数进行上舍入 |
cos(x) | 返回数的余弦 |
exp(x) | 返回 E 的 x 次幂的值 |
floor(x) | 对 x 进行下舍入 |
log(x) | 返回数的自然对数(底为e) |
max(x,y,z,...,n) | 返回 x,y,z,...,n 中的最高值 |
min(x,y,z,...,n) | 返回 x,y,z,...,n中的最低值 |
pow(x,y) | 返回 x 的 y 次幂 |
random() | 返回 0 ~ 1 之间的随机数 |
round(x) | 把数四舍五入为最接近的整数 |
sin(x) | 返回数的正弦 |
sqrt(x) | 返回数的平方根 |
tan(x) | 返回角的正切 |
acos() 方法
语法:
Math.acos(x)
acos() 方法可返回一个数的反余弦。返回的值是 0 到 PI 之间的弧度值
注意:如果参数 x 超过了 -1.0 ~ 1.0 的范围,那么浏览器将返回 NaN。如果参数 x 取值 -1,那么将返回 PI
asin() 方法
语法:
Math.asin(x)
asin() 方法返回-PI/2 到 PI/2 之间的弧度值
注意:如果参数 x 超过了 -1.0 ~ 1.0 的范围,那么浏览器将返回 NaN。如果参数 x 取值 1,那么将返回 PI/2。
JavaScript RegExp 对象
RegExp:是正则表达式(regular expression)的简写
什么是 RegExp?
正则表达式是描述字符模式的对象
正则表达式用于对字符串模式匹配及检索替换,是对字符串执行模式匹配的强大工具
当您检索某个文本时,可以使用一种模式来描述要检索的内容。RegExp 就是这种模式。简单的模式可以是一个单独的字符。更复杂的模式包括了更多的字符,并可用于解析、格式检查、替换等等。可以规定字符串中的检索位置,以及要检索的字符类型,等等
语法
var patt=new RegExp(pattern,modifiers);
or more simply:
var patt=/pattern/modifiers;
pattern(模式) 描述了表达式的模式
modifiers(修饰符) 用于指定全局匹配、区分大小写的匹配和多行匹配
RegExp 修饰符
修饰符用于执行不区分大小写和全文的搜索
i - 修饰符是用来执行不区分大小写的匹配
g - 修饰符是用于执行全文的搜索(而不是在找到第一个就停止查找,而是找到所有的匹配)
var str="Is this all there is?";
var patt1=/is/gi;
document.write(str.match(patt1)); //Is,is,is
test()
test()方法搜索字符串指定的值,根据结果并返回真或假。
下面的示例是从字符串中搜索字符 "e" :
var patt1=new RegExp("e");
document.write(patt1.test("The best things in life are free")); //true
exec()
exec()方法检索字符串中的指定值。返回值是被找到的值。如果没有发现匹配,则返回 null
下面的示例是从字符串中搜索字符 "e" :
var patt1=new RegExp("e");
document.write(patt1.exec("The best things in life are free")); //e
修饰符
修饰符用于执行区分大小写和全局匹配:
修饰符 | 描述 |
---|---|
i | 执行对大小写不敏感的匹配 |
g | 执行全局匹配(查找所有匹配而非在找到第一个匹配后停止) |
m | 执行多行匹配 |
方括号
方括号用于查找某个范围内的字符:
表达式 | 描述 |
---|---|
[abc] | 查找方括号之间的任何字符 |
[^abc] | 查找任何不在方括号之间的字符 |
[0-9] | 查找任何从 0 至 9 的数字 |
[a-z] | 查找任何从小写 a 到小写 z 的字符 |
[A-Z] | 查找任何从大写 A 到大写 Z 的字符 |
[A-z] | 查找任何从大写 A 到小写 z 的字符 |
[adgk] | 查找给定集合内的任何字符 |
[^adgk] | 查找给定集合外的任何字符 |
(red | blue |
元字符
元字符(Metacharacter)是拥有特殊含义的字符:
元字符 | 描述 |
---|---|
. | 查找单个字符,除了换行和行结束符 |
\w | 查找单词字符 |
\W | 查找非单词字符 |
\d | 查找数字 |
\D | 查找非数字字符 |
\s | 查找空白字符 |
\S | 查找非空白字符 |
\b | 匹配单词边界 |
\B | 匹配非单词边界 |
\0 | 查找 NUL 字符 |
\n | 查找换行符,返回换行符位置或-1 |
\f | 查找换页符 |
\r | 查找回车符 |
\t | 查找制表符 |
\v | 查找垂直制表符 |
\xxx | 查找以八进制数 xxx 规定的字符 |
\xdd | 查找以十六进制数 dd 规定的字符 |
\uxxxx | 查找以十六进制数xxxx规定的 Unicode 字符 |
\s 元字符
\s 元字符用于查找空白字符
空白字符可以是:
空格符 (space character)
制表符 (tab character)
回车符 (carriage return character)
换行符 (new line character)
垂直换行符 (vertical tab character)
换页符 (form feed character)
\B 元字符
\B 元字符匹配非单词边界。匹配位置的上一个和下一个字符的类型是相同的:即必须同时是单词,或必须同时是非单词字符。字符串的开头和结尾处被视为非单词字符。如果未找到匹配,则返回 null
量词
量词 | 描述 |
---|---|
n+ | 匹配任何包含至少一个 n 的字符串 |
n* | 匹配任何包含零个或多个 n 的字符串 |
n? | 匹配任何包含零个或一个 n 的字符串 |
n{X} | 匹配包含 X 个 n 的序列的字符串 |
n{X,Y} | 匹配包含至少X最多Y个n的序列的字符串 |
n{X,} | 匹配包含至少 X 个 n 的序列的字符串 |
n$ | 匹配任何结尾为 n 的字符串 |
^n | 匹配任何开头为 n 的字符串 |
?=n | 匹配任何其后紧接指定字符串 n 的字符串 |
?!n | 匹配任何其后没有紧接指定字符串n的字符串 |
RegExp 对象方法
方法 | 描述 | FF | IE |
---|---|---|---|
compile | 用于在脚本执行过程中编译/改变正则表达式 | 1 | 4 |
exec | 检索字符串中指定的值。返回找到的值,并确定其位置 | 1 | 4 |
test | 检索字符串中指定的值。返回 true 或 false | 1 | 4 |
支持正则表达式的 String 对象的方法
方法 | 描述 | FF | IE |
---|---|---|---|
search | 检索与正则表达式相匹配的值 | 1 | 4 |
match | 找到一个或多个正则表达式的匹配 | 1 | 4 |
replace | 替换与正则表达式匹配的子串 | 1 | 4 |
split | 把字符串分割为字符串数组 | 1 | 4 |