CSS 、JS实现浪漫流星雨动画
建站知识 2021-07-03 07:54www.168986.cn长沙网站建设
1，效果图
2，源码
HTML
< body >
< div class = “container” >
< div id = “mask” > </ div >
< div id = “sky” > </ div >
< div id = “moon” > </ div >
< div id = “stars” > </ div >
< div class = “cloud cloud-1” ></ div >
<div class = “cloud cloud-2” > </ div >
< div class = “cloud cloud-3” > </ div >
</ div >
</ body >
CSS
/ - - - - - - 重启 - - - - - - /
{
保证金0 ;
填充0 ;
}
html，
body {
width100％ ;
最小宽度1000px ;
身高100％ ;
最小高度400px ;
溢出隐藏;
}
/ ------------画布------------ /
.container {
positionrelative;
身高100％ ;
}
/ 遮罩层 /
#mask {
positionabsolute;
宽度100％ ;
身高100％ ;
backgroundrgba（0,0,0，.8）;
z-index900 ;
}
/ 天空背景 /
#sky {
width100％ ;
身高100％ ;
background线性渐变（rgba（0,150,255,1），rgba（0,150,255，.8），rgba（0,150,255，.5））;
}
/ 月亮 /
#moon {
positionabsolute;
上50px ;
右200px ;
宽度120px ;
身高120px ;
背景rgba（251,255,25,0.938）;
border-radius50％ ;
box-shadow0 0 20px rgba（251,255,25,0.5）;
z-index9999 ;
}
/ 闪烁星星 /
.blink {
positionabsolute;
backgroundrgb（255,255,255）;
border-radius50％ ;
box-shadow0 0 5px rgb（255,255,255）;
不透明度0 ;
z-index10000 ;
}
/ 流星 /
.star {
positionabsolute;
不透明度0 ;
z-index10000 ;
}
.star :: after {
content“” ;
显示块;
边界坚固;
border-width2px 0 2px 80px ;
/ 流星随长度逐渐缩小 /
border-color透明透明透明rgba（255,255,255,1）;
border-radius2px 0 0 2px ;
transformrotate（-45deg）;
transform-origin0 0 0 ;
盒子阴影0 0 20px rgba（255,255,255，.3）;
}
/ 云 /
.cloud {
positionabsolute;
宽度100％ ;
身高100px ;
}
.cloud-1 {
bottom - 100px ;
z-index1000 ;
不透明度1 ;
变换规模（1.5）;
-webkit-transformscale（1.5）;
-moz-transformscale（1.5）;
-ms-transformscale（1.5）;
-o-transformscale（1.5）;
}
.cloud-2 {
left - 100px ;
底部 - 50px ;
z-index999 ;
不透明度。5 ;
变换旋转（7deg）;
-webkit-transformrotate（7deg）;
-moz-transformrotate（7deg）;
-ms-transformrotate（7deg）;
-o-transformrotate（7deg）;
}
.cloud-3 {
left120px ;
底部 - 50px ;
z-index999 ;
不透明度。1 ;
transformrotate（-10deg）;
-webkit-transformrotate（-10deg）;
-moz-transformrotate（-10deg）;
-ms-transformrotate（-10deg）;
-o-transformrotate（-10deg）;
}
.circle {
positionabsolute;
border-radius50％ ;
背景#fff ;
}
.circle-1 {
width100px ;
身高100px ;
上 - 50px ;
左10px ;
}
.circle-2 {
width150px ;
身高150px ;
上 - 50px ;
左30px ;
}
.circle-3 {
width300px ;
身高300px ;
上 - 100px ;
左80px ;
}
.circle-4 {
width200px ;
身高200px ;
上 - 60px ;
左300px ;
}
.circle-5 {
width80px ;
身高80px ;
上 - 30px ;
左450px ;
}
.circle-6 {
width200px ;
身高200px ;
上 - 50px ;
左500px ;
}
.circle-7 {
width100px ;
身高100px ;
上 - 10px ;
左650px ;
}
.circle-8 {
width50px ;
身高50px ;
上30px ;
左730px ;
}
.circle-9 {
width100px ;
身高100px ;
上30px ;
左750px ;
}
.circle-10 {
width150px ;
身高150px ;
上10px ;
左800px ;
}
.circle-11 {
width150px ;
身高150px ;
上 - 30px ;
左850px ;
}
.circle-12 {
width250px ;
身高250px ;
上 - 50px ;
左900px ;
}
.circle-13 {
width200px ;
身高200px ;
上 - 40px ;
左1000px ;
}
.circle-14 {
width300px ;
身高300px ;
上 - 70px ;
左1100px ;
}
JS
//流星动画
setInterval（function（） {
const obj = addChild（“#sky”，“div”，2，“star”）;
for（let i = 0 ; i <obj.children.length; i ++）{
const = -50 + Math .random（） 200 + “px”，
left = 200 + Math .random（） 1200 + “px”，
scale = 0.3 + Math .random（） 0.5 ;
const timer = 1000 + Math .random（） 1000 ;
obj.children [i] .style. = ;
obj.children [i] .style.left = left;
obj.children [i] .style.transform = `scale（$ {scale}）` ;
requestAnimation（{
eleobj.children [i]，
attr[ “”，“left”，“opacity” ]，
值[ 150，-150，.8 ]，
timetimer，
flagfalse，
fnfunction（） {
requestAnimation（{
ELEobj.children [I]，
ATTR“顶”，“左”，“不透明” ]，
值[ 150，-150，0 ]，
时间定时器，
标志假，
FN（） => {
obj.parent.removeChild（obj.children [I]）;
}
}）
}
}）;
}
}，1000）;
//闪烁星星动画
setInterval（function（） {
const obj = addChild（“#stars”，“div”，2，“blink”）;
for（let i = 0 ; i <obj.children.length; i ++）{
const = -50 + Math .random（） 500 + “px”，
left = 200 + Math .random（） 1200 + “px”，
round = 1 + Math .random（） 2 + “px” ;
const timer = 1000 + Math .random（） 4000 ;
obj.children [i] .style. = ;
obj.children [i] .style.left = left;
obj.children [i] .style.width = round;
obj.children [i] .style.height = round;
requestAnimation（{
eleobj.children [i]，
attr“opacity”，
值.5，
timetimer，
flagfalse，
fnfunction（） {
requestAnimation（{
eleobj.children [i]，
attr“opacity”，
value0，
timetimer，
flagfalse，
fnfunction（） {
obj.parent.removeChild（obj.children [I]）;
}
}）;
}
}）;
}
}，1000）;
//月亮移动
requestAnimation（{
ele“＃moon”，
attr“right”，
值1200，
时间10000000，
}）;
//添加云
const clouds = addChild（“。cloud”，“div”，14，“circle”，true）;
for（let i = 0 ; i <clouds.children.length; i ++）{
for（let j = 0 ; j <clouds.children [i] .length;）{
clouds.children [i] [j] .classList.add（`circle- $ {++ j} `）;
}
}
//云动画
let flag = 1 ;
的setInterval（
功能（） {
const clouds = document .querySelectorAll（“。cloud”）;
const left = Math .random（） 5 ;
bottom = Math .random（） 5 ;
let timer = 0 ;
for（let i = 0 ; i <clouds.length; i ++）{
requestAnimation（{
eleclouds [i]，
attr[ “left”，“bottom” ]，
valueflag％2？[-left，-bottom][left，bottom]，
timetimer + = 500，
flagfalse，
fnfunction（） {
requestAnimation（{
eleclouds [i]，
attr[ “left”，“bottom” ]，
valueflag％2？[left，bottom][ - left，-bottom]，
timetimer，
flagfalse
}）
}
}）;
}
标志++;
}，2000）
封装方法
// -------------------------------------------动画---- -----------------------------------------------
//运动动画，调用Tween.js
// eledom | 班级| id | 标签节点| 类名| id名| 标签名，只支持选择一个节点，类类名以及标签名只能选择页面中第一个
// attr属性属性名
//值目标值目标值
//时间持续时间持续时间
//补间定时function函数方程
// flagBoolean判断是按值移动还是按位置移动，默认按位置移动
// fncallback回调函数
//增加返回值将内部参数对象返回，可以通过设置返回对象的属性s为true打断动画
函数 requestAnimation（obj） {
// -------------------------------------参数设置---------------------------------------------
//默认属性
const参数= {
elenull，
attrnull，
valuenull，
time1000，
tween“linear”，
flagtrue，
sfalse，
fn“”
}
//合并传入属性
Object .assign（parameter，obj）; //覆盖重名属性
// -------------------------------------动画设置--------- ------------------------------------
//创建运动方程初始参数，方便复用
let start = 0 ; //用于保存初始时间戳
let target =（typeof parameter.ele === “string”？document .querySelector（parameter.ele）parameter.ele），//目标节点
attr = parameter.attr，//目标属性
beginAttr = parseFloat（getComputedStyle（target）[attr]），// attr起始值
value = parameter.value，//运动目标值
count = value - beginAttr，//实际运动值
time = parameter.time，//运动持续时间，
tween = parameter.tween，//运动函数
flag = parameter.flag，
callback = parameter.fn，//回调函数
curVal = 0 ; //运动当前值
//判断传入函数是否为数组，多段运动
（function（） {
if（attr instanceof Array）{
beginAttr = [];
count = [];
对于（让我的 ATTR）{
常量 VAL = parseFloat（的getComputedStyle（目标）[I]）;
beginAttr.push（VAL）;
count.push（value - val）;
}
}
if（value instanceof Array）{
for（let i in value）{
count [i] = value [i] - beginAttr [i];
}
}
}）（）;
//运动函数
功能 动画（时间戳） {
如果（parameter.s）返回 ; //打断
//存储初始时间戳
if（！start）start = timestamp;
//已运动时间
让 t =时间戳 - 开始;
//判断多段运动
if（beginAttr instanceof Array）{
// const len = beginAttr.length //存数组长度，复用
//多段运动第1类 - 多属性，同目标，间/不间
if（typeof count === “number”）{ //同目标
//间
if（typeof time === “number”）{
if（t> time）t = time; //判断是否超出目标值
//循环attr，分别赋值
为（let i in beginAttr）{
if（flag）curVal = Tween [tween]（t，beginAttr [i]，count，time）; //调用Tween，返回当前属性值，此时计算方法为移动到
写入位置else curVal = Tween [tween]（t，beginAttr [i]，count + beginAttr [i]，time）; //调用Tween，返回当前属性值，此时计算方法为移动了
写入距离if（attr [i] === “opacity”）target.style [attr [i]] = curVal; //给属性赋值
else target.style [attr [i]] = curVal + “px” ; //给属性赋值
if（t <time）requestAnimationFrame（animate）; //判断是否运动完
其他回调&& callback（）; //调用回调函数
}
回归 ;
}
//不间
if（time instanceof Array）{
//循环时间，attr，分别赋值
为（让我在 beginAttr中）{
//错误判断
if（！time [i] && time [i]！== 0）{
throw new Error（
“输入时间的长度不等于属性的长度”）;
}
//判断是否已经完成动画，完成则跳过此次循环
if（parseFloat（getComputedStyle（target）[attr [i]]）===（typeof value === “number”？valuevalue [i]） ）
继续 ;
// t =时间戳 - 开始; //每次循环初始化t
if（t> time [i]）t = time [i]; //判断是否超出目标值
if（flag || attr [i] === “opacity”）curVal = Tween [tween]（t，beginAttr [i]，count，i）; //调用Tween，返回当前属性值，此时计算方法为移动到
写入位置else curVal = Tween [tween]（t，beginAttr [i]，count + beginAttr [i]，i）; //调用Tween，返回当前属性值，此时计算方法为移动了
写入距离if（attr [i] === “opacity”）target.style [attr [i]] = curVal; //给属性赋值
else target.style [attr [i]] = curVal + “px” ; //给属性赋值
}
if（t < Math .max（... time））requestAnimationFrame（animate）; //判断函数是否运动完
其他回调&& callback（）; //如果已经执行完时间最长的动画，则调查回调函数
return ;
}
}
//多段运动第2类 - 多属性，不同目标，间/不间
if（count instanceof Array）{
//间
if（typeof time === “number”）{
if（t> time）t = time; //判断是否超出目标值
for（let i in beginAttr）{ //循环attr，count，分别赋值
//错误判断
if（！count [i] && count [i]！== 0）{
throw new Error（
“输入值的长度不是等于属性的长度“）;
}
if（flag || attr [i] === “opacity”）curVal = Tween [tween]（t，beginAttr [i]，count [i]，time）; //调用Tween，返回当前属性值，此时计算方法为移动到
写入位置else curVal = Tween [tween]（t，beginAttr [i]，count [i] + beginAttr [i]，time）; //调用Tween，返回当前属性值，此时计算方法为移动了
写入距离if（attr [i] === “opacity”）target.style [attr [i]] = curVal; //给属性赋值
else target.style [attr [i]] = curVal + “px” ; //给属性赋值
}
if（t <time）requestAnimationFrame（animate）; //判断函数是否运动完
其他回调&& callback（）; //如果已经执行完时间最长的动画，则调查回调函数
return ;
}
//不间
if（time instanceof Array）{
for（let i in beginAttr）{
//错误判断
if（！time [i] && time [i]！== 0）{
throw new Error（
“输入时间的长度）不等于属性的长度“）;
}
//判断是否已经完成动画，完成则跳过此次循环
if（parseFloat（getComputedStyle（target）[attr [i]]）===（typeof value === “number”？valuevalue [i]） ）
继续 ;
if（t> time [i]）t = time [i]; //判断是否超出目标值
//错误判断
if（！count [i] && count [i]！== 0）{
throw new Error（
“输入值的长度不等于属性的长度”）;
}
if（flag || attr [i] === “opacity”）curVal = Tween [tween]（t，beginAttr [i]，count [i]，time [i]）; //调用Tween，返回当前属性值，此时计算方法为移动到
写入位置其他 curVal = Tween [tween]（t，beginAttr [i]，count [i] + beginAttr [i]，time [i]） ; //调用Tween，返回当前属性值，此时计算方法为移动了
写入距离if（attr [i] === “opacity”）target.style [attr [i]] = curVal;
否则 target.style [attr [i]] = curVal + “px” ;
}
if（t < Math .max（... time））requestAnimationFrame（animate）;
else callback && callback（）;
回归 ;
}
}
}
//单运动模式
if（t> time）t = time;
if（flag || attr === “opacity”）curVal = Tween [tween]（t，beginAttr，count，time）; //调用Tween，返回当前属性值，此时计算方法为移动到
写入位置else curVal = Tween [tween]（t，beginAttr [i]，count + beginAttr，time）; //调用Tween，返回当前属性值，此时计算方法为移动了
写入距离if（attr === “opacity”）target.style [attr] = curVal;
否则 target.style [attr] = curVal + “px” ;
if（t <time）requestAnimationFrame（animate）;
else callback && callback（）;
}
requestAnimationFrame（动画）;
返回参数; //返回对象，供打断或其他用途
}
//Tween.js
/
t时间已过时间
b开始起始值
c计算总的运动值
d持续时间持续时间
曲线方程
http://.blogs./bluedream2009/archive/2010/06/19/1760909.html
/
让 Tween = {
linearfunction（t，b，c，d） { //匀速
返回 c t / d + b;
}，
easeInfunction（t，b，c，d） { //加速曲线
return c （t / = d） t + b;
}，
easeOutfunction（t，b，c，d） { //减速曲线
return -c （t / = d）（t - 2）+ b;
}，
easeBothfunction（t，b，c，d） { //加速减速曲线
if（（t / = d / 2）< 1）{
return c / 2 t t + b;
}
return -c / 2 （（ - t）（t - 2） - 1）+ b;
}，
easeInStrongfunction（t，b，c，d） { //加加速曲线
return c （t / = d） t t t + b;
}，
easeOutStrongfunction（t，b，c，d） { //减减曲线
返回 -c （（t = t / d - 1） t t t - 1）+ b;
}，
easeBothStrongfunction（t，b，c，d） { //加速减减速线
如果（（t / = d / 2）< 1）{
return c / 2 t t t t + b;
}
return -c / 2 （（t - = 2） t t t - 2）+ b;
}，
elasticInfunction（t，b，c，d，a，p） { //正弦衰减曲线（弹动渐入）
if（t === 0）{
return b;
}
if（（t / = d）== 1）{
return b + c;
}
if（！p）{
p = d 0.3 ;
}
if（！a || a < Math .abs（c））{
a = c;
var s = p / 4 ;
} else {
var s = p /（2 Math .PI） Math .asin（c / a）;
}
返回 - （A 数学 .pow（2，10 （T - = 1）） 数学 .sin（（T d - S）（2 数学 .PI）/ P））+ B;
}，
elasticOutfunction（t，b，c，d，a，p） { //正弦增强曲线（弹动渐出）
if（t === 0）{
return b;
}
if（（t / = d）== 1）{
return b + c;
}
if（！p）{
p = d 0.3 ;
}
if（！a || a < Math .abs（c））{
a = c;
var s = p / 4 ;
} else {
var s = p /（2 Math .PI） Math .asin（c / a）;
}
返回 a Math .pow（2，-10 t） Math .sin（（t d - s）（2 Math .PI）/ p）+ c + b;
}，
elasticBothfunction（t，b，c，d，a，p） {
if（t === 0）{
return b;
}
if（（t / = d / 2）== 2）{
return b + c;
}
if（！p）{
p = d （0.3 1.5）;
}
if（！a || a < Math .abs（c））{
a = c;
var s = p / 4 ;
} else {
var s = p /（2 Math .PI） Math .asin（c / a）;
}
如果（T < 1）{
返回 -0.5 （A 数学 .pow（2，10 （T - = 1））
数学 .sin（（T d - S）（2 数学 .PI）/ p））+ b;
}
返回 a Math .pow（2，-10 （t - = 1））
Math .sin（（t d - s）（2 Math .PI）/ p） 0.5 + c + b;
}，
backInfunction（t，b，c，d，s） { //回退加速（回退渐入）
if（typeof s == 'undefined'）{
s = 1.70158 ;
}
return c （t / = d） t （（s + 1） t - s）+ b;
}，
backOutfunction（t，b，c，d，s） {
if（typeof s == 'undefined'）{
s = 3.70158 ; //回缩的距离
}
return c （（t = t / d - 1） t （（s + 1） t + s）+ 1）+ b;
}，
backBothfunction（t，b，c，d，s） {
if（typeof s == 'undefined'）{
s = 1.70158 ;
}
if（（t / = d / 2）< 1）{
return c / 2 （t t （（（s =（1.525））+ 1） t - s））+ b;
}
return c / 2 （（t - = 2） t （（（s =（1.525））+ 1） t + s）+ 2）+ b;
}，
bounceInfunction（t，b，c，d） { //弹球渐出）
返回 c - Tween [ 'bounceOut' ]（d - t，0，c，d）+ b;
}，
bounceOutfunction（t，b，c，d） {
if（（t / = d）<（1 / 2.75））{
return c （7.5625 t t）+ b;
} else if（t <（2 / 2.75））{
return c （7.5625 （t - =（1.5 / 2.75）） t + 0.75）+ b;
} else if（t <（2.5 / 2.75））{
return c （7.5625 （t - =（2.25 / 2.75）） t + 0.9375）+ b;
}
return c （7.5625 （t - =（2.625 / 2.75）） t + 0.984375）+ b;
}，
bounceBoth函数（T，B，C，d） {
如果（T <d / 2）{
返回吐温[ 'bounceIn' ]（T 2，0，C，d） 0.5 + B;
}
return Tween [ 'bounceOut' ]（t 2 - d，0，c，d） 0.5 + c 0.5 + b;
}
}
// ------------------------------------------- DOM操作--- ------------------------------------------------
//添加节点
// ele父节点，支持输入变量，id值，类值，标签值。除变量外，其余值必须为字符串
//节点添加的标签名，值为字符串
// n节点添加个数
// className节点绑定的类名，值为字符串，多个类名用空格隔开
//布尔是否选中所有目标父节点。可选参数，不输入则判定为false，则只匹配选中的第一个节点
函数 addChild（ele，node，n，className，boolean） {
//获取节点
let parent = null ;
if（typeof ele！== “string”）parent = ele;
else if（ele [ 0 ] === “＃”）parent = document .getElementById（ele.slice（1））;
else if（ele [ 0 ] === “。”）{
if（boolean === false）parent = document .getElementsByClassName（ele.slice（1））[ 0 ];
else parent = document .getElementsByClassName（ele.slice（1））;
} else {
if（boolean === false）parent = docuemnt.getElementsByTagName（ele）[ 0 ];
else parent = document .getElementsByTagNameNS（ele）;
}
//声明用于存储父节点及子节点的对象
const obj = {
“parent”parent，
“children”[]
};
//添加节点
if（boolean）{
for（let i = 0 ; i <parent.length; i ++）{
//创建容器碎片
const fragment = document .createDocumentFragment（）;
//保存子节点，用于返回值
obj.children [i] = [];
for（let j = 0 ; j <n; j ++）{
const target = document .createElement（node）;
target.className = className;
fragment.appendChild（目标）;
//添加子节点到数组，用于返回值
obj.children [i] [j] =目标;
}
父[I] .appendChild（片段）
}
} else {
//创建碎片容器
const fragment = document .createDocumentFragment（）;
for（let i = 0 ; i <n; i ++）{
const target = document .createElement（node）;
target.className = className;
fragment.appendChild（目标）;
//添加子节点，用于返回值
obj.children [i] =目标;
}
//将碎片容器一次性添加到父节点
parent.appendChild（片段）;
}
//返回参数，供动画函数调用
return obj;
}
3，案例解析
HTML
由于节点很多，并且我想尽量做得逼真有趣有点，还给节点加了随机位置。所以节点的输出都是用JS控制的，HTML这边只写了几个父元素盒子，加上相应的ID名和类类名，结构相对简单。
CSS
CSS部分的难点就是流星的样式和用圈圈画云层，然后将云层堆叠出立体效果。
说一下流星的样式
#sky .star {
positionabsolute;
不透明度0 ;
z-index10000 ;
}
.star :: after {
content“” ;
显示块;
边界坚固;
border-width2px 0 2px 80px ;
/ 流星随长度逐渐缩小 /
border-color透明透明透明rgba（255,255,255,1）;
border-radius2px 0 0 2px ;
transformrotate（-45deg）;
transform-origin0 0 0 ;
盒子阴影0 0 20px rgba（255,255,255，.3）;
}
先提取了公共样式，添加定位属性;
然后在星后通过后伪类添加流星，用边界特性画
1）模型绘制border-width的顺序为四边，right，bottom，left，同理border-color的顺序也为四边，right，bottom，left。这样将border-width与border-color一一对应后，就能看出2px的是流星的宽度，80px是流星的长度，而0像素流星就是尾巴的这样就形成了一个。头部2px的宽，尾部0像素，长度80px的流星模型 ;
2）稍微逼真通过边界半径？给流星的头部增加个圆角，让它看起来更逼真通过roteta旋转一个角度，让它看起来像是往下掉;
3）增加闪光通过箱阴影给流星增加一点光晕，让它看起来有闪光的效果;
通过以上3步，一个流星就画好了。
然后是画云
因为云的代码比较长，这里就不贴出来了方法无非是通过一个一个的圆，相互叠加覆盖，完成一个云朵的形状。
完成一个云层之后，copy一个，然后多个云层通过rotate，opacity，left定位等，做出一个渐隐叠加的立体效果;
JS
JS部分以流星举例说明
setInterval（function（） {
const obj = addChild（“#sky”，“div”，2，“star”）; //插入流星
for（let i = 0 ; i <obj.children.length; i ++）{
//随机位置
const = -50 + Math .random（） 200 + “px”，
left = 200 + Math .random（） 1200 + “px”，
scale = 0.3 + Math .random（） 0.5 ;
const timer = 1000 + Math .random（） 1000 ;
obj.children [i] .style. = ;
obj.children [i] .style.left = left;
obj.children [i] .style.transform = `scale（$ {scale}）` ;
//添加动画
requestAnimation（{
eleobj.children [i]，
attr[ “”，“left”，“opacity” ]，
值[ 150，-150，.8 ]，
timetimer，
flagfalse，
fnfunction（） {
requestAnimation（{
ELEobj.children [I]，
ATTR“顶”，“左”，“不透明” ]，
值[ 150，-150，0 ]，
时间定时器，
标志假，
FN（） => {
obj.parent.removeChild（obj.children [I]）; //动画结束删除节点
}
}）
}
}）;
}
}，1000）;
这里边用到了我自己封装的两个方法，一个是基于requestAnimationFrame的requestAnimation，以及基于appendChild的addChild。
为了达成星星位置随机的效果，通过定时器的setInterval的不停插入与删除流星
，每次添加2个流星到页面，定时器的间隔时间小于流星的动画时间，这样就能保证页面中的流星的数量不是一个固定值，但肯定是大于2的。不然一次2个流星略显冷清;
然后，通过对循环（也可以用为式，换的，都行。对于-的最简单）给每个新添加到页面中的流星一个随机的位置（顶部，左侧），随机的大小（规模），随机的动画执行时间（定时器）;
，在用于循环中，给每个新添加到页面中的流星加上动画，并通过回调函数在执行完动画后删除节点。这里要注意的是，要动画分成两个阶段（出现与消失，主要是opacity控制）。我这里的处理，每个流星都移动相同的距离300px，这个距离我觉得也可以通过随机数控制，但我犯了个懒，就没有做。
4，小问题
目前我发现的问题有2个
一是DOM操作本身的问题页面不停的添加与删除节点，造成不停地。回流与重绘，很耗性能;
二是requestAnimationFrame本身的问题因为定时器不断在添加节点，而requestAnimationFrame的特性- 当离开当前页面去浏览其他页面时，动画会暂停。这就造成了一个问题，节点一直在加，但动画全在停那没有执行那么下次再回到这个页面的时候，就吊杆!!!动画就炸了，你会看到画面一卡，很多小蝌蚪集体出动去找妈妈。
5，
这个小案例虽然从难度上来看很简单，它可拓展性很高 - 比如表个白啊，寄个相思，耍个浪漫啊等等，用纯CSS也可以实现。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持狼蚁SEO。
上一篇：纯CSS表头固定的实现代码
下一篇：CSS未知高度垂直居中的实现
长沙网站设计
- 如何自己建一个网站 自己想建个网站,怎么建
- 如何制作网站免费建站 创建网站免费注册
- html简单网页代码 html简单网页代码超链接
- dreamweaver网页制作 dreamweaver网页制作模板
- 上海网站建设 上海网站建设制作微信
- 如何制作网站和网页 如何制作一个网页
- html网页制作代码大全 端午节html网页制作代码大
- app开发公司 app开发公司前十名
- html网页制作 html网页制作文字居中
- app制作一个需要多少钱 请人制作一个app多少钱
- 成都网站制作 成都网站制作维护
- 百度建一个网站多少钱 百度做个公司网站要多少
- html+css网页制作成品 web网页制作成品css+javascrip
- html网页制作案例 html网页设计案例
- html+css网页制作成品 web网页制作成品css+javascrip
- 个人网站模板 个人网站模板HTML