1.图片轮播基础之缓速轮播
◆使用封装的缓慢速动画来DIY滑动轮播图，也就是鼠标移动到123456这些数字上后，图片以缓慢速滑动的方式进行切换。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>使用封装的缓速动画制作滑动轮播图</title>
<style type="text/css">
body, ul, li, div, span, img {
padding: 0;
margin: 0;
}
img {
border: 0 none;
vertical-align: top;
}
.box {
width: 490px;
height: 170px;
padding: 5px;
border: 1px solid #f09;
margin: 100px auto;
}
.inner {
width: 490px;
height: 170px;
position: relative;
overflow: hidden;
cursor: pointer;
}
ul {
list-style: none;
width: 500%;
position: absolute;
left: 0;
}
li {
width: 490px;
height: 170px;
float: left;
}
.square {
position: absolute;
bottom: 10px;
right: 10px;
}
.square span {
display: inline-block;
width: 16px;
height: 16px;
line-height: 14px;
border: 1px solid #ccc;
background-color: #fff;
text-align: center;
margin-left: 5px;
cursor: pointer;
}
.square .current {
background-color: #f00;
color: #fff;
}
</style>
</head>
<body>
<div class="box">
<div class="inner" id="inner">
<ul>
<li><img src="images1/01.jpg"></li>
<li><img src="images1/02.jpg"></li>
<li><img src="images1/03.jpg"></li>
<li><img src="images1/04.jpg"></li>
<li><img src="images1/05.jpg"></li>
</ul>
<div class="square">
<span class="current">1</span>
<span>2</span>
<span>3</span>
<span>4</span>
<span>5</span>
</div>
</div>
</div>
<script>
//需求：当鼠标移动指定的索引时，切换到对应索引的图片（缓速动画）
//思路：当鼠标移动到指定的索引时，图片移动的距离（-索引*某张图片的实际宽度）
//步骤：
//1.获取事件源及相关对象
//2.绑定事件
//3.书写事件驱动程序
//1.获取事件源及相关对象
var inner = document.getElementById("inner");
var ul = inner.children[0];
var spanArr = inner.children[1].children;
//获取某张图片的实际宽度 图片框的宽度就是 一张图片的宽度
var imgWidth = inner.offsetWidth;
//2.绑定事件
for (var i = 0; i < spanArr.length; i++) {
//给每一个span绑定一个索引 因为图片移动的时候需要用
spanArr[i].index = i;
spanArr[i].onmouseover = function () {
//先处理span 给当前的span添加高亮样式
for (var j = 0; j < spanArr.length; j++) {
spanArr[j].className = "";
}
this.className = "current";
//开始移动ul
animateX(ul, -this.index * imgWidth);
}
}
//3.书写事件驱动程序
/**
* 功能：元素水平方向缓速移动
* @param element
* @param target
*/
function animateX(element, target) {
//使用定时器之前先清除定时器
clearInterval(element.timer);
//使用定时器
element.timer = setInterval(function () {
//获取步长 缓速的步长=（指定距离 -当前距离）/10
element.speed = (target - element.offsetLeft) / 10;
//二次计算步长 因为如果当步长为小数时 可能会导致 水取不尽 定时器永远停不下来
element.speed = element.speed > 0 ? Math.ceil(element.speed) : Math.floor(element.speed);
//判断 剩下的距离是否小于或者等于步长，如果是的话，
// 那就不需要再移动了，直接指定位置然后清除定时器
//判断要取绝对值，因为步长可负可正
if (Math.abs(target - element.offsetLeft) <= element.speed) {
element.style.left = target + "px";
clearInterval(element.timer);
return;
}
//如果剩下的距离不小于或者等于步长 那么就老老实实的缓速移动
element.style.left = element.offsetLeft + element.speed + "px";
}, 30);
}
</script>
</body>
</html>
◆使用封装的缓速动画来DIY左右轮播图，也就是点击左右按钮的时候，图片左右缓速切换。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>使用封装的缓速动画制作左右轮播图</title>
<style type="text/css">
body, ul, li, div, span, img {
padding: 0;
margin: 0;
}
img {
border: 0 none;
vertical-align: top;
}
.box {
width: 520px;
height: 280px;
padding: 5px;
border: 1px solid #f09;
margin: 100px auto;
}
.inner {
width: 520px;
height: 280px;
position: relative;
overflow: hidden;
cursor: pointer;
}
ul {
list-style: none;
width: 500%;
position: absolute;
left: 0;
}
li {
width: 520px;
height: 280px;
float: left;
}
/*鼠标移动到图片框时 就显示*/
.inner:hover .square {
display: block;
}
.square {
width: 100%;
position: absolute;
top: 50%;
margin-top: -20px;
display: none;
/*默认不显示*/
}
.square span {
display: block;
width: 30px;
height: 60px;
background-color: #fff;
font: 500 25px/60px "consolas";
text-align: center;
cursor: pointer;
color: #fff;
background-color: rgba(0, 0, 0, 0.3);
}
#sq-left {
float: left;
}
#sq-right {
float: right;
}
</style>
</head>
<body>
<div class="box">
<div class="inner" id="inner">
<ul>
<li><img src="images2/1.jpg"></li>
<li><img src="images2/2.jpg"></li>
<li><img src="images2/3.jpg"></li>
<li><img src="images2/4.jpg"></li>
<li><img src="images2/5.jpg"></li>
</ul>
<div class="square">
<span id="sq-left"><</span>
<span id="sq-right">></span>
</div>
</div>
</div>
<script>
//需求：当点击左右箭头时，切换到上一张或下一张图片，如果是第一张或者最后一张，则给出提示
//思路：点击左右箭头，图片的索引值++ 切换原理是移动图片 （-图片索引*图片实际的宽度）
//步骤：
//1.获取事件源及相关元素对象
//2.绑定事件
//3.书写事件驱动程序
//1.获取事件源及相关元素对象
var inner = document.getElementById("inner");
var ul = inner.firstElementChild || inner.firstChild;
var spleft = document.getElementById("sq-left");
var spright = document.getElementById("sq-right");
//2.绑定事件
var index = 0;//定义一个全局变量图片索引
spleft.onclick = function () {
//3.书写事件驱动程序
index--;//向左边切换
if (index < 0) {
index=0;
alert("已经是第一张了！");
return;
}
//移动
animateX(ul, -index * inner.offsetWidth);
}
spright.onclick = function () {
//3.书写事件驱动程序
index++;//向右边切换
if (index > ul.children.length-1) {
index=ul.children.length-1;
alert("已经是最后一张");
return;
}
//移动
animateX(ul, -index * inner.offsetWidth);
}
/**
* 功能：缓速移动元素
* @param element
* @param target
*/
function animateX(element, target) {
//使用定时器之前先清除定时器
clearInterval(element.timer);
//使用定时器
element.timer = setInterval(function () {
//获取步长：步长=（指定距离-当前距离）/10
element.speed = (target - element.offsetLeft) / 10;
//二次计算步长 防止有小数时 水取不尽而导致定时器永远不停
element.speed=element.speed>0?Math.ceil(element.speed):Math.floor(element.speed);
//判断 剩余的距离是否只剩一步之遥
//如果只剩一步之遥 就直接移动到指定位置 然后清除定时器
//因为 步长可正可负 所以取绝对值来比较
if(Math.abs(target - element.offsetLeft)<=Math.abs(element.speed)){
element.style.left=target+"px";
clearInterval(element.timer);
return;
}
//如果距离还很长 ，那就老老实实的缓速移动
element.style.left=element.offsetLeft+element.speed+"px";
}, 25);
}
</script>
</body>
</html>
◆ 使用封装的缓速动画来DIY无缝轮播图，轮播的本质就是来回移动图片的位置，无缝轮播其实是多加了一张图片在最后面，当你切换到最后一张图片时，最后一张图片再往后切换时，实际上会瞬间切换到第一张然后再继续切换缓速切换到第二张，因为最后一张和第一张一模一样，所以瞬间切换的过程根本看不出来，所以就像很完整的无缝轮播了。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>使用封装的缓速动画制作无缝轮播图</title>
<style type="text/css">
body, ul, ol, li, div, span, img {
padding: 0;
margin: 0;
}
img {
border: 0 none;
vertical-align: top;
}
.box {
width: 500px;
height: 200px;
padding: 5px;
border: 1px solid #f09;
margin: 100px auto;
}
.inner {
width: 500px;
height: 200px;
position: relative;
overflow: hidden;
/*cursor: pointer;*/
}
ul {
list-style: none;
width: 620%;
position: absolute;
left: 0;
}
ul li {
float: left;
}
/*鼠标移动到图片框时 就显示*/
.inner:hover .square {
display: block;
}
.square {
width: 100%;
position: absolute;
top: 50%;
margin-top: -20px;
display: none;
/*默认不显示*/
}
.square span {
display: block;
width: 30px;
height: 60px;
background-color: #fff;
font: 500 25px/60px "consolas";
text-align: center;
cursor: pointer;
color: #fff;
background-color: rgba(0, 0, 0, 0.3);
}
#sq-left {
float: left;
}
#sq-right {
float: right;
}
ol {
position: absolute;
bottom: 10px;
right: 10px;
}
ol li {
display: inline-block;
width: 16px;
height: 16px;
line-height: 14px;
font-size: 12px;
border: 1px solid #ccc;
background-color: #fff;
text-align: center;
margin-left: 5px;
cursor: pointer;
}
ol .current {
background-color: #f00;
color: #fff;
}
</style>
</head>
<body>
<div class="box">
<div class="inner" id="inner">
<ul>
<li><img src="images3/1.jpg"></li>
<li><img src="images3/2.jpg"></li>
<li><img src="images3/3.jpg"></li>
<li><img src="images3/4.jpg"></li>
<li><img src="images3/5.jpg"></li>
</ul>
<ol>
</ol>
<div class="square">
<span id="sq-left"><</span>
<span id="sq-right">></span>
</div>
</div>
</div>
<script>
//需求：
// ol的li根据ul中li动态生成
// 鼠标移入到ol中li时就切换到相应的图片
// 鼠标点击左右箭头时就切换图片
// 自动从左至右轮播图片
// 鼠标移动到图片框时，图片就不动了
// 要求实现无缝缓速轮播
//思路：
// 遍历ul中li 动态创建ol中li 添加到ol中去
// 克隆第一个li然后追加到ul中
// 给ol中li绑定事件 鼠标移入到哪一个li中就切换对应的图片 也就是移动ul的位置
// 鼠标点击左右箭头时 就切换对应的图片
// 设置定时器，图片隔段时间就自动切换
// 给图片框设置移入移出事件 移入就清除定时器 移出就开启定时器
// 无缝轮播的原理是 第一张和最后一张一样，
// 当移动到最后一张时，继续向下移动时就瞬间移动到第一张，
// 并且在此时还执行移动到第二张的动画，由于速度很快，所以看不出来，就像是无缝了。
//步骤：
//1.获取事件源及相关元素对象
//2.绑定事件
//3.书写事件驱动程序
//1.获取事件源及相关元素对象
var inner = document.getElementById("inner");
var ul = inner.firstElementChild || inner.firstChild;
var ol = inner.children[1];
var sqleft = document.getElementById("sq-left");
var sqright = document.getElementById("sq-right");
//遍历ul中li 动态创建ol中li 添加到ol中去
for (var i = 0; i < ul.children.length; i++) {
var li = document.createElement("li");
li.innerHTML = i + 1;
if (i == 0) {
li.className = "current";
}
ol.appendChild(li);
}
//克隆第一个li然后追加到ul中
ul.appendChild(ul.children[0].cloneNode(true));
//2.绑定事件
var lastIndex=0;
for (var i = 0; i < ol.children.length; i++) {
//给每一个li绑定索引
ol.children[i].index = i;
//绑定事件
ol.children[i].onmouseover = function () {
//3.书写事件驱动程序
//排他原则
for (var j = 0; j < ol.children.length; j++) {
ol.children[j].className = "";
}
//复活自己
this.className = "current";
// //如果你是从最后一张跳到第一张的话
// if(this.index==0&&lastIndex==ol.children.length-1){
// autoplay();
// //如果是从第一张跳到最后一张的话
// }else if(this.index==ol.children.length-1&&lastIndex==0){
// rautoplay();
// }else if(lastIndex-this.index==-1){
// autoplay();
// }else if(lastIndex-this.index==1)
// {
// rautoplay();
// }else{
//移动图片
animateX(ul, -this.index * inner.offsetWidth);
// for(var k=0;k<this.index;k++){
//
// }
// }
//给左右箭头切换时记住当前的图片索引
key = this.index;
//记录最后一次 切换的图片索引
lastIndex=key;
}
}
//左右箭头的单击事件
sqleft.onclick = function () {
rautoplay();
}
sqright.onclick = function () {
autoplay();
}
//正方向自动轮播
var key = 0;//切换记住图片的索引
function autoplay() {
key++;
if (key > ol.children.length) {
ul.style.left=0;
key = 1;
}
//移动图片
animateX(ul, -key * inner.offsetWidth);
////按左右箭头切换图片时 ol中的li样式也要跟着改变
//排他原则
for (var j = 0; j < ol.children.length; j++) {
ol.children[j].className = "";
}
//这个key是ul图片的索引，ul图片比方块儿多一张
// 所以这里是判断方块儿是否到了最大的极限了
if(key > ol.children.length-1) {
//复活自己
ol.children[0].className = "current";
}else {
//复活自己
ol.children[key].className = "current";
}
//记录最后一次 切换的图片索引
lastIndex=key;
}
//反方向自动轮播
function rautoplay() {
key--;
if (key < 0) {
//图片从第一张切换到最后一张 瞬间
ul.style.left = -ol.children.length * inner.offsetWidth + "px";
key = ol.children.length - 1;//动画的索引 切换到倒数第二张
}
//移动图片
animateX(ul, -key * inner.offsetWidth);
//按左右箭头切换图片时 ol中的li样式也要跟着改变
//排他原则
for (var j = 0; j < ol.children.length; j++) {
ol.children[j].className = "";
}
//复活自己
ol.children[key].className = "current";
//记录最后一次 切换的图片索引
lastIndex=key;
}
//自动轮播
var timer= setInterval(autoplay,1000);
//鼠标移入到图片框是 停止自动轮播
inner.onmouseover=function(){
clearInterval(timer);
}
//鼠标移出到图片框是 开始自动轮播
inner.onmouseout=function(){
timer= setInterval(autoplay,1000);
}
/**
* 功能：元素缓速移动的动画
* @param element
* @param target
*/
function animateX(element, target) {
//使用计时器之前先清除定时器
clearInterval(element.timer);
//使用定时器
element.timer = setInterval(function () {
//获取步长 缓速步长计算公式：步长=（指定位置-当前位置）/10
element.speed = (target - element.offsetLeft) / 10;
//二次计算步长 防止步长带有小数 导致水永远取不完 然后定时器永远都不会停
element.speed = element.speed > 0 ? Math.ceil(element.speed) : Math.floor(element.speed);
//判断指定的距离与当前的位置是否只剩一步之遥
//如果只剩一步之遥，那就直接移动到指定的位置，然后停止计时器
//由于步长可正可负，所以判断时要使用绝对值
if (Math.abs(target - element.offsetLeft) <= Math.abs(element.speed)) {
element.style.left = target + "px";
clearInterval(element.timer);
return;
}
//如果剩余的距离不止是一步之遥，那么老老实实的 缓速移动
element.style.left = element.offsetLeft + element.speed + "px";
}, 18);
}
</script>
</body>
</html>
2.使用缓速动画加scroll来DIY补充：楼层缓速跳跃
◆楼层缓速跳跃：同时设置html，body，ul，li的width:100%;height:100%，会让li继承占满一整页空间，因为这个时候html、body、ul、li的宽度和高度都是默认占满一整页，无论怎么放大缩小，都是默认占满一整页。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>楼层缓速跳跃</title>
<style type="text/css">
body, ul, li, ol {
margin: 0;
padding: 0;
}
html, body, ul, li {
width: 100%;
height: 100%;
}
ol {
list-style: none;
position: fixed;
left: 50px;
top: 180px;
}
ol li {
border: 1px solid #000;
width: 88px;
height: 88px;
line-height: 88px;
text-align: center;
margin-top: -1px;
cursor: pointer;
}
</style>
<script>
window.onload = function () {
//需求：给ol和ul中的li添加背景色
// 当点击ol中li时缓速跳转到对应的ul中li中，
// 也就是楼层跳转
//思路：创建一个数组，循环给每一个li添加背景色
// 给ol中的li添加单击事件，获取每一个对应的ul中li的距离上面的距离，然后设置缓速移动
//步骤：
//1.获取事件源及相关元素对象
//2.绑定事件
//3.书写事件驱动程序
//1.获取事件源及相关元素对象
var bgcolor = ["#f09", "#f00", "#0f0", "#ff0", "#909"];
var ul = document.getElementsByTagName("ul")[0];
var ol = document.getElementsByTagName("ol")[0];
//循环给每一个li添加背景色
for (var i = 0; i < bgcolor.length; i++) {
ul.children[i].style.backgroundColor = bgcolor[i];
ol.children[i].style.backgroundColor = bgcolor[i];
}
//2.绑定事件
for (var i = 0; i < ol.children.length; i++) {
//绑定索引
ol.children[i].index = i;
//绑定单击事件
ol.children[i].onclick = function () {
//每一次点击获取 对应ul中li被卷去的距离
var target = ul.children[this.index].offsetTop;
//使用定时器之前先清除定时器
clearInterval(ul.timer);
ul.timer = setInterval(function () {
//获取步长 缓速步长获取原理：步长=（指定位置-当前位置）/10
ul.speed = (target - scroll().top) / 10;
//二次计算步长
ul.speed = ul.speed > 0 ? Math.ceil(ul.speed) : Math.floor(ul.speed);
//判断指定位置与当前位置是否只剩一步之遥
//如果只剩一步之遥，那就直接移动到指定位置，然后清除定时器
//由于步长可正可负，所以要取绝对值
if (Math.abs(target - scroll().top) <= Math.abs(ul.speed)) {
window.scrollTo(0, target);
clearInterval(ul.timer);
return;
}
//如果不止一步之遥 就继续缓速移动
window.scrollTo(0, scroll().top + ul.speed);
}, 18);
}
}
//3.书写事件驱动程序
}
/**
* 功能：获取兼容性的scroll对象
* @returns {{left: (Number|number), top: (Number|number)}}
*/
function scroll() {
return {
left: window.pageXOffset || document.body.offsetLeft || document.documentElement.offsetLeft,
top: window.pageYOffset || document.body.offsetTop || document.documentElement.offsetTop
}
}
</script>
</head>
<body>
<ul>
<li>大仙女</li>
<li>大熊猫</li>
<li>大小熊</li>
<li>大考拉</li>
<li>大袋鼠</li>
</ul>
<ol>
<li>小仙女</li>
<li>小熊猫</li>
<li>小小熊</li>
<li>小考拉</li>
<li>小袋鼠</li>
</ol>
</body>
</html>
3.event对象
◆在触发dom上的某个事件的时候，会产生一个事件对象event，这个对象中包含着所有与事件有关的信息。所有浏览器都支持event，但支持的方式不同。例如操作鼠标时，就会添加鼠标位置的相关信息到事件对象中，普通浏览器支持event（传参数），但是IE678只支持 window.event(不传参数)
document.onclick=function(event){
//兼容性写法
event=event||window.event
console.log(event);
}
在IE678中，通过传参数的方式是无法获取到event对象的，只能够使用window.event，但是在一些主流浏览器上可以通过传递参数的方式获取event对象，所以以上的兼容性写法由此而来。
◆event对象的相关属性值
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>event对象</title>
</head>
<body>
<script>
/**
* 在触发dom上的某个事件的时候，会产生一个事件对象event，
这个对象中包含着所有与事件有关的信息。所有浏览器都支持
event，但支持的方式不同。例如操作鼠标时，就会添加鼠标位置
的相关信息到事件对象中，普通浏览器支持event（传参数），但
是IE678只支持 window.event(不传参数)
* @param event
*/
document.onclick = function (event) {
//兼容性写法
event = event || window.event;
console.log(event);
console.log(event.timeStamp)//：返回事件生成的日期和时间。
console.log(event.bubbles)//：返回布尔值，指示事件是否是起泡事件类型。
console.log(event.button)//：返回当事件被触发时，哪个鼠标按钮被点击。
console.log(event.pageX)//：光标相对于该网页的水平位置（ie无）
console.log(event.pageY)//：光标相对于该网页的垂直位置（ie无）
console.log(event.screenX)//光标相对于该屏幕的水平位置
console.log(event.screenY)//光标相对于该屏幕的垂直位置
console.log(event.target)//该事件被传送到的对象
console.log(event.type)//事件的类型
console.log(event.clientX)//光标相对于该网页的水平位置 （当前可见区域）
console.log(event.clientY)//光标相对于该网页的垂直位置
}
/**
* 在IE678中，通过传参数的方式是无法获取到event对象的，只
能够使用window.event，但是在一些主流浏览器上可以通过传递
参数的方式获取event对象，所以以上的兼容性写法由此而来
*/
</script>
</body>
</html>
4.pageY与screenY与clientY的区别
◆event对象的pageY和pageX、screenY和screenX、clientY和clientX都是很常用的属性。
◆pageY和pageX是以页面文档(0,0)为基准的，页面文档就是html区域，指的是整个html区域，无论html页面有多长
◆screenY和screenX是以屏幕(0,0)点为基准，屏幕就是你的显示器里的桌面
◆clientY和clientX是以浏览器（浏览器可视区域）的(0,0)点为基准，浏览器指的也是html区域，指的html区域是指当前可见的那部分的html区域
◆当页面被卷去的距离为0时，pageY和pageX与clientY和clientX是一样的，但是当页面被卷去的距离不为0时，pageY=clientY+scroll().scrollTop,pageX=clientX+scroll().scrollLeft，这就是以页面为基准和以浏览器为基准的区别，在IE678中不支持pageX和pageY这两个属性，所以只能通过pageY=clientY+scroll().scrollTop,pageX=clientX+scroll().scrollLeft来实现兼容，通过event对象获取鼠标位于页面文档的真实坐标，获取鼠标位于页面文档的真实坐标的兼容性写法
var pageX=event.pageX||event.clientX+scroll().scrollLeft;
var pageY=event.pageY||event.clientY+scroll().scrollTop;
◆
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>pageY与screenY与clientY的区别</title>
<style type="text/css">
body {
height: 5000px;
}
</style>
</head>
<body>
<script>
/**
* pageY和pageX是以页面文档(0,0)为基准的，
* screenY和screenX是以屏幕(0,0)点为基准，
* clientY和clientX是以浏览器（浏览器可视区域）的(0,0)点为基准，
* 屏幕就是你的显示器里的桌面，
* 页面文档就是html区域，
* 浏览器指的也是html区域，
* 但是不同的地方在于，
* 页面文档指的是整个html区域，无论html有多长，
* 而浏览器指的html区域是指当前可见的那部分的html区域，
* 所以当页面被卷去的距离为0时，
* pageY和pageX与clientY和clientX是一样的，
* 但是当页面被卷去的距离不为0时，
* pageY=clientY+scroll().scrollTop,
* pageX=clientX+scroll().scrollLeft，
* 这就是以页面为基准和以浏览器为基准的区别
*
* 在IE678中不支持pageX和pageY这两个属性，
* 所以只能通过
* pageY=clientY+scroll().scrollTop,
* pageX=clientX+scroll().scrollLeft
* 来实现兼容
* @param event
*/
document.onclick=function(event){
//兼容性写法
event=event || window.event;
console.log("以页面文档为基准：("+event.pageX+","+event.pageY+")");
console.log("以桌面屏幕为基准：("+event.screenX+","+event.screenY+")");
console.log("以浏览器可视为基准：("+event.clientX+","+event.clientY+")");
var pagey = event.pageY ||event.clientY+scroll().top;
var pagex= event.pageX || event.clientX+scroll().left;
console.log("以页面文档为基准的兼容性写法：("+pagex+","+pagey+")");
}
/**
* 功能：获取兼容性的scroll
*/
function scroll() {
return {
left: window.pageXOffset || document.body.scrollLeft || document.documentElement.scrollLeft,
top: window.pageYOffset || document.body.scrollTop || document.documentElement.scrollTop
}
}
</script>
</body>
</html>
5.使用event对象配合offset家族和scroll家族来DIY动画：鼠标点击后小图片缓速跟随的动画
◆鼠标点击后小图片缓速跟随的动画：鼠标每点击页面中某个位置，都会让这个小图片以缓速移动的方式移动到这个位置。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>鼠标点击后小图片缓速跟随的动画</title>
<style type="text/css">
img {
vertical-align: top;
border: 1px solid #000;
padding:10px 0;
position: absolute;
cursor: pointer;
}
</style>
</head>
<body>
<img src="data:image/jpeg;base64,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" width="100">
<script type="text/javascript">
//需求：当鼠标 点击页面时，小图片 缓速移动到鼠标点击的这个距离
//思路：鼠标点击时获取 相应的事件对象，获取当前的坐标值 然后 设置元素缓速移动的动画
//步骤：
//1.老三步：
// 获取事件源及相关元素对象、
// 绑定事件、
// 书写事件驱动程序
//2.新五步：
// 获取兼容性的事件对象、
// 获取兼容性的坐标值、
// 先清除定时器再开启定时器
// 设置缓素移动的步长然后二次加工步长、
// 判断是否符合要求然后清除定时器
//1.老三步：
// 获取事件源及相关元素对象、
var img = document.getElementsByTagName("img")[0];
// 绑定事件、
document.onclick = function (event) {
// 书写事件驱动程序
// 获取兼容性的事件对象、 在IE678中不支持传参 只支持window.event 但是其它浏览器支持传参
event = event || window.event;
// 获取兼容性的坐标值、在IE678中没有pageX和pageY
var targetY = event.pageY || event.clientY + scroll().top;
var targetX = event.pageX || event.clientX + scroll().left;
//附加需求：如果想要鼠标在图片正中间
// 鼠标点击后，图片默认左上角对着鼠标
// 直接让图片少移动自身的一半距离即可
targetX=Math.ceil(targetX-img.offsetWidth/2);//向上取整
targetY=Math.ceil(targetY-img.offsetHeight/2);//向上取整
//使用定时器之前先清除定时器
clearInterval(img.timer);
//开启定时器
img.timer = setInterval(function () {
//设置缓素移动的步长
img.speedX = (targetX - img.offsetLeft) / 10;//x轴的步长
img.speedY = (targetY - img.offsetTop) / 10;//y轴的步长
// 二次加工步长、
img.speedX = img.speedX > 0 ? Math.ceil(img.speedX) : Math.floor(img.speedX);
img.speedY = img.speedY > 0 ? Math.ceil(img.speedY) : Math.floor(img.speedY);
//判断x轴与y轴的指定位置是否都与当前位置相差一步之遥
//如果相差一步之遥那么就直接设置为指定位置然后清除定时器
//因为无论是y轴还是x轴的步长都可正可负，所以相比较时要取绝对值
if (
Math.abs(targetX - img.offsetLeft) <= Math.abs(img.speedX)
&&
Math.abs(targetY - img.offsetTop) <= Math.abs(img.speedY)
) {
img.style.left = targetX + "px";
img.style.top = targetY + "px";
clearInterval(img.timer);
return;
}
//如果 移动的距离并不是相差一步之遥 那么就继续缓速移动
img.style.left = img.offsetLeft+img.speedX + "px";
img.style.top = img.offsetTop+img.speedY + "px";
}, 18);
}
//2.新五步：
// 获取兼容性的事件对象、
// 获取兼容性的坐标值、
// 先清除定时器再开启定时器
// 设置缓素移动的步长然后二次加工步长、
// 判断是否符合要求然后清除定时器
/**
* 功能：获取兼容性的scroll
*/
function scroll() {
return {
left: window.pageXOffset || document.body.scrollLeft || document.documentElement.scrollLeft,
top: window.pageYOffset || document.body.scrollTop || document.documentElement.scrollTop
}
}
</script>
</body>
</html>
6.使用event对象配合offset家族和scroll家族来DIY动画补充一：指定区域图片放大镜
◆图片放大镜基础之获取小鼠标基于小盒子的坐标值
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>获取小鼠标基于小盒子的坐标值</title>
<style type="text/css">
div {
width: 300px;
height: 200px;
position: absolute;
left: 100px;
top: 100px;
/*border: 1px solid #000;*/
background-color: #f09;
font: 18px/30px "simsun";
text-align: center;
padding-top: 100px;
color: #fff;
}
</style>
</head>
<body>
<div>
鼠标位于盒子的x轴坐标值：100 px <br>
鼠标位于盒子的y轴坐标值：100 px <br>
</div>
<script>
//需求：当鼠标移入到盒子中时，开始计算鼠标位于盒子内部(0,0)点的坐标
//思路：先获取鼠标位于当前页面文档的坐标，
// 然后获取盒子位于当前文档的坐标，
// 二者相减就能够得到鼠标位于盒子内部的坐标值
//步骤：
//1.老三步
//获取事件源及相关对象
//绑定事件
//书写事件驱动程序
//获取事件源及相关对象
var div = document.getElementsByTagName("div")[0];
//绑定事件
div.onmousemove = function (event) {
//书写事件驱动程序
//获取兼容性的事件对象
event = event || window.event;
//获取兼容性的页面坐标对象
var pagex = event.pageX || event.clientX + scroll().left;
var pagey = event.pageY || event.clientY + scroll().top;
//获取盒子位于页面文档的坐标
var divx = div.offsetLeft;
var divy = div.offsetTop;
//计算鼠标位于盒子的坐标值
var mouseOfDivX = pagex - divx;
var mouseOfDivY = pagey - divy;
//防止数值造成的抖动
mouseOfDivX = mouseOfDivX < 10 ? "00" + mouseOfDivX : mouseOfDivX < 100 ? "0" + mouseOfDivX : mouseOfDivX;
mouseOfDivY = mouseOfDivY < 10 ? "00" + mouseOfDivY : mouseOfDivY < 100 ? "0" + mouseOfDivY : mouseOfDivY;
div.innerHTML = "鼠标位于盒子的x轴坐标值：" +
mouseOfDivX + " px <br>鼠标位于盒子的y轴坐标值：" +
mouseOfDivY + " px <br>";
}
/**
* 功能：获取兼容性的scroll
* @returns {{left: (Number|number), top: (Number|number)}}
*/
function scroll() {
return {
left: window.pageXOffset || document.body.scrollLeft || document.documentElement.scrollLeft,
top: window.pageYOffset || document.body.scrollTop || document.documentElement.scrollTop
}
}
</script>
</body>
</html>
◆图片放大镜进阶之鼠标区域性移动时显示放大镜效果：图片放大的比例计算公式：（大图片的实际宽度-大盒子的实际宽度）/(小盒子的实际宽度-遮盖层的实际宽度)，使用的原理是，让多余的部分进行对比，这样才能够更加准确的获取比例。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>鼠标区域性移动时显示放大镜效果</title>
<style type="text/css">
body, img, div {
margin: 0;
padding: 0;
}
img {
vertical-align: top;
border: 0 none;
}
.box {
width: 350px;
height: 350px;
border: 1px solid #f09;
position: relative;
margin-top: 150px;
margin-left: 100px;
}
.small {
width: 350px;
height: 350px;
position: relative;
}
.small .mask {
width: 175px;
height: 175px;
background-color: rgba(255, 200, 200, 0.3);
position: absolute;
left: 0;
top: 0;
cursor: move;
display: none;
}
.big {
width: 400px;
height: 400px;
position: absolute;
top: 0;
left: 360px;
border: 1px solid #0f0;
overflow: hidden;
display: none;
}
</style>
</head>
<body>
<div class="box" id="box">
<div class="small">
<img src="data:image/jpeg;base64,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"/>
<div class="mask"></div>
</div>
<div class="big">
<img src="data:image/jpeg;base64,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" />
</div>
</div>
<script>
//需求：
// 1.当鼠标移入到small盒子中时 显示mask层也显示big盒子，移出时不显示mask层也不显示big盒子
// 2.当鼠标在small盒子中移动时 mask层也跟着移动
// 3.当mask层移动时big盒子中的图片也随之移动，即呈现放大效果
//思路：
// 1.设置small盒子的鼠标移入移出事件，给mask盒子和big盒子设置显示的样式或者隐藏的样式
// 2.设置small盒子的鼠标移动事件，鼠标在small盒子中移动时就获取鼠标在盒子中的坐标，
// 然后赋值给mask盒子，最后给mask盒子设置可移动的坐标边界，防止mask出界了
// 3.计算small中的图片和遮盖层的比例和big中的图片与big盒子的比例，
// 根据比例来计算mask层移动时big层中的图片应该移动的距离。
//步骤：
//1.获取事件源及相关对象
//2.绑定事件
//3.书写事件驱动程序
//1.获取事件源及相关对象
var box = document.getElementById("box");
var small = box.children[0];
var mask = small.children[1];
var big = box.children[1];
var bigImg = big.children[0];
//2.绑定事件
//设置small盒子的鼠标移入移出事件，给mask盒子和big盒子设置显示的样式或者隐藏的样式
//移入
small.onmouseover = function () {
//3.书写事件驱动程序
show(mask);
show(big);
}
//移出
small.onmouseout = function () {
//3.书写事件驱动程序
hide(mask);
hide(big);
}
//移动
//设置small盒子的鼠标移动事件，鼠标在small盒子中移动时就获取鼠标在盒子中的坐标
small.onmousemove = function (event) {
//获取兼容性的 event
event = event || window.event;
//获取兼容性的坐标位置
var pagex = event.pageX || event.clientX + scroll().left;
var pagey = event.pageY || event.clientY + scroll().top;
//获取鼠标位于盒子的坐标 并且设置鼠标在遮盖层的中间显示
var mouseOfSamllX = Math.ceil(pagex - box.offsetLeft - mask.offsetWidth / 2);
var mouseOfSamllY = Math.ceil(pagey - box.offsetTop - mask.offsetHeight / 2);
//最后给mask盒子设置可移动的坐标边界，防止mask出界了
if (mouseOfSamllX < 0) {
mouseOfSamllX = 0;
}
if (mouseOfSamllX > small.offsetWidth - mask.offsetWidth) {
mouseOfSamllX = small.offsetWidth - mask.offsetWidth;
}
if (mouseOfSamllY < 0) {
mouseOfSamllY = 0;
}
if (mouseOfSamllY > small.offsetHeight - mask.offsetHeight) {
mouseOfSamllY = small.offsetHeight - mask.offsetHeight;
}
//然后赋值给mask盒子
mask.style.left = mouseOfSamllX + "px";
mask.style.top = mouseOfSamllY + "px";
//计算small中的图片和遮盖层的比例和big中的图片与big盒子的比例
//比例公式：（大图片的实际宽度-大盒子的实际宽度）/(小盒子的实际宽度-遮盖层的实际宽度)
//原理：也就是让多余的部分进行对比，从而产生精确的比例
var bili = (bigImg.offsetWidth - big.offsetWidth) / (small.offsetWidth - mask.offsetWidth);
bigImg.style.marginLeft = -mouseOfSamllX * bili + "px";
bigImg.style.marginTop = -mouseOfSamllY * bili + "px";
}
//显示
function show(element) {
element.style.display = "block";
}
//隐藏
function hide(element) {
element.style.display = "none";
}
//获取兼容性的scroll对象
function scroll() {
return {
left: window.pageXOffset || document.body.scrollLeft || document.documentElement.scrollLeft,
top: window.pageYOffset || document.body.scrollTop || document.documentElement.scrollTop
}
}
</script>
</body>
</html>
7.使用event对象配合offset家族和scroll家族来DIY动画补充二：鼠标拖拽自定义的确认框移动+模拟自定义的窗体滚动条滚动
◆鼠标拖拽自定义的确认框移动：这个确认框有一点点好看，之前文章说的制作无限弹窗，这个demo中有提到过一小部分，把代码一解注释就会出现效果了。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>鼠标拖拽自定义的确认框移动</title>
<style type="text/css">
.dialog {
width: 360px;
height: 210px;
border: 4px solid #903;
/*颜色 x轴阴影偏移 y轴阴影偏移 模糊半径 阴影半径*/
box-shadow: #901 0px 0px 50px 5px;
position: absolute;
left: 0;
top: 0;
}
.title {
height: 30px;
background-color: #901;
padding-left: 20px;
color: #fff;
font: 600 15px/27px "microsoft";
cursor: move;
}
.content {
height: 180px;
background-color: #ffe;
}
.cont-top {
height: 100px;
text-align: center;
font: 600 20px/100px "microsoft";
color: #902;
}
.cont-top:hover {
color: #e00;
}
.cont-bottom {
height: 120px;
text-align: left;
}
.cont-bottom b {
display: inline-block;
width: 100px;
height: 30px;
margin-left: 50px;
border: 2px solid #901;
text-align: center;
color: #901;
font: 600 15px/30px "microsoft";
cursor: pointer;
background-color: #ffd;
}
b:hover {
background-color: #fff;
border-color: #d00;
color: #e00;
}
</style>
</head>
<body>
<div class="dialog" id="dialog">
<div class="title">提示框</div>
<div class="content">
<div class="cont-top">你真的真的真的要关闭吗？</div>
<div class="cont-bottom">
<b>狠心关掉</b><b>让它待着</b>
</div>
</div>
</div>
<script>
//需求：当鼠标移动到标题部分时，鼠标按下然后移动时，窗体也跟着移动
//思路：给提示框title添加鼠标按下的事件，获取鼠标为与当前盒子的坐标，
// 然后再设置鼠标移动事件，然后再获取鼠标位于当前页面的坐标，
// 之后后设置left top属性即可，鼠标放下时，
// 就清除已经设置的鼠标移入事件
//步骤：
//1.获取事件源及相关元素对象
//2.绑定事件
//3.书写事件驱动程序
//1.获取事件源及相关元素对象
var dialog = document.getElementById("dialog");
var title = dialog.children[0];
//2.绑定事件
title.onmousedown = function (event) {
//获取兼容性的事件对象
event = event || window.event;
//获取兼容性的鼠标坐标对象
var pageY = event.pageY || event.clientY + scroll().top;
var pageX = event.pageX || event.clientX + scroll().left;
//获取鼠标位于当前盒子中的位置
var mouseOfDialogY = pageY - dialog.offsetTop;
var mouseOfDialogX = pageX - dialog.offsetLeft;
document.onmousemove = function (event) {
//获取兼容性的事件对象
//获取兼容性的事件对象
event = event || window.event;
//获取兼容性的鼠标坐标对象
var pageY = event.pageY || event.clientY + scroll().top;
var pageX = event.pageX || event.clientX + scroll().left;
//获取移动后的盒子的坐标位置
var dialogY = pageY - mouseOfDialogY;
var dialogX = pageX - mouseOfDialogX;
// 下面的盒子是弄着玩儿的 页面会出现无数的提示框 有点好玩儿
// var newDialog = dialog.cloneNode(true);
// document.body.appendChild(newDialog);
// newDialog.style.left = dialogX + "px";
// newDialog.style.top = dialogY + "px";
//设置当前盒子的坐标位置
dialog.style.left = dialogX + "px";
dialog.style.top = dialogY + "px";
//清除选中文字
window.getSelection ?
window.getSelection().removeAllRanges() :
document.selection.empty();
}
title.onmouseup = function () {
document.onmousemove = null;
}
}
//3.书写事件驱动程序
//获取兼容性的scroll对象
function scroll() {
return {
left: window.pageXOffset || document.body.scrollLeft || document.documentElement.scrollLeft,
top: window.pageYOffset || document.body.scrollTop || document.documentElement.scrollTop
}
}
</script>
</body>
</html>
◆模拟自定义的窗体滚动条滚动
◇动态设置滚动条的滑块儿的长度，公式：可见的内容的高度/内容的高度*可见的内容的高度。
◇清除选中的内容：
△window.getSelection().removeAllRanges();在IE9及以上等其它主流浏览器支持这种清除选中内容的方式，如IE9、Firefox、Safari、Chrome和Opera支持window.getSelection().removeAllRanges();
△ocument.selection.empty();IE9以下支持这种清除选中的内容的方式。
△兼容性写法：window.getSelection?window.getSelection().removeAllRanges():document.selection.empty();
◇这个窗体有一点点好看，不仅有滑块儿，还可以移动窗体，是一个综合性的demo。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>模拟自定义的窗体滚动条滚动</title>
<style type="text/css">
.dialog {
width: 600px;
height: 500px;
border: 4px solid #903;
/*颜色 x轴阴影偏移 y轴阴影偏移 模糊半径 阴影半径*/
box-shadow: #901 0px 0px 50px 5px;
position: absolute;
left: 320px;
top: 50px;
}
.title {
height: 30px;
background-color: #901;
padding-left: 20px;
color: #fff;
font: 600 15px/27px "microsoft";
cursor: move;
}
.container {
height: 470px;
width: 566px;
overflow: hidden;
}
.content {
padding: 15px;
background-color: #ffe;
text-align: left;
font: 600 15px/25px "microsoft";
color: #902;
}
.content:hover {
color: #e00;
}
#scroll {
height: 470px;
width: 30px;
border-left: 4px solid #a01;
/*border-right: 2px solid #a01;*/
position: absolute;
right: 0;
bottom: 0;
background-color: #fbb;
}
#bar {
width: 30px;
height: 150px;
background-color: #501;
border-radius: 6px;
cursor: pointer;
box-shadow: #f02 0px 0px 50px 6px;
position: absolute;
left: 0;
top: 0;
}
#bar:hover {
background-color: #301;
}
</style>
<script>
//需求：当点击滚动条之后，往下滑动时，页面的内容也会对应的滑动
//思路：设置滚动条的鼠标按下的事件，
// 设置鼠标移动事件，
// 设置滚动条可移动的范围，
// 设置页面内容的的margin即可
//步骤：
//1.获取事件源及相关元素对象
//2.绑定事件
//3.书写事件驱动程序
window.onload = function () {
//1.获取事件源及相关元素对象
var dialog = document.getElementById("dialog");
var container = dialog.children[1]
var contentObj = container.children[0];
var scrollObj = document.getElementById("scroll");
var bar = document.getElementById("bar");
//2.绑定事件
bar.onmousedown = function (event) {
//获取兼容性的事件对象
event = event || window.event;
//获取兼容性的坐标值
var pageY = event.pageY || event.clientY + scroll().top;
// var pageX = event.pageX || event.clientX + scroll().left;
//获取当前鼠标位于scroll条的位置 只需要一个y轴的坐标值
var mouseOfScollY = pageY - bar.offsetTop;
document.onmousemove = function (event) {
//获取兼容性的事件对象
event = event || window.event;
//获取兼容性的坐标值
var pageY = event.pageY || event.clientY + scroll().top;
//获取滚动条的位置坐标
var barY = pageY - mouseOfScollY;
//设置一下约束 防止滑块儿抛出滚动条内部
if (barY < 0) {
barY = 0;
}
if (barY > scrollObj.offsetHeight - bar.offsetHeight) {
barY = scrollObj.offsetHeight - bar.offsetHeight;
}
//设置bar的坐标值
bar.style.top = barY + "px";
//开始设置页面内容了
//等比例公式：（内容的高度-可见的内容的高度）/（滚动条的高度-滑块儿的高度）
var bili = (contentObj.offsetHeight - container.offsetHeight) /
(scrollObj.offsetHeight - bar.offsetHeight);
//计算页面内容需要移动的距离
var marginY = -barY * bili;
//开始移动
contentObj.style.marginTop = marginY + "px";
//取消选中
window.getSelection ? window.getSelection().removeAllRanges()
: document.selection.empty();
}
}
//鼠标移入的事件
bar.onmouseup = function () {
document.onmousemove = null;
}
//动态设置滚动条的滑块儿的长度
//公式：可见的内容的高度/内容的高度*可见的内容的高度
var barHeight = container.offsetHeight / contentObj.offsetHeight * container.offsetHeight;
bar.style.height = barHeight + "px";
////////////新增移动会话框部分
var title = dialog.children[0];
//2.绑定事件
title.onmousedown = function (event) {
//获取兼容性的事件对象
event = event || window.event;
//获取兼容性的鼠标坐标对象
var pageY = event.pageY || event.clientY + scroll().top;
var pageX = event.pageX || event.clientX + scroll().left;
//获取鼠标位于当前盒子中的位置
var mouseOfDialogY = pageY - dialog.offsetTop;
var mouseOfDialogX = pageX - dialog.offsetLeft;
document.onmousemove = function (event) {
//获取兼容性的事件对象
//获取兼容性的事件对象
event = event || window.event;
//获取兼容性的鼠标坐标对象
var pageY = event.pageY || event.clientY + scroll().top;
var pageX = event.pageX || event.clientX + scroll().left;
//获取移动后的盒子的坐标位置
var dialogY = pageY - mouseOfDialogY;
var dialogX = pageX - mouseOfDialogX;
// 下面的盒子是弄着玩儿的 页面会出现无数的提示框 有点好玩儿
// var newDialog = dialog.cloneNode(true);
// document.body.appendChild(newDialog);
// newDialog.style.left = dialogX + "px";
// newDialog.style.top = dialogY + "px";
//设置当前盒子的坐标位置
dialog.style.left = dialogX + "px";
dialog.style.top = dialogY + "px";
//清除选中文字
window.getSelection ?
window.getSelection().removeAllRanges() :
document.selection.empty();
}
title.onmouseup = function () {
document.onmousemove = null;
}
}
}
//获取兼容性的scroll对象
function scroll() {
return {
left: window.pageXOffset || document.body.scrollLeft || document.documentElement.scrollLeft,
top: window.pageYOffset || document.body.scrollTop || document.documentElement.scrollTop
}
}
</script>
</head>
<body>
<div class="dialog" id="dialog">
<div class="title">会话框</div>
<div class="container">
<div class="content">
--------------------------开始--------------------------。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
横看成林侧成峰，远近高低各不同。横看成林侧成峰，远近高低各不同。<br>
--------------------------结束--------------------------。<br>
</div>
</div>
<div id="scroll">
<div id="bar"></div>
</div>
</div>
</body>
</html>
