JS的输出语句
<!--JS代码需要编写到script标签中-->
<script type="text/javascript">
/*
* 控制浏览器弹出一个警告框
* alert("这是我的第一行JS代码");
*/
/*
*让计算机在页面输出一个内容
* document.write()可以向body中输出一个内容
* document.write("kanjianwo!!");
*/
/*
* 向控制台输出一个内容
* console.log()的作用是向控制台输出一个内容
* console.log("你猜我在哪呢?");
*/
alert("这是我的第一行JS代码,内部代码");
document.write("kanjianwo!!");
console.log("你猜我在哪呢?");
JS编写位置,行内链接,内联外联
DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>title>
<script type="text/javascript" src="script.js">script>
<script type="text/javascript">
alert("这是我的第一行JS代码,内部代码");
script>
head>
<body>
<button onclick="alert('讨厌,你点我干嘛');">点我一下button>
<a href="javascript:alert('让你点你就点');">你也点我一下a>
<a href="javascript">你也点我一下a>
body>
html>
alert("我是JS文件中的代码");
注释
DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>title>
<script type="text/javascript">
/*
多行注释,注释中的内容不会被执行,但是可以在源代码中查看
JS注释
要养成良好的写注释的习惯,也可以通过注释来对代码进行一些简单的调试
*/
//单行注释
/*
* 1.JS中严格区分大小写
* 2.JS中每一条语句以分号 ; 结尾
* -如果不加分号,有时候浏览器会自动加,但是会消耗掉系统资源
* 有时候,浏览器会加错分号,所以在开发中分号必须写
* 3.JS中会忽略多个空格和换行,所以我们可以利用空格和换行对代码进行格式化。
*
*/
script>
head>
<body>
body>
html>
字面量和变量
DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>title>
<script type="text/javascript">
/*
*
* 字面量,都是一些不可改变的值。比如:1 2 3 4 5
* 字面量都是可以直接使用的,但我们一半不会直接使用字面量
*
* 变量 变量可以用来保存字面量,而且变量的值是可以任意改变的。
* 变量更加方便使用,所以开发中通过变量去保存一个字面量,而很少使用字面量
* 可以通过变量对字面量进行描述
*/
//声明变量 在js中使用var关键字来声明一个变量
var a;
//为变量赋值
a = 123;
a = 456;
a = 123454563456;
//声明和赋值同时进行
var b = 789;
var c = 0;
var age = 80;
console.log(age);
/*
* 标识符
* - 在js中所有的可以由我们自主命名的都可以成为是标识符
* - 例如:变量名、函数名、属性名
* - 命名一个标识符时需要遵循如下规则:
* 1.标识符中可以含有字母、数字、_、$
* 2.标识符不能以数字开头
* 3.标识符不能是js中的关键字和保留字
* 4.标识符一般采用驼峰命名法:
* - 首字母小写,之后的每个单词的开头字母大写,其他字母小写
*
* js底层保存标识符时实际上采用的Unicode编码
* - 所以理论上讲,所有的utf-8中含有的内容都可以作为标识符。
*/
//utf-8中包括中文,所以可以这样用
//但是一般不这样用
var 锄禾日当午 = 234;
document.write(锄禾日当午);
script>
head>
<body>
body>
html>
六种数据类型
String类型
DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>title>
<script type="text/javascript">
/*
* 数据类型指的就是字面量的类型
* 在js中一共有6种数据类型
* String 字符串
* Number 数值
* Boolean 布尔值
* Null 空值
* Undefined 未定义
* Object 对象
*
* 其中String Number Boolean Null Undefined属于基本数据类型
* 而Object 属于引用数据类型
*
*/
/*
* String字符串
* —在js中,字符串需要使用引号引起来
* —使用双引号或单引号都可以,但是不能混着用
* —引号不能嵌套,双引号不能放双引号,单引号不能放单引号
*/
var str = "hello";
str = '我说:"今天天气不错!"'
document.write(str);
/*
在字符串中我们可以使用\作为转义字符
当我们表示一些特殊符号时可以使用\进行转义
\" 表示 "
\' 表示 '
\n 表示 换行
\t 表示制表符
*/
str = "我说:\"今天\t天气真不错!\""
document.write(str);
str = "\\"
document.write(str);
//输出字面量:字符串类型的str
// alert("str");
//输出变量
// alert(str);
var str2 = "hello";
str2= "你好";
// alert(str2);
script>
head>
<body>
body>
html>
数值类型number
<script>
/*
* 在js中所有的数值都是Number类型
* 包括整数和浮点数(小数)
*
* JS中可以表示的数字的最大值
* Number.MAX_VALUE
* 1.7976931348623157e+308
*
* Number.MIN_VALUE 大于0的最小值
* 5e-324
*
* 如果使用Number表示的数字超过了最大值,则会返回一个
* Infinity 表示正无穷
* -Infinity 表示负无穷
* 使用typeof检查Infinity也会返回number
*
* NaN是一个特殊的数字,表示Not A Number
* 使用typeof检查NaN也会返回number
*/
//数字123
var a = 123;
//字符串123
var b = "123";
document.write(a);
document. write(b);
/*
可以使用一个运算符 typeof 来检查一个变量的类型
语法:typeof 变量。
检查字符串时,会返回string
检查数值时,会返回number
*/
document.write(typeof a);
document.write(typeof b);
c = -Number.MAX_VALUE * Number.MAX_VALUE
// c = Infinity;
document.write(c);
console.log (c);
alert(typeof c);
a = "abc" * "bcd";
a = NaN;
//console.log(typeof a);
a=Number.MIN_VALUE
//console.log(a);
/*
* 在JS中整数的运算基本可以保证精确
*/
var c =1865789 + 7654321;
/*
* 如果使用JS进行浮点运算,可能得到一个不精确的结果。
* 所以千万不要使用JS进行精确度比较高的运算。比如:钱的交易。
*/
var c = 0.1 + 0.2;
console.log(c);
script>
Boolean类型
<script>
/*
* Boolean 布尔值
* 布尔值只有两个:
* true
* -表示真
* false
* -表示假
*
* 使用typeof检查一个布尔值时,会返回boolean
*/
var bool = true;
console.log(typeof bool);
script>
Null类型、Undefined类型
<script>
/*
* Null类型的值只有一个,就是null
* null这个值专门用来表示一个为空的对象
* 使用typeof检查一个null值时,会返回object
*
* Undefined类型的值只有一个,就underfind
* 当声明一个变量,但是并不给变量赋值时,他的值就是undefined
* 使用typeof 检查一个undefined时也会返回underfined
*/
var a = null;
var e = undefined;
console.log(typeof e);
script>
强制类型转换
转换为String
<script type="text/javascript">
/*
*强制类型转换
* —指将一个数据类型强制转换为其他的类型
* —类型转换主要指:将其他的数据类型转换为:String、Number、Boolean
*
*/
/*
*将其他的数据类型转换为String
* 方式一:
* --调用被转换数据类型的toString()方法
* --调用该方法不会影响到原变量,它会将转换的结果返回。
* --注意:null和undefined这两个值没有toString()方法
* 如果调用他们的方法,会报错.
* 方式二:
* --调用String()函数,并将转换的数据作为参数传递给函数.
* --使用String()函数做强制类型转换时
* 对于Number和Boolean实际上就是调用toString()方法
* 但是对于null和undefined:
* 它会将null转换成"null",将undefined转换成"undefined"
*/
var a = 123;
//调用a的toString()方法
//调用xxx的yyy()方法,就是xxx.yyy()
//var b = a.toString(); 也可以直接用a接收这个值
a = a.toString();
a = true;
a = a.toString();
a = null;
//a = a.toString();
a = undefined;
//a = a.toString();
a = 123;
//调用String()函数,来将a转换为字符串
a = String(a);
a = null;
a = String(a);
a = undefined;
a = String(a);
// console.log(typeof a);
// console.log(a);
script>
其他类型转换为number
<script>
/*
*将其他的数据类型转换成Number
* 转换方式一:
* 使用Number()函数
* --字符串---数字
* 1、纯字符的字符串,则直接将其转换为数字。
* 2、如果字符串中有非数字的内容,转换为NaN
* 3、如果是空串或者是全是空格的字符串,转换为0
* 布尔值---数字
* true 1
* false 0
* null 0
* undefined NaN
*
* 转换方式二:
* --这种方式用来对付字符串
* parseInt()把一个字符串转换为一个整数
* parseFloat()把一个字符串转成一个浮点数
*/
a = "123";
//调用Number()函数将a转换成Number类型
a = Number(a);
a = false;
a = Number(a);//0
a = null;
a = Number(a);//0
a = undefined;
a = Number(a);//NAN
a = "12.3px23445d3";
a = parseInt(a);//12
//parseInt()可以将一个字符串中的数字取出来,转换成number
//但是只取整数,碰到其他字符不再取,例字母后面即使还有数字,也不再取
a = "1.23.23psdf";
a = parseFloat(a);//1.23
//与parseInt()类似,不过这个可以取小数。碰见其他字符同样不再取。
a = true;
a = parseInt(a);//NaN
//如果非String使用parseInt()或parseFloat(),会将其先转换为String再进行操作
// console.log(typeof a);
// document.write(a);
script>
十六进制、八进制、二进制的表示
<script>
/*
*在js中,表示 十六 进制的数字:以0x开头
* 八 进制 0
* 二 进制 0b
* 不是所有的浏览器都支持,如:IE就不支持
*/
//16进制
a = 0x10;
a = 0xcafe;
//8进制
a = 070;
//二进制
a = 0b10;
//像“070”这种字符串,有些浏览器当成8进制解析,有些当成10进制解析
a = "070";
//a = parseInt(a);
//可以在parseInt中传递第二个参数,指定数字的进制
a = parseInt(a,8);
// document.write(typeof a);
// console.log(a);
script>
转换为Boolean类型
<script>
/*
* 将其他的数据类型转换成Boolean
* -使用Boolean()函数
* - 数字----布尔
* -0和NaN false
* -其他的全是 true
*
* - 字符串----布尔
* 除了空串,其他全是true
*
* - null和undefined都会转换为false
*
* - 对象也会转换成true
*/
a = 123;//true
a = -123;//true
a = 0;//false
a = Infinity;//true
a = NaN;//false
//调用Boolean()函数将a转换为布尔值
a = Boolean(a);
a = "sdf";//true
a = "啊我的"//true
a = ""//false
a = Boolean(a);
a = null;//false
a = undefined;//false
a = Boolean(a);
document.write(typeof a);
console.log(a);
script>
运算符
算术运算符
<script type="text/javascript">
/*
*运算符也叫操作符
* 可以对一个或多个值进行运算,并获取结果
* 如:typeof 就是运算符,可以来获得一个结果
* 它会将该值的类型以字符串的形式返回
* number string boolean undefined object
*
* 算数运算符
* 当对非Number类型的值进行运算时,会将这些值转换成Number然后再运算
* 任何值和NaN做运算:都是NaN
* +
* 可以对两个值进行加法运算,并将结果返回
* 如果对两个字符串进行加法运算,会将他们拼成一个字符串然后返回
* 任何的值和字符串作加减运算,都会先转换成字符串,然后再拼串
* -
* 对两个值进行减法运算,返回结果
* 、-、*、、、、、
*
*
*/
var a = 123;
var result = typeof a;
//document.write(typeof result);// typefo返回一个值的类型 以String类型输出结果
result = a + 1;
result = 123 + 123;
result = true + 1;//2
result = true +false;//1
result = 2 + null;//2
result = 3 +NaN;//NaN
result = "123" + "456";
result = "12"+1;
result = true +"halppy";
//任何值和字符串相加,都会拼串
//利用这一点,任何类型的值+""即可转换为string
//这是一种隐式的类型转换,浏览器自动完成,实际上也是调用String()函数完成。
var c = 1223;
c = c + "";
// document.write(c);
// document.write(typeof c);
result = 1 + 2 +"3";//33
//number类型的做加法运算,直至遇到字符串类型的做拼串
result = "1" + 2 + 3;//123
//如果开头就是字符串类型的,直接做拼串
result = 100 - true;//99
//除了加法运算,其余运算都是将其转换为number进行运算.
result = 100 - "10";//90
result = 2 * "2";//4
result = 2 * undefined;//NaN
result = 2 * null;//0
result = 3/(true+true);//1.5
//document.write(result);
/* 任何值做-、*、/ 运算时都会转换成Number
* 利用这一隐式特点,
* 通过-0、*1、/1,就可以很方便的将其转换成Number.
* 原理与Number()函数一样
*/
var d = "123";
d = d - 0;
// document.write(d);
//document.write(d);
script>
一元运算符
<script>
/*
*一元运算符,只需要一个操作数
* + 正号
* 不会对数字产生任何影响
* - 负号
* 符号可以对数字进行符号的取反
* --对于非number类型的值,
* 先将其转换为number,再运算。
* 可以对一个其他类型的数据使用+,来将其转换为number
* 它的原理和number()函数一样。 如:a = "18";
* a = +a;
*/
a = 123;
a = -a;//-123
a = true;// boolean true
a = -a;//number -1
a = "18";//18 string
//a = -a; //-18 number
a = +a; //18 number
// document.write(a);
// document.write(typeof a);
result = 1 + "2" + 3;//123
result = 1 + +"2" + 3//6
//document.write(result);
script>
自增、自减,以及逻辑运算符
<script>
/*
* 自增 ++
* 通过自增使变量在自身的基础上增加1
* a++,先赋值再自加1
* ++a,先运算在赋值
* 自减 --
* a--,先赋值再自减1
* --a,先运算再赋值
* 参考java
*/
/*
*逻辑运算符
* ! 非
* 对一个值进行非运算,!true = false; !false = true;
* 如果对非boolean值进行取反,先转换为布尔值再取反
* 可以对一个值取反两次,就会将其转换为布尔值。原理与Boolean()函数一样
* && 与
* 真真为真,有假为假
* js中的&&为短路与,如果第一个值为false则不会再判断第二个值的真假
* || 或
* 有真为真,假假为假。
* js中的||为短路或,如果第一个值为true,则不再判断第二个值的真假
*/
b = 10;
b = !!b;
// document.write(b);
// document.write(typeof b);
/*
* && || 非布尔值的情况。
* 对于非布尔值进行与/或的运算时,先转换为布尔值,再运算。
* 如果要输出结果,则输出判断的最后一个值。
*/
// 真真 &&, 输出判断的最后一个数。
b = 1 && 2;//2
b = 2 && 1; //1
// 假假 && 第一个就为假,则直接返回,不再判断第二个数值的真假
b = 0 && NaN;//0
b = NaN && 0; //NaN
//真假 && 碰见假的就输出。
b = 0 && 3;//0
b = 9 && 0;//0
// || 返回判断的最后一个值
//全真返回第一个值,全假返回第二个值,真假返回真,假真返回真
b = NaN || 1; //1
b = NaN || 0; //0
b = 2 || 1;
b = "" || "hello";//hello
b = -1 || "你好";//-1
document.write(b);
script>
赋值运算符
<script type="text/javascript">
/**
* =
* 可以将符号右侧的值赋值给符号左侧的变量
* +=
* a += 5; 等同于 a = a + 5;
* -=
* a -= 5; 等同于 a = a - 5;
* *=
* a *= 5; 等同于 a = a * 5;
* /=
* a /= 5; 等同于 a = a / 5;
* %=
* a %= 5; 等同于 a = a % 5;
*/
var a= 10;
var b= 10;
var c= 10;
var d= 10;
var e= 10;
a += 5; //等同于a = a+5
document.write("a="+a);//15
b -= 5;
document.write("b="+b);//5
c *= 5;
document.write("c="+c);//50
d /= 5;
document.write("d="+d);//2
e %= 5;
document.write("e="+e);//0
script>
关系运算符
<script type="text/javascript">
/**
* 通过关系运算符比较两个值之间的大小关系
* 关系成立返回:true,反之返回:false
*
* > 判断左边是否大于右边,大于:true,反之:false
* 参照java
* >=
* <
* <=
*
* 非数值的情况:
* - 非数值进行比较的时候,先转换成数字然后再比较
* - 如果比较两个字符串,不会将其转换为数字进行比较,
* 而是会比较字符串中字符的Unicode编码
*
* 注意:
* - 任何值和NaN作比较都是:false
* - 比较来两个字符串时,比较的是字符串的字符编码
* 比较字符串编码时,一位一位进行比较,
* 如果两位一样,则比较下一位,所以借用它可以对英文进行排序
*
* - 如果比较的是两个字符串类型,其中放的是数字,可能得到不可预期的结果
* 所以在比较两个字符串类型的数字时,一定要转型。
*
*/
script>
在网页中使用Unicode编码输出字符
DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>title>
<script type="text/javascript">
/**
* 在字符串中使用转义字符输入Unicode编码
* \u四位编码
*/
document.write("\u2620");
script>
head>
<body>
<h1>਼h1>
<h1 style="font-size:100px;">☠h1>
<h1 style="font-size:100px;">⚀h1>
body>
html>
相等运算符
<script type="text/javascript">
/**
* 相等运算符用来比较两个值是否相等
* ==
* 相等运算。
* 使用==比较两个值时,如果值的了类型不同,则会自动进行类型转换
* 将其转换成为相同类型,然后再比较
* != 不等运算
* 也会对变量进行自动的类型转换,转会后再判断
*
* ===
* 判断两个值是否全等,但是它不会进行自动类型转换
* 如果两个值的类型不同,直接返回false
*
* !==
* 不全等
* 和全等类似,也不会进行自动类型转换。
* 两个值的类型不同,则直接返回false
*
*
* 注意:
* undefined 衍生于 null,所以这两个值做==时,返回true
*
*
*
* NaN不和任何值相等,包括它本身
* 所以即使一个变量的值是NaN,也无法通过==判断它是否为NaN
* 只能通过idNaN()函数来判断一个值是否为NaN
*/
var b = NaN;
document.write(isNaN(b));//true
script>
条件运算符 ,也叫:三元运算符
<script type="text/javascript">
/**
* 条件运算符也叫三元运算符
* 语法:
* 条件表达式?语句1:语句2
* ——执行过程:
* 条件运算符在执行时,首先对条件表达式进行判断
* - 如果条件表达式为:true,执行语句1,返回执行结果
* - 如果条件表达式为:false,执行语句2,返回执行结果
* - 如果条件的表达式的求职结果是一个非布尔值:
* 会将其转换为布尔值之后再判断
*/
var a = 30;
var b = 140;
var c = 80;
//a>b?alert("a牛"):alert("b牛");
//获取a和b中的最大值
var max = a > b ? a : b;
//alert(max);//40
//获取a b c中的最大值
max = max > c? max : c;
//alert(max);//80
//合并(不推荐使用,阅读较难)
max = a>b? a>c?a:c : b>c?b:c;
//即:max = a>b?(a>c?a:c):(b>c?b:c);
//分析:如果a>b,则执行a>c?a:c这个表达式
// 反之执行b>c?b:c
alert(max);
script>
<script type="text/javascript">
//运算符, 使用,可以分割多个语句,一般可以在声明多个变量的时候使用
//使用,可以同时声明多个变量
//var a , b , c;
//可以同时声明多个变量并赋值
var a=1 , b=2 , c=3 ;
//alert(a);//1
/**
* 运算符的优先级,跟数学一样:先乘除再加减....
* js中有一个运算符优先级的表:表中越靠上的优先级越高
* 哪个级别高哪个先运算
* 如果优先级一样高,则从左往右按顺序算
* 这个表不需要记忆,如果遇到优先级不清楚的,可以使用()来改变优先级
*/
var result = 1||2&&3
document.write(result);//1
//分析:&&的优先级更高先计算2&&3,都为真,返回后判断的3,1||3,1为true不再继续返回1
//可以使用()的方式改变优先级
result = (1||2)&&3
alert(result);
//分析:1||2在()中,1是true不再继续判断返回1
//然后执行1&&3,都为true,返回最后一个判断的数3
script>
代码块
<script type="text/javascript">
/**
* 我们的程序是一条一条语句构成的
* 语句是按照自上向下的顺序一条一条执行的
*
* 在js中可以使用{}来为语句进行分组
* 同一个{}中的语句我们称为是一组语句,要么都执行,要么都不执行
* 一个{}中的语句也成为:一个代码块。代码快后面不用再编写;了
*
* JS中的代码块,只具有分组的作用,没有其他的用途
*/
console.log("我是一个语句");
document.write("我也是一个语句");
{
console.log("我在一个代码块中");
document.write("我也在这个代码块中");
}
//代码块不是域,不具有分割作用。内部的在外部也可以访问
{
var a="我在代码块内部,但是外部也可以访问我";
}
alert(a);
script>
流程控制语句
概述
<script type="text/javascript">
/**
* 流程控制语句
* - JS中的程序是从上到下逐行执行的
* - 通过流程控制语句可以控制程序执行流程,使程序根据一定条件来选择执行
*
* 流程控制语句的分类:
* 1、条件判断语句
* 2、条件分支语句
* 3、循环语句
*
* - if语句
* ——语法一:
* if(条件表达式)
* 语句
* if语句在执行的时候,会先对条件表达式进行求值判断,
* 如果条件表达式的值为true,执行if后面的语句
* 如果为false,则不会执行if后面的语句。
*
* if语句智能控制其后面跟着的一条语句
* 如果希望if语句可以控制多条语句,可以将这些语句放到一个代码块中
* if语句后面的代码块不是必须的,但是在开发中尽量写上代码块,即使if后面只有一条语句
*
*/
var a = 11;
/* if(a>10)
document.write("a比10大");
document.write("谁也管不了我"); */
//放到代码块中可以被统一控制
/* if(a>10){
document.write("a比10大");
document.write("谁也管不了我");
} */
if(a>10 && a<=20){
document.write("a>10 并且a<=20");
}
script>
if语句(简写、参考java)
if语句
语法二:
if(条件表达式){
语句
}else{
语句
}
语法三:
if(条件表达式){
}else if(条件表达式){
}else{
}
prompt()函数
prompt()可以弹出一个提示框,该提示框中会带有一个文本框,用户可以在文本框中输入一段内容,该函数需要一个字符串作为参数,该字符串将会作为提示框输入的文字
用户输入的内容会作为函数的返回值返回,可以定义一个变量来接受该内容
var score = prompt("请输入。。。")
条件分支语句
条件分支语句,也叫:switch语句
语法:
switch(条件表达式){
case 表达式:
语句...
break;
case 表达式:
语句...
break;
case 表达式:
语句...
break;
case 表达式:
语句...
break;
default:
语句...
break;
//break;语句用来推出switch语句
}
执行流程;
switch..case..语句
在执行时会一次将case后的表达式的值和switch后的条件表达式的值进行全等比较
- 如果比较结果为true,则执行当前case后的代码,知道break结束
- 如果为false,则继续向下比较。
- 如果所有的case都为false,则只执行default后的语句
switch和if功能实际上有重复的,使用switch可以实现if的功能,使用if也能实现switch的功能,使用时:根据自己的习惯选择。
while循环
while循环
语法:
while(条件表达式){
语句。。。
}
while执行原理
先对条件表达式进行判断
-如果为true,则执行循环体
循环体执行完毕后,继续进行判断
如果为true,继续执行循环体,类推
-如果为false,则终止循环
可以在循环体内使用break;来退出循环
do..while循环
语法:
do{
}while();
执行流程:
先执行一次循环体,一次循环完毕后对while进行判断,如果为true,则一直执行,知道while 中为false时终止循环
for语句:也是一个循环语句,也称为一个for循环
for循环中,提供了三个表达式
语法
for(初始化表达式;条件表达式;更新表达式){
循环体
}
执行流程:
- 执行初始化表达式,初始化容量
- 执行条件表达式,判断是否执行循环
如果为true,继续循环
如果false,终止循环
-每次循环完成之后执行更新表达式,更新之后继续判断为true继续执行,一直循环直到为false
break和continue关键字
break关键字可以用来推出switch或循环语句
break会立即终止离他最近的那个循环
可以为循环语句创建一个label,来标识当前的循环
label:循环语句
使用break语句时,可以在break后面跟一个label,这样break就会终止指定的循环,而不是最近的。
continue关键字可以用来跳过当前循环,同样continue也是默只会对离他最近的循环起作用
计时器
需要测试程序的性能时,在程序执行前,开启计时器。
console.time("计时器的名字")可以用来开启一个计时器
//需要一个字符串作为参数,这个字符串将会作为计时器的标识
//开启计时器
console.time("text");
所需执行的程序
//终止计时器
console.timeEnd("计时器的名字")用来停止一个计时器,需要一个计时器的名字作为参数。
console.timeEnd("text");
<script type="text/javascript">
/**
* JS中数据类型:
* String字符串、Number数值、Boolean布尔值、Null空值、Undefined未定义
* 以上这五种类型属于基本数据类型,以后我们看到的值
* ,只要不是以上的5种,就都是对象
* Object 对象
*
* 基本数据类型都是单一的值"hello"、123、true,值和值之间没有任何联系
*
* 在JS中来表示一个人的信息(name gender age)
* var name="孙悟空"
* var gender="男"
* var age="18"
* 如果使用基本数据类型的数据,我们所创建的变量都是独立,不能成为一个属性。
*
* 对象属于一种复合的数据类型,在对象中可以保存多个不同数据类型的属性。
*
* 对象的分类:
* 1、内建对象
* - 由ES标准中定义的对象,在任何的ES视线中都可以使用
* 比如:Math、String、Number、Boolean、Function、Object....
* 2、宿主对象
* - 由JS的运行环境提供的对象,目前来讲主要指由浏览器提供的对象
* 比如:BOM:浏览器对象模型、DOM:文档对象模型。这是两组对象
* 如:console.log()、document.write(),
* 这两个对象用的时候不用创建,都是浏览器来提供的。
* 3、自定义对象
* - 由开发人员自己创建的对象。
*
*
*/
//创建对象
/**
* 使用new关键字调用的函数,是构造函数constructor,构造函数是专门用来创建对象的函数
* 使用typeof 检查一个对象的时候,会返回object
*/
var obj = new Object();
//document.write(obj);//[object Object]
//document.write(typeof obj)//object
/**
* 在对象中保存的值称为属性
* 在对象中添加属性语法:对象.属性名 = 属性值;
*/
//向对象中添加一个name属性
obj.name = "孙悟空";
//向对象中添加一个gender属性
obj.gender = "男";
//向对象中添加一个age属性
obj.age = "18";
//console.log(obj);// {name: "孙悟空", gender: "男", age: "18"}
/**
* 读取对象中的属性,语法:对象.属性名
*
* 注意:如果读取对象中没有的属性,不会报错而是会返回undefined
*/
document.write(obj.age);
console.log(obj.gender);
//读取对象中没有的值,返回:undefined。
//console.log(obj.hello);//undefined
/**
* 修改对象的属性值
* 语法:对象.属性名 = 新值。
*/
obj.name = "tom";
document.write(obj.name);
/**
* 删除对象的属性:
* 语法:delete 对象.属性名
*/
delete obj.name;
document.write(obj.name);//undefined
script>
属性名和属性值
<script type="text/javascript">
/**
* 向对象中添加属性
* 属性名:
* - 对象的属性名不强制要求遵守标识符的规范,什么名字都可以使用
* - 但是我们使用时还是尽量按照标识符的规范去命名
*/
var obj = new Object;
obj.name="孙悟空";
obj.var="hello";
console.log(obj.var); //"hello"
/**
* 如果要使用特殊的属性名,不能采用.的方式
* 需要使用另一种方式:
* 语法:对象["属性名"]=属性值
* 读取时也需要采用这种方式
*
*/
obj["123"] = 123;
document.write(obj["123"]);//123
/**
* 使用[]这种形式去操作属性,更加的灵活
* 在[]中可以直接传递一个变量,这样变量值是多少就会读取那个属性。
*/
var n ="123";
console.log(obj["123"]);//123
console.log(obj[n]); //123
/**
* 属性值:
* JS对象的属性值,可以是任意的数据类型
*/
obj.test = true;
document.write(obj.test);//true
obj.test = null; //null
document.write(obj.test);
obj.test= undefined;
document.write(obj.test);//undefined
var obj2 = new Object();
obj2.name="猪八戒";
//将obj2设置为obj的属性
obj.test = obj2;
console.log(obj.test);// {name: "猪八戒"}
console.log(obj.test.name);//猪八戒
/**
* in运算符
* - 通过该运算符可以检查一个对象中是否含有指定的属性
* 如果有则返回true,没有则返回false
* - 语法:
* "属性名" in 对象
*/
console.log("test2" in obj); //false
console.log("test" in obj); //true
console.log("name" in obj); //true
script>
基本和引用数据类型
<script type="text/javascript">
/**
* 基本数据类型
* String、Number、Boolean、Null、Undefined
*
* 引用数据类型
* Object
*
* JS中的变量都是保存到栈内存中的
* 基本数据类型的值直接在栈内存中存储
* 值与值之间是独立的,修改一个变量不会影响其他变量
*/
var obj = new Object();
obj.name = "sunsun";
var obj2 = obj; //这里是把obj中保存的内存地址复制了一份给了obj2,实际上他们都指向同一个对象。
console.log(obj.name);//sunsun
console.log(obj2.name);//sunsun
//改变obj的name
obj.name="zhuzhu"
//obj与obj2指向同一个对象
console.log(obj.name);//zhuzhu
console.log(obj2.name);//zhuzhu
//设置obj2为null
obj2 = null;
console.log(obj2);//null
console.log(obj);//{name: "zhuzhu"}
/**
* ==
* - 比较两个基本数据类型的值的时候,就是比较值
* - 比较两个引用数据类型时,他比较的是两个对象的内存地址。
* 如果两个对象的属性以及值相等,但是内存地址不同,就会返回false
*/
var obj3 = new Object();
var obj4 = new Object();
obj3.name="ss";
obj4.name="ss";
console.log(obj3);// {name: "ss"}
console.log(obj4);// {name: "ss"}
console.log(obj3 == obj4);//false
script>
对象字面量
<script type="text/javascript">
/**
* 创建对象的两种方式:
* var obj = new Object();
* 使用对象字面量来创建一个对象
* var obj = {};
*/
var obj = {
};
obj.name = "ss";
console.log(obj);//{name:"ss"}
/**
* 使用对象字面量,可以再创建对象时,直接指定对象中的属性
* 语法:{属性名:属性值,属性名:属性值.....}
* 对象字面量的属性名可以加引号也可以不加,建议不加。
* 如果需要使用一些特殊的字符作为属性名时,则必须加引号
*
* 属性名和属性值是一组一组的名值对结构,
* 名和值之间使用:连接,多个名值对之间使用,隔开
* 如果一个属性之后没有其他的属性了,就不要写。
*/
var obj2 = {
name:"猪八戒",
age:"28",
gender:"男",
test:{
name:"沙和尚"}
}
console.log(obj2);//{name: "猪八戒", age: "28", gender: "男", test: {…}}
console.log(obj2.test);//{name: "沙和尚"}
script>
函数
<script type="text/javascript">
/**
* 函数
* - 函数也是一个对象
* - 函数中可以封装一些功能(代码),在需要时也可以执行这些功能。(代码)
* - 函数中可以保存一些代码在需要的时候调用
* - 使用typeof检查一个函数对象时,会返回function
*/
//创建一个函数对象
//可以将要封装的代码以字符串的形式传递给构造函数。
//实际开发中,很少使用构造函数来创建一个函数对象。
var fun = new Function("console.log('hello 这是我的第一个函数')");
//封装到函数中的代码不会立即执行,函数中的代码会在函数调用的时候执行。
//调用函数语法:函数对象(),当调用函数时,函数中封装的代码回按照顺序执行。
fun();//hello 这是我的第一个函数
fun.hello = "nihao";
console.log(fun.hello);//你好
/**
* 使用函数声明来创建一个函数
* 语法:
* function 函数名([形参1,形参2,....形参N]){
语句......
}
*/
function fun2(){
console.log("这是我的第二个函数");
alert("哈哈哈哈");
document.write("dfdkfsdlfjsdflksdj");
}
//console.log(fun2);
fun2();
/**
* 使用函数表达式来创建一个函数
* var 函数名 = function([形参1,形参2,....形参N]){
语句......
};
*/
var fun3 = function(){
console.log("我是匿名函数中封装到代码");
};
fun3();
script>
函数的参数
<script type="text/javascript">
/**
* 定义一个用来求两个数和的函数
* 可以在函数的()中指定一个或多个参数(形式参数)
* 多个形参之间使用,隔开 声明形参就相当于在函数内部声明了对应的变量,但是并不赋值
*/
function sum(a,b){
console.log(a);
console.log(b);
console.log(a+b);
}
/**
* 在调用函数的时候,可以在()中传入实际参数(实参)
* 实参将会赋值给函数中对应的形参
*/
sum(1,2); //3
sum(123,456); //579
/**
* 调用函数时,解析器不会检查实参的类型。函数的实参可以是任意的数据类型
* 所以要注意,是否有可能会接收到非法的参数,如果有可能则需要对参数进行类型的检查
*
*/
sum(123,"hello");//123hello
sum(true,false);//1
/**
* 调用函数时,解析器也不会检查实参的数量
* 多余参数不会被赋值
* 如果实参的数量少于形参的数量,则没有对应实参的形参是undefined
*/
sum(123,456,"hello",true,null);//579
sum(123);//undefined
script>
返回值
<script type="text/javascript">
/**
* 创建一个函数,用来计算三个数的和
*
* 可以使用return 来设置函数的返回值
* 语法:
* return 值
* return后面可以跟任意类型的值
*
* return后的值将会作为函数的执行结果返回
* 可以定义一个变量接收该结果。
*
* 并且函数中return后的语句都不会执行
*
* 如果return语句后不跟任何值就相当于返回一个undefined
* 如果函数中不写return,则也会返回undefined
*/
function sum(a, b ,c){
var d = a + b + c;
return d;
}
//调用函数
//变量result的值就是函数的执行结果,函数返回什么result的值就是什么
var result = sum(4,5,6);
console.log(result);//15
var result2 = alert("hello");
console.log(result2);//undefined,说明alert函数没有返回值
script>
实参可以是函数也可以是对象
<script type="text/javascript">
/**
* 实参可以是一个对象,也可以是一个函数
*
*/
function fun(a){
console.log(a);
}
fun(123);
fun(function(){
});// function (){}
/**
* fun()
* - 调用函数
* - 相当于使用函数的返回值
*
* fun
* - 函数对象
* - 相当于直接使用函数对象
*/
script>
函数的返回值
<script type="text/javascript">
/**
* 使用break可以退出当前循环
* break;
*
* 使用continue用于跳过当前循环
* continue;
*
* 使用return可以结束整个函数
* retrun;
*/
/**
* 返回值可以是任意的数据类型
* 也可以是一个对象,或是一个函数
*/
script>
立即执行函数
<script type="text/javascript">
/**
* 函数对象();
*
* 立即执行函数
* 函数定义了以后,立即被调用,这种函数叫做立即执行函数
* 立即执行函数往往只会执行一次
*/
//使用()将匿名函数圈起来表示一个整体,然后再在最后面加一个(),即会立即执行。
(function(){
alert("我是一个匿名函数");
})();
//后面的()还可以为匿名函数传递参数
(function(a,b){
alert(a+b);
})(123,456);
script>
方法
<script type="text/javascript">
//创建一个对象
var obj = new Object();
//向对象中添加属性
obj.name = "孙悟空";
obj.age = 18;
//对象的属性值可以是任何数据的类型,也可以是个函数
obj.printName = function(){
console.log(obj.name);
}
//调用该方法(函数作为对象的属性即为:方法)
obj.printName();
//调用函数
//fun();
/**
* 函数也可以成为是对象的属性:
* 如果一个函数作为对象的属性保存,那么我们称这个函数是这个对象的方法
* 调用这个函数就说调用对象的方法(method)
*
* 但是他只是名称上的区别,没有其他区别。
*/
//调用console对象的log()方法
console.log()
//调用document对象的方法
document.write();
var obj2 = {
name:"猪八戒",
age:18,
printName:function(){
console.log(obj2.name);
}
};
//调用方法
obj2.printName();
script>
枚举对象中的属性
<script type="text/javascript">
var obj = {
name:"孙悟空",
age:10,
gender:"男",
address:"花果山"
}
/**
* 枚举对象中的属性:使用for...in 语句
* 语法:
* for(var 变量 in 对象){
} for..in语句,对象中有几个属性,循环体就会执行几次。
每次执行时,会将对象中的一个属性的名字赋值给变量
*/
for(var n in obj){
console.log("属性名"+n+",,属性值:"+obj[n]);
}
for(var n in document){
document.write(n+":"+obj[n]);
}
script>
全局作用域
<script type="text/javascript">
/**
* 作用域:
* - 作用域指一个变量的作用的范围
* - 在JS中一共有两种作用域:
* 1、全局作用域
* - 直接编写在script标签中的js代码,都在全局作用域
* - 全局作用域在页面打开时创建,页面关闭时销毁
* - 在全局作用域中有一个对象window
* 他代表的是一个浏览器窗口,它由浏览器创建,我们可以直接使用
* - 在全局作用域中:
* 创建的变量都会作为window对象的属性保存
* 创建的方法都会作为window对象的方法保存
* - 全局作用域中的变量都是全局变量,在页面的任意位置都可以访问到
*
*
* 2、函数作用域
*/
var a = 10;
var b = 20;
console.log(window.a);
function fun(){
console.log("我是fun函数");
}
window.fun();
script>
变量、函数 的声明提前
<script type="text/javascript">
/**
* 变量的声明提前
* - 使用var关键字声明的变量,会在所有代码执行之前被声明(但不会赋值)
* 但如果声明变量时不使用var关键字,则变量不会被声明提前
*
* 函数的声明提前
* - 使用函数声明形式创建的函数function函数(){}
* 会在所有的代码执行之前就被创建,所以我们可以在函数声明前就调用函数
* - 使用函数表达式创建的函数var fun2 = function{}
* 变量fun2声明提前了,但是函数不会被声明提前,所以不能在声明前被调用
*/
//变量的声明提前
console.log(a);//undefined
var a = 123;
//函数的声明提前
fun(); //fun函数
//fun2();// Uncaught TypeError: fun2 is not a function
//函数声明,会被提前
function fun(){
console.log("fun函数");
}
//函数表达式,不会被提前创建
var fun2 = function(){
console.log("fun2函数");
}
script>
函数作用域
<script type="text/javascript">
/**
* 函数作用域
* - 调用函数时创建函数作用域,函数执行完毕以后,函数作用域销毁
* - 每调用一次函数就会创建一个新的函数作用域,他们之间是互相独立的
* - 在函数作用域中可以访问到全局作用域中的变量
* 函数作用域中的变量只能在函数作用域中使用,外部无法使用。
* - 当在函数作用域操作一个变量时,他会现在自身作用域中寻找,如果有就直接使用
* 如果没有则向上寻找,直到找到全局作用域,如果全局变量作用域中依然没有找到,则会报错ReferenceError
* - 在函数中要访问全局变量可以使用window对象
*
*
* 函数作用域中也有声明提前的特性:
* 使用var关键字声明变量,会在函数中所有的代码块执行之前被声明。
* 函数声明也会在函数中所有的代码执行之前执行。
*
* 在函数中,不使用var关键字声明的变量都会成为全局变量
*
* 定义形参就相当于在函数作用域中声明了变量
*/
//创建一个变量
var a = 10
function fun(){
var a = "函数中的变量a";
console.log(a);//函数中的变量a
}
fun();
script>
this
<script type="text/javascript">
/**
* 解析器再调用函数时每次都会像函数内部传递进一个隐含的参数,这个隐含的参数就是this,
* this指向的是一个对象,这个对象我们称为函数执行的上下文对象
* 根据函数的调用方式不同,this会指向不同的对象:
* - 以函数的形式调用时,this永远都是window
* - 以方法的形式调用时,this就是调用方的那个对象
*
* 根据函数的调用方式的不同,this会指向不同的对象
*/
function fun(){
console.log(this);
}
fun();
//创建一个对象
var obj ={
name:"孙悟空",
printName:fun
}
obj.printName();//object对象
script>
使用工厂方法创建对象
<script type="text/javascript">
/**
* 使用工厂方法创建对象
* 通过该方法可以大批量的创建对象
*/
function createObject(name,age,gender){
//创建一个新的对象
var obj = new Object();
//向对象中添加属性
obj.name=name;
obj.age=age;
obj.gender=gender;
obj.printName = function(){
alert(this.name);
}
//将新的对象返回
return obj;
}
var obj1 = createObject("猪八戒",28,"男");
var obj2 = createObject("白骨精",18,"女");
var obj3 = createObject("蜘蛛精",20,"女");
console.log(obj1);
console.log(obj2);
console.log(obj3);
obj1.printName();
/**
* 使用工厂创建的对象,使用的构造方法都是Object,所以创建的对象都是Object这个类型
* 就导致我们无法区分出哪个对象是人对象,哪个对象是动物对象
*
*/
//用来创建狗对象
function createDog(name,age){
var obj = new Object();
obj.name = name;
obj.age = age;
obj.sayHello = function(){
alert("汪汪~~~");
}
return obj;
}
//创建一个狗对象
var dog = createDog("旺财",5);
console.log(dog);
script>
构造函数
<script type="text/javascript">
/**
* 创建一个构造函数,专门用来创建Person对象的
* 构造函数就是一个普通的函数,创建方式和普通函数没有区别,不同的是构造函数习惯上首字母大写
*
* 构造函数和普通函数的区别就是调用方式的不同
* 普通函数是直接调用,而构造函数需要使用new关键字来调用
*
* 构造函数的执行流程:
* 1、立刻创建一个新的对象
* 2、将新建的对象设置为函数中的this,在构造函数中可以使用this来引用新建的对象
* 3、逐行执行函数中的代码
* 4、将新建的对象作为范围值返回。
*
* 使用同一个构造函数创建出来的对象,我们称为他们是一类对象,也将一个构造函数称为一个类
* 我们将通过一个构造函数创建的对象,称为是该类的实例。
*
* this表示
* 1、当以函数的形式调用时,this是window
* 2、当以方法的形式调用时,哪个对象调用方法,哪个对象就是this
* 3、当以构造函数的形式调用时,this就是创建的那个对象
*/
function Person(name,age,gender){
this.name=name;
this.age = age;
this.gender = gender;
this.sayName= function(){
alert(this.name);
};
}
function Dog(){
}
var per = new Person("孙悟空",18,"男");
console.log(per);
var dog = new Dog();
console.log(dog);
/**
* 使用instanceof可以检查一个对象是否属于某个类型(类)
* 语法:
* 对象 instanceof 构造函数
* 如果是返回:true,反之false
*/
console.log(per instanceof Person);//true
console.log(dog instanceof Person);//false
/**
* Object是所有类的根,所以任何对象都是Object类型的
*/
console.log(per instanceof Object);//true
script>
构造函数的修改
<script type="text/javascript">
/**
* 创建一个Person构造函数
* - 在Person构造函数中,为每一个对象都添加了一个printName方法
* 目前我们的方法是在构造函数内部创建的。也就是构造函数每执行一次
* 就会创建一个新的printName方法。
* 这就导致了构造函数执行一次就会创建一个新的方法。
* 执行10000次就会创建10000个新的方法,而10000个方法都是一模一样的
* 这是完全没有必要的,完全可以所有的对象共享一个方法。
*/
function Person(name,age,gender){
this.name = name;
this.age = age;
this.gender = gender;
//向对象中添加一个方法
//this.printName = fun;
/* this.printName = function(){
alert("hello,我是"+this.name);
} */
}
//将printName方法定义在全局作用域中
/**
* 出现的问题:将函数定义在全局作用域,污染了全局作用域的命名空间
* 而且定义在全局作用域中也很不安全
*/
/* function fun(){
alert("hello,我是"+this.name);
} */
//向原型中添加printName()方法
Person.prototype.printName = function(){
alert("hello,我是"+this.name);
}
//创建一个Person实例
var per = new Person("孙悟空",18,"男");
per.printName();
script>
原型
<script type="text/javascript">
/**
* 原型:prototype
* 我们所创建的每一个函数,解析器都会向函数中添加一个属性prototype
* 这个属性对应着一个对象,这个对象就是我们所谓的原型对象。
*
* 如果函数作为普通函数调用prototype没有任何作用。
* 当函数以构造函数调用时,它创建的对象中都会有一个隐含的属性指向该构造函数的原型对象
* 我们可以通过__proto__来访问该属性
*
* 原型对象就相当于一个公共的区域,所有同一个类的实例都可以访问到这个原型对象
* 我们可以将对象中共有的内容,统一设置到原型对象中
*
* 当我们访问对象的一个属性或方法时,他会先在对象自身中寻找,如果有则直接使用
* 如果没有则会去原型中寻找,如果找到则直接使用。
*
* 以后我们创建构造函数时,可以将这些对象共有的属性和方法,统一添加到构造函数的原型对象中
* 这样不用分别为每一个对象添加,也不会影响到全局作用域,就可以使每个对象都具有这些属性和方法了。
*/
function MyClass(){
}
//向MyClass的原型中添加属性a
MyClass.prototype.a = "123";
//向MyClass原型中添加一个方法
MyClass.prototype.sayHello =function(){
alert("hello");
}
var mc = new MyClass();
console.log(mc.__proto__ == MyClass.prototype);//true
console.log(mc.a);//123
console.log(mc.sayHello());
script>
原型对象
<script type="text/javascript">
/**
* 创建一个构造函数
*
*/
function MyClass(){
}
//向MyClass的原型中添加一个name属性
MyClass.prototype.name = "我是原型中的名字";
var mc = new MyClass();
mc.age = 18;
console.log(mc.name);
//使用in检查对象中是否含有某个属性时,如果对象中没有但是原型中有,也会返回true
console.log("name" in mc);//true
//可以使用对象的hasOwnProperty()来检查对象自身中是否含有该属性
//使用该方法只有对象自身中含有该属性时,才会返回true,反之即使原型中有该属性,也返回false
console.log(mc.hasOwnProperty("name"));//false
console.log(mc.hasOwnProperty("age"));//true
/**
* 原型对象也是对象,所以他也有原型
* 当我们使用一个对象的属性或者方法时,会先在自身找,自身有,则直接使用。
* 自身没有,去原型对象中找,如果原型对象中有,则使用
* 如果没有则去原型对象的原型中找,直到找到Object对象的原型。
* Object对象的原型没有原型,如果在Object中依然没有找到,则返回undefined
*/
//在自身找
console.log(mc.hasOwnProperty("hasOwnProperty"));//false
//在原型中找
console.log(mc.__proto__.hasOwnProperty("hasOwnProperty"));//false
//在原型的原型中找
console.log(mc.__proto__.__proto__.hasOwnProperty("hasOwnProperty"));//true
script>
toString 方法
<script type="text/javascript">
function Person(name,age,gender){
this.name = name;
this.age = age;
this.gendr = gender;
}
//创建一个Person实例
var per = new Person("孙悟空",18,"男");
//当我们直接在页面中打印一个对象时,事实上是输出对象的toString()方法的返回值
//如果我们希望在输出对象时不输出[object,Object],可以调用对象的toString方法
console.log(per);//[object Object]
console.log(per.toString());//{"age":18,"gendr":"男","name":"孙悟空"}
//修改per 的toString 方法
/* per.toString = function(){
return "我是一个快乐的小Person";
} */
console.log(per);//[object Object]
console.log(per.toString());//"我是一个快乐的小Person"
//修改Person原型的同toString
Person.prototype.toString = function(){
return "我是原型中的toString";
}
console.log(per.toString());//"我是原型中的toString"
script>
垃圾回收机制
<script type="text/javascript">
/**
* 垃圾回收(GC)
* - 就像人生活的时间长了会产生垃圾一样,长须运行过程中也会产生垃圾
* 这些垃圾积攒过多以后,会导致程序运行的速度过慢。所以我们需要一个垃圾回收机制
* 来处理程序运行过程中产生的垃圾
*
* - 当一个对象没有任何的变量或属性对他进行引用,此时我们将永远无法操作该对象
* 此时这种对象就是一个垃圾,这种对象过多会占用大量的内存空间,导致程序运行过慢
* 所以这种垃圾必须进行清理
*
* - 在JS中拥有自己的垃圾回收机制,会自动将这些垃圾对象从内存中销毁。
* 我们不需要也不能进行垃圾回收的操作
*
* - 我们需要做的只是要将不再使用的对象设置为null即可。
*/
script>
数组
<script type="text/javascript">
/**
* 内建对象
* 宿主对象
* 自定义对象
*
* 数组(Array)
* - 数组也是一个对象
* - 她和我们普通对象功能类似,也是用来存储一些值的
* 不同:普通对象是使用字符串作为属性名
* 数组:使用数字类作为索引操作元素
*
* - 索引:从0开始,以1递增的整数。
* - 数组的存储性能比普通对象更好,在开发中我们经常使用数组来存储一些数据。
*
*/
//创建数组对象
var arr = new Array();
console.log(typeof arr);//object
//向数组中添加对象。语法:数组[索引] = 值。
arr[0] = 10;
arr[1] = 20;
arr[2] = 33;
//读取数组中的元素。语法:数组[索引]
console.log(arr);//{"0":10,"1":20,"2":33,"length":3}
console.log(arr[2]);//3
//如果读取不存在的索引,他不会报错,而是返回:undefined
console.log(arr[3]);//undefined
/**
* 使用length属性获取数组的长度(数组中元素的个数)
* 语法:数组.length
*
* 对于连续的数组,使用legth可以获取到数组的长度(元素的个数)
*
* 对于非连续的数组,使用length会获取到数组的最大索引+1
* 没有添加的位置会空出来,浪费内存,所以尽量不要创建非连续数组
*/
console.log(arr.length);3
var arr2 = new Array();
arr2[10] = 11;
console.log(arr2);//{"10":11,"length":11}
console.log(arr2.length);//11
/**
* 修改length
* - 如果修改的lenth大于原长度,则多余部分会空余出来
* - 如果修改的lenth小于原长度,则多余部分会删除。
*/
//arr2.length = 5;
//console.log(arr2);// {"length":5}
//向数组的最后一个位置添加元素
//语法:数组[数组.length] = 值;
arr[arr.length] = 70;
arr[arr.length] = 80;
arr[arr.length] = 90;
//{"0":10,"1":20,"2":33,"3":70,"4":80,"5":90,"length":6}
script>
数组字面量
<script type="text/javascript">
/**
* 使用字面量创建数组
* 语法:[]
* var arr = [];
*/
//使用字面量创建数组时,可以在创建时就指定数组中的元素
var arr = [1,3,5,10,20];
console.log(arr);// {"0":1,"1":3,"2":5,"3":10,"4":20,"length":5}
//使用构造函数创建数组时,也可以同时添加元素。将要添加的元素作为构造方法的参数传递
//元素之间使用,隔开
var arr2 = new Array(9,34,42);
console.log(arr2);//{"0":9,"1":34,"2":42,"length":3}
//创建一个数组,数组中只有一个元素10
arr3 =[10];
console.log(arr3);// {"0":10,"length":1}
//创建一个长度为10的数组
var arr4 = new Array(10);
console.log(arr4);//{"length":10}
//数组中的元素可以是任意类型
var arr5 = ["hello",1,true,null,undefined];
document.write(arr5); //hello,1,true,,
//数组中也可以放对象
var obj = {
name:"孙悟空"};
arr5[arr.length] = obj;
console.log(arr5[5],name);//{"name":"孙悟空"}
//也可以是一个函数
arr6 = [function(){
},function(){
}]
console.log(arr6);//{"0":"function (){}","1":"function (){}","length":2}
//数组中也可以放数组,这种数组称为:二维数组
arr7 = [[1,2,3],[4,5,6],[7,8,9]];
console.log(arr7);
//{"0":{"0":1,"1":2,"2":3,"length":3},"1":{"0":4,"1":5,"2":6,"length":3},"2":{"0":7,"1":8,"2":9,"length":3},"length":3}
script>
数组的方法
<script type="text/javascript">
//创建一个数组
var arr = ["孙悟空","猪八戒","沙和尚"];
/**
* push()
* - 该方法可以向数组的末尾添加一个或多个元素,并返回数组的新的长度
* - 可以将要添加的元素作为方法的参数传递,这样这些元素将会自动添加到数组的末尾
* - 该方法会将数组新的长度作为返回值返回。
*
*/
var result = arr.push("唐僧","蜘蛛精","白骨精");
console.log(arr);//{"0":"孙悟空","1":"猪八戒","2":"沙和尚","3":"唐僧","4":"蜘蛛精","5":"白骨精","length":6}
console.log("result="+result);//result=6
/**
* pop()
* - 该方法可以删除数组的最后一个元素,并将被删除的元素作为返回值返回
*/
result = arr.pop();//白骨精
console.log(arr);//{"0":"孙悟空","1":"猪八戒","2":"沙和尚","3":"唐僧","length":4}
console.log(result);
/**
* unshift();
* - 像数组开头添加一个或多个元素,并返回新的数组长度。
* - 向前面插入元素以后,其他的元素会依次调整。
* - 返回值为:添加元素后数组的长度
*/
var aa = arr.unshift("牛魔王");
console.log(arr);//{"0":"牛魔王","1":"孙悟空","2":"猪八戒","3":"沙和尚","4":"唐僧","5":"蜘蛛精","length":6}
console.log(aa);//6
/**
* shift();
* - 可以删除数组的第一个元素,并将被删除的元素作为返回值返回。
*/
result = arr.shift();
console.log(arr);//{"0":"孙悟空","1":"猪八戒","2":"沙和尚","3":"唐僧","4":"蜘蛛精","length":5}
console.log(result);// 牛魔王
script>
数组的遍历
<script type="text/javascript">
//创建一个数组
var arr = ["孙悟空","猪八戒","沙和尚","唐僧"];
//遍历数组:就是把数组中所有的元素取出来
for(var i=0 ;i<arr.length;i++){
console.log(arr[i]);
}
script>
forEach
<script type="text/javascript">
/**
* 一般我们都是使用for循环去遍历数组
* JS中还为我们提供了一个方法,遍历数组
* forEach()
* - 这个方法只支持IE8以上的浏览器
*/
//创建一个数组
var arr = ["孙悟空","猪八戒","沙和尚","唐僧"];
/**
* forEach()方法需要一个函数作为参数
* - 像这种参数,由我们创建但不是由我们调用的,我们称之为回调函数
* - 数组中有几个元素就会执行几次。每次执行时,浏览器会将遍历到的元素以
* 实参的形式传递进来,我们可以来定义形参,来读取这些内容.
* - 浏览器会在回调函数中传递三个参数。
* 第一个参数:就是当前正在遍历的元素。
* 第二个参数:当前正在遍历的元素的索引
* 第三个参数:就是正在遍历的数组。
*/
arr.forEach(function (name,index,obj){
console.log(name+" "+index+" "+obj);
});
/*
孙悟空 0 孙悟空,猪八戒,沙和尚,唐僧 at 41、forEach增强for循环.html:29
猪八戒 1 孙悟空,猪八戒,沙和尚,唐僧 at 41、forEach增强for循环.html:29
沙和尚 2 孙悟空,猪八戒,沙和尚,唐僧 at 41、forEach增强for循环.html:29
唐僧 3 孙悟空,猪八戒,沙和尚,唐僧
*/
script>
数组方法
<script type="text/javascript">
/**
* slice()
* - 可以用来从数组提取指定元素
* - 该方法不会改变数组元素,而是将截取到的元素封装到一个新的数组中返回
* - 参数:
* 1、截取开始位置的索引(包含该索引所对应的元素)
* 2、截取结束位置的索引(不包含该索引对应元素)
* ——第二个参数可以省略不写,会截取从开始索引往后的所有元素
*
* - 参数可以是负数
* 参数是负数的时候表示:从后往前算
* -1:倒数第一个
* -2:倒数第二个
*/
var arr = ["孙悟空","猪八戒","沙和尚","唐僧","白骨精"]
console.log(arr);//{"0":"孙悟空","1":"猪八戒","2":"沙和尚","3":"唐僧","4":"白骨精","length":5}
var result = arr.slice(0,2);
console.log(result);//{"0":"孙悟空","1":"猪八戒","length":2}
result =arr.slice(1);
console.log(result);//{"0":"猪八戒","1":"沙和尚","2":"唐僧","3":"白骨精","length":4}
/**
* splice()
* - 可以用来删除数组中的指定元素
* - 使用splice()会影响到原数组,会将指定元素从原数组中删除
* 并将被删除的元素作为返回值返回。
* - 参数:
* 第一个:表示开始位置的索引
* 第二个:表示删除的数量
* 第三个:可以传递一些新的元素,这些元素将会自动插入到开始位置索引前
*/
result = arr.splice(0,2,"牛魔王","铁扇公主","红孩儿");
console.log(arr);//{"0":"牛魔王","1":"铁扇公主","2":"红孩儿","3":"沙和尚","4":"唐僧","5":"白骨精","length":6}
console.log(result);//{"0":"孙悟空","1":"猪八戒","length":2}
script>
数组去重
<script type="text/javascript">
//创建一个数组
var arr = [1,2,3,2,2,2,2,2,1,2,2,2,1,3,3,1,3,4,2,5,6,5,8,74,1,4,45,5,5,5,5,566];
//去除数组中重复的数字
for(var i=0;i<arr.length;i++){
//取出数组中的每一个元素
for(var j=i+1;j<arr.length;j++){
//让每一次传进来的数组元素与他之后的每个元素进行比较,相同的则删除重复出现的元素
if(arr[i] == arr[j]){
//相同则删除
arr.splice(j,1);
//当删除了当前j所在的元素后,后面的元素会自动补位。
//此时如果下一个元素跟当前元素是相同的,补位后不会被比较,就会出现重复的数字
j--
//此时可以让k-1,然后重新跟这个元素比较,就不会再出现重复的东西了。
}
}
}
document.write(arr);//1,2,3,4,5,6,874,45,566
script>
数组的剩余方法
<script type="text/javascript">
/**
* concat() 可以连接两个或多个数组,并将新的数组返回
* - 该方法不会对原数组产生影响
*/
var arr = [1,2,3];
var arr2 = [4,5,6];
var result = arr.concat(arr2);
console.log(result);//{"0":1,"1":2,"2":3,"3":4,"4":5,"5":6,"length":6}
var arr3 = ["二郎神","哮天犬"];
var result = arr.concat(arr2,arr3,"天王老儿","小鸡炖蘑菇");
console.log(result);
// {"0":1,"1":2,"2":3,"3":4,"4":5,"5":6,"6":"二郎神","7":"哮天犬","8":"天王老儿","9":"小鸡炖蘑菇","length":10}
/**
* join()方法
* - 该方法可以将数组转换为一个字符串
* - 该方法不会对原数组产生影响,而是将转换后的字符串作为结果返回
* - 在join()中可以指定一个字符串作为参数,这个字符串将会成为数组中元素的连接符
* - 如果不指定连接符,则默认使用,连接。
* - 如果想他们拼串:join(""),可以传一个空串进去
*/
arr=["张三","李四","王五","赵六"];
result = arr.join("and");
console.log(result);//张三and李四and王五and赵六
console.log(typeof result);//String
result = arr.join("@@___@@");
console.log(result);//张三@@___@@李四@@___@@王五@@___@@赵六
/**
* reverse()
* - 该方法用来反转数组(前面的转去后面,后面的去前面)
* - 该方法会直接修改原数组
*
*/
arr.reverse();
console.log(arr);//{"0":"赵六","1":"王五","2":"李四","3":"张三","length":4}
/**
* sort()
* - 可以用来对数组中的元素进行排序
* - 也会对原数组产生影响,默认会按照Unicode编码进行排序
*/
arr =["b","d","a","e","c"];
arr.sort();
console.log(arr);//{"0":"a","1":"b","2":"c","3":"d","4":"e","length":5}
/**
* 即使对于纯数字的数组,使用sort方法排序时,也会按照Unicode编码来排序
* 对数字进行排序时,可能会得到错误的信息
*/
arr = [2,5,3,6,11,8,64];
arr.sort();
//document.write(arr);//11,2,3,5,6,64,8
/**
* 对数字排序时,我们可以自己来指定排序规则
* 我们可以在sort()添加一个回调函数,来指定排序规则
* 回调函数需要定义两个形参
* 浏览器会分别使用数组中的元素作为实参去调用回调函数
* 使用哪个元素调用不确定,但是肯定的是在数组中a一定在b前面
* - 浏览器会根据回调函数的返回值来决定元素的顺序
* 如果返回一个大于0的值,则元素会交换位置
* 如果返回一个小于0的值,则元素位置不变。
* 如果返回一个等于0的值,也不交换位置
*
//升序排列
return a-b;
//如果a>b,则返回正数,交换位置;
//如果a
/* arr.sort(function(a,b){
//从小到大
if(a>b){
return 1;
}else if(ab){
return -1;
}else if(a
//优化
arr.sort(function(a,b){
//升序排列
return a-b;
//如果a>b,则返回正数,交换位置;
//如果a
//如果a=b,返回0,位置不变
//反之,就是降序排列
//return b-a;
})
document.write(arr);//2,3,5,6,8,11,64
script>
函数对象的方法:call和apply
<script type="text/javascript">
/**
* caall()和apply()
* - 这两个方法都是函数对象的方法,需要通过函数对象来调用。
* - 当对函数调用call()和apply()时都会调用函数执行
*
* - 调用call()和apply()可以将一个对象指定为第一个参数
* 此时这个对象将会称为函数执行时的this
*
* - call()方法可以将实参在对象之后依次传递
* - apply()方法需要将实参封装到一个数组中统一传递。
*
* - this的情况
* 1、以函数的形式调用,this永远都是window
* 2、以方法的形式调用,this时调用方法的对象
* 3、以构造函数形式调用,this是新创建的哪个对象
* 4、使用call和apply调用时,this是指定的那个对象
*/
/* function fun(){
console.log(this);
} */
fun.call();//window对象
fun.apply();//window对象
var obj ={
name:"obj",
printName:function(){
alert(this.name);
}
};
var obj2={
name:"obj2"
}
//fun.call(obj);//object对象obj
//fun.apply(obj);//object对象obj
//obj.printName.apply(obj2);//obj2
function fun(a,b){
console.log("a:"+a);
console.log("b:"+b);
}
// - call()方法可以将实参在对象之后依次传递
// - apply()方法需要将实参封装到一个数组中统一传递。
//fun.call(obj,1,2); //a:1、b:2
fun.apply(obj,[2,3]);//a:2、b:3
script>
arguments类数组对象
<script type="text/javascript">
/**
* 在调用函数时,浏览器每次都会传递两个隐含的参数:
* 1、函数的上下文对象this
* 2、封装实参的对象arguments
* - arguments是一个类数组对象
* 他也可以通过索引来操作对象,也可以获取长度
* - 在调用函数时,我们所传递的参数都会在arguments中保存
* - arguments.length可以用来获取实参的长度
* - 我们即使不定义形参,也可以通过arguments来使用实参,只不过比较麻烦。
* arguments[0] 表示第一个实参
* arguments[1] 表示第二个实参
* - 它里面有一个属性叫:callee
* 这个属性对应一个函数对象,就是当前正在执行的函数的对象
*/
function fun(){
//console.log(arguments);
//方法Array.isArray(),判断是否是一个数组对象
console.log(Array.isArray(arguments));//false
}
fun();//false
//arguments.length可以用来获取实参的长度
function fun2(){
console.log(arguments.length);
}
fun2("hello");//1
//arguments[0] 表示第一个实参,arguments[1] 表示第二个实参
//可以定义形参,也可以不定义
function fun3(){
console.log(arguments[0]);
console.log(arguments[1]);
console.log(arguments[2]);
}
fun3("hello",true);//hello、true、undefined
//arguments的callee属性对应一个函数对象,就是当前正在执行的函数的对象
function fun4(){
console.log(arguments.callee);
console.log(arguments.callee == fun4);//true
}
fun4("hello");//function fun4(){ console.log(arguments.callee); }
script>
Date对象
<script type="text/javascript">
/**
* Date对象
* - 在JS中使用Date对象来表示一个时间
*/
//创建一个date对象
//如果直接使用构造函数创建一个Date对象,则会封装当前代码执行时间
var d = new Date();
console.log(d); //Tue Mar 30 2021 23:12:01 GMT+0800
//创建一个指定的指定对象。需要在构造函数中传递一个表示时间的字符串作为对象
//日期格式:"月/日/年 时:分:秒"
var d2 = new Date("03/30/2021 23:19:30");
console.log(d2);//Tue Mar 30 2021 23:19:30 GMT+0800
/**
* getDate();
* - 获取当前对象的日期是几月几日的:几日。
*/
var monday = d2.getDate();
console.log("date= " + monday );//30
/**
* getDay()
* - 获取当前日期对象是周几
* - 会返回一个0~6的值:0表示周日、1表示周一。以此类推
*/
var weekday = d2.getDay();
console.log("weekday = "+weekday);//2:表示星期二
/**
* getMonth();会获取当前时间对象的月份。
* - 会返回一个0~11的值。
* 0表示一月,1表示2月...11表示12月
*/
var month = d2.getMonth();
console.log("month = "+month);//2:表示3月
/**
* getFullYear()
* - 获取当前对象的年份
*/
var year = d2.getFullYear();
console.log("year = "+ year);//2021
/**
* getTime()
* - 获取当前对象的时间戳
* - 时间戳:指的是从格林威治标准时间1970年1月1日0时0分0秒到当前日期所花费的毫秒数
* 1秒 = 1000毫秒
* - 计算机底层在保存时间时都是使用时间戳
*/
var time = d2.getTime();
console.log(time);// 1617117570000毫秒
console.log(time/1000/60/60/24/365);//51.2785年
//利用时间戳来测试代码的执行的性能
//获取当前的时间戳
var start = Date.now();
for(var i=0; i<100; i++){
console.log(i);
}
var end = Date.now();
console.log("耗费时间"+(end-start)+"毫秒")//26毫秒
script>
Math对象
<script type="text/javascript">
/**
* Math
* - Math和其他对象不同,他不是一个构造函数
* 它属于一个工具类,不用创建对象,它里面封装了数学运算的相关方法
* - 比如:Math.PI 表示圆周率
*/
console.log(Math.PI);// 3.141592653589793
//abs()用来计算一个数的绝对值。
console.log(Math.abs(-34));//34
//Math.ceil() 可以对一个数向上取整,小数位只要有值就自动进1
console.log(Math.ceil(1.001));//2
//Math.floor() 可以对一个数进行向下取整,小数部分会被舍掉
console.log(Math.floor(1.99))//1
//Math.round() 可以对一个数进行四舍五入取整
//小数位后一位大于等于5向上进1
console.log(Math.round(1.5));//2
console.log(Math.round(1.4999));//1
/**
* Math.random()
* - 可以用来生成一个0~1之间的随机数
* 把该方法嵌套进四舍五入的方法就可以得到整数
* - 生成一个0~10之间的随机整数
* Math.round(Math.random()*10);
*
* - 生成一个0~x之间的随机整数
* Math.round(Math.random()*x);
*
* - 生成一个x~y之间的随机整数
* Math.round(Math.random()*(y-x)+x);
*/
console.log(Math.random());// 0.0638895
console.log(Math.random());//0.915273
//生成1~6之间的随机整数
console.log(Math.round(Math.random()*5+1));//5
//max() 可以获取多个数中的最大值
var max = Math.max(10,78,62,452);
console.log(max);//452
//min() 获取多个数种的最小值
var min = Math.min(10,12,1.2,120);
console.log(min);//1.2
//Math.pow(x,y) 返回x的y次幂
console.log(Math.pow(2,3));//8
//Math.sqrt() 用于对一个数进行开方运算
console.log(Math.sqrt(9));//3
script>
包装类
<script type="text/javascript">
/**
* 基本数据类型
* String 、Number、Boolean、Null、Undefined
*
* 引用数据类型 ——Object
*
* 在JS中为我们提供了三个包装类,通过这三个包装类可以将基本数据类型的数据转换为对象。
* String()
* ——可以将基本数据类型字符串转换为String对象
* Number()
* ——可以将基本数据类型的数字转换为Number对象
* Boolean()
* ——可以将基本数据类型的布尔值转换为Boolean对象
* 但是注意:我们在实际应用中不会使用基本数据类型的对象
* 如果使用基本数据类型的对象,在做一些比较时可能会带来一些不可预期的结果
*/
var a = 123;
console.log(typeof a);//Number
//创建一个Number类型的对象
var num = new Number(3);
var str = new String("hello");
var flag = new Boolean(true);
console.log(typeof num); //Object
console.log(typeof str); //Object
console.log(typeof flag); //Object
//可以向对象中添加属性
num.hello = "abc";
console.log(num.hello);//abc
/**
* 方法和属性只能添加给对象,不能添加给基本数据类型
* 当我们对一些基本数据类型的值取调用属性和方法时,浏览器会临时调用包装类将其转换为对象
* 调用完以后,会将其再次转换为基本数据类型
*/
num = 123;
num = num.toString();//浏览器临时调用包赚类调用同toString方法,然后将结果赋给num变量
console.log(num); //123
console.log(typeof num);//String
num.hello = "nihao"//这里浏览器调用包装类赋值给num的hello属性,调用完以后再次转换成了基本数据类型
console.log(num.hello);//undefined//这里访问的跟上面赋值的那个不是同一个对象,所以访问不到上面定义的hello属性
//这是浏览器访问该基本数据类型变量num时,临时调用包装类将其转换成对象,跟之前的没关系了,
//因为每一个都是调用完后就重新转回基本数据类型。是一个新的对象,没定义就访问返回:underfined。
script>
字符串相关方法
<script type="text/javascript">
//创建一个字符串
var str = "Hello world";
/**
* 在底层字符串是以字符串数组的形式保存的
* ["H","e","e","l"]
*
* length 属性——可以用来获取字符串的长度
*/
console.log(str[5]);//" "
console.log(str[6]);//w
console.log(str.length);//11
/**
* charAt()
* 返回字符串指定位置的字符,根据索引获取指定字符
*/
str = "hello world";
var result = str.charAt(0);
console.log(result);//h
/**
* charCodeAt()
* - 获取指定位置字符的字符编码(Unicode编码)
*/
result = str.charCodeAt(1);//101
console.log(result);
/**
* fromCharCode()
* - 可以根据字符编码去获取字符
*/
result = String.fromCharCode(101);
console.log(result);//e
/**
* concat()
* - 可以用来连接两个或多个字符串,作用和+一样
*/
result = str.concat("你好","kitty");//hello world你好kitty
console.log(result);
/**
* indexOf()
* - 该方法可以检索一个字符串中是否含有指定内容
* - 如果字符串中含有该内容,则会返回第一次出现的索引
* - 如果没有找到指定的内容,则返回-1
* - 可以指定第二个参数:指定开始查找的位置(包括指定的这个位置的索引)
*
* lastIndexOf()
* - 该方法用法与indexOf()一样
* 不同的是indexOf是从前往后找、lastIndexOf是从后往前找
*
* - 也可以指定开始查找的位置
*/
str = "hello kittyhello"
result = str.indexOf("e");
console.log(result);//1
result = str.indexOf("l");
console.log(result);//2
result = str.indexOf("a");
console.log(result);//-1
result = str.indexOf("l",3);
console.log(result);//3
result = str.indexOf("l",4);
console.log(result);//13
result = str.lastIndexOf("l");
console.log(result);//14
result = str.lastIndexOf("l",3);
console.log(result);//3
/**
* slice()
* - 可以从字符串中截取指定的内容
* - 不会影响原字符,而是将截取到的内容返回
* - 参数:
* 第一个:开始位置的索引(包括开始位置)
* 第二个:结束位置的索引(包括结束位置)
* - 如果省略第二个参数,则会截取到后边所有的字符。
* - 也可以传递一个负数作为参数,负数的话将从后面开始计算.
* -1就是最后一个字符,不包括结束位置的。
*/
str = "abcdefghijk";
result = str.slice(0,2);
console.log(result);//ab
result = str.slice(1,4);
console.log(result);//bcd
result = str.slice(3);
console.log(result);// defghijk
result = str.slice(3,-1);
console.log(result);// defghij
/**
* substring()
* - 可以用来截取一个字符串,与slice()类似
* - 参数:
* 也是第一个参数为:起始截取的索引位置
* 第二个参数为:结束截取的索引位置
* - 不同:substring()不能接收负值,如果传递了一个负数,则默认为0
* - 而且该方法会自动调整参数位置,如果第二个参数小于第一个,会自动交换
* 如:substring(1,0) 就成为:substring(0,1)
*/
result = str.substring(1,-10);
console.log(result);//a
result = str.substring(1,0);
console.log(result);//a
result = str.substring(3,1);
console.log(result);//bc
/**
* substr()
* - 用来截取字符串
* - 第一个参数:截取开始位置的索引。
* 第二个参数:截取的长度
*/
str = "abcdef"
result = str.substr(4,2);
console.log(result);//ef
/**
* split()
* - 可以将一个字符串拆分成一个数组
* - 参数:
* 需要将一个字符串作为参数,将会根据该字符串去拆分数组
*
* - 如果传递一个空串作为参数,则会将每个字符都拆分称为数组中的一个元素
*/
str="abc-def-ghi-jkl";
result = str.split("-");
console.log(result);// {"0":"abc","1":"def","2":"ghi","3":"jkl","length":4}
console.log(Array.isArray(result));//true
console.log(result.length);//4
str ="abcde";
result = str.split("");
console.log(result);{
"0":"a","1":"b","2":"c","3":"d","4":"e","length":5}
/**
* toUpperCase()
* - 将一个字符串转换为大写并返回
*/
str = "abcde"
result = str.toUpperCase(str);
console.log(result);//ABCDEF
/**
* toLowerCase()
* - 将一个字符串转换为小写并返回
*/
str = "ABCDEFGHIJK"
result = str.toLowerCase(str);
console.log(result);//abcdefghijk
script>
正则表达式简介
<script type="text/javascript">
/**
* 正则表达式:
* - [email protected]
* 邮件的规则:
* 1、前面可以是xxx
* 2、跟着一个@
* 3、后面可以是xxx
* 4、.com
*
* 正则表达式用于定义一些字符串的规则
* 计算机可以根据正则表达式,来检查一个字符串是否符合规则
* 获取字符串,其中符合规则的内容提取出来
*/
/**
* 创建正则表达式对象
* 语法:
* - var 变量 = new RegExp("正则表达式","匹配模式");
* - 使用typeof检查正则对象,会返回object
*
* - var reg = new RegExp("a");
* 这个正则表达式可以用来检查一个字符串中是否含有a
*
* - 在构造函数中可以传递一个匹配模式作为第二个参数。可以是:
* "i" :忽略大小写
* "g" :全局匹配模式
*/
var reg = new RegExp("a");
console.log(reg); // /a/
console.log(typeof reg);//object
/**
* 正则表达式的方法:
* test()
* - 使用这个方法可以用来检查一个字符串是否符合正则表达式的规则
* 如果符合规则返回true,否则返回false
*/
var result = reg.test("a");
console.log(result);//true
result = reg.test("cdabc");
console.log(result);//true
result = reg.test("cc");
console.log(result);//false
result = reg.test("AA");
console.log(result);//false
reg = new RegExp("a","i");
result = reg.test("A");
console.log(result);//true
script>
正则表达式语法
<script type="text/javascript">
/**
* 使用字面量来创建正则表达式
* 语法: var 变量 = /正则表达式/匹配模式
* 使用字面量的方式创建更加简单,但是使用字面量的方式创建更加灵活
*/
var reg = /a/i;
console.log(typeof reg);//object
console.log(reg.test("Abc")); //true
/**
* 创建一个正则表达式,检查一个字符串中是否有a或b或c
* 使用 | 表示或者的意思
*/
reg = /a|b|c/;
console.log(reg.test("adf"));//true
console.log(reg.test("dfgbkj"));//true
console.log(reg.test("oeirc"));//true
/**
* 创建一个正则表达式检查一个字符串中是否有字母
*/
//reg =/a|b|c|d|e|f|g/; //这种方式需要一直写到z
/**
* []中的内容也是或的关系
* [ab] == a|b
* [a-z]表示:任意小写字母
* [A-Z]表示:任意大写字母
* [A-z]表示:任意字母
* [0-9]表示:任意数字
*/
reg = /[A-z]/;
console.log(reg.test("Z"));//true
//检查一个字符串中是否含有abc或adc或aec
//reg = /abc|adc|aec/
reg =/a[bde]c/;//等同于reg = /a[b-e]c/;
console.log(reg.test("aec"));//true
/**
* [^ab] 除了
*/
//检查一个字符串中除了a和b字母外否有别的字符
reg = /[^ab]/;
console.log(reg.test("c"));//true
console.log(reg.test("a"));//false
console.log(reg.test("abc"));//true
/**
* [0-9]表示:任意数字
*/
reg = /[0-9]/;
console.log(reg.test("123"));//true
//除了数字有没有别的字符
reg = /[^0-9]/;
console.log(reg.test("123"));//false
console.log(reg.test("12a3"));//true
script>
字符串和正则相关的方法
<script type="text/javascript">
/**
* split()
* - 可以将一个字符串拆分成为一个数组
* - 方法中可以传递一个正则表达式作为参数,这样方法将会根据正则表达式去拆分字符串
* - 这个方法即使不指定全局匹配,也会全部拆分。
*/
var str="1a2b3c4d5e6f7";
//根据字母c拆
var result = str.split("c");
console.log(result);//{"0":"1a2b3","1":"4d5e6f","length":2}
//根据任意字母拆
result = str.split(/[A-z]/);
console.log(result);//{"0":"1","1":"2","2":"3","3":"4","4":"5","5":"6","6":"7","length":7}
/**
* search()
* - 可以搜索字符串中是否含有指定内容
* - 如果搜索到指定内容,则会返回第一次出现的索引,如果没有搜索到返回-1
* - 它可以接收一个正则表达式作为参数,然后根据正则表达式去检索字符串
* - search()即使设置了全局匹配,也只查找第一个。
*/
str = "hello abc hello abc";
result = str.search("abc");
console.log(result);// 6
result = str.search("abcd");
console.log(result);//-1
//接收正则表达式作为参数
str = "hello helloaec afc aac abc";
//搜索字符串aac、abc、aec、afc
result = str.search(/a[b-f]c/);
console.log(result);//11
/**
* match()
* - 可以根据正则表达式,从一个字符串中将符合条件的内容提取出来
* - 默认情况下我们的match只会找到第一个符合要求的内容,找到以后就停止检索
* 我们可以设置正则表达式为全局匹配模式,这样就会匹配到所有的内容
* 可以为一个正则表达式设置多个匹配模式,且顺序无所谓
* - match()会将匹配到的内容封装到一个数组中返回,即使只查到一个结果
*/
str = "1a2b3c4d5e6f7";
//默认情况下我们的match只会找到第一个符合要求的内容,找到以后就停止检索
result = str.match(/[A-z]/);
console.log(result);//只提取出一个:a
// 我们可以设置正则表达式为全局匹配模式,这样就会匹配到所有的内容
str = "1a2b3c4d5e6f7A8B9C";
result = str.match(/[A-z]/g);
console.log(result);
//{"0":"a","1":"b","2":"c","3":"d","4":"e","5":"f","6":"A","7":"B","8":"C","length":9}
//还可以这样
result = str.match(/[a-z]/gi);//i和g没有顺序要求 等同于str.match(/[A-z]/g);
console.log(result);
//{"0":"a","1":"b","2":"c","3":"d","4":"e","5":"f","6":"A","7":"B","8":"C","length":9}
//macth()以数组形式返回结果
console.log(typeof result);//object
console.log(Array.isArray(result));//true
/**
* replace()
* - 可以将参数中指定的内容替换为新的内容
* - 参数:
* 1、被替换的内容
* 2、新的内容
* - 默认只会替换第一个
*/
str = "1a2a3a4a5A6A7A";
result = str.replace("a","@@@");
//默认只会替换第一个
console.log(result);//1@@@2a3a4a5A6A7A
//使用正则表达式作为参数,全局匹配模式:g。即可全部替换
result = str.replace(/a/g,"@_@");
console.log(result);//1@_@2@_@3@_@4@_@5A6A7A
//再加上忽略大小写的:i
result = str.replace(/a/gi,"_@_");
console.log(result);//1_@_2_@_3_@_4_@_5_@_6_@_7_@_
//替换任意字母:
str = "1a2B3C4D5F6e7f8888"
result = str.replace(/[A-z]/gi,"_@_");
console.log(result);//1_@_2_@_3_@_4_@_5_@_6_@_7_@_8888
//删除字母,传一个空串:""(中间不能有空格)
result = str.replace(/[A-z]/gi,"");//12345678888
console.log(result);
script>
正则表达式语法
<script type="text/javascript">
/**
* 创建一个正则表达式检查一个字符串中是否含有aaa
*
* 量词:
* - 通过量词可以设置一个内容出现的次数 。
* - 注意:量词只对它前面的一个字符起作用。
* ♥表示任意字符,如:a
* - ♥{n}:正好出现n次
* - ♥{m,n}:正好出现m-n次,如果超过n次则报错
* - ♥{m,}:出现m次及m次以上
* - ♥+ :至少出现一次,相当于{1,}
* - ♥* :0个或多个,相当于{0,}。有没有都行
* - ♥? :0个或1个,相当于{0,1}。
* 如果想要多个字符出现多次,则需要把这几个字符用小括号括起来
*
*
*/
//检查一个字符串中是否有连续的3个a
var reg = /a{3}/;
console.log(reg.test("naadd"));//false
console.log(reg.test("naaad"));//true
//量词只对它前面的一个字符起作用
reg = /ab{3}/;
console.log(reg.test("dfabbb"));//true
//如果想要判断为:连续的三次ab,则需要在ab上加()
reg = /(ab){3}/;
console.log(reg.test("abbb"));//false
console.log(reg.test("sdfabababfd"));//true
//{m,n}:正好出现m-n次,如果超过n次则报错
reg = /ab{1,3}c/;
console.log(reg.test("abc"));//true
console.log(reg.test("abbbbc"));//false
//- {m,} :出现m次及m次以上
reg = /ab{3,}c/;
console.log(reg.test("abbc"));//false
console.log(reg.test("abbbc"));//true
console.log(reg.test("abbbbbbbbc"));//true
//+ 最少出现一此
reg = /ab+c/;
console.log(reg.test("efabcer"));//true
console.log(reg.test("efabbbbbbbbbbbc"));//true
//* :0个或多个,相当于{0,}。有没有都行
reg = /ab*c/;
console.log(reg.test("reace"));//true
console.log(reg.test("erdabbbbbbbbbc"));//true
//? :0个或1个,相当于{0,1}。
reg = /ab?c/;
console.log(reg.test("eqac"));//true
console.log(reg.test("eqabc"));//true
console.log(reg.test("eqabbc"));//false
/**
* 检查一个字符串是否以a开头
* ^表示开头
*/
reg = /^a/;
console.log(reg.test("badcdaac"));//false
console.log(reg.test("acb"));//true
/**
* 检查一个字符串是否以a结尾
* $ 表示结尾
*/
reg = /a$/;
console.log(reg.test("aac"));//false
console.log(reg.test("bca"));//true
/**
* 如果正则表达式中同时使用^ $则要求字符串必须完全符合正则表达式
*/
reg = /^a$/;//表示以a开头并且以a结尾,只能是一个a,不能是aa或aaa
console.log(reg.test("aa"));//false
console.log(reg.test("a"));//true
//如果需要以a开头或者以a结尾,则需要在中间加|,如:/^a|a$/
reg = /^a|a$/;
console.log(reg.test("abc"));//true
console.log(reg.test("bca"));//true
/**
* 检查一个正则表达式,用来检查一个字符串是否是一个合法的手机号
*
* 手机号规则:
* - 以1开头:^1
* - 第二位3-9的任意数字:[3-9]
* - 三位以后任意数字9个,并且结尾:[0-9]{9}$
*/
var phoneStr = "13735925921";
//这里的^和$必须有
var reg =/^1[3-9][0-9]{9}$/;
console.log(reg.test(phoneStr));
//如果不使用^和$进行限制则会出现问题
//如:一下这个虽然电话号是对的,但是两边还有字母以及数字。
//所以一定要加^和$进行开头结尾的限制
phoneStr = "sdfsd1373592592134";
var reg =/1[3-9][0-9]{9}/; //
console.log(reg.test(phoneStr));//true
script>
正则表达式语法续
<script type="text/javascript">
/**
* 检查一个字符串中是否含有 字符.
* .是特殊字符,表示任意字符
* 在正则表达式中使用\作为转义字符
* \.表示:字符.
* \\表示:\
*
* 注意:如果是使用构造函数,由于它的参数是一个字符串,而/是字符串中的转义字符
* 如果要使用\来进行转义,则需要使用:\\
* 如果需要使用字符\作为正则中的字符,使用构造函数需要传进入\\\\
* 字符串中转义后是:\\,\\传入正则再转义:就是字符\
*/
var reg = /./;
console.log(reg.test("a"))//true;
reg = /\./;
console.log(reg.test("a"));//false
console.log(reg.test("a."));//true
console.log(reg.test(".b"));//true
//使用构造函数
reg = new RegExp("\.")//转义后\.还是.,传入正则的只有一个.即表示:任意字符
console.log(reg.test("a"));//true
//解决问题
reg = new RegExp("\\.")//转移后是\.,\.传入正则再转义即表示:字符.
console.log(reg.test("a"));//fasle
console.log(reg.test("a."));//ture
/**
* \w 表示:任意字母、数字、下划线_
* \W 表示:除了字母、数字、_之外的其他字符
* \d 表示:任意数字
* \D 表示:除了数字
* \s 表示:空格
* \S 表示:除了空格
* \b 表示:单词边界
* \B 表示:除了单词边界
*/
// \w 表示:任意字母、数字、下划线_
reg = /\w/;
console.log(reg.test("z"));//true
console.log(reg.test("8"));//true
console.log(reg.test("_"));//true
//\W 表示:除了字母、数字、_之外的其他字符
reg = /\W/;
console.log(reg.test("z"));//false
console.log(reg.test("#"));//true
console.log(reg.test("@"));//true
//\d 表示:任意数字
reg = /\d/;
console.log(reg.test("123"));//true
console.log(reg.test("z"));//false
console.log(reg.test("@"));//false
// \D 表示:除了数字
reg = /\D/;
console.log(reg.test("123"));//false
console.log(reg.test("z"));//true
console.log(reg.test("@"));//true
//\s 表示:空格
reg = /\s/;
console.log(reg.test("de2"));//false
console.log(reg.test("12 3"));//true
console.log(reg.test(" "));//true
//\S 表示:除了空格
reg = /\S/;
console.log(reg.test("de2"));//true
console.log(reg.test("12 3"));//true
console.log(reg.test(" "));//false
/**
* 创建一个正则表达式检查一个字符串中是否含有单词child
* \b 表示:单词边界 这个单词两边都必须是空格
* \B表示:除了单词边界 ,这个单词旁边不能有空格
*/
reg = /\bchild\b/;
console.log(reg.test("hello children"));//false
console.log(reg.test("hello child"));//true
reg = /\Bchild\B/;
console.log(reg.test("hello dfchildren"));//true
console.log(reg.test("hello child"));//false
//去除字符串中所有的空格:使用""代替空格
var str = " h e l lo ";
console.log(str);// h e l lo
str = str.replace(/\s/g,"");
console.log(str);//hello 字符串中的空格也被去除了
//去除开头的空格
str = " h e l lo ";
str = str.replace(/^\s*/,"");
console.log(str);//h e l lo
//去除结尾的空格
str = " h e l lo ";
str = str.replace(/\s*$/,"");
console.log(str);// h e l lo
//只去除字符串前后的空格 /^\s*|\s*$/g 匹配开头和结尾的空格
str = " h e l lo ";
str = str.replace(/^\s*|\s*$/g,"");
console.log(str);//h e l lo
//接收用户键盘输入
str = prompt("请输入你的用户名:");
console.log(str);
script>
邮件的正则
<script type="text/javascript">
/**
* 电子邮件
* [email protected]
* 任意字符数字下划线 . 任意字符下划线@任意字母数字.任意字母(2-5位).任意字母(2-5位)
*
* \w{3,}(\.\w+)*@ [A-z0-9]+ (\.[A-z]{2-5}){1,2}
* 其次邮件两边不能有其他字符,所以在前面加上^,在后面加上$
*/
var emailReg = /^\w{3,}(\.\w+)*@[A-z0-9]+(\.[A-z]{2,5}){1,2}$/;
var email = "[email protected]"
console.log(emailReg.test(email));//true
script>
DOM全称:Document Object Model 文档对象模型
节点:
获取button对象,修改其中的文字
<body>
<button id="btn">我是一个按钮button>
<script type="text/javascript">
/**
* 浏览器已经为我们提供文档节点对象,这个对象是window属性
* 可以在页面中直接使用,文档节点代表的是整个网页
*/
//console.log(document);//#document
//获取button对象
var btn = document.getElementById("btn");
//获取按钮中的文字,使用属性innerHTML
console.log(btn.innerHTML);//我是一个按钮
//修改按钮的文字
btn.innerHTML = "我是button";
console.log(btn.innerHTML);//我是button
script>
body>
事件
<body>
<button id="btn">我是一个按钮button>
<script type="text/javascript">
//获取按钮对象
var btn =document.getElementById("btn");
/**
* 可以为按钮的对应时间绑定处理函数的形式来响应事件
*/
//绑定一个单击事件
//像这种为单击事件绑定的函数,我们成为单击响应函数。
btn.onclick = function(){
alert("你还点~~~");
};
script>
body>
文档的加载
DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>title>
<script type="text/javascript">
/**
* 浏览器在加载一个界面时,是按照自上向下的顺序加载的
* 读取到一行就运行一行,如果将script标签写道页面的上边
* 代码执行时,页面没有加载,页面加载不了DOM对象,也无法获取
* 所以要写在下面。写在下面就是为了在页面加载完毕以后再执行js代码
*
*onload事件会在整个页面加载完成之后才触发
* 为window绑定一个onload事件.
* 该事件对应的响应函数将会在页面加载完成之后执行
* 这样可以确保我们的代码执行时所有的DOM对象已经加载完毕了。
*/
window.onload= function(){
//获取id为btn的按钮
var btn = document.getElementById("btn");
//为按钮绑定一个单击响应函数
btn.onclick = function(){
alert("hello");
};
};
script>
head>
<body>
<button id="btn">点我一下button>
body>
html>
获取元素节点
获取元素节点
通过document对象调用
1、getElementById() ——通过id属性获取一个元素节点对象
2、getElementsByTagName()——通过标签名获取一组元素节点对象
3、getElementsByName()——通过name属性获取一组元素节点对象
dom查询练习
DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Untitled Documenttitle>
<link rel="stylesheet" type="text/css" href="style/css.css" />
<script type="text/javascript">
window.onload = function(){
//为id为btn01的按钮绑定一个单击响应函数
var btn01 = document.getElementById("btn01");
btn01.onclick = function(){
//查找#bj节点
var bj = document.getElementById("bj");
//打印bj
//innerHTML 通过这个属性可以获取到元素内部的html代码
alert(bj.innerHTML);
};
//为id为btn02的按钮绑定一个单击响应函数
var btn02 = document.getElementById("btn02");
btn02.onclick = function(){
//查找所有li节点
//getElementsByTagName()可以根据标签名来获取一组元素节点对象
//这个方法会返回一个类数组对象,所有查询到的元素都会封装到对象中
//即使查询到的元素只有一个,也会封装到数组中
var lis = document.getElementsByTagName("li");
alert(lis.length);
//遍历lis
for(var i =0 ;i<lis.length;i++){
alert(lis[i].innerHTML);
}
};
//为id为btn03的按钮绑定一个单击响应函数
var btn03 = document.getElementById("btn03");
btn03.onclick =function(){
//查找nam = gender的所有节点
var inputs = document.getElementsByName("gender");
//遍历
/**
* innerHTML用于获取元素内部的HTML代码,对于自结束标签,这个属性没有意义
* inputs[i].innerHTML
*
* 如果需要读取元素属性,直接使用元素.属性名
* 例如:元素.name 、元素.id 、元素.value
* 注意:class属性不能使用:元素.class。
* 要使用:元素.className
*/
for(var i=0;i<inputs.length;i++){
//alert(inputs[i].innerHTML);
alert(inputs[i].value);
}
};
//查找#city下所有li节点
//返回#city的所有子节点
//返回#phone的第一个子节点
//返回#bj的父节点
//返回#android的前一个兄弟节点
//读取#username的value属性值
//设置#username的value属性值
//返回#bj的文本值
};
script>
head>
<body>
<div id="total">
<div class="inner">
<p>
你喜欢哪个城市?
p>
<ul id="city">
<li id="bj">北京li>
<li>上海li>
<li>东京li>
<li>首尔li>
ul>
<br>
<br>
<p>
你喜欢哪款单机游戏?
p>
<ul id="game">
<li id="rl">红警li>
<li>实况li>
<li>极品飞车li>
<li>魔兽li>
ul>
<br />
<br />
<p>
你手机的操作系统是?
p>
<ul id="phone"><li>IOSli><li id="android">Androidli><li>Windows Phoneli>ul>
div>
<div class="inner">
gender:
<input class="hello" type="radio" name="gender" value="male"/>
Male
<input class="hello" type="radio" name="gender" value="female"/>
Female
<br>
<br>
name:
<input type="text" name="name" id="username" value="abcde"/>
div>
div>
<div id="btnList">
<div><button id="btn01">查找#bj节点button>div>
<div><button id="btn02">查找所有li节点button>div>
<div><button id="btn03">查找name=gender的所有节点button>div>
<div><button id="btn04">查找#city下所有li节点button>div>
<div><button id="btn05">返回#city的所有子节点button>div>
<div><button id="btn06">返回#phone的第一个子节点button>div>
<div><button id="btn07">返回#bj的父节点button>div>
<div><button id="btn08">返回#android的前一个兄弟节点button>div>
<div><button id="btn09">返回#username的value属性值button>div>
<div><button id="btn10">设置#username的value属性值button>div>
<div><button id="btn11">返回#bj的文本值button>div>
div>
body>
html>
图片轮播/切换
DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>title>
<style type="text/css">
*{
margin:0;
padding:0;
}
#outer{
width:500px;
margin:50px auto;
padding:10px;
background-color:greenyellow;
/* 设置文本居中 */
text-align:center;
}
style>
<script type="text/javascript">
/**
* 点击按钮切换图片
* 切换图片就是要修改img标签的src属性
*/
window.onload = function(){
//获取两个按钮
var prev = document.getElementById("prev");
var next = document.getElementById("next");
//获取img标签,获取到以后返回一个类数组对象,[0]表示取第一个
var img = document.getElementsByTagName("img")[0];
//创建一个数组,用来保存图片的路径
var imgArr = ["img/1.jpg","img/2.jpg","img/3.jpg","img/4.jpg","img/5.jpg"];
//创建一个变量,保存当前正在显示的图片的索引
var index = 0
//获取id为info的p元素
var info = document.getElementById("info");
//设置提示文字
info.innerHTML = "一共"+imgArr.length+"张图片,当前第"+(index+1)+"张";
//分别为两个按钮绑定单击响应函数
//修改img标签的src属性:元素.属性 = 属性值
prev.onclick = function(){
//切换到上一张,数组索引-1 ,即:index--
//如果index<0的话跳转到最后一张,即数组索引为length-1
if(--index < 0){
index = imgArr.length-1;
}
img.src = imgArr[index];
info.innerHTML = "一共"+imgArr.length+"张图片,当前第"+(index+1)+"张";
};
next.onclick =function(){
//切换到下一张,数组索引+1
if(++index > imgArr.length-1){
index = 0;
}
img.src = imgArr[index];
info.innerHTML = "一共"+imgArr.length+"张图片,当前第"+(index+1)+"张";
};
}
script>
head>
<body>
<div id="outer">
<p id="info">p>
<img src="img/1.jpg" alt="冰棍"/>
<button id="prev">上一张button>
<button id="next">下一张button>
div>
body>
html>
获取元素节点的子节点
通过具体的元素节点调用
- getElementsByTagName() 方法,返回当前节点的指定标签名后代节点
- childNodes 属性,表示当前节点的所有子节点
- firstChild 属性,表示当前节点的第一个子节点
- lastChild 属性,表示当前节点的最后一个子节点
练习
DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Untitled Documenttitle>
<link rel="stylesheet" type="text/css" href="style/css.css" />
<script type="text/javascript">
window.onload = function(){
//为id为btn04的按钮绑定一个单击响应函数
var btn04 = document.getElementById("btn04");
btn04.onclick = function(){
//获取id为city的元素
var city = document.getElementById("city");
//查找#city下所有li节点
var lis = city.getElementsByTagName("li");
//遍历li
for(var i=0 ; i<lis.length ; i++){
alert(lis[i].innerHTML);
};
};
//为id为btn05的按钮绑定了一个单击响应函数
var btn05 = document.getElementById("btn05");
btn05.onclick = function(){
//获取id为city的节点
var city = document.getElementById("city");
//返回#city中的所有子节点
/**
* childNodes属性会获取包括文本节点在内的所有节点
* 根据DOM标签空间内空白也会当成文本节点。
* 注意:IE8及以下的浏览器中,不会将空白文本当成子节点。
* 所以该属性在IE8中会返回4个子元素而其他浏览器是9个。
*/
var citys = city.childNodes;
for(var i=0 ; i<citys.length ;i++){
alert(citys[i].innerHTML);
};
/**
* children属性可以获取当前元素的所有子元素
* 不会出现两个标签之间的空白部分了
*/
var citys2 = city.children;
alert(citys2.length);//4
};
//为id为btn06的按钮绑定一个单击响应函数
var btn06 = document.getElementById("btn06");
btn06.onclick = function(){
//获取id为phone的子元素
var phone = document.getElementById("phone");
//返回phone的第一个子节点
//firstChild可以获取到当前元素的第一个子节点(包括空白文本节点)
var fir = phone.firstChild;
alert(fir);
/**
* firstElementChild获取当前元素的第一个子元素(不包含空白文本节点)
* 不支持IE8及以下的浏览器,如果需要兼容,则尽量不使用
*/
fir = phone.firstElementChild;
alert(fir);
};
//返回#bj的父节点
//返回#android的前一个兄弟节点
//读取#username的value属性值
//设置#username的value属性值
//返回#bj的文本值
};
script>
head>
<body>
<div id="total">
<div class="inner">
<p>
你喜欢哪个城市?
p>
<ul id="city">
<li id="bj">北京li>
<li>上海li>
<li>东京li>
<li>首尔li>
ul>
<br>
<br>
<p>
你喜欢哪款单机游戏?
p>
<ul id="game">
<li id="rl">红警li>
<li>实况li>
<li>极品飞车li>
<li>魔兽li>
ul>
<br />
<br />
<p>
你手机的操作系统是?
p>
<ul id="phone"><li>IOSli><li id="android">Androidli><li>Windows Phoneli>ul>
div>
<div class="inner">
gender:
<input class="hello" type="radio" name="gender" value="male"/>
Male
<input class="hello" type="radio" name="gender" value="female"/>
Female
<br>
<br>
name:
<input type="text" name="name" id="username" value="abcde"/>
div>
div>
<div id="btnList">
<div><button id="btn01">查找#bj节点button>div>
<div><button id="btn02">查找所有li节点button>div>
<div><button id="btn03">查找name=gender的所有节点button>div>
<div><button id="btn04">查找#city下所有li节点button>div>
<div><button id="btn05">返回#city的所有子节点button>div>
<div><button id="btn06">返回#phone的第一个子节点button>div>
<div><button id="btn07">返回#bj的父节点button>div>
<div><button id="btn08">返回#android的前一个兄弟节点button>div>
<div><button id="btn09">返回#username的value属性值button>div>
<div><button id="btn10">设置#username的value属性值button>div>
<div><button id="btn11">返回#bj的文本值button>div>
div>
body>
html>
获取父节点和兄弟节点
通过具体的节点调用
- parentNode 属性,表示当前节点的父节点
- previousSibling 属性,表示当前节点的前一个兄弟节点
- nextSibling 属性,表示当前节点的后一个兄弟节点
练习
DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Untitled Documenttitle>
<link rel="stylesheet" type="text/css" href="style/css.css" />
<script type="text/javascript">
/**
* 定义一个函数,专门为指定元素绑定单击响应函数
* 参数:
* idStr 要绑定单击响应函数的对象的id属性值
* fun 事件的回调函数,当单击元素时,该函数将会被触发
*/
function myClick(idStr,fun){
var btn = document.getElementById(idStr);
btn.onclick = fun;
};
window.onload = function(){
//为btn07按钮绑定一个单击响应函数
myClick("btn07",function(){
//获取id为bj的节点
var bj = document.getElementById("bj");
//返回#bj的父节点
var bjparent = bj.parentNode;
alert(bjparent.innerHTML);
/**
* innerText
* - 该属性可以获取到元素内部的文本内容
* - 它和innerHTML类似,不同的是它会自动将html标签抹除,只剩下文本
*/
alert(bjparent.innerText);
});
//为btn08的按钮绑定一个单击响应函数
myClick("btn08",function(){
//获取id为android的元素
var android =document.getElementById("android");
//返回#android的前一个兄弟节点(也可能获取到空白文本)
var andpre =android.previousSibling;
alert(andpre.innerHTML);
//previousElementSibling获取前一个兄弟元素,IE8及以下不支持
andpre = android.previousElementSibling;
alert(andpre.innerHTML);
})
//为btn09的按钮绑定一个单击响应函数
myClick("btn09",function(){
//获取id为username的元素
var uname = document.getElementById("username");
//读取#username的value属性值
alert(uname.value);
});
//为btn10的按钮设置一个单击响应事件
myClick("btn10",function(){
//获取id为username的元素
var uname = document.getElementById("username");
//设置#username的value属性值
uname.value = "阳光明媚";
});
//返回#bj的文本值
myClick("btn11",function(){
//获取id为bj的元素
var bj = document.getElementById("bj");
alert(bj.innerHTML);
alert(bj.innerText);
alert(bj.firstChild.nodeValue);
});
};
script>
head>
<body>
<div id="total">
<div class="inner">
<p>
你喜欢哪个城市?
p>
<ul id="city">
<li id="bj">北京li>
<li>上海li>
<li>东京li>
<li>首尔li>
ul>
<br>
<br>
<p>
你喜欢哪款单机游戏?
p>
<ul id="game">
<li id="rl">红警li>
<li>实况li>
<li>极品飞车li>
<li>魔兽li>
ul>
<br />
<br />
<p>
你手机的操作系统是?
p>
<ul id="phone"><li>IOSli><li id="android">Androidli><li>Windows Phoneli>ul>
div>
<div class="inner">
gender:
<input class="hello" type="radio" name="gender" value="male"/>
Male
<input class="hello" type="radio" name="gender" value="female"/>
Female
<br>
<br>
name:
<input type="text" name="name" id="username" value="abcde"/>
div>
div>
<div id="btnList">
<div><button id="btn01">查找#bj节点button>div>
<div><button id="btn02">查找所有li节点button>div>
<div><button id="btn03">查找name=gender的所有节点button>div>
<div><button id="btn04">查找#city下所有li节点button>div>
<div><button id="btn05">返回#city的所有子节点button>div>
<div><button id="btn06">返回#phone的第一个子节点button>div>
<div><button id="btn07">返回#bj的父节点button>div>
<div><button id="btn08">返回#android的前一个兄弟节点button>div>
<div><button id="btn09">返回#username的value属性值button>div>
<div><button id="btn10">设置#username的value属性值button>div>
<div><button id="btn11">返回#bj的文本值button>div>
div>
body>
html>
全选练习
DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>全选练习title>
<script type="text/javascript">
window.onload = function(){
//获取四个多选框items(每个函数里都需要用到,所以写到这里,就不用在每个函数里单独写了)
var items = document.getElementsByName("items");
//1.#checkedAllBtn
//为id为 #checkedAllBtn的按钮绑定一个单击响应函数
var checkedAllBtn = document.getElementById("checkedAllBtn");
checkedAllBtn.onclick = function(){
//遍历items
for(var i=0 ; i<items.length ;i++){
//通过多选框的checked属性设置多选框的选中状态
//设置四个多选框为选中状态
items[i].checked=true;
}
//全选按钮里:设置checkedAllBox为选中状态
checkedAllBox.checked = true;
};
/**
* 全不选:点击按钮以后,四个多选框都变成没选中的状态
*/
//2.#checkedNoBtn //为id为checkedNoBtn的按钮绑定一个单击响应函数
var checkedNoBtn = document.getElementById("checkedNoBtn");
checkedNoBtn.onclick = function(){
//遍历items
for(var i=0 ; i<items.length ;i++){
//通过多选框的checked属性设置多选框的选中状态
//设置四个多选框为选中状态
items[i].checked=false;
}
//全不选按钮里:设置checkedAllBox为取消状态
checkedAllBox.checked = false;
}
//反选按钮:选中的变没选中,没选中的变选中
//3.#checkedRevBtn
var checkedRevBtn = document.getElementById("checkedRevBtn");
checkedRevBtn.onclick = function(){
for(var i=0 ; i<items.length ;i++){
//先判断该多选框的选中状态,如果为true,则设置为false
/* if(items[i].checked){
items[i].checked=false;
}else{//反之,就是为false,则设置为true
items[i].checked=true;
} */
//或者使用三目运算符
//items[i].checked?items[i].checked=false:items[i].checked=true;
//或者取反
items[i].checked = !items[i].checked;
}
//取反后判断是否为全选,如果为全选则checkedAllBox为选中状态,反之为false
//每一个多选框一旦选中,随即设置checkedAllBox为选中状态
checkedAllBox.checked = true;
//然后开始循环,判断四个多选框是否都为选中状态,只要有一个不是选中状态就不是全选
for(var j=0 ; j<items.length; j++){
if(!items[j].checked){
//一旦进入判断即:非全选状态,则设置checkAllBox为false
checkedAllBox.checked = false;
//一旦进入判断,取消选中之后,即可结束循环
break;
}
}
}
//4.#sendBtn 提交按钮:将所有的多选框的value属性值弹出
//为sendBtn绑定单击响应函数
var sendBtn = document.getElementById("sendBtn");
sendBtn.onclick = function(){
for(var i = 0 ; i<items.length;i++){
if(items[i].checked){
alert(items[i].value);
}
}
};
//5.#checkedAllBox 全选/全不选多选框:当它选中时:所有的都选中;取消时,所有的都取消
//为checkedAllBox绑定单击响应函数
var checkedAllBox = document.getElementById("checkedAllBox");
checkedAllBox.onclick = function(){
//设置多选框的选中状态
for(var i = 0 ; i<items.length ; i++){
//这四个多选框的状态与checkedAllBox这个多选框的状态保持一致即可。
//items[i].checked = checkedAllBox.checked;
//在事件的响应函数中,响应函数是给谁绑定的,this就是谁
items[i].checked = this.checked;
}
};
//6.items
//如果四个多选框全部都选中,则checkedAllBox也应该选中,反之checkedAllBox也不应该选中
//为四个多选框分别绑定单机响应函数
for(var i = 0 ; i<items.length ; i++){
items[i].onclick = function(){
//每一个多选框一旦选中,随即设置checkedAllBox为选中状态
checkedAllBox.checked = true;
//然后开始循环,判断四个多选框是否都为选中状态,只要有一个不是选中状态就不是全选
for(var j=0 ; j<items.length; j++){
if(!items[j].checked){
//一旦进入判断即:非全选状态,则设置checkAllBox为false
checkedAllBox.checked = false;
//一旦进入判断,取消选中之后,即可结束循环
break;
}
}
}
}
};
script>
head>
<body>
<form method="post" action="">
你爱好的运动是?<input type="checkbox" id="checkedAllBox" />全选/全不选
<br />
<input type="checkbox" name="items" value="足球" />足球
<input type="checkbox" name="items" value="篮球" />篮球
<input type="checkbox" name="items" value="羽毛球" />羽毛球
<input type="checkbox" name="items" value="乒乓球" />乒乓球
<br />
<input type="button" id="checkedAllBtn" value="全 选" />
<input type="button" id="checkedNoBtn" value="全不选" />
<input type="button" id="checkedRevBtn" value="反 选" />
<input type="button" id="sendBtn" value="提 交" />
form>
body>
html>
DOM查询的其他方法
DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>title>
<script type="text/javascript">
window.onload = function(){
//获取body标签:在document中有一个属性body,他保存的是body的引用
var body = document.body;
console.log(body); //body标签
//document.documentElement保存的是html的根标签
var html = document.documentElement;
console.log(html);//html标签
//document.all代表页面中所有的元素
//document.getElementsByTagName("*")也表示页面中所有的元素
var all = document.all;
console.log(all.length);
/**
* 根据元素的class属性值查询一组元素节点对象
* getElementsByClassName()可以根据calss属性获取一组元素节点对象
* 不支持IE8及以下的浏览器
*/
var box1 = document.getElementsByClassName("box1");
console.log(box1.length);//1
//获取页面中所有的div
var divs = document.getElementsByTagName("div");
//获取class为box1中的所有的div .box1 div
/**
* document.querySelector()
* - 需要一个选择器的字符串作为参数,可以根据一个css选择器来查询一个元素节点对象
* - 虽然IE8中没有getElementsByClassName()但是可以使用querySelector()代替
* - 使用该方法总会返回唯一的一个元素,如果满足条件的元素有多个,那么它也只会返回第一个
*/
var div = document.querySelector(".box1 div");
console.log(div.innerHTML);//我是box1中的div
var box1 = document.querySelector(".box1");
console.log(box1);
/**
* document.querySelectorAll()
* 该方法与querySelector类似,不同的是它会将符条件的元素封装到一个数组中返回
* 即使符合条件的元素只有一个,他也会返回数组
*/
box1 = document.querySelectorAll(".box1");
console.log(box1.length);//3
};
script>
head>
<body>
<div class="box1">
<div>我是box1中的divdiv>
div>
<div class="box1">div>
<div class="box1">div>
body>
html>
DOM的增删改
DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Untitled Documenttitle>
<link rel="stylesheet" type="text/css" href="style/css.css" />
<script type="text/javascript">
window.onload = function() {
//创建一个广州节点,添加到#city下
myClick("btn01",function(){
//创建广州节点:- 广州
/**
* document.createElement()
* 可以用于创建一个元素节点对象
* 它需要一个标签名作为参数,将会根据该标签名创建元素节点对象
* 并将创建好的对象作为返回值返回
*/
var li = document.createElement("li");
//创建广州文本节点
/**
* document.createTextNode()
* 可以用来创建一个文本节点对象
* 需要一个文本内容作为参数,将会根据该内容创建文本节点,并将新的节点返回
*/
var gzText = document.createTextNode("广州");
//将gzText设置为li的子节点
/**
* appendChild()
* - 向一个父节点中添加一个新的子节点。
* - 用法:父节点.appendChild(子节点);
*/
li.appendChild(gzText);
//获取id为city的节点
var city = document.getElementById("city");
//将广州添加到city下。
city.appendChild(li);
});
//将“广州节点”插入到#bj前面
myClick("btn02",function(){
//创建一个广州节点
var li = document.createElement("li");
var gzText = document.createTextNode("广州");
li.appendChild(gzText);
//获取id为bj的节点
var bj = document.getElementById("bj");
//获取city
var city = document.getElementById("city");
/**
* insertBefore()
* - 可以在指定的子节点前插入新的子节点
* - 语法:父节点.insertBefore(新节点,旧节点);
*/
city.insertBefore(li,bj);
});
//使用“广州”节点替换#bj节点
myClick("btn03",function(){
//创建广州节点
var li = document.createElement("li");
var gzText = document.createTextNode("广州");
li.appendChild(gzText);
//获取bj节点
var bj = document.getElementById("bj");
//获取city节点
var city = document.getElementById("city");
/**
* replaceChild()
* - 可以使用指定的子节点替换已有的子节点
* - 语法:父节点.replaceChild(新节点,旧节点);
*/
city.replaceChild(li,bj);
});
//删除北京节点
myClick("btn04",function(){
//获取id为bj的节点
var bj = document.getElementById("bj");
//获取city节点
var city = document.getElementById("city");
/**
* removeChild()
* - 可以删除一个子节点
* - 语法:子节点.removeChild(子节点);
*
* 另一种删除元素的方法
* 子节点.parentNode.removeChild(子节点);
*/
//获取父节点之后调用方法
//city.removeChild(bj);
//常用:
//通过子元素寻找到父节点之后调用删除子节点的方法
bj.parentNode.removeChild(bj);
});
//读取#city中的HTMl代码
myClick("btn05",function(){
//获取city节点
var city = document.getElementById("city");
//获取其中的html代码:
alert(city.innerHTML);
});
//设置#bj内的html代码
myClick("btn06",function(){
//获取bj
var bj = document.getElementById("bj");
bj.innerHTML="昌平"
});
//使用innerHTML为city中添加广州节点
myClick("btn07",function(){
var city = document.getElementById("city");
/**
* 使用innerHTML也可以完成DOM的增删改查的操作
*/
//这种方法相当于改动了整个id为city的ul标签。一般不这么使用
//city.innerHTML += "- 广州
"
//一般我们会两种方式结合使用
//先创建一个li
var li = document.createElement("li");
//向li中设置文本:
li.innerHTML = "广州";
//将li添加到city中
city.appendChild(li);
});
};
//设置按钮的响应函数
function myClick(idStr,fun){
var btn = document.getElementById(idStr);
btn.onclick = fun;
}
script>
head>
<body>
<div id="total">
<div class="inner">
<p>
你喜欢哪个城市?
p>
<ul id="city">
<li id="bj">北京li>
<li>上海li>
<li>东京li>
<li>首尔li>
ul>
div>
div>
<div id="btnList">
<div><button id="btn01">创建一个"广州"节点,添加到#city下button>div>
<div><button id="btn02">将"广州"节点插入到#bj前面button>div>
<div><button id="btn03">使用"广州"节点替换#bj节点button>div>
<div><button id="btn04">删除#bj节点button>div>
<div><button id="btn05">读取#city内的HTML代码button>div>
<div><button id="btn06">设置#bj内的HTML代码button>div>
<div><button id="btn07">创建一个"广州"节点,添加到#city下button>div>
div>
body>
html>
添加删除记录练习
DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>添加删除记录练习title>
<link rel="stylesheet" type="text/css" href="ex_2_style/css.css" />
<script type="text/javascript">
window.onload = function(){
//点击超链接以后,删除一个员工信息
//删除tr的响应函数
function del(){
/**
* 点击超链接以后,需要删除超链接所在的那行
* 这里我们点击哪个超链接,this就是谁
*/
//获取当前的tr
var tr = this.parentNode.parentNode;
//获取要删除的员工的名字
//var name = tr.children[0].innerHTML;
var name = tr.getElementsByTagName("td")[0].innerHTML;
/**
* 删除之前弹出一个提示框
* confirm()用于弹出一个带有确认和取消按钮的提示框
* 需要一个字符串作为参数,该字符串将会作为提示文字显示出来
* 如果用户点击确认返回true,点击取消返回:false
*/
var flag = confirm("确认删除"+name+"吗?");
//如果用户确认删除则删除
if(flag){
//tr再获取它的父节点,通过removeChild()方法删除自己
tr.parentNode.removeChild(tr);
}
/**
* 点击超链接以后,超链接会跳转页面,这个是超链接的默认行为
* 但是此时我们不希望出现默认行为,可以通过在响应函数的最后
* return false 来取消默认行为
*/
return false;
};
//获取所有的超链接
var allA = document.getElementsByTagName("a");
//为每个超链接都绑定一个单击响应函数
for(var i = 0 ; i<allA.length;i++){
/**
* for循环会在页面加载完成之后立即执行,而响应函数会在超链接被点击时才执行
* 当响应函数执行时,for循环早已执行完毕
*/
allA[i].onclick = del;
}
//添加员工的功能:点击按钮之后,将员工的信息添加到表格中
//为提交按钮绑定一个单击响应函数
var addEmpButton = document.getElementById("addEmpButton");
addEmpButton.onclick=function(){
//获取用户添加的员工信息
//获取员工的名字、email、salary
var name = document.getElementById("empName").value;
var email = document.getElementById("email").value;
var salary = document.getElementById("salary").value;
//将获取到的信息保存到tr中
var tr = document.createElement("tr");
//设置tr中的内容
tr.innerHTML = ""+name+" "+
""+email+" "+
""+salary+" "+
"Delete "
//获取刚刚添加的a元素,并为其绑定单击响应函数
var a = tr.getElementsByTagName("a")[0];
a.onclick = del;
//获取table
var employeeTable = document.getElementById("employeeTable");
//获取employeeTable中的tbody
var tbody = employeeTable.getElementsByTagName("tbody")[0];
//将tr添加到tbody中
tbody.appendChild(tr);
};
};
script>
head>
<body>
<table id="employeeTable">
<tr>
<th>Nameth>
<th>Emailth>
<th>Salaryth>
<th> th>
tr>
<tr>
<td>Tomtd>
<td>[email protected]td>
<td>5000td>
<td><a href="javascript:;">Deletea>td>
tr>
<tr>
<td>Jerrytd>
<td>[email protected]td>
<td>8000td>
<td><a href="deleteEmp?id=002">Deletea>td>
tr>
<tr>
<td>Bobtd>
<td>[email protected]td>
<td>10000td>
<td><a href="deleteEmp?id=003">Deletea>td>
tr>
table>
<div id="formDiv">
<h4>添加新员工h4>
<table>
<tr>
<td class="word">name: td>
<td class="inp">
<input type="text" name="empName" id="empName" />
td>
tr>
<tr>
<td class="word">email: td>
<td class="inp">
<input type="text" name="email" id="email" />
td>
tr>
<tr>
<td class="word">salary: td>
<td class="inp">
<input type="text" name="salary" id="salary" />
td>
tr>
<tr>
<td colspan="2" align="center">
<button id="addEmpButton" value="abc">
Submit
button>
td>
tr>
table>
div>
body>
html>
使用DOM操作CSS
DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>title>
<style type="text/css">
#box1{
width:200px;
height:200px;
background-color: red;
}
style>
<script type="text/javascript">
window.onload = function(){
//点击按钮以后,修改box1的大小
//获取box1
var box1 = document.getElementById("box1");
//为按钮绑定单击响应函数
var btn01 = document.getElementById("btn01");
btn01.onclick = function(){
//修改box1的宽度
/**
* 通过js修改元素的样式;
* 语法:元素.style.样式名 = 样式值
*
* 注意:如果CSS的央视中含有-
* 这种名称在js中是不合法的,比如:background-color
* 需要将这种样式名修改为驼峰命名法:去掉-,然后将-后的字母大写
*
* 我们通过style属性设置的样式都是内联样式,而内联样式有较高的优先级
* 所以通过js修改的样式往往会立即显示
*
* 但是如果在样式中加了:!important,则此时样式会有最高的优先级,
* 即使通过JS也不能覆盖该样式,此时会导致JS修改样式失效
* 所以尽量不要为样式添加!important
*/
box1.style.width = "300px";
box1.style.height = "300px";
box1.style.backgroundColor = "yellow";
};
//点击按钮2以后,读取元素的样式
var btn02 = document.getElementById("btn02");
btn02.onclick = function(){
//读取box1的样式
/**
* 语法:元素.style.样式名
* 通过style属性设置和读取的都是内联样式,无法读取样式表中的样式
*/
alert(box1.style.width);//300px;
};
};
script>
head>
<body>
<button id="btn01">点我一下button>
<button id="btn02">获取样式button>
<br>
<div id="box1">div>
body>
html>
读取元素的样式
DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>title>
<style type="text/css">
#box1{
width: 100px;
height: 100px;
background-color: yellow;
}
style>
<script type="text/javascript">
window.onload=function(){
//点击按钮以后读取box1的样式
var box1 = document.getElementById("box1");
var btn01 = document.getElementById("btn01");
btn01.onclick = function(){
/**
* 获取元素当前显示的样式
* 语法:元素.currentStyle.样式名
* 它可以用来读取当前正在显示的样式。如果当前元素没有设置该样式,则获取它的默认值
*
* 注意:currentStyle只有IE浏览器支持,其他的浏览器不支持
*/
//alert(box1.currentStyle.width);
/**
* 在其他的浏览器中可以使用:
* getComputedStyle()这个方法来获取元素当前的样式
* 这个方法时window的方法,可以直接使用。
* 有两个参数:
* 第一个:要获取样式的元素
* 第二个:可以传一个伪元素,一般都传null
*
* 该方法会返回一个对象,对象中封装了当前元素对应的样式
* 可以通过对象.样式名来读取样式:getComputedStyle(box1,null).width
*
* 如果获取的样式没有设置,则会获取到真实的值,而不是默认值,
* 例如:没有设置width,他不会获取到auto,而是一个长度px值
* 注意:该方法不支持IE8及以下的浏览器
*
* 通过currentStyle和ComputedStyle()读取到的样式都是只读的,不能修改
* 如果要修改,必须通过style属性
*/
//var obj = getComputedStyle(box1,null);
//alert(getComputedStyle(box1,null).width);//100px
//alert(getStyle(box1,"width"));
var w = getStyle(box1,"width");
alert(w);
};
};
/**
* 定义一个函数,用来获取指定元素当前的样式
* 参数:
* - obj:要获取样式的元素
* - name:要获取的样式名
*/
function getStyle(obj ,name){
//这里加个window,getComputedStyle就是一个属性了,属性没定义返回undefined
if(window.getComputedStyle){
//正常浏览器里有getComputedStyle()方法
//这里的name是变量,需要放在[] 里传递
return getComputedStyle(obj,null)[name];
}else{
//IE浏览器
return obj.currentStyle[name];
}
//简化,但使用以上代码结构更清晰
//return window.getComputedStyle?getComputedStyle(obj,null)[name]:obj.currentStyle[name];
}
script>
head>
<body>
<button id="btn01">点我一下button>
<br>
<div id="box1">div>
body>
html>
其他样式操作的属性
DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>title>
<style type="text/css">
#box1{
width: 100px;
height: 100px;
background-color: red;
padding:10px;
border:10px solid yellow;
}
#box2{
padding:100px;
background-color: #bfa;
}
#box4{
width: 200px;
height: 300px;
background-color: #FF0000;
overflow: auto;
}
#box5{
width:450px;
height:600px;
background-color: yellow;
}
style>
<script type="text/javascript">
window.onload = function(){
var box1 = document.getElementById("box1");
var btn01 = document.getElementById("btn01");
var box4 = document.getElementById("box4");
btn01.onclick = function(){
/**
* clientWidth
* clientHeight
* - 这两个属性可以获取元素的可见宽度和高度
* - 这些属性都是不带px的,返回值是一个数字,可以直接进行计算
* - 会获取元素宽度和高度,包括内容和内边距。不包括边框
* - 这些属性都是只读的,不能修改
*/
//alert(box1.clientWidth);
/**
* offsetWidth
* offsetHeight
* - 获取元素的整个宽度和高度,包括内容区、内边距和边框。
*/
//alert(box1.offsetWidth);
/**
* offsetParent
* - 可以用来获取当前元素的定位父元素
* - 会获取到离当前元素最近的开启了定位的祖先元素。
* 如果所有的祖先元素都没有开启定位,则返回body
*/
var op = box1.offsetParent;
//alert(op);
/**
* offsetLeft
* - 当前元素当对于其定位父元素的水平偏移量
* offsetTop
* - 当前元素当对于其定位父元素的垂直偏移量
*/
//alert(box1.offsetLeft);
/**
* scrollWidth
* scrollHeight
* - 可以获取元素整个滚动区域的宽度和高度
*/
alert(box4.scrollHeight);
/**
* scrollLeft
* - 可以获取水平滚动条滚动的距离
* scrollTop
* - 可以获取垂直滚动条滚动的距离
*/
//当满足scrollHeight - scrollTop == clientHeight 时,说明垂直滚动条到底了
//当满足scrollWidth - scrollLeft == clientWidth 时,说明水平滚动条滚动到底了
};
};
script>
head>
<body>
<button id="btn01">点我一下button>
<br />
<div id="box4">
<div id="box5">div>
div>
<br />
<div id="box2" style="position:relative;">
<div id = "box1">div>
div>
body>
html>
事件对象
DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Insert title heretitle>
<style type="text/css">
#areaDiv {
border: 1px solid black;
width: 300px;
height: 50px;
margin-bottom: 10px;
}
#showMsg {
border: 1px solid black;
width: 300px;
height: 20px;
}
style>
<script type="text/javascript">
window.onload = function(){
//当鼠标在areaDiv中移动时,在showMsg中来显示鼠标的坐标
//获取两个div
var areaDiv = document.getElementById("areaDiv");
var showMsg = document.getElementById("showMsg");
/**
* onmousemove
* - 该事件将会在鼠标在元素中移动时被触发
*
* 事件对象
* - 当事件的响应函数被触发时,浏览器每次都会讲一个事件对象作为实际参数传递进响应函数
* 在事件对象中封装了当前事件相关的一切信息,如:鼠标的坐标、键盘那个按键被按下、鼠标滚轮滚动的方向
*
*/
areaDiv.onmousemove = function(event){
/**
* 在IE8中,响应函数被触发时,浏览器不会传递事件对象
* 在IE8及以下的浏览器中,是将事件对象作为window对象的属性保存的
*/
//判断浏览器中是否有event对象,如果没有则让event = window.event
/* if(!event){
event = window.event;
} */
//或者这样写:
//解决事件对象的兼容性问题
event = event || window.event;
/**
* clientX可以获取鼠标指针的水平坐标
* clientY可以获取鼠标指针的垂直坐标
*/
var x = event.clientX;
var y = event.clientY;
//在showMsg中显示鼠标的坐标
showMsg.innerHTML = "x="+x+", y="+y;
}
};
script>
head>
<body>
<div id="areaDiv">div>
<div id="showMsg">div>
body>
html>
div跟随鼠标移动。
DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>title>
<style type="text/css">
body{
height: 1500px;
width: 2000px;
}
#box1{
width:100px;
height:100px;
background-color: aquamarine;
/*开启box1的绝对定位*/
position:absolute;
}
style>
<script type="text/javascript">
window.onload = function(){
//使div跟随鼠标移动
//获取box1
var box1 = document.getElementById("box1");
//绑定鼠标移动事件:需要绑定在整个界面上,这样只要鼠标不移出浏览器界面
//不管向哪个方向移动,div都会随着移动
document.onmousemove = function(event){
//解决兼容性问题
event = event || window.event;
/**
* 获取滚动条滚动的距离
*
* chrome认为浏览器的滚动条是body的,可以通过body.scrollTop来获取
* 火狐等浏览器认为浏览器的滚动条是html的
*/
//垂直
var st = document.body.scrollTop || document.documentElement.scrollTop;
//水平
var sl = document.body.scrollLeft || document.documentElement.scrollLeft;
//获取到鼠标的坐标
/**
* clientX 和ClientY
* 用于获取鼠标在当前的可见窗口的坐标。div的偏移量,是相对于整个页面的
*
* pageX和pageY可以获取鼠标相对于当前页面的坐标
* 但是这两个属性在IE8中不支持,所以要兼容IE8,则不要使用
*/
var left = event.clientX;
var top = event.clientY;
//设置div的偏移量
box1.style.left = left + sl + "px";
box1.style.top = top + st +"px";
};
};
script>
head>
<body>
<div id="box1">
div>
body>
html>
事件的冒泡
DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>title>
<style type="text/css">
#box1{
width: 200px;
height: 200px;
background-color: yellowgreen;
}
#s1{
background-color: yellow;
}
style>
<script type="text/javascript">
window.onload = function(){
/**
* 事件的冒泡(Bubble)
* - 所谓事件的冒泡就是事件的向上传导,当后代元素上的事件被触发时,其祖先元素的相同事件也会被触发
* - 在开发中大部分情况冒泡都是有用的,如果不希望发生事件冒泡可以通过事件对象来取消冒泡
*/
//为s1绑定一个单击响应函数
var s1 = document.getElementById("s1");
s1.onclick = function(event){
event = event || window.event;
alert("我是span的单击响应函数");
//取消冒泡:将事件对象的cancelBubble设置为true,即可取消冒泡
event.cancelBubble = true;
};
//为box1绑定一个单击响应函数
var box1 = document.getElementById("box1");
box1.onclick = function(event){
event = event || window.event;
alert("我是div的单击响应函数");
//取消冒泡:将事件对象的cancelBubble设置为true,即可取消冒泡
event.cancelBubble = true;
};
//为body绑定一个单击响应函数
document.body.onclick = function(){
alert("我是body的单击响应函数");
};
};
script>
head>
<body>
<div id="box1">
我是box1
<span id="s1">我是spanspan>
div>
body>
html>
事件的委派
DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>title>
<script type="text/javascript">
window.onload = function(){
var u1 = document.getElementById("u1");
//点击按钮以后添加超链接
var btn01 = document.getElementById("btn01");
btn01.onclick = function(){
//创建一个li
var li = document.createElement("li");
li.innerHTML = "新建的超链接";
//将li添加到ul中
u1.appendChild(li);
};
/*
* 为每一个超链接都绑定一个单击响应函数
* 这里我们为每一个超链接都绑定了一个单击响应函数,这种操作比较麻烦,
* 而且这些操作只能为已有的超链接设置事件,而新添加的超链接必须重新绑定
*/
//获取所有的a
var allA = document.getElementsByTagName("a");
//遍历
/*for(var i=0 ; i
/*
* 我们希望,只绑定一次事件,即可应用到多个的元素上,即使元素是后添加的
* 我们可以尝试将其绑定给元素的共同的祖先元素
*
* 事件的委派
* - 指将事件统一绑定给元素的共同的祖先元素,这样当后代元素上的事件触发时,会一直冒泡到祖先元素
* 从而通过祖先元素的响应函数来处理事件。
* - 事件委派是利用了冒泡,通过委派可以减少事件绑定的次数,提高程序的性能
*/
//为ul绑定一个单击响应函数
u1.onclick = function(event){
event = event || window.event;
/*
* target
* - event中的target表示的触发事件的对象
*/
//alert(event.target);
//如果触发事件的对象是我们期望的元素,则执行否则不执行
if(event.target.className == "link"){
alert("我是ul的单击响应函数");
}
};
};
script>
head>
<body>
<button id="btn01">添加超链接button>
<ul id="u1" style="background-color: #bfa;">
<li>
<p>我是p元素p>
li>
<li><a href="javascript:;" class="link">超链接一a>li>
<li><a href="javascript:;" class="link">超链接二a>li>
<li><a href="javascript:;" class="link">超链接三a>li>
ul>
body>
html>
事件的绑定
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>title>
<script type="text/javascript">
window.onload = function(){
/*
* 点击按钮以后弹出一个内容
*/
//获取按钮对象
var btn01 = document.getElementById("btn01");
/*
* 使用 对象.事件 = 函数 的形式绑定响应函数,
* 它只能同时为一个元素的一个事件绑定一个响应函数,
* 不能绑定多个,如果绑定了多个,则后边会覆盖掉前边的
*/
//为btn01绑定一个单击响应函数
/*btn01.onclick = function(){
alert(1);
};*/
//为btn01绑定第二个响应函数
/*btn01.onclick = function(){
alert(2);
};*/
/*
* addEventListener()
* - 通过这个方法也可以为元素绑定响应函数
* - 参数:
* 1.事件的字符串,不要on
* 2.回调函数,当事件触发时该函数会被调用
* 3.是否在捕获阶段触发事件,需要一个布尔值,一般都传false
*
* 使用addEventListener()可以同时为一个元素的相同事件同时绑定多个响应函数,
* 这样当事件被触发时,响应函数将会按照函数的绑定顺序执行
*
* 这个方法不支持IE8及以下的浏览器
*/
/*btn01.addEventListener("click",function(){
alert(1);
},false);
btn01.addEventListener("click",function(){
alert(2);
},false);
btn01.addEventListener("click",function(){
alert(3);
},false);*/
/*
* attachEvent()
* - 在IE8中可以使用attachEvent()来绑定事件
* - 参数:
* 1.事件的字符串,要on
* 2.回调函数
*
* - 这个方法也可以同时为一个事件绑定多个处理函数,
* 不同的是它是后绑定先执行,执行顺序和addEventListener()相反
*/
/*btn01.attachEvent("onclick",function(){
alert(1);
});
btn01.attachEvent("onclick",function(){
alert(2);
});
btn01.attachEvent("onclick",function(){
alert(3);
});*/
/*btn01.addEventListener("click",function(){
alert(this);
},false);*/
/*btn01.attachEvent("onclick",function(){
alert(this);
});*/
bind(btn01 , "click" , function(){
alert(this);
});
};
//定义一个函数,用来为指定元素绑定响应函数
/*
* addEventListener()中的this,是绑定事件的对象
* attachEvent()中的this,是window
* 需要统一两个方法this
*/
/*
* 参数:
* obj 要绑定事件的对象
* eventStr 事件的字符串(不要on)
* callback 回调函数
*/
function bind(obj , eventStr , callback){
if(obj.addEventListener){
//大部分浏览器兼容的方式
obj.addEventListener(eventStr , callback , false);
}else{
/*
* this是谁由调用方式决定
* callback.call(obj)
*/
//IE8及以下
obj.attachEvent("on"+eventStr , function(){
//在匿名函数中调用回调函数
callback.call(obj);
});
}
}
script>
head>
<body>
<button id="btn01">点我一下button>
body>
html>
事件的传播
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>title>
<style type="text/css">
#box1{
width: 300px;
height: 300px;
background-color: yellowgreen;
}
#box2{
width: 200px;
height: 200px;
background-color: yellow;
}
#box3{
width: 150px;
height: 150px;
background-color: skyblue;
}
style>
<script type="text/javascript">
window.onload = function(){
/*
* 分别为三个div绑定单击响应函数
*/
var box1 = document.getElementById("box1");
var box2 = document.getElementById("box2");
var box3 = document.getElementById("box3");
/*
* 事件的传播
* - 关于事件的传播网景公司和微软公司有不同的理解
* - 微软公司认为事件应该是由内向外传播,也就是当事件触发时,应该先触发当前元素上的事件,
* 然后再向当前元素的祖先元素上传播,也就说事件应该在冒泡阶段执行。
* - 网景公司认为事件应该是由外向内传播的,也就是当前事件触发时,应该先触发当前元素的最外层的祖先元素的事件,
* 然后在向内传播给后代元素
* - W3C综合了两个公司的方案,将事件传播分成了三个阶段
* 1.捕获阶段
* - 在捕获阶段时从最外层的祖先元素,向目标元素进行事件的捕获,但是默认此时不会触发事件
* 2.目标阶段
* - 事件捕获到目标元素,捕获结束开始在目标元素上触发事件
* 3.冒泡阶段
* - 事件从目标元素向他的祖先元素传递,依次触发祖先元素上的事件
*
* - 如果希望在捕获阶段就触发事件,可以将addEventListener()的第三个参数设置为true
* 一般情况下我们不会希望在捕获阶段触发事件,所以这个参数一般都是false
*
* - IE8及以下的浏览器中没有捕获阶段
*/
bind(box1,"click",function(){
alert("我是box1的响应函数")
});
bind(box2,"click",function(){
alert("我是box2的响应函数")
});
bind(box3,"click",function(){
alert("我是box3的响应函数")
});
};
function bind(obj , eventStr , callback){
if(obj.addEventListener){
//大部分浏览器兼容的方式
obj.addEventListener(eventStr , callback , true);
}else{
/*
* this是谁由调用方式决定
* callback.call(obj)
*/
//IE8及以下
obj.attachEvent("on"+eventStr , function(){
//在匿名函数中调用回调函数
callback.call(obj);
});
}
}
script>
head>
<body>
<div id="box1">
<div id="box2">
<div id="box3">div>
div>
div>
body>
html>
拖拽
1
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>title>
<style type="text/css">
#box1{
width: 100px;
height: 100px;
background-color: red;
position: absolute;
}
#box2{
width: 100px;
height: 100px;
background-color: yellow;
position: absolute;
left: 200px;
top: 200px;
}
style>
<script type="text/javascript">
window.onload = function(){
/*
* 拖拽box1元素
* - 拖拽的流程
* 1.当鼠标在被拖拽元素上按下时,开始拖拽 onmousedown
* 2.当鼠标移动时被拖拽元素跟随鼠标移动 onmousemove
* 3.当鼠标松开时,被拖拽元素固定在当前位置 onmouseup
*/
//获取box1
var box1 = document.getElementById("box1");
//为box1绑定一个鼠标按下事件
//当鼠标在被拖拽元素上按下时,开始拖拽 onmousedown
box1.onmousedown = function(event){
event = event || window.event;
//div的偏移量 鼠标.clentX - 元素.offsetLeft
//div的偏移量 鼠标.clentY - 元素.offsetTop
var ol = event.clientX - box1.offsetLeft;
var ot = event.clientY - box1.offsetTop;
//为document绑定一个onmousemove事件
document.onmousemove = function(event){
event = event || window.event;
//当鼠标移动时被拖拽元素跟随鼠标移动 onmousemove
//获取鼠标的坐标
var left = event.clientX - ol;
var top = event.clientY - ot;
//修改box1的位置
box1.style.left = left+"px";
box1.style.top = top+"px";
};
//为document绑定一个鼠标松开事件
document.onmouseup = function(){
//当鼠标松开时,被拖拽元素固定在当前位置 onmouseup
//取消document的onmousemove事件
document.onmousemove = null;
//取消document的onmouseup事件
document.onmouseup = null;
};
};
};
script>
head>
<body>
<div id="box1">div>
<div id="box2">div>
body>
html>
2
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>title>
<style type="text/css">
#box1{
width: 100px;
height: 100px;
background-color: red;
position: absolute;
}
#box2{
width: 100px;
height: 100px;
background-color: yellow;
position: absolute;
left: 200px;
top: 200px;
}
style>
<script type="text/javascript">
window.onload = function(){
/*
* 拖拽box1元素
* - 拖拽的流程
* 1.当鼠标在被拖拽元素上按下时,开始拖拽 onmousedown
* 2.当鼠标移动时被拖拽元素跟随鼠标移动 onmousemove
* 3.当鼠标松开时,被拖拽元素固定在当前位置 onmouseup
*/
//获取box1
var box1 = document.getElementById("box1");
var box2 = document.getElementById("box2");
//为box1绑定一个鼠标按下事件
//当鼠标在被拖拽元素上按下时,开始拖拽 onmousedown
box1.onmousedown = function(event){
//设置box1捕获所有鼠标按下的事件
/*
* setCapture()
* - 只有IE支持,但是在火狐中调用时不会报错,
* 而如果使用chrome调用,会报错
*/
/*if(box1.setCapture){
box1.setCapture();
}*/
box1.setCapture && box1.setCapture();
event = event || window.event;
//div的偏移量 鼠标.clentX - 元素.offsetLeft
//div的偏移量 鼠标.clentY - 元素.offsetTop
var ol = event.clientX - box1.offsetLeft;
var ot = event.clientY - box1.offsetTop;
//为document绑定一个onmousemove事件
document.onmousemove = function(event){
event = event || window.event;
//当鼠标移动时被拖拽元素跟随鼠标移动 onmousemove
//获取鼠标的坐标
var left = event.clientX - ol;
var top = event.clientY - ot;
//修改box1的位置
box1.style.left = left+"px";
box1.style.top = top+"px";
};
//为document绑定一个鼠标松开事件
document.onmouseup = function(){
//当鼠标松开时,被拖拽元素固定在当前位置 onmouseup
//取消document的onmousemove事件
document.onmousemove = null;
//取消document的onmouseup事件
document.onmouseup = null;
//当鼠标松开时,取消对事件的捕获
box1.releaseCapture && box1.releaseCapture();
};
/*
* 当我们拖拽一个网页中的内容时,浏览器会默认去搜索引擎中搜索内容,
* 此时会导致拖拽功能的异常,这个是浏览器提供的默认行为,
* 如果不希望发生这个行为,则可以通过return false来取消默认行为
*
* 但是这招对IE8不起作用
*/
return false;
};
};
script>
head>
<body>
我是一段文字
<div id="box1">div>
<div id="box2">div>
body>
html>
测试IE8
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>title>
<script type="text/javascript">
window.onload = function(){
//分别为两个按钮绑定单击响应函数
var btn01 = document.getElementById("btn01");
var btn02 = document.getElementById("btn02");
btn01.onclick = function(){
alert(1);
};
btn02.onclick = function(){
alert(2);
};
//设置btn01对鼠标按下相关的事件进行捕获
//当调用一个元素的setCapture()方法以后,这个元素将会把下一次所有的鼠标按下相关的事件捕获到自身上
btn01.setCapture();
};
script>
head>
<body>
<button id="btn01">按钮01button>
<button id="btn02">按钮02button>
body>
html>
3
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>title>
<style type="text/css">
#box1{
width: 100px;
height: 100px;
background-color: red;
position: absolute;
}
#box2{
width: 100px;
height: 100px;
background-color: yellow;
position: absolute;
left: 200px;
top: 200px;
}
style>
<script type="text/javascript">
window.onload = function(){
/*
* 拖拽box1元素
* - 拖拽的流程
* 1.当鼠标在被拖拽元素上按下时,开始拖拽 onmousedown
* 2.当鼠标移动时被拖拽元素跟随鼠标移动 onmousemove
* 3.当鼠标松开时,被拖拽元素固定在当前位置 onmouseup
*/
//获取box1
var box1 = document.getElementById("box1");
var box2 = document.getElementById("box2");
var img1 = document.getElementById("img1");
//开启box1的拖拽
drag(box1);
//开启box2的
drag(box2);
drag(img1);
};
/*
* 提取一个专门用来设置拖拽的函数
* 参数:开启拖拽的元素
*/
function drag(obj){
//当鼠标在被拖拽元素上按下时,开始拖拽 onmousedown
obj.onmousedown = function(event){
//设置box1捕获所有鼠标按下的事件
/*
* setCapture()
* - 只有IE支持,但是在火狐中调用时不会报错,
* 而如果使用chrome调用,会报错
*/
/*if(box1.setCapture){
box1.setCapture();
}*/
obj.setCapture && obj.setCapture();
event = event || window.event;
//div的偏移量 鼠标.clentX - 元素.offsetLeft
//div的偏移量 鼠标.clentY - 元素.offsetTop
var ol = event.clientX - obj.offsetLeft;
var ot = event.clientY - obj.offsetTop;
//为document绑定一个onmousemove事件
document.onmousemove = function(event){
event = event || window.event;
//当鼠标移动时被拖拽元素跟随鼠标移动 onmousemove
//获取鼠标的坐标
var left = event.clientX - ol;
var top = event.clientY - ot;
//修改box1的位置
obj.style.left = left+"px";
obj.style.top = top+"px";
};
//为document绑定一个鼠标松开事件
document.onmouseup = function(){
//当鼠标松开时,被拖拽元素固定在当前位置 onmouseup
//取消document的onmousemove事件
document.onmousemove = null;
//取消document的onmouseup事件
document.onmouseup = null;
//当鼠标松开时,取消对事件的捕获
obj.releaseCapture && obj.releaseCapture();
};
/*
* 当我们拖拽一个网页中的内容时,浏览器会默认去搜索引擎中搜索内容,
* 此时会导致拖拽功能的异常,这个是浏览器提供的默认行为,
* 如果不希望发生这个行为,则可以通过return false来取消默认行为
*
* 但是这招对IE8不起作用
*/
return false;
};
}
script>
head>
<body>
我是一段文字
<div id="box1">div>
<div id="box2">div>
<img src="img/an.jpg" id="img1" style="position: absolute;"/>
body>
html>
滚轮事件
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>title>
<style type="text/css">
#box1{
width: 100px;
height: 100px;
background-color: red;
}
style>
<script type="text/javascript">
window.onload = function(){
//获取id为box1的div
var box1 = document.getElementById("box1");
//为box1绑定一个鼠标滚轮滚动的事件
/*
* onmousewheel鼠标滚轮滚动的事件,会在滚轮滚动时触发,
* 但是火狐不支持该属性
*
* 在火狐中需要使用 DOMMouseScroll 来绑定滚动事件
* 注意该事件需要通过addEventListener()函数来绑定
*/
box1.onmousewheel = function(event){
event = event || window.event;
//event.wheelDelta 可以获取鼠标滚轮滚动的方向
//向上滚 120 向下滚 -120
//wheelDelta这个值我们不看大小,只看正负
//alert(event.wheelDelta);
//wheelDelta这个属性火狐中不支持
//在火狐中使用event.detail来获取滚动的方向
//向上滚 -3 向下滚 3
//alert(event.detail);
/*
* 当鼠标滚轮向下滚动时,box1变长
* 当滚轮向上滚动时,box1变短
*/
//判断鼠标滚轮滚动的方向
if(event.wheelDelta > 0 || event.detail < 0){
//向上滚,box1变短
box1.style.height = box1.clientHeight - 10 + "px";
}else{
//向下滚,box1变长
box1.style.height = box1.clientHeight + 10 + "px";
}
/*
* 使用addEventListener()方法绑定响应函数,取消默认行为时不能使用return false
* 需要使用event来取消默认行为event.preventDefault();
* 但是IE8不支持event.preventDefault();这个玩意,如果直接调用会报错
*/
event.preventDefault && event.preventDefault();
/*
* 当滚轮滚动时,如果浏览器有滚动条,滚动条会随之滚动,
* 这是浏览器的默认行为,如果不希望发生,则可以取消默认行为
*/
return false;
};
//为火狐绑定滚轮事件
bind(box1,"DOMMouseScroll",box1.onmousewheel);
};
function bind(obj , eventStr , callback){
if(obj.addEventListener){
//大部分浏览器兼容的方式
obj.addEventListener(eventStr , callback , false);
}else{
/*
* this是谁由调用方式决定
* callback.call(obj)
*/
//IE8及以下
obj.attachEvent("on"+eventStr , function(){
//在匿名函数中调用回调函数
callback.call(obj);
});
}
}
script>
head>
<body style="height: 2000px;">
<div id="box1">div>
body>
html>
键盘事件
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>title>
<script type="text/javascript">
window.onload = function(){
/*
* 键盘事件:
* onkeydown
* - 按键被按下
* - 对于onkeydown来说如果一直按着某个按键不松手,则事件会一直触发
* - 当onkeydown连续触发时,第一次和第二次之间会间隔稍微长一点,其他的会非常的快
* 这种设计是为了防止误操作的发生。
* onkeyup
* - 按键被松开
*
* 键盘事件一般都会绑定给一些可以获取到焦点的对象或者是document
*/
document.onkeydown = function(event){
event = event || window.event;
/*
* 可以通过keyCode来获取按键的编码
* 通过它可以判断哪个按键被按下
* 除了keyCode,事件对象中还提供了几个属性
* altKey
* ctrlKey
* shiftKey
* - 这个三个用来判断alt ctrl 和 shift是否被按下
* 如果按下则返回true,否则返回false
*/
//console.log(event.keyCode);
//判断一个y是否被按下
//判断y和ctrl是否同时被按下
if(event.keyCode === 89 && event.ctrlKey){
console.log("ctrl和y都被按下了");
}
};
/*document.onkeyup = function(){
console.log("按键松开了");
};*/
//获取input
var input = document.getElementsByTagName("input")[0];
input.onkeydown = function(event){
event = event || window.event;
//console.log(event.keyCode);
//数字 48 - 57
//使文本框中不能输入数字
if(event.keyCode >= 48 && event.keyCode <= 57){
//在文本框中输入内容,属于onkeydown的默认行为
//如果在onkeydown中取消了默认行为,则输入的内容,不会出现在文本框中
return false;
}
};
};
script>
head>
<body>
<input type="text" />
body>
html>
上下左右键控制div移动练习
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>title>
<style type="text/css">
#box1{
width: 100px;
height: 100px;
background-color: red;
position: absolute;
}
style>
<script type="text/javascript">
//使div可以根据不同的方向键向不同的方向移动
/*
* 按左键,div向左移
* 按右键,div向右移
* 。。。
*/
window.onload = function(){
//为document绑定一个按键按下的事件
document.onkeydown = function(event){
event = event || window.event;
//定义一个变量,来表示移动的速度
var speed = 10;
//当用户按了ctrl以后,速度加快
if(event.ctrlKey){
speed = 500;
}
/*
* 37 左
* 38 上
* 39 右
* 40 下
*/
switch(event.keyCode){
case 37:
//alert("向左"); left值减小
box1.style.left = box1.offsetLeft - speed + "px";
break;
case 39:
//alert("向右");
box1.style.left = box1.offsetLeft + speed + "px";
break;
case 38:
//alert("向上");
box1.style.top = box1.offsetTop - speed + "px";
break;
case 40:
//alert("向下");
box1.style.top = box1.offsetTop + speed + "px";
break;
}
};
};
script>
head>
<body>
<div id="box1">div>
body>
html>
BOM概述
DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title>title>
<script type="text/javascript">
/*
* BOM
* - 浏览器对象模型
* - BOM可以使我们通过JS来操作浏览器
* - 在BOM中为我们提供了一组对象,用来完成对浏览器的操作
* - BOM对象
* Window
* - 代表的是整个浏览器的窗口,同时window也是网页中的全局对象
* Navigator
* - 代表的当前浏览器的信息,通过该对象可以来识别不同的浏览器
* Location
* - 代表当前浏览器的地址栏信息,通过Location可以获取地址栏信息,或者操作浏览器跳转页面
* History
* - 代表浏览器的历史记录,可以通过该对象来操作浏览器的历史记录
* 由于隐私原因,该对象不能获取到具体的历史记录,只能操作浏览器向前或向后翻页
* 而且该操作只在当次访问时有效
* Screen
* - 代表用户的屏幕的信息,通过该对象可以获取到用户的显示器的相关的信息
*
*
* 这些BOM对象在浏览器中都是作为window对象的属性保存的,
* 可以通过window对象来使用,也可以直接使用
*
*
*/
//console.log(navigator);
//console.log(location);
//console.log(history);
/*
* Navigator
* - 代表的当前浏览器的信息,通过该对象可以来识别不同的浏览器
* - 由于历史原因,Navigator对象中的大部分属性都已经不能帮助我们识别浏览器了
* - 一般我们只会使用userAgent来判断浏览器的信息,
* userAgent是一个字符串,这个字符串中包含有用来描述浏览器信息的内容,
* 不同的浏览器会有不同的userAgent
*
* 火狐的userAgent
* Mozilla/5.0 (Windows NT 6.1; WOW64; rv:50.0) Gecko/20100101 Firefox/50.0
*
* Chrome的userAgent
* Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36
*
* IE8
* Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; WOW64; Trident/7.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; .NET4.0E)
*
* IE9
* Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/7.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; .NET4.0E)
*
* IE10
* Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; WOW64; Trident/7.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; .NET4.0E)
*
* IE11
* Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; .NET4.0E; rv:11.0) like Gecko
* - 在IE11中已经将微软和IE相关的标识都已经去除了,所以我们基本已经不能通过UserAgent来识别一个浏览器是否是IE了
*/
//alert(navigator.appName);
var ua = navigator.userAgent;
console.log(ua);
if(/firefox/i.test(ua)){
alert("你是火狐!!!");
}else if(/chrome/i.test(ua)){
alert("你是Chrome");
}else if(/msie/i.test(ua)){
alert("你是IE浏览器~~~");
}else if("ActiveXObject" in window){
alert("你是IE11,枪毙了你~~~");
}
/*
* 如果通过UserAgent不能判断,还可以通过一些浏览器中特有的对象,来判断浏览器的信息
* 比如:ActiveXObject
*/
/*if("ActiveXObject" in window){
alert("你是IE,我已经抓住你了~~~");
}else{
alert("你不是IE~~~");
}*/
/*alert("ActiveXObject" in window);*/
script>
head>
<body>
body>
html>
History对象
test01
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>title>
head>
<body>
<h1>TEST01h1>
<a href="test02.html">去test02a>
body>
html>
test02
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>title>
head>
<body>
<h1>TEST02h1>
<a href="02.History.html">去02.History.htmla>
body>
html>
History的使用
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>title>
<script type="text/javascript">
/*
* History
* - 对象可以用来操作浏览器向前或向后翻页
*/
window.onload = function(){
//获取按钮对象
var btn = document.getElementById("btn");
btn.onclick = function(){
/*
* length
* - 属性,可以获取到当成访问的链接数量
*/
//alert(history.length);
/*
* back()
* - 可以用来回退到上一个页面,作用和浏览器的回退按钮一样
*/
//history.back();
/*
* forward()
* - 可以跳转下一个页面,作用和浏览器的前进按钮一样
*/
//history.forward();
/*
* go()
* - 可以用来跳转到指定的页面
* - 它需要一个整数作为参数
* 1:表示向前跳转一个页面 相当于forward()
* 2:表示向前跳转两个页面
* -1:表示向后跳转一个页面
* -2:表示向后跳转两个页面
*/
history.go(-2);
};
};
script>
head>
<body>
<button id="btn">点我一下button>
<h1>Historyh1>
<a href="01.BOM.html">去BOMa>
body>
html>
location对象
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>title>
<script type="text/javascript">
/*
* Location
* - 该对象中封装了浏览器的地址栏的信息
*/
window.onload = function(){
//获取按钮对象
var btn = document.getElementById("btn");
btn.onclick = function(){
//如果直接打印location,则可以获取到地址栏的信息(当前页面的完整路径)
//alert(location);
/*
* 如果直接将location属性修改为一个完整的路径,或相对路径
* 则我们页面会自动跳转到该路径,并且会生成相应的历史记录
*/
//location = "http://www.baidu.com";
//location = "01.BOM.html";
/*
* assign()
* - 用来跳转到其他的页面,作用和直接修改location一样
*/
//location.assign("http://www.baidu.com");
/*
* reload()
* - 用于重新加载当前页面,作用和刷新按钮一样
* - 如果在方法中传递一个true,作为参数,则会强制清空缓存刷新页面
*/
//location.reload(true);
/*
* replace()
* - 可以使用一个新的页面替换当前页面,调用完毕也会跳转页面
* 不会生成历史记录,不能使用回退按钮回退
*/
location.replace("01.BOM.html");
};
};
script>
head>
<body>
<button id="btn">点我一下button>
<h1>Locationh1>
<input type="text" />
<a href="01.BOM.html">去BOMa>
body>
html>
定时调用
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>title>
<script type="text/javascript">
window.onload = function(){
//获取count
var count = document.getElementById("count");
//使count中的内容,自动切换
/*
* JS的程序的执行速度是非常非常快的
* 如果希望一段程序,可以每间隔一段时间执行一次,可以使用定时调用
*/
/*for(var i=0 ; i<10000 ; i++){
count.innerHTML = i;
alert("hello");
}*/
/*
* setInterval()
* - 定时调用
* - 可以将一个函数,每隔一段时间执行一次
* - 参数:
* 1.回调函数,该函数会每隔一段时间被调用一次
* 2.每次调用间隔的时间,单位是毫秒
*
* - 返回值:
* 返回一个Number类型的数据
* 这个数字用来作为定时器的唯一标识
*/
var num = 1;
var timer = setInterval(function(){
count.innerHTML = num++;
if(num == 11){
//关闭定时器
clearInterval(timer);
}
},1000);
//console.log(timer);
//clearInterval()可以用来关闭一个定时器
//方法中需要一个定时器的标识作为参数,这样将关闭标识对应的定时器
//clearInterval(timer);
};
script>
head>
<body>
<h1 id="count">h1>
body>
html>
切换图片练习
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>title>
<script type="text/javascript">
window.onload = function(){
/*
* 使图片可以自动切换
*/
//获取img标签
var img1 = document.getElementById("img1");
//创建一个数组来保存图片的路径
var imgArr = ["img/1.jpg","img/2.jpg","img/3.jpg","img/4.jpg","img/5.jpg"];
//创建一个变量,用来保存当前图片的索引
var index = 0;
//定义一个变量,用来保存定时器的标识
var timer;
//为btn01绑定一个单击响应函数
var btn01 = document.getElementById("btn01");
btn01.onclick = function(){
/*
* 目前,我们每点击一次按钮,就会开启一个定时器,
* 点击多次就会开启多个定时器,这就导致图片的切换速度过快,
* 并且我们只能关闭最后一次开启的定时器
*/
//在开启定时器之前,需要将当前元素上的其他定时器关闭
clearInterval(timer);
/*
* 开启一个定时器,来自动切换图片
*/
timer = setInterval(function(){
//使索引自增
index++;
//判断索引是否超过最大索引
/*if(index >= imgArr.length){
//则将index设置为0
index = 0;
}*/
index %= imgArr.length;
//修改img1的src属性
img1.src = imgArr[index];
},1000);
};
//为btn02绑定一个单击响应函数
var btn02 = document.getElementById("btn02");
btn02.onclick = function(){
//点击按钮以后,停止图片的自动切换,关闭定时器
/*
* clearInterval()可以接收任意参数,
* 如果参数是一个有效的定时器的标识,则停止对应的定时器
* 如果参数不是一个有效的标识,则什么也不做
*/
clearInterval(timer);
};
};
script>
head>
<body>
<img id="img1" src="img/1.jpg"/>
<br /><br />
<button id="btn01">开始button>
<button id="btn02">停止button>
body>
html>
移动div的优化
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>title>
<style type="text/css">
#box1{
width: 100px;
height: 100px;
background-color: red;
position: absolute;
}
style>
<script type="text/javascript">
//使div可以根据不同的方向键向不同的方向移动
/*
* 按左键,div向左移
* 按右键,div向右移
* 。。。
*/
window.onload = function(){
//定义一个变量,来表示移动的速度
var speed = 10;
//创建一个变量表示方向
//通过修改dir来影响移动的方向
var dir = 0;
//开启一个定时器,来控制div的移动
setInterval(function(){
/*
* 37 左
* 38 上
* 39 右
* 40 下
*/
switch(dir){
case 37:
//alert("向左"); left值减小
box1.style.left = box1.offsetLeft - speed + "px";
break;
case 39:
//alert("向右");
box1.style.left = box1.offsetLeft + speed + "px";
break;
case 38:
//alert("向上");
box1.style.top = box1.offsetTop - speed + "px";
break;
case 40:
//alert("向下");
box1.style.top = box1.offsetTop + speed + "px";
break;
}
},30);
//为document绑定一个按键按下的事件
document.onkeydown = function(event){
event = event || window.event;
//当用户按了ctrl以后,速度加快
if(event.ctrlKey){
speed = 500;
}else{
speed = 10;
}
//使dir等于按键的值
dir = event.keyCode;
};
//当按键松开时,div不再移动
document.onkeyup = function(){
//设置方向为0
dir = 0;
};
};
script>
head>
<body>
<div id="box1">div>
body>
html>
延时调用
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>title>
<script type="text/javascript">
var num = 1;
//开启一个定时器
/*setInterval(function(){
console.log(num++);
},3000);*/
/*
* 延时调用,
* 延时调用一个函数不马上执行,而是隔一段时间以后在执行,而且只会执行一次
*
* 延时调用和定时调用的区别,定时调用会执行多次,而延时调用只会执行一次
*
* 延时调用和定时调用实际上是可以互相代替的,在开发中可以根据自己需要去选择
*/
var timer = setTimeout(function(){
console.log(num++);
},3000);
//使用clearTimeout()来关闭一个延时调用
clearTimeout(timer);
script>
head>
<body>
body>
html>
定时器
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>title>
<style type="text/css">
*{
margin: 0;
padding: 0;
}
#box1{
width: 100px;
height: 100px;
background-color: red;
position: absolute;
left: 0;
}
style>
<script type="text/javascript">
window.onload = function(){
//获取box1
var box1 = document.getElementById("box1");
//获取btn01
var btn01 = document.getElementById("btn01");
//定义一个变量,用来保存定时器的标识
var timer;
//点击按钮以后,使box1向右移动(left值增大)
btn01.onclick = function(){
//关闭上一个定时器
clearInterval(timer);
//开启一个定时器,用来执行动画效果
timer = setInterval(function(){
//获取box1的原来的left值
var oldValue = parseInt(getStyle(box1,"left"));
//在旧值的基础上增加
var newValue = oldValue + 1;
//判断newValue是否大于800
if(newValue > 800){
newValue = 800;
}
//将新值设置给box1
box1.style.left = newValue + "px";
//当元素移动到800px时,使其停止执行动画
if(newValue == 800){
//达到目标,关闭定时器
clearInterval(timer);
}
},30);
};
};
/*
* 定义一个函数,用来获取指定元素的当前的样式
* 参数:
* obj 要获取样式的元素
* name 要获取的样式名
*/
function getStyle(obj , name){
if(window.getComputedStyle){
//正常浏览器的方式,具有getComputedStyle()方法
return getComputedStyle(obj , null)[name];
}else{
//IE8的方式,没有getComputedStyle()方法
return obj.currentStyle[name];
}
}
script>
head>
<body>
<button id="btn01">点击按钮以后box1向右移动button>
<br /><br />
<div id="box1">div>
<div style="width: 0; height: 1000px; border-left:1px black solid; position: absolute; left: 800px;top:0;">div>
body>
html>
定时器2
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>title>
<style type="text/css">
*{
margin: 0;
padding: 0;
}
#box1{
width: 100px;
height: 100px;
background-color: red;
position: absolute;
left: 0;
}
style>
<script type="text/javascript">
window.onload = function(){
//获取box1
var box1 = document.getElementById("box1");
//获取btn01
var btn01 = document.getElementById("btn01");
//获取btn02
var btn02 = document.getElementById("btn02");
//点击按钮以后,使box1向右移动(left值增大)
btn01.onclick = function(){
move(box1 , 800 , 10);
};
//点击按钮以后,使box1向左移动(left值减小)
btn02.onclick = function(){
move(box1 , 0 , 10);
};
};
//定义一个变量,用来保存定时器的标识
var timer;
//尝试创建一个可以执行简单动画的函数
/*
* 参数:
* obj:要执行动画的对象
* target:执行动画的目标位置
* speed:移动的速度(正数向右移动,负数向左移动)
*/
function move(obj , target ,speed){
//关闭上一个定时器
clearInterval(timer);
//获取元素目前的位置
var current = parseInt(getStyle(obj,"left"));
//判断速度的正负值
//如果从0 向 800移动,则speed为正
//如果从800向0移动,则speed为负
if(current > target){
//此时速度应为负值
speed = -speed;
}
//开启一个定时器,用来执行动画效果
timer = setInterval(function(){
//获取box1的原来的left值
var oldValue = parseInt(getStyle(obj,"left"));
//在旧值的基础上增加
var newValue = oldValue + speed;
//判断newValue是否大于800
//从800 向 0移动
//向左移动时,需要判断newValue是否小于target
//向右移动时,需要判断newValue是否大于target
if((speed < 0 && newValue < target) || (speed > 0 && newValue > target)){
newValue = target;
}
//将新值设置给box1
obj.style.left = newValue + "px";
//当元素移动到0px时,使其停止执行动画
if(newValue == target){
//达到目标,关闭定时器
clearInterval(timer);
}
},30);
}
/*
* 定义一个函数,用来获取指定元素的当前的样式
* 参数:
* obj 要获取样式的元素
* name 要获取的样式名
*/
function getStyle(obj , name){
if(window.getComputedStyle){
//正常浏览器的方式,具有getComputedStyle()方法
return getComputedStyle(obj , null)[name];
}else{
//IE8的方式,没有getComputedStyle()方法
return obj.currentStyle[name];
}
}
script>
head>
<body>
<button id="btn01">点击按钮以后box1向右移动button>
<button id="btn02">点击按钮以后box1向左移动button>
<br /><br />
<div id="box1">div>
<div style="width: 0; height: 1000px; border-left:1px black solid; position: absolute; left: 800px;top:0;">div>
body>
html>
定时器3
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>title>
<style type="text/css">
*{
margin: 0;
padding: 0;
}
#box1{
width: 100px;
height: 100px;
background-color: red;
position: absolute;
left: 0;
}
#box2{
width: 100px;
height: 100px;
background-color: yellow;
position: absolute;
left: 0;
top: 200px;
}
style>
<script type="text/javascript" src="js/tools.js">script>
<script type="text/javascript">
window.onload = function(){
//获取box1
var box1 = document.getElementById("box1");
//获取btn01
var btn01 = document.getElementById("btn01");
//获取btn02
var btn02 = document.getElementById("btn02");
//点击按钮以后,使box1向右移动(left值增大)
btn01.onclick = function(){
move(box1 ,"left", 800 , 20);
};
//点击按钮以后,使box1向左移动(left值减小)
btn02.onclick = function(){
move(box1 ,"left", 0 , 10);
};
//获取btn03
var btn03 = document.getElementById("btn03");
btn03.onclick = function(){
move(box2 , "left",800 , 10);
};
//测试按钮
var btn04 = document.getElementById("btn04");
btn04.onclick = function(){
//move(box2 ,"width", 800 , 10);
//move(box2 ,"top", 800 , 10);
//move(box2 ,"height", 800 , 10);
move(box2 , "width" , 800 , 10 , function(){
move(box2 , "height" , 400 , 10 , function(){
move(box2 , "top" , 0 , 10 , function(){
move(box2 , "width" , 100 , 10 , function(){
});
});
});
});
};
};
//定义一个变量,用来保存定时器的标识
/*
* 目前我们的定时器的标识由全局变量timer保存,
* 所有的执行正在执行的定时器都在这个变量中保存
*/
//var timer;
script>
head>
<body>
<button id="btn01">点击按钮以后box1向右移动button>
<button id="btn02">点击按钮以后box1向左移动button>
<button id="btn03">点击按钮以后box2向右移动button>
<button id="btn04">测试按钮button>
<br /><br />
<div id="box1">div>
<div id="box2">div>
<div style="width: 0; height: 1000px; border-left:1px black solid; position: absolute; left: 800px;top:0;">div>
body>
html>
轮播图
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>title>
<style type="text/css">
*{
margin: 0;
padding: 0;
}
/*
* 设置outer的样式
*/
#outer{
/*设置宽和高*/
width: 520px;
height: 333px;
/*居中*/
margin: 50px auto;
/*设置背景颜色*/
background-color: greenyellow;
/*设置padding*/
padding: 10px 0;
/*开启相对定位*/
position: relative;
/*裁剪溢出的内容*/
overflow: hidden;
}
/*设置imgList*/
#imgList{
/*去除项目符号*/
list-style: none;
/*设置ul的宽度*/
/*width: 2600px;*/
/*开启绝对定位*/
position: absolute;
/*设置偏移量*/
/*
* 每向左移动520px,就会显示到下一张图片
*/
left: 0px;
}
/*设置图片中的li*/
#imgList li{
/*设置浮动*/
float: left;
/*设置左右外边距*/
margin: 0 10px;
}
/*设置导航按钮*/
#navDiv{
/*开启绝对定位*/
position: absolute;
/*设置位置*/
bottom: 15px;
/*设置left值
outer宽度 520
navDiv宽度 25*5 = 125
520 - 125 = 395/2 = 197.5
* */
/*left: 197px;*/
}
#navDiv a{
/*设置超链接浮动*/
float: left;
/*设置超链接的宽和高*/
width: 15px;
height: 15px;
/*设置背景颜色*/
background-color: red;
/*设置左右外边距*/
margin: 0 5px;
/*设置透明*/
opacity: 0.5;
/*兼容IE8透明*/
filter: alpha(opacity=50);
}
/*设置鼠标移入的效果*/
#navDiv a:hover{
background-color: black;
}
style>
<script type="text/javascript" src="js/tools.js">script>
<script type="text/javascript">
window.onload = function(){
//获取imgList
var imgList = document.getElementById("imgList");
//获取页面中所有的img标签
var imgArr = document.getElementsByTagName("img");
//设置imgList的宽度
imgList.style.width = 520*imgArr.length+"px";
/*设置导航按钮居中*/
//获取navDiv
var navDiv = document.getElementById("navDiv");
//获取outer
var outer = document.getElementById("outer");
//设置navDiv的left值
navDiv.style.left = (outer.offsetWidth - navDiv.offsetWidth)/2 + "px";
//默认显示图片的索引
var index = 0;
//获取所有的a
var allA = document.getElementsByTagName("a");
//设置默认选中的效果
allA[index].style.backgroundColor = "black";
/*
点击超链接切换到指定的图片
点击第一个超链接,显示第一个图片
点击第二个超链接,显示第二个图片
* */
//为所有的超链接都绑定单击响应函数
for(var i=0; i<allA.length ; i++){
//为每一个超链接都添加一个num属性
allA[i].num = i;
//为超链接绑定单击响应函数
allA[i].onclick = function(){
//获取点击超链接的索引,并将其设置为index
index = this.num;
//切换图片
/*
* 第一张 0 0
* 第二张 1 -520
* 第三张 2 -1040
*/
//imgList.style.left = -520*index + "px";
//设置选中的a
setA();
//使用move函数来切换图片
move(imgList , "left" , -520*index , 20 , function(){
});
};
}
//创建一个方法用来设置选中的a
function setA(){
//遍历所有a,并将它们的背景颜色设置为红色
for(var i=0 ; i<allA.length ; i++){
allA[i].style.backgroundColor = "";
}
//将选中的a设置为黑色
allA[index].style.backgroundColor = "black";
};
};
script>
head>
<body>
<div id="outer">
<ul id="imgList">
<li><img src="img/1.jpg"/>li>
<li><img src="img/2.jpg"/>li>
<li><img src="img/3.jpg"/>li>
<li><img src="img/4.jpg"/>li>
<li><img src="img/5.jpg"/>li>
ul>
<div id="navDiv">
<a href="javascript:;">a>
<a href="javascript:;">a>
<a href="javascript:;">a>
<a href="javascript:;">a>
<a href="javascript:;">a>
div>
div>
body>
html>
轮播图
DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>title>
<style type="text/css">
*{
margin: 0;
padding: 0;
}
/*
* 设置outer的样式
*/
#outer{
/*设置宽和高*/
width: 520px;
height: 333px;
/*居中*/
margin: 50px auto;
/*设置背景颜色*/
background-color: greenyellow;
/*设置padding*/
padding: 10px 0;
/*开启相对定位*/
position: relative;
/*裁剪溢出的内容*/
overflow: hidden;
}
/*设置imgList*/
#imgList{
/*去除项目符号*/
list-style: none;
/*设置ul的宽度*/
/*width: 2600px;*/
/*开启绝对定位*/
position: absolute;
/*设置偏移量*/
/*
* 每向左移动520px,就会显示到下一张图片
*/
left: 0px;
}
/*设置图片中的li*/
#imgList li{
/*设置浮动*/
float: left;
/*设置左右外边距*/
margin: 0 10px;
}
/*设置导航按钮*/
#navDiv{
/*开启绝对定位*/
position: absolute;
/*设置位置*/
bottom: 15px;
/*设置left值
outer宽度 520
navDiv宽度 25*5 = 125
520 - 125 = 395/2 = 197.5
* */
/*left: 197px;*/
}
#navDiv a{
/*设置超链接浮动*/
float: left;
/*设置超链接的宽和高*/
width: 15px;
height: 15px;
/*设置背景颜色*/
background-color: red;
/*设置左右外边距*/
margin: 0 5px;
/*设置透明*/
opacity: 0.5;
/*兼容IE8透明*/
filter: alpha(opacity=50);
}
/*设置鼠标移入的效果*/
#navDiv a:hover{
background-color: black;
}
style>
<script type="text/javascript" src="js/tools.js">script>
<script type="text/javascript">
window.onload = function(){
//获取imgList
var imgList = document.getElementById("imgList");
//获取页面中所有的img标签
var imgArr = document.getElementsByTagName("img");
//设置imgList的宽度
imgList.style.width = 520*imgArr.length+"px";
/*设置导航按钮居中*/
//获取navDiv
var navDiv = document.getElementById("navDiv");
//获取outer
var outer = document.getElementById("outer");
//设置navDiv的left值
navDiv.style.left = (outer.offsetWidth - navDiv.offsetWidth)/2 + "px";
//默认显示图片的索引
var index = 0;
//获取所有的a
var allA = document.getElementsByTagName("a");
//设置默认选中的效果
allA[index].style.backgroundColor = "black";
/*
点击超链接切换到指定的图片
点击第一个超链接,显示第一个图片
点击第二个超链接,显示第二个图片
* */
//为所有的超链接都绑定单击响应函数
for(var i=0; i<allA.length ; i++){
//为每一个超链接都添加一个num属性
allA[i].num = i;
//为超链接绑定单击响应函数
allA[i].onclick = function(){
//关闭自动切换的定时器
clearInterval(timer);
//获取点击超链接的索引,并将其设置为index
index = this.num;
//切换图片
/*
* 第一张 0 0
* 第二张 1 -520
* 第三张 2 -1040
*/
//imgList.style.left = -520*index + "px";
//设置选中的a
setA();
//使用move函数来切换图片
move(imgList , "left" , -520*index , 20 , function(){
//动画执行完毕,开启自动切换
autoChange();
});
};
}
//开启自动切换图片
autoChange();
//创建一个方法用来设置选中的a
function setA(){
//判断当前索引是否是最后一张图片
if(index >= imgArr.length - 1){
//则将index设置为0
index = 0;
//此时显示的最后一张图片,而最后一张图片和第一张是一摸一样
//通过CSS将最后一张切换成第一张
imgList.style.left = 0;
}
//遍历所有a,并将它们的背景颜色设置为红色
for(var i=0 ; i<allA.length ; i++){
allA[i].style.backgroundColor = "";
}
//将选中的a设置为黑色
allA[index].style.backgroundColor = "black";
};
//定义一个自动切换的定时器的标识
var timer;
//创建一个函数,用来开启自动切换图片
function autoChange(){
//开启一个定时器,用来定时去切换图片
timer = setInterval(function(){
//使索引自增
index++;
//判断index的值
index %= imgArr.length;
//执行动画,切换图片
move(imgList , "left" , -520*index , 20 , function(){
//修改导航按钮
setA();
});
},3000);
}
};
script>
head>
<body>
<div id="outer">
<ul id="imgList">
<li><img src="img/1.jpg"/>li>
<li><img src="img/2.jpg"/>li>
<li><img src="img/3.jpg"/>li>
<li><img src="img/4.jpg"/>li>
<li><img src="img/5.jpg"/>li>
<li><img src="img/1.jpg"/>li>
ul>
<div id="navDiv">
<a href="javascript:;">a