文章简介
本文是我在 Runoob.com 菜鸟教程上的总结与学习笔记。
除了引用 菜鸟教程上的内容之外,我添加了许多它没有介绍,但是也很重要的内容。
另外,我对 JavaScript 的内容进行了重新排版,排版后的内容更适合阅读。
如果你想直接访问菜鸟教程,请点击上方的超链接。
强烈建议,当遇到不能理解的知识点,去菜鸟教程上运行实例观察。
或者你也可以在你的电脑上运行。
JavaScript
简介
官方说明
JavaScript 是互联网上最流行的客户端脚本语言,这门语言可用于 HTML 和 web,更可广泛用于服务器、PC、笔记本电脑、平板电脑和智能手机等设备。
# 脚本语言:不需要编译,直接可被浏览器解析执行。
JavaScript 是可插入 HTML 页面的编程代码,由浏览器执行。每一个浏览器都有 JavaScript 的解析引擎。
我的解释
JavaScript 使得用户在客户端进行操作时,可以不需要与服务器端产生交互。由此来避免一些对用户极其不友好的体验。
比如,填写了半个小时表单,提交给服务器后,服务器响应结果为“密码格式错误,请重新填写!”,用户又需要重新填写表单。而像格式校验这样的工作,我们其实就可以交给 JavaScript 来解决,这样是最为合理的方式。
发展史
1992年,Nombase公司,开发出第一门客户端脚本语言,专门用于表单的校验。命名为 : C-- ,后来更名为 ScriptEase
1995年,Netscape(网景)公司,开发了一门客户端脚本语言:LiveScript。后来,请来SUN公司的专家,修改LiveScript,并该名为 JavaScript
1996年,微软抄袭 JavaScript 开发出 JScript
于是,”客户端脚本语言界的三足鼎立“开始了。当然这对程序员非常不友好,因为此时程序员需要编写三份不用的代码以适配所有浏览器。
1997年,ECMA(欧洲计算机制造商协会),制定出客户端脚本语言的标准:ECMAScript
最终,ECMAScript 成为了所有脚本语言的标准化规范,终止了客户端脚本语言界混乱不堪的现象。
我们可以将 ECMAScript 理解为“标准”,将ScriptEase、JavaScript、JScript理解为“标准的实现和扩展”。
所以,其实如今的 JavaScript 其实是由:公共的ECMAScript 和 独有的JavaScript(DOM,BOM) 这两个部分组成。
ECMAScript
注释
单行注释://注释内容
多行注释:/*注释内容*/
// 注释
/* 注释 */
验证js支持
如果用户不能确定浏览器是否支持JavaScript脚本,那么可以应用HTML提供的注释符号进行验证。
对于不支持 JavaScript 的浏览器,将会把编写的 JavaScript 脚本作为注释处理。
<script>
<!--
document.write("您的浏览器支持JavaScript脚本!");
//-->
</script>
<script>标签
- <script>可以定义在html页面的任何位置。
- <script>可以定义多个。
- <script>定义的位置会影响执行顺序。
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>菜鸟教程(runoob.com)</title>
</head>
<body>
<script>
document.write("<h1>这是一个标题</h1>");
document.write("<p>这是一个段落。</p>");
</script>
</body>
</html>
内部样式
在 html文件中的 <script>标签中,直接编写 JavaScript代码。
<script>
document.write("我在html文件中,我是内部js语句!");
</script>
<script>
alert("我在html文件中,我是内部js语句!");
</script>
外部样式
在 html文件中的 <script>标签中,使用 “src”属性 来引入 外部js文件。
document.write("我在js文件中,我是外部js语句!");
alert("我在js文件中,我是外部js语句!");
<script src="style01.js">
</script>
<script src="style02.js">
</script>
如果<script>标签中,既有 JavaScript代码,又引用了 外部js文件,那么依然会执行 外部js代码。
<script src="style01.js">
/* 内部js语句不会执行 */
document.write("我在html文件中,我是内部js语句!");
</script>
<script src="style02.js">
/* 内部js语句不会执行 */
alert("我在html文件中,我是内部js语句!");
</script>
函数
我们把一个 JavaScript 函数放置到 HTML 页面的 <head> 部分,该函数会在点击按钮时被调用。
<!DOCTYPE html>
<html>
<head>
<script>
function myFunction(){
document.getElementById("demo").innerHTML="我的第一个 JavaScript 函数";
}
</script>
</head>
<body>
<p id="demo">一个段落</p>
<button type="button" onclick="myFunction()">点我</button>
</body>
</html>
输出
JavaScript 可以通过不同的方式来输出数据:
- 使用 window.alert() 弹出警告框。
- 使用 innerHTML 写入到 HTML 元素。
- 使用 document.write() 方法将内容写到 HTML 文档中。
- 使用 console.log() 写入到浏览器的控制台。
window.alert()
在浏览器中弹出警告框:
<script>
window.alert(5 + 6);
</script>
innerHTML
获取元素后,修改元素的内容:
document.getElementById(“demo”) 是使用 id 属性来查找 HTML 元素的 JavaScript 代码 。
innerHTML = “段落已修改。” 是用于修改元素的 HTML 内容(innerHTML)的 JavaScript 代码。
<p id="demo">我的第一个段落</p>
<script>
document.getElementById("demo").innerHTML = "段落已修改。";
</script>
document.write()
直接写在HTML 文档中:
<p>我的第一个段落。</p>
<script>
document.write(Date());
</script>
如果在文档已完成加载后执行 document.write,整个 HTML 页面将被覆盖:
<p>我的第一个段落。</p>
<button onclick="myFunction()">点我</button>
<script>
function myFunction() {
document.write(Date());
}
</script>
onsole.log()
如果您的浏览器支持调试,你可以使用 console.log() 方法在浏览器中显示 JavaScript 值。
浏览器中使用 F12 来启用调试模式, 在调试窗口中点击 “Console” 菜单。
<script>
console.log("喜欢");
</script>
变量
Java 是强类型语言。
在开辟变量存储空间时,定义了空间将来存储的数据的数据类型。
变量只能存储固定类型的数据。
语法:数据类型 变量名 = 初始化值;
int i = 1;
float f = 1.11f;
String s = "ABC"
JavaScript 是弱类型语言。
在开辟变量存储空间时,不定义空间将来的存储的数据的数据类型。
变量可以存放任意类型的数据。
语法:var 变量名 = 初始化值;
var i = 1;
var f = 1.11f;
var c = "ABC"
命名规则
- 变量必须以字母开头
- 变量也能以 $ 和 _ 符号开头(不过我们不推荐这么做)
- 变量名称对大小写敏感(y 和 Y 是不同的变量)
声明
您可以在一条语句中声明很多变量。该语句以 var 开头,并使用逗号分隔变量即可:
var lastname="Doe", age=30, job="carpenter";
声明也可横跨多行:
var lastname="Doe",
age=30,
job="carpenter";
一条语句中声明的多个不可以赋同一个值:
var x,y,z=1; // x,y=undefined z=1
如果重新声明 JavaScript 变量,该变量的值不会丢失。
在以下两条语句执行后,变量 carname 的值依然是 “Volvo”:
var carname="Volvo";
var carname;
局部变量
"let"关键字 允许你声明一个作用域被限制在块级中的变量、语句或者表达式。在Function中局部变量推荐使用let变量,避免变量名冲突。
function varTest() {
var x = 1;
if (true) {
var x = 2; // 同样的变量!
console.log(x); // 2
}
console.log(x); // 2
}
function letTest() {
let x = 1;
if (true) {
let x = 2; // 不同的变量!
console.log(x); // 2
}
console.log(x); // 1
}
常量
"const"关键字 用来声明 JavaScript中的常量。
//定义常量a并赋值为0
const a = 0;
//报错(不能重新赋值)
a = 1;
//报错(不能重新声明)
const a = 2;
//输出0
console.log("a is: " + a);
全局变量
如果您把值赋给尚未声明的变量,该变量将被自动作为 window 的一个属性。
这条语句,将声明 window 的一个属性 carname:
carname = "Volvo";
非严格模式下给未声明变量赋值创建的全局变量,是全局对象的可配置属性,可以删除:
var var1 = 1; // 不可配置全局属性
var2 = 2; // 没有使用 var 声明,可配置全局属性
console.log(this.var1); // 1
console.log(window.var1); // 1
console.log(this.var2); // 2
console.log(window.var2); // 2
delete var1; // false 无法删除
console.log(var1); // 1
delete var2; // true 可以删除
console.log(var2); // 报错变量未定义
数据类型
JavaScript 拥有动态类型。这意味着相同的变量可用作不同的类型:
var x; // x 为 undefined
var x = 5; // 现在 x 为数字
var x = "John"; // 现在 x 为字符串
字符串
字符串可以是引号中的任意文本。
您可以使用单引号或双引号:
var an = "cat";
var an = 'cat';
你可以在字符串中使用引号,只要不匹配包围字符串的引号即可:
var answer = "It's alright";
var answer = "He is called 'Johnny'";
var answer = 'He is called "Johnny"';
你也可以在字符串添加转义字符来使用引号:
var x = 'It\'s alright';
var y = "He is called \"Johnny\"";
字符串可以是对象:
var x = "John";
var y = new String("John");
typeof x // 返回 String
typeof y // 返回 Object
数字
JavaScript 只有一种数字类型。
数字可以带小数点,也可以不带:
var x1 = 34.00; //使用小数点来写
var x2 = 34; //不使用小数点来写
极大或极小的数字可以通过科学(指数)计数法来书写:
var y=123e5; // 12300000
var z=123e-5; // 0.00123
布尔值
布尔(逻辑)只能有两个值:true 或 false。
var x = true;
var y = false;
数组
下面的代码创建名为 cars 的数组:
var cars = new Array();
cars[0] = "Saab";
cars[1] = "Volvo";
cars[2] = "BMW";
或者 (condensed array):
var cars = new Array("Saab","Volvo","BMW");
或者 (literal array):
var cars=["Saab","Volvo","BMW"];
对象
对象由 花括号{} 分隔,属性由 逗号, 分隔。
在括号内部,对象的属性以名称和值对的形式 (name : value) 来定义。
下面的例子中,对象 (person) 有三个属性:firstname、lastname 以及 id:
var person = {firstname:"John", lastname:"Doe", id:5566};
空格和折行无关紧要。声明可横跨多行:
var person = {
firstname : "John",
lastname : "Doe",
id : 5566
};
对象属性有两种寻址方式:
name = person.lastname;
name = person["lastname"];
在对象中定义一个方法:
var person = {
firstname : "John",
lastname : "Doe",
id : 5566 ,
talk : funciton(){
document.write("HelloWorld!")
}
};
Undefined / Null / NaN
- undefined
- 一个没有设置值的变量。
- 当一个变量没有给定初始化值时,自动赋值。
- 可以通过将变量的值设置为 undefined 来清空变量。值为 undefined, 类型为 undefined。
- Null
- 主动释放。
- 可以通过将变量的值设置为 null 来清空变量。值为 null(空), 但类型为对象。
- NaN
- 一个不是数字的数字类型。 (Not A Number)
- NaN参加运算,任何运算结果都为NaN。
注意:null 和 undefined 的值相等,但类型不等:
typeof undefined // undefined
typeof null // object
null === undefined // false
null == undefined // true
判断变量的数据类型
typeof 方法
你可以使用 typeof 操作符来检测变量的数据类型,括号可加可不加。
typeof(1) // number
typeof(1.11) // number
typeof(NaN) // number
typeof "ABC" // string
typeof 'ABC' // string
typeof true // boolean
typeof false // boolean
typeof undefined // undefined
typeof null // object
typeof [1,2,3,4]; // object
typeof {name:'John', age:34} // object
typeof new Date() // object
typeof function () {} // function
isArray 方法
注意:isArray 只能用来判断 Array!
var cars=new Array();
cars[0]="Saab";
cars[1]="Volvo";
cars[2]="BMW";
// 判断是否支持该方法
if (Array.isArray) {
// 检验该对象是否为数组
if(Array.isArray(cars)) {
document.write("true") ;
}
}
instanceof 操作符
注意:instanceof 只能用来判断 Object !
var cars=new Array();
cars[0]="Saab";
cars[1]="Volvo";
cars[2]="BMW";
if (cars instanceof Array) {
document.write("该对象是一个数组。") ;
}
作用域
局部作用域
在局部作用域:只能在函数内部访问。
变量在函数内声明,即为局部变量。
局部变量在函数开始执行时创建,函数执行完后局部变量会自动销毁。
// 此处不能调用 carName 变量
function myFunction() {
var carName = "Volvo";
// 函数内可调用 carName 变量
}
全局作用域
全局作用域:网页中所有脚本和函数均可使用。
变量在函数外定义,即为全局变量。
全局变量在页面关闭后销毁。
var carName = " Volvo";
// 此处可调用 carName 变量
function myFunction() {
// 函数内可调用 carName 变量
}
如果变量没有声明(没有使用 var 关键字),该变量也为全局变量,不论这个变量在哪被使用。
// 函数myFunction被调用后,此处可调用 carName 变量
function myFunction() {
carName = "Volvo";
// 此处可调用 carName 变量
}
运算符
类型转换
如果变量不是运算符所要求的类型,变量将自动进行类型转换。
其他类型转number:
// string -> number
var num1 = +"123"; // 123
var num2 = +"abc"; // NaN
// boolean -> number
var num3 = +true; // 1
var num4 = +false; // 0
// null -> number
var num5 = +null; // 0
// undefined -> number
var num6 = +undefined; // NaN
其他类型转boolean:
// number:0或NaN为假,其他为真
document.write( !!3 + "<br>"); //true
document.write( !!0 + "<br>");
document.write( !!NaN + "<br><br>");
// string:除了空字符串(""),其他为真
document.write( !!"a" + "<br>"); //true
document.write( !!"" + "<br><br>");
// null:假
document.write( !!null + "<br><br>");
// undefined:假
document.write( !!undefined + "<br><br>");
// object:真
document.write( !!new Date() + "<br><br>"); //true
所以 Java的条件语句为:if(obj != null),而 JavaScript的条件语句为:if(obj)。
比较方式
类型相同,直接比较
字符串按照字典顺序,逐位比较ASCII码大小。
document.write("a" > "z"); // false
document.write("azzzz" > "zaaaa"); // false
类型不同,先转换类型,再比较
document.write("123" == 123); // true
=== 绝对等于:值和类型均相等。
document.write("123" === 123); // false
条件运算符
条件运算符可以基于某些条件对变量进行赋值。
三元运算符
- age<18 成立,返回"年龄太小"
- age<18 不成立,返回"年龄已达到"
voteable = ( age < 18 ) ? "年龄太小" : "年龄已达到";
多元运算符
- p>1 成立:
- p<12 成立,返回 p>12(false)。
- p<12 不成立,返回 p=6。
- p>1 不成立:
- 返回 p=3。
function test(p,b){
return p>1 ? p<12 ? p>12 : p=6 : p=3;
// p>1 ? 整体 : p=3 和 p<12 ? p>12 : p=6
}
流程控制语句
if…else…
只有当指定条件为 true 时,该语句才会执行代码。
if (condition) {
当条件为 true 时执行的代码
}
在条件为 true 时执行代码,在条件为 false 时执行其他代码。
if (condition) {
当条件为 true 时执行的代码}
else {
当条件不为 true 时执行的代码
}
选择多个代码块之一来执行。
if (condition1) {
当条件 1 为 true 时执行的代码
} else if (condition2) {
当条件 2 为 true 时执行的代码
} else {
当条件 1 和 条件 2 都不为 true 时执行的代码
}
switch
在 Java 中,switch语句可以接受的数据类型:byte int short char 枚举(1.5) String(1.7)。
在 JavaScript 中,switch语句可以接受任意的原始数据类型。
switch(n) {
case 1:
执行代码块 1
break;
case 2:
执行代码块 2
break;
default:
匹配不存在时做的事情
}
for
语句 1 (代码块)开始前执行
语句 2 定义运行循环(代码块)的条件
语句 3 在循环(代码块)已被执行之后执行
for (语句1 ; 语句2 ; 语句3) {
循环体
}
语句 1
通常我们会使用语句 1 初始化循环中所用的变量 (var i=0)。
语句 1 是可选的,不使用语句 1 也可以。
您可以在语句 1 中初始化任意(或者多个)值:
var i=2,len=cars.length;
for (; i<len; i++){
document.write(cars[i] + "<br>");
}
语句 2
通常语句 2 用于评估初始变量的条件。
语句 2 同样是可选的。
如果语句 2 返回 true,则循环再次开始,如果返回 false,则循环将结束。
如果您省略了语句 2,那么必须在循环内提供 break。否则循环就无法停下来。这样有可能令浏览器崩溃。
语句 3
通常语句 3 会增加初始变量的值。
语句 3 也是可选的(比如当循环内部有相应的代码时):
var i=0,len=cars.length;
for (; i<len; ){
document.write(cars[i] + "<br>");
i++;
}
for In
遍历数组,则变量为索引:
var nums = [1, 3, 5];
for (var x in nums) {
document.write(nums[x]+ "<br />");
}
for of
遍历数组,则变量为元素:
var nums = [1, 3, 5];
for (var x of nums) {
document.write( x + "<br />");
}
while
while 循环会在指定条件为真时循环执行代码块。
while (条件)
{
需要执行的代码
}
do/while
do/while 循环会在检查条件是否为真之前执行一次代码块,然后如果条件为真的话,就会重复这个循环。
do
{
需要执行的代码
}
while (条件);
break & continue
break 语句可用于跳出循环。
for (i=0;i<10;i++)
{
if (i==3)
{
break;
}
x = x + "The number is " + i + "<br>";
}
// 该数字为 0
// 该数字为 1
// 该数字为 2
continue 语句跳出循环后,会继续执行该循环之后的代码(如果有的话)。
for (i=0;i<6;i++)
{
if (i==3)
{
countinue;
}
x = x + "The number is " + i + "<br>";
}
// 该数字为 0
// 该数字为 1
// 该数字为 2
// 该数字为 4
// 该数字为 5
标记
如需标记 JavaScript 语句,请在语句之前加上冒号:
label:
statements
break 和 continue 语句仅仅是能够跳出代码块的语句。
通过标签引用,break 语句可用于跳出任何 JavaScript 代码块:
var nums = [1, 2, 3];
// 标签
label:
for (var x of nums) {
for (var y of nums) {
document.write( (x*y) + " ");
if (y == 2 && x == 2 ) {
// 跳出两个循环
break label;
}
}
document.write("<br />");
}
- 练习:99乘法表
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>99乘法表</title>
<style>
td{
border: 1px solid;
}
</style>
<script>
document.write("<table align='center'>");
//1.完成基本的for循环嵌套,展示乘法表
for (var i = 1; i <= 9 ; i++) {
document.write("<tr>");
for (var j = 1; j <=i ; j++) {
document.write("<td>");
//输出 1 * 1 = 1
document.write(i + " * " + j + " = " + ( i*
document.write("</td>");
}
/*//输出换行
document.write("<br>");*/
document.write("</tr>");
}
//2.完成表格嵌套
document.write("</table>");
</script>
</head>
<body>
</body>
</html>
类型转换
字符串
全局方法 String() 可以将变量转换为字符串。
该方法可用于任何类型的数字,字母,变量,表达式:
String(123)
String(false)
String(new Date())
toString() 也是有同样的效果:
(123).toString()
false.toString()
new Date().toString()
数字
Number("3.14") // 返回 3.14
Number(" ") // 返回 0
Number("") // 返回 0
Number("99 88") // 返回 NaN
Number(false) // 返回 0
Number(true) // 返回 1
Number(new Date()) // 返回 1404568027739
"111".valueOf() // 111
parseInt("111") // 111
正则表达式
正则表达式(英语:Regular Expression,在代码中常简写为regex、regexp或RE)使用单个字符串来描述、匹配一系列符合某个句法规则的字符串搜索模式。
/正则表达式主体/修饰符(可选)
例如:var patt = /runoob/i
/runoob/i 是一个正则表达式。
runoob 是一个正则表达式主体 (用于检索)。
i 是一个修饰符 (搜索不区分大小写)。
String对象的方法
在 JavaScript 中,正则表达式通常用于两个字符串方法 : search() 和 replace()。
search() 方法 用于检索字符串中指定的子字符串,或检索与正则表达式相匹配的子字符串,并返回子串的起始位置。
var str = "Visit Runoob!";
var n = str.search(/Runoob/i);
search 方法可使用字符串作为参数,字符串参数会转换为正则表达式:
var str = "Visit Runoob!";
var n = str.search("Runoob");
replace() 方法 用于在字符串中用一些字符替换另一些字符,或替换一个与正则表达式匹配的子串。
var str = "Visit microsoft!";
var txt = str.replace(/microsoft/i,"Runoob");
replace() 方法将接收字符串作为参数,字符串参数会转换为正则表达式:
var txt = str.replace("microsoft","Runoob");
修饰符
修饰符 | 描述 |
---|---|
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|green) | 查找任何指定的选项。 |
元字符
元字符是拥有特殊含义的字符:
元字符 | 描述 |
---|---|
. | 查找单个字符,除了换行和行结束符。 |
\w | 查找单词字符。 |
\W | 查找非单词字符。 |
\d | 查找数字。 |
\D | 查找非数字字符。 |
\s | 查找空白字符。 |
\S | 查找非空白字符。 |
\b | 匹配单词边界。 |
\B | 匹配非单词边界。 |
\0 | 查找 NULL 字符。 |
\n | 查找换行符。 |
\f | 查找换页符。 |
\r | 查找回车符。 |
\t | 查找制表符。 |
\v | 查找垂直制表符。 |
\xxx | 查找以八进制数 xxx 规定的字符。 |
\xdd | 查找以十六进制数 dd 规定的字符。 |
\uxxxx | 查找以十六进制数 xxxx 规定的 Unicode 字符。 |
量词
量词 | 描述 |
---|---|
n+ | 1 或 n。例如,/a+/ 匹配 “candy” 中的 “a”,“caaaaaaandy” 中所有的 “a”。 |
n* | 0 或 n。例如,/bo*/ 匹配 “A ghost booooed” 中的 “boooo”,“A bird warbled” 中的 “b”,但是不匹配 “A goat grunted”。 |
n? | 0 或 1。例如,/e?le?/ 匹配 “angel” 中的 “el”,“angle” 中的 “le”。 |
n{X} | x。例如,/a{2}/ 不匹配 “candy,” 中的 “a”,但是匹配 “caandy,” 中的两个 “a”,且匹配 “caaandy.” 中的前两个 “a”。 |
n{X,} | 至少 x 个。例如,/a{2,}/ 不匹配 “candy” 中的 “a”,但是匹配 “caandy” 和 “caaaaaaandy.” 中所有的 “a”。 |
n{X,Y} | x 至 y。例如,/a{1,3}/ 不匹配 “cndy”,匹配 “candy,” 中的 “a”,“caandy,” 中的两个 “a”,匹配 “caaaaaaandy” 中的前面三个 “a”。注意,当匹配 “caaaaaaandy” 时,即使原始字符串拥有更多的 “a”,匹配项也是 “aaa”。 |
n$ | 结尾为字符串 n 。 |
^n | 开头为字符串 n 。 |
?=n | 其后紧接字符串 n 。 |
?!n | 其后没有紧接字符串 n 。 |
对象
Function对象
- 特点
- length:代表形参的个数
- 函数不用写形参类型和返回值类型。
- 函数是一个对象,如果定义名称相同的函数,原本的函数会被覆盖。
- 函数的调用,仅与其名称有关,和参数列表无关。
- 函数仅能调用一次。
- length:代表形参的个数
创建Function对象的方法,有以下三种方式:
var fun1 = new Function("a" , "b" , "document.write( a + '<br>'); document.write( b + '<br>'); document.write(fun1.length + '<br>' + '<br>');");
function fun2(a,b,c) {
document.write(a + "<br>");
document.write(b+'<br>');
document.write(c+'<br>');
document.write(fun2.length+'<br>'+'<br>');
}
var fun3 = function(a,b,c,d){
document.write(a+'<br>');
document.write(b+'<br>');
document.write(c+'<br>');
document.write(d+'<br>');
document.write(fun3.length+'<br>'+'<br>');
}
在函数声明中有一个隐藏的内置对象(数组),arguments封装了所有的实际参数。
function add(){
var sum = 0;
for (var i = 0; i < arguments.length; i++) {
sum += arguments[i];
}
return sum;
}
var sum = add(1,2,3,4,5,6,7,8,9,10);
document.write(sum); // 55
Array对象
- 特点
- 元素类型可变。
- 数组长度可变。
创建对象
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"];
对象方法
indexOf() 方法可返回数组中某个指定的元素位置。
var y = myCars.indexOf("Volvo")
join() 方法用于把数组中的所有元素转换一个字符串。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var energy = fruits.join();
// 输出为 Banana,Orange,Apple,Mango
push() 方法可向数组的末尾添加一个或多个元素,并返回新的长度。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.push("Kiwi")
// 输出为 Banana,Orange,Apple,Mango,Kiwi
pop() 方法用于删除数组的最后一个元素并返回删除的元素。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.pop();
// 输出为 Banana,Orange,Apple
Date对象
创建对象
Date 对象用于处理日期和时间。
可以通过 new 关键词来定义 Date 对象。
有四种方式初始化日期:
new Date() // 当前日期和时间 Fri Feb 07 2020 18:03:29 GMT+0800 (中国标准时间)
new Date(1581069604154) //返回从 1970 年 1 月 1 日至今的毫秒数
new Date("October 13, 1975 11:13:00") // 指定日期和时间的字符串
new Date(9,5,24,11,33,0) // year month day hours minutes seconds milliseconds
设置日期
通过使用针对日期对象的方法,我们可以很容易地对日期进行操作。
在下面的例子中,我们为日期对象设置了一个特定的日期 (2010 年 1 月 14 日):
var myDate = new Date();
myDate.setFullYear(2010,0,14);
在下面的例子中,我们将日期对象设置为 5 天后的日期:
var myDate = new Date();
myDate.setDate(myDate.getDate() + 5);
对象方法
getTime() 方法可返回距 1970 年 1 月 1 日之间的毫秒数。
var d = new Date();
var n = d.getTime();
// 输出为 1581069604154
toLocaleString() 方法可根据本地时间把 Date 对象转换为字符串,并返回结果。
var d=new Date();
var n=d.toLocaleTimeString();
// 输出为 2020/2/7 下午6:04:45
Math对象
创建对象
Math对象不用创建,直接使用。
var x = Math.PI;
var y = Math.sqrt(16);
对象方法
方法 | 描述 |
---|---|
abs(x) | 返回 x 的绝对值。 |
ceil(x) | 对 x 进行上舍入。 |
floor(x) | 对 x 进行下舍入。 |
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) | 四舍五入,底层为 floor(x+0.5)。 |
sqrt(x) | 返回数的平方根。 |
如下所示:
Math.abs(1) // 1
Math.abs(-1) // 1
Math.ceil(1.1) // 2
Math.ceil(1.9) // 2
Math.floor(1.1) // 1
Math.floor(1.9) // 1
Math.max(1,2,3,4,5) // 5
Math.min(1,2,3,4,5) // 1
pow(2,10) // 1024
Math.round(-1) // floor(-0.5) = -1
Math.round(1) // floor(1.5) = 1
Math.round(-1.5) // floor(-1) = -1
Math.round(1.5) // floor(2) = 2
Math.sprt(1024) // 32
RegExp对象
RegExp:是正则表达式(regular expression)的简写。
正则表达式描述了字符的模式对象。
当您检索某个文本时,可以使用一种模式来描述要检索的内容。RegExp 就是这种模式。
创建对象
- 模式(parttern) 描述了一个表达式模型。
- 修饰符(modifiers) 描述了检索是否是全局,区分大小写等。
var patt=new RegExp(pattern,modifiers);
或更简单的方法
var patt=/pattern/modifiers;
例如:
var re = new RegExp("\\w+");
var re = /\w+/;
在字符串中不区分大小写找"is":
var patt1 = /is/i;
全文查找 “is”:
var patt1=/is/g;
全文查找和不区分大小写搜索 “is”:
var patt1=/is/gi;
对象方法
test()方法搜索字符串指定的值,根据结果并返回真或假。
var str = 'runoob';
var patt1 = new RegExp('\\w', 'g'); // 有转义,作为正则表达式处理
var patt2 = new RegExp('\w', 'g'); // 无转义,作为字符串处理
document.write( patt1.test(str) ) //输出 true
document.write( patt2.test(str) ) //输出 false
Global对象
创建对象
Global全局对象,其方法不需要对象就可以直接调用。
对象方法
encodeURI() 方法可把字符串作为 URI 进行编码。
该方法不会对 ASCII 字母和数字进行编码,也不会对这些 ASCII 标点符号进行编码: , / ? : @ & = + $ #
encodeURI("123") // 123
encodeURI("abcABC") // abcABC
encodeURI("@") // @
encodeURI("¥") // %EF%BF%A5
encodeURI("笑") // %E7%AC%91
encodeURI("http://www.baidu.com?username=李白")
// http://www.baidu.com?username=%E6%9D%8E%E7%99%BD
decodeURI() 方法可对 encodeURI() 方法编码过的 URI 进行解码。
var str = "恭喜发财";
var uri = encodeURI(str); // %E6%81%AD%E5%96%9C%E5%8F%91%E8%B4%A2
var str = decodeURI(uri); // 恭喜发财
encodeURIComponent() 方法可把字符串作为 URI 组件进行编码。
该方法不会对 ASCII 字母和数字进行编码,也不会对这些 ASCII 标点符号进行编码: - _ . ! ~ * ’ ( ) 。
decodeURIComponent() 方法可对 encodeURIComponent() 方法编码的 URI 进行解码。
encodeURIComponent("123") // 123
encodeURIComponent("abcABC") // abcABC
encodeURIComponent("@") // %40
encodeURIComponent("¥") // %EF%BF%A5
encodeURIComponent("笑") // %E7%AC%91
encodeURI("http://www.baiducom?username=李白")
// http%3A%2F%2Fwww.baidu.com%3Fusername%3D%E6%9D%8E%E7%99%BD
parseInt() 方法可解析一个字符串,并返回一个整数。
parseInt("11") // 11
parseInt("11.11") // 11
parseInt("11 12 13") // 11
parseInt(" 11 ") // 11
parseInt("11 years") // 11
parseInt("He was 11") // NaN
parseInt("10",16) // 16
parseInt("10",10) // 10
parseInt("10",8) // 8
parseInt("0x10") // 16
parseInt("010") // 10
isNaN() 方法用于检查其参数是否是非数字值。
如果参数值为 NaN 或字符串、对象、undefined等非数字值则返回 true, 否则返回 false。
isNaN(123) // false
isNaN(-1.23) // false
isNaN(5-2) // false
isNaN(0) // false
isNaN("Hello") // true
isNaN("2005/12/12") // true
eval() 方法计算 JavaScript 字符串,并把它作为脚本代码来执行。
如果参数是一个表达式,eval() 函数将执行表达式。如果参数是Javascript语句,eval()将执行 Javascript 语句。
eval("x=10;y=20;document.write(x*y)");
document.write("<br>" + eval("2+2"));
document.write("<br>" + eval(x+17));
// 输出为 200 4 27
编码
URL
URL 统一资源定位符(Uniform Resource Locator),其实就是我们访问web页面时需要输入的”网页地址“”网址“,比如:https://www.google.com/ 就是URL。
完整定义如下:
协议类型 😕/ 登录信息(认证) @ 服务器地址 : 端口号 / 带层次的文件路径 ? 查询字符串 # 片段标识符
htttp 😕/ user:pass @ www.example.jp : 80 / dir/index.html ? uid=1 # ch
URI
URI 统一资源标识符(Uniform Resource Identifier),就是某个网络协议方案表示的资源的定位标识符,比如:https://www.google.com/ 也同样可以说是,在https网络协议下的一个URI。
如果想要了解 URI统一资源标识符,那么我们必须理清它和 URL统一资源定位符 之间的关系。
第一,URL统一资源定位符 是一个具体的概念,而 URI统一资源标识符 是一个抽象的概念。
第二,URL统一资源定位符 是 URI统一资源标识符 的子集。
它是 URL,而 URL 属于 URI。:
htttp 😕/ user:pass @ www.example.jp : 80 /dir/index.html ? uid=1#ch
它是 URI:
联系地址 😕/ 访客:央视记者 @ 央视 : 直播 / 中国/湖北/武汉/红十字会的仓库 ? 物品=捐款物资
- utf-8:每个汉字3个字节;gbk:每个汉字2个字节;
- 在转码时,将1个字节转化成8个二进制,每4个二进制转化成1个十进制,每2个十进制分为1个组,在每组前头加上%。
- 传智播客 = %E4%BC%A0 %E6%99%BA %E6%92%AD %E5%AE%A2
- 在转码时,将1个字节转化成8个二进制,每4个二进制转化成1个十进制,每2个十进制分为1个组,在每组前头加上%。
DOM
当网页被加载时,浏览器会创建页面的 DOM 文档对象模型(Document Object Model)。通过这种可编程的对象模型,JavaScript 获得了足够的能力来创建动态的 HTML。
也就是说,DOM将标记语言文档的各个组成部分封装为对象,然后我们可以使用这些对象,并对标记语言文档进行CRUD的动态操作。
- JavaScript 能够改变页面中的所有 HTML 元素
- JavaScript 能够改变页面中的所有 HTML 属性
- JavaScript 能够改变页面中的所有 CSS 样式
- JavaScript 能够对页面中的所有事件做出反应
DOM 虽然属于 BOM,但由于DOM功能强大,所以单独算一类。
根据 W3C 标准,DOM 被分为3个不同的部分:
- 核心 DOM:针对任何结构化文档的标准模型
- Node:节点对象,其他5个的父对象
- Document:文档对象
- Element:元素对象
- Attribute:属性对象
- Text:文本对象
- Comment:注释对象
- XML DOM:针对 XML 文档的标准模型
- HTML DOM:针对 HTML 文档的标准模型
Document对象
获取HTML元素
通过 id 查找 id=“intro” 元素:
<p id="intro"> Hello World!!! </p>
<script>
x = document.getElementById("intro");
document.write("<p>文本来自 id 为 intro 段落: " + x.innerHTML + "</p>");
</script>
通过 标签名 查找 id=“main” 元素中的所有 <p> 元素:
<div id="main">
<p> Hello World!!! </p>
<p> Hello JavaScript!!! </p>
</div>
<script>
var x = document.getElementById("main");
var y = x.getElementsByTagName("p");
document.write('id="main"元素中的第一个段落为:' + y[0].innerHTML);
</script>
通过 class 查找 class=“intro” 的元素:
<p class="intro"> Hello World!!! </p>
<script>
x = document.getElementsByClassName("intro");
document.write("<p>文本来自 class 为 intro 段落: " + x[0].innerHTML + "</p>");
</script>
改变HTML内容
document.write() 可用于直接向 HTML 输出流写内容。
<script>
document.write(Date());
</script>
使用 innerHTML 属性 修改 HTML 内容。
<p id="p1">Hello World!</p>
<script>
document.getElementById("p1").innerHTML="新文本!";
</script>
改变HTML属性
如需改变 HTML 元素的属性,请使用这个语法:
document.getElementById(id).attribute = 新属性值
本例改变了 <img> 元素的 src 属性:
<img id="image" src="smiley.gif">
<script>
document.getElementById("image").src = "landscape.jpg";
</script>
改变HTML样式
如需改变 HTML 元素的样式,请使用这个语法:
document.getElementById(id).style.property = 新样式
下面的例子会改变 <p> 元素的样式:
<p id="p1">Hello World!</p>
<p id="p2">Hello World!</p>
<script>
document.getElementById("p2").style.color = "blue";
document.getElementById("p2").style.fontFamily = "Arial";
document.getElementById("p2").style.fontSize = "larger";
</script>
还可以 通过 HTML 元素的方法,改变和删除元素的属性:
<body>
<h1>恭喜发财</h1>
<input id="set" type="button" value="setAttribute">
<input id="remove" type="button" value="removeAttribute">
</body>
<script>
var h = document.getElementsByTagName("h1")[0];
document.getElementById("set").onclick = function () {
h.setAttribute("style","color: lightblue");
}
document.getElementById("remove").onclick = function () {
h.removeAttribute("style");
}
</script>
事件
HTML DOM 使 JavaScript 有能力对 HTML 事件做出反应。
事件可以描述为,特定组件被执行了特定的操作后,触发特定代码的执行。
我们可以将这个过程比喻为:
- 我方水晶被摧毁后,我就责备对友。
- 敌方水晶被摧毁后,我就夸奖自己。
具体事件的例子:
- 当用户点击鼠标时
- 当网页已加载时
- 当图像已加载时
- 当鼠标移动到元素上时
- 当输入字段被改变时
- 当提交 HTML 表单时
- 当用户触发按键时
分配事件
使用 HTML事件属性 向 button 元素分配 onclick 事件:
<p id="demo"></p>
<button onclick="displayDate()">点这里</button>
<script>
function displayDate(){
document.getElementById("demo").innerHTML = Date();
}
</script>
使用 HTML DOM 向 button 元素分配 onclick 事件:
<p id="demo"></p>
<button id="myBtn">点这里</button>
<script>
document.getElementById("myBtn").onclick = function(){displayDate()};
function displayDate(){
document.getElementById("demo").innerHTML = Date();
}
</script>
onload/onunload事件
onload 和 onunload 事件会在用户进入或离开页面时被触发。
onload 事件可用于检测访问者的浏览器类型和浏览器版本,并基于这些信息来加载网页的正确版本。
onload 和 onunload 事件可用于处理 cookie。
<body onload="checkCookies()">
<script>
function checkCookies(){
if (navigator.cookieEnabled == true){
alert("Cookies 可用")
}
else{
alert("Cookies 不可用")
}
}
</script>
</body>
onchange事件
onchange 事件 会在输入字段改变时被触发。
本例当用户改变输入字段的内容时,会调用 upperCase() 函数。
<head>
<script>
function myFunction(){
var x = document.getElementById("fname");
x.value = x.value.toUpperCase();
}
</script>
</head>
<body>
输入你的名字: <input type="text" id="fname" onchange="myFunction()">
<p>当你离开输入框后,函数将被触发,将小写字母转为大写字母。</p>
</body>
鼠标事件
属性 | 描述 |
---|---|
onclick | 当用户点击某个对象时调用的事件句柄。 |
oncontextmenu | 在用户点击鼠标右键打开上下文菜单时触发 |
ondblclick | 当用户双击某个对象时调用的事件句柄。 |
onmousedown | 鼠标按钮被按下。 |
onmouseenter | 当鼠标指针移动到元素上时触发。 |
onmouseleave | 当鼠标指针移出元素时触发 |
onmousemove | 鼠标被移动。 |
onmouseover | 鼠标移到某元素之上。 |
onmouseout | 鼠标从某元素移开。 |
onmouseup | 鼠标按键被松开。 |
键盘事件
属性 | 描述 |
---|---|
onkeydown | 某个键盘按键被按下。 |
onkeypress | 某个键盘按键被按下并松开。 |
onkeyup | 某个键盘按键被松开。 |
框架/对象事件
属性 | 描述 |
---|---|
onabort | 图像的加载被中断。 ( <object>) |
onbeforeunload | 该事件在即将离开页面(刷新或关闭)时触发 |
onerror | 在加载文档或图像时发生错误。 ( <object>, <body>和 <frameset>) |
onhashchange | 该事件在当前 URL 的锚部分发生修改时触发。 |
onload | 一张页面或一幅图像完成加载。 |
onpageshow | 该事件在用户访问页面时触发 |
onpagehide | 该事件在用户离开当前网页跳转到另外一个页面时触发 |
onresize | 窗口或框架被重新调整大小。 |
onscroll | 当文档被滚动时发生的事件。 |
onunload | 用户退出页面。 ( <body> 和 <frameset>) |
表单事件
属性 | 描述 |
---|---|
onblur | 元素失去焦点时触发 |
onchange | 该事件在表单元素的内容改变时触发( <input><keygen><select><textarea>) |
onfocus | 元素获取焦点时触发 |
oninput | 元素获取用户输入时触发 |
onreset | 表单重置时触发 |
onsearch | 用户向搜索域输入文本时触发 ( <input=“search”>) |
onselect | 用户选取文本时触发 ( <input> 和 <textarea>) |
onsubmit | 表单提交时触发 |
剪贴板事件
属性 | 描述 | DOM |
---|---|---|
oncopy | 该事件在用户拷贝元素内容时触发 | |
oncut | 该事件在用户剪切元素内容时触发 | |
onpaste | 该事件在用户粘贴元素内容时触发 |
Element对象
在 HTML DOM (Document Object Model) 中, 每个东西都是 节点 :
- 文档本身就是一个文档对象
- 所有 HTML 元素都是元素节点
- 所有 HTML 属性都是属性节点
- 插入到 HTML 元素文本是文本节点
- 注释是注释节点
属性
属性 | 描述 |
---|---|
element.attributes | 返回一个元素的属性数组 |
element.childNodes | 返回元素的一个子节点的数组 |
element.className | 设置或返回元素的class属性 |
element.firstChild | 返回元素的第一个子节点 |
element.id | 设置或者返回元素的 id。 |
element.innerHTML | 设置或者返回元素的内容。 |
element.lang | 设置或者返回一个元素的语言。 |
element.lastChild | 返回的最后一个子节点 |
element.nextSibling | 返回该元素紧跟的一个节点 |
element.nodeName | 返回元素的标记名(大写) |
element.nodeType | 返回元素的节点类型 |
element.nodeValue | 返回元素的节点值 |
element.parentNode | 返回元素的父节点 |
element.previousSibling | 返回某个元素紧接之前元素 |
element.style | 设置或返回元素的样式属性 |
方法
方法 | 描述 |
---|---|
element.appendChild() | 为元素添加一个新的子元素 |
element.focus() | 设置文档或元素获取焦点 |
element.getAttribute() | 返回指定元素的属性值 |
element.getAttributeNode() | 返回指定属性节点 |
element.hasFocus() | 返回布尔值,检测文档或元素是否获取焦点 |
element.removeAttribute() | 从元素中删除指定的属性 |
element.removeAttributeNode() | 删除指定属性节点并返回移除后的节点。 |
element.removeChild() | 删除一个子元素 |
element.replaceChild() | 替换一个子元素 |
element.setAttribute() | 设置或者改变指定属性并指定值。 |
element.setAttributeNode() | 设置或者改变指定属性节点。 |
BOM
BOM 浏览器对象模型(Browser Object Model)将浏览器的各个组成部分封装成对象。
Window对象
所有浏览器都支持 window 对象,它表示浏览器窗口。
所有 JavaScript 全局对象、函数以及变量均自动成为 window 对象的成员。
全局变量是 window 对象的属性。
全局函数是 window 对象的方法。
Window对象不需要创建可以直接使用 window使用。
甚至 HTML DOM 的 document 也是 window 对象的属性之一:
window.document.getElementById("header");
与此相同,window引用可以省略:
document.getElementById("header");
尺寸
有三种方法能够确定浏览器窗口的尺寸。
对于Internet Explorer、Chrome、Firefox、Opera 以及 Safari:
- window.innerHeight - 浏览器窗口的内部高度(包括滚动条)
- window.innerWidth - 浏览器窗口的内部宽度(包括滚动条)
对于 Internet Explorer 8、7、6、5:
- document.documentElement.clientHeight
- document.documentElement.clientWidth
或者
- document.body.clientHeight
- document.body.clientWidth
实用的 JavaScript 方案(涵盖所有浏览器):
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<p id="demo"></p>
<script>
var w = window.innerWidth
|| document.documentElement.clientWidth
|| document.body.clientWidth;
var h = window.innerHeight
|| document.documentElement.clientHeight
|| document.body.clientHeight;
x=document.getElementById("demo");
x.innerHTML="浏览器window宽度: " + w + ", 高度: " + h + "。"
</script>
</body>
</html>
弹窗
我们可以在 JavaScript 中创建三种消息框:警告框、确认框、提示框。
警告框
警告框经常用于确保用户可以得到某些信息。
当警告框出现后,用户需要点击确定按钮才能继续进行操作。
语法
window.alert("*sometext*");
window.alert() 方法可以不带上window对象,直接使用**alert()**方法。
alert("你好,我是一个警告框!");
确认框
确认框通常用于验证是否接受用户操作。
当确认卡弹出时,用户可以点击 “确认” 或者 “取消” 来确定用户操作。
当你点击 “确认”, 确认框返回 true, 如果点击 “取消”, 确认框返回 false。
语法
window.confirm("*sometext*");
window.confirm() 方法可以不带上window对象,直接使用**confirm()**方法。
<p>点击按钮,显示确认框。</p>
<button onclick="myFunction()">点我</button>
<p id="demo"></p>
<script>
function myFunction(){
var x;
var r = confirm("按下按钮!");
if (r == true){
x="你按下了\"确定\"按钮!";
}
else{
x="你按下了\"取消\"按钮!";
}
document.getElementById("demo").innerHTML=x;
}
</script>
提示框
提示框经常用于提示用户在进入页面前输入某个值。
当提示框出现后,用户需要输入某个值,然后点击确认或取消按钮才能继续操纵。
如果用户点击确认,那么返回值为输入的值。如果用户点击取消,那么返回值为 null。
语法
window.prompt("*sometext*","*defaultvalue*");
window.prompt() 方法可以不带上window对象,直接使用**prompt()**方法。
<p>点击按钮查看输入的对话框。</p>
<button onclick="myFunction()">点我</button>
<p id="demo"></p>
<script>
function myFunction(){
var x;
var person=prompt("请输入你的名字","Harry Potter");
if (person!=null && person!=""){
x = "你好 " + person + "! 今天感觉如何?";
document.getElementById("demo").innerHTML = x;
}
}
</script>
定时器
通过使用 JavaScript,我们有能力做到在一个设定的时间间隔之后来执行代码,而不是在函数被调用后立即执行。我们称之为计时事件。
在 JavaScritp 中使用计时事件是很容易的,两个关键方法是:
- setInterval():间隔指定的毫秒数不停地执行指定的代码。
- setTimeout():在指定的毫秒数后执行指定代码。
setInterval() 方法
setInterval() 间隔指定的毫秒数不停地执行指定的代码,
语法
window.setInterval("*javascript function*",*milliseconds*);
window.setInterval() 方法可以不使用 window 前缀,直接使用函数 setInterval()。
setInterval() 第一个参数是函数(function),第二个参数是间隔的毫秒数
注意: 1000 毫秒是一秒。
setInterval(function(){alert("Hello")},3000);
本例显示当前时间:
<p id="demo"></p>
<script>
var myVar = setInterval(function(){myTimer()},1000);
function myTimer(){
var d = new Date();
var t = d.toLocaleTimeString();
document.getElementById("demo").innerHTML = t;
}
</script>
clearInterval() 方法
clearInterval() 方法用于停止 setInterval() 方法执行的函数代码。
语法
window.clearInterval(*intervalVariable*)
window.clearInterval() 方法可以不使用window前缀,直接使用函数clearInterval()。
要使用 clearInterval() 方法, 在创建计时方法时你必须使用全局变量:
myVar = setInterval("*javascript function*",*milliseconds*);
然后你可以使用 clearInterval() 方法来停止执行。
以下例子,我们添加了 “停止” 按钮:
<p>页面上显示时钟:</p>
<p id="demo"></p>
<button onclick="myStopFunction()">停止</button>
<script>
var myVar = setInterval(function(){myTimer()},1000);
function myTimer(){
var d = new Date();
var t = d.toLocaleTimeString();
document.getElementById("demo").innerHTML=t;
}
function myStopFunction(){
clearInterval(myVar);
}
</script>
setTimeout() 方法
语法
myVar = window.setTimeout("*javascript function*", *milliseconds*);
setTimeout() 方法会返回某个值。在上面的语句中,值被储存在名为 myVar 的变量中。假如你希望取消这个 setTimeout(),你可以使用这个变量名来指定它。
setTimeout() 的第一个参数是含有 JavaScript 语句的字符串。这个语句可能诸如 “alert(‘5 seconds!’)”,或者对函数的调用,诸如 alertMsg,第二个参数是指示从当前起多少毫秒后执行第一个参数。
提示:1000 毫秒等于一秒。
等待3秒,然后弹出 “Hello”:
<p>点击按钮,在等待 3 秒后弹出 "Hello"。</p>
<button onclick="myFunction()">点我</button>
<script>
function myFunction(){
setTimeout(function(){alert("Hello")},3000);
}
</script>
clearTimeout() 方法
clearTimeout() 方法用于停止执行setTimeout()方法的函数代码。
语法
window.clearTimeout(*timeoutVariable*)
window.clearTimeout() 方法可以不使用window 前缀。
要使用clearTimeout() 方法, 你必须在创建超时方法中(setTimeout)使用全局变量:
myVar = setTimeout("*javascript function*",*milliseconds*);
如果函数还未被执行,你可以使用 clearTimeout() 方法来停止执行函数代码。
以下是同一个实例, 但是添加了 “Stop the alert” 按钮:
<p>点击第一个按钮等待3秒后出现"Hello"弹框。</p>
<p>点击第二个按钮来阻止第一个函数运行。(你必须在3秒之前点击它)。</p>
<button onclick="myFunction()">点我</button>
<button onclick="myStopFunction()">停止弹框</button>
<script>
var myVar;
function myFunction(){
myVar=setTimeout(function(){alert("Hello")},3000);
}
function myStopFunction(){
clearTimeout(myVar);
}
</script>
其他
一些其他方法:
- window.open() - 打开新窗口,返回Window对象
- window.close() - 关闭当前窗口
- window.moveTo() - 移动当前窗口
- window.resizeTo() - 调整当前窗口的尺寸
<body>
<input id="open" value="open" type="button">
<input id="close" value="close" type="button"><br><br>
</body>
<script>
// open():打开一个新的浏览器窗口,并返回一个新的Window对象
var openObj = document.getElementById("open");
var newWindow;
openObj.onclick = function () {
newWindow = open("https://www.zhuye.kim");
}
// close():关闭浏览器窗口。谁调用,谁关闭。
var closeObj = document.getElementById("close");
closeObj.onclick = function () {
newWindow.close();
}
</script>
Window Location对象
window.location 对象用于获得当前页面的地址 (URL),并把浏览器重定向到新的页面。
window.location 对象在编写时可不使用 window 这个前缀。 一些例子:
- location.hostname:返回 web 主机的域名
- location.pathname:返回当前页面的路径和文件名
- location.port:返回 web 主机的端口 (80 或 443)
- location.protocol:返回所使用的 web 协议(http: 或 https:)
href 属性用于设置或返回完整的URL:
<body>
<input type="button" id="href" value="获取当前路径">
<input type="button" id="goto" value="跳转页面">
</body>
<script>
var hr = document.getElementById("href");
hr.onclick = function () {
alert(location.href);
}
var goto = document.getElementById("goto");
goto.onclick = function () {
location.href = "https://www.zhuye.kim";
}
</script>
reload() 方法用于重新加载当前文档:
<body>
<input type="button" id="reload" value="刷新">
</body>
<script>
var rel = document.getElementById("reload");
rel.onclick = function () {
location.reload();
}
</script>
Window History对象
window.history 对象包含浏览器的历史。
window.history对象在编写时可不使用 window 这个前缀。
为了保护用户隐私,对 JavaScript 访问该对象的方法做出了限制。
history.back()
history.back() 方法加载历史列表中的前一个 URL。
这与在浏览器中点击后退按钮是相同的。
本例在页面上创建后退按钮:
<head>
<script>
function goBack(){
window.history.back()
}
</script>
</head>
<body>
<input type="button" value="Back" onclick="goBack()">
</body>
history.forward()
history forward() 方法加载历史列表中的下一个 URL。
这与在浏览器中点击前进按钮是相同的:
<head>
<script>
function goForward(){
window.history.forward()
}
</script>
</head>
<body>
<input type="button" value="Forward" onclick="goForward()">
</body>
history.go()
history.go() 方法 加载 history 列表中的某个具体页面。
如果参数是正数,则前进几个历史记录;负数则后退。
history.go(-1); // history.back();
history.go(0); // location.reload();
history.go(1); // history.foward();