日志 – 淡紫色的茶几

60行JavaScript代码俄罗斯方块游戏解析

总结起来主要是以下三点

1.使用eval来产生JavaScript代码，减小了代码体积
2.以字符串作为游戏场景数据，使用正则表达式做查找和匹配，省去了通常应当手动编写的查找验证代码
3.以二进制方式管理俄罗斯方块数据和场景数据，通过位运算简化比较和验证
另外，原作者代码换行很少，代码写的比较紧凑，这也是导致这个程序仅仅只有60行的一个原因。

下面给出经过我排版注释后的代码。

  1 <!doctype html>  
  2 <html>
  3     <head>
  4         <title>俄罗斯方块</title>
  5     </head>
  6     
  7     <body>  
  8         <div id = "box"
  9              style = "margin : 20px auto;
 10                       text-align : center;
 11                       width : 252px;
 12                       font : 25px / 25px 宋体;
 13                       background : #000;
 14                       color : #9f9;
 15                       border : #999 20px ridge;
 16                       text-shadow : 2px 3px 1px #0f0;">
 17         </div>
 18         
 19         <script>  
 20             //eval的功能是把字符串变成实际运行时的JavaScript代码
 21             //这里代码变换之后相当于 var map = [0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0xfff];
 22             //其二进制形式如下
 23             //100000000001 十六进制对照 0x801
 24             //100000000001              0x801
 25             //100000000001              0x801
 26             //100000000001              0x801
 27             //100000000001              0x801
 28             //100000000001              0x801
 29             //100000000001              0x801
 30             //100000000001              0x801
 31             //100000000001              0x801
 32             //100000000001              0x801
 33             //100000000001              0x801
 34             //100000000001              0x801
 35             //100000000001              0x801
 36             //100000000001              0x801
 37             //100000000001              0x801
 38             //100000000001              0x801
 39             //100000000001              0x801            
 40             //100000000001              0x801
 41             //100000000001              0x801
 42             //100000000001              0x801
 43             //100000000001              0x801
 44             //100000000001              0x801
 45             //111111111111              0xfff
 46             //数据呈U形分布，没错，这就是俄罗斯方块的地图（或者游戏场地更为合适？）的存储区
 47             var map = eval("[" + Array(23).join("0x801,") + "0xfff]"); 
 48             
 49             //这个锯齿数组存储的是7种俄罗斯方块的图案信息
 50             //俄罗斯方块在不同的旋转角度下会产生不同的图案，当然可以通过算法实现旋转图案生成，这里为了减少代码复杂性直接给出了不同旋转状态下的图案数据
 51             //很明显，第一个0x6600就是7种俄罗斯方块之中的正方形方块
 52             //0x6600二进制分四行表示如下
 53             //0110
 54             //0110
 55             //0000
 56             //0000
 57             //这就是正方形图案的表示，可以看出，这里统一采用一个16位数来存储4 * 4的俄罗斯方块图案
 58             //因为正方形图案旋转不会有形状的改变，所以此行只存储了一个图案数据
 59             var tatris = [[0x6600],
 60                           [0x2222, 0x0f00],
 61                           [0xc600, 0x2640],
 62                           [0x6c00, 0x4620],
 63                           [0x4460, 0x2e0, 0x6220, 0x740],
 64                           [0x2260, 0x0e20, 0x6440, 0x4700], 
 65                           [0x2620, 0x720, 0x2320, 0x2700]];  
 66 
 67             //此对象之中存储的是按键键值（上，下，左，右）和函数之间的调用映射关系，之后通过eval可以做好调用映射
 68             var keycom = {"38" : "rotate(1)",
 69                           "40" : "down()",
 70                           "37" : "move(2, 1)",
 71                           "39" : "move(0.5, -1)"};
 72             
 73             //dia存储选取的俄罗斯方块类型（一共七种俄罗斯方块类型）
 74             //pos是前台正在下落的俄罗斯方块图案（每一种俄罗斯方块类型有属于自己的图案，如果不清楚可以查看上文的锯齿数组）对象
 75             //bak里存储关于pos图案对象的备份，在需要的时候可以实现对于pos运动的撤销
 76             var dia, pos, bak, run;
 77             
 78             //在游戏场景上方产生一个新的俄罗斯方块
 79             function start(){ 
 80             
 81                 //产生0~6的随机数，~运算符在JavaScript依然是位取反运算，隐式实现了浮点数到整形的转换，这是一个很丑陋的取整实现方式
 82                 //其作用是在七种基本俄罗斯方块类型之中随机选择一个
 83                 dia = tatris[~~(Math.random() * 7)];
 84                 
 85                 //pos和bak两个对象分别为前后台，实现俄罗斯方块运动的备份和撤销
 86                 bak = pos = {fk : [],                                    //这是一个数组存储的是图案转化之后的二进制数据
 87                              y : 0,                                        //初生俄罗斯方块的y坐标 
 88                              x : 4,                                     //初生俄罗斯方块的x坐标，相对于右侧
 89                              s : ~~(Math.random() * dia.length)};        //在特定的俄罗斯方块类型之中随机选择一个具体的图案
 90                 
 91                 //新生的俄罗斯方块不旋转，所以这里参数为0
 92                 rotate(0);
 93             } 
 94             
 95             //旋转，实际上这里做的处理只不过是旋转旋转之后的俄罗斯方块具体图案，之后进行移位，根据X坐标把位置移动到场景里对应的地点
 96             function rotate(r){ 
 97             
 98                 //这里是根据旋转参数 r 选择具体的俄罗斯方块图案，这里的 f ，就是上文之中的十六进制数
 99                 //这里把当前pos.s的值和r（也就是旋转角度）相加，最后和dia.length求余，实现了旋转循环
100                 var f = dia[pos.s = (pos.s + r) % dia.length];
101                 
102                 //根据f（也就是上文之中提供的 16 位数据）每4位一行填写到fk数组之中
103                 for(var i = 0; i < 4; i++) {
104                     
105                     //初生的俄罗斯方块pos.x的值为4，因为是4 * 4的团所以在宽度为12的场景里左移4位之后就位于中间四列范围内
106                     pos.fk[i] = (f >> (12 - i * 4) & 0x000f) << pos.x;
107                 }
108                 
109                 //更新场景
110                 update(is());  
111             }      
112 
113             //这是什么意思，这是一个判断，判断有没有重叠
114             function is(){  
115             
116                 //对于当前俄罗斯方块图案进行逐行分析
117                 for(var i = 0; i < 4; i++) {
118                 
119                     //把俄罗斯方块图案每一行的二进制位与场景内的二进制位进行位与，如果结果非0的话，那么这就证明图案和场景之中的实体（比如墙或者是已经落底的俄罗斯方块）重合了
120                     //既然重合了，那么之前的运动就是非法的，所以在这个if语句里面调用之前备份的bak实现对于pos的恢复
121                     if((pos.fk[i] & map[pos.y + i]) != 0) {
122                         
123                         return pos = bak;
124                     }                            
125                 }    
126 
127                 //如果没有重合，那么这里默认返回空
128             }      
129             
130             //此函数产生用于绘制场景的字符串并且写入到div之中完成游戏场景的更新
131             function update(t){  
132             
133                 //把pos备份到bak之中，slice(0)意为从0号开始到结束的数组，也就是全数组，这里不能直接赋值，否则只是建立引用关系，起不到数据备份的效果
134                 bak = {fk : pos.fk.slice(0), y : pos.y, x : pos.x, s : pos.s};  
135                 
136                 //如果俄罗斯方块和场景实体重合了的话，就直接return返回，不需要重绘场景
137                 if (t) {
138                 
139                     return;
140                 }
141                 
142                 //这里是根据map进行转换，转化得到的是01加上换行的原始串
143                 for(var i = 0, a2 = ""; i < 22; i++) {
144                 
145                     //br就是换行，在这个循环里，把地图之中所有数据以二进制数字的形式写入a2字符串
146                     //这里2是参数，指定基底，2的话就是返回二进制串的形式
147                     //slice(1, -1)这里的参数1，-1作用是取除了墙（收尾位）之外中间场景数据（10位）
148                     a2 += map[i].toString(2).slice(1, -1) + "<br/>";
149                 }
150                 
151                 //这里实现的是对于字符串的替换处理，就是把原始的01字符串转换成为方块汉字串
152                 for(var i = 0, n; i < 4; i++) {
153                 
154                     //这个循环处理的是正在下落的俄罗斯方块的绘制
155                     ////\u25a1是空格方块，这里也是隐式使用正则表达式
156                     if(/([^0]+)/.test(bak.fk[i].toString(2).replace(/1/g, "\u25a1"))) { 
157                     
158                         a2 = a2.substr(0, n = (bak.y + i + 1) * 15 - RegExp.$_.length - 4) + RegExp.$1 + a2.slice(n + RegExp.$1.length);
159                     }
160                 }
161                 
162                 //对于a2字符串进行替换，并且显示在div之中，这里是应用
163                 ////\u25a0是黑色方块 \u3000是空，这里实现的是替换div之中的文本，由数字替换成为两种方块或者空白
164                 document.getElementById("box").innerHTML = a2.replace(/1/g, "\u25a0").replace(/0/g, "\u3000");
165             }  
166         
167             //游戏结束
168             function over(){  
169             
170                 //撤销onkeydown的事件关联
171                 document.onkeydown = null;
172                 
173                 //清理之前设置的俄罗斯方块下落定时器
174                 clearInterval(run);
175                 
176                 //弹出游戏结束对话框
177                 alert("游戏结束");  
178             }  
179 
180             //俄罗斯方块下落
181             function down(){ 
182             
183                 //pos就是当前的（前台）俄罗斯方块，这里y坐标++，就相当于下落
184                 ++pos.y; 
185                 
186                 //如果俄罗斯方块和场景实体重合了的话
187                 if(is()){ 
188                 
189                     //这里的作用是消行
190                     for(var i = 0; i < 4 && pos.y + i < 22; i++) { 
191                     
192                         //和实体场景进行位或并且赋值，如果最后赋值结果为0xfff，也就说明当前行被完全填充了，可以消行
193                         if((map[pos.y + i] |= pos.fk[i]) == 0xfff) {
194                         
195                             //行删除
196                             map.splice(pos.y + i, 1);
197                             //首行添加，unshift的作用是在数组第0号元素之前添加新元素，新的元素作为数组首元素
198                             map.unshift(0x801);
199                         }
200                     }                                
201                     
202                     //如果最上面一行不是空了，俄罗斯方块垒满了，则游戏结束
203                     if(map[1] != 0x801) {
204                         
205                         return over();
206                     }
207                     
208                     //这里重新产生下一个俄罗斯方块
209                     start();  
210                 } 
211                 
212                 //否则的话更新，因为这里不是局部更新，是全局更新，所以重新绘制一下map就可以了
213                 update();  
214             }  
215 
216             //左右移动，t参数只能为2或者是0.5
217             //这样实现左移右移（相当于移位运算）这种方法也很丑陋，但是为了简短只能这样了
218             //这样做很丑陋，但是可以让代码简短一些
219             function move(t, k){  
220             
221                 pos.x += k;  
222                 
223                 for(var i = 0; i < 4; i++) { 
224                     
225                     //*=t在这里实现了左右移1位赋值的功能
226                     pos.fk[i] *= t;  
227                 }
228                 
229                 //左右移之后的更新，这里同样进行了重合判断，如果和左右墙重合的话，那么一样会撤销操作并且不更新场景
230                 update(is());  
231             }  
232 
233             //设置按键事件映射，这样按下键的时候就会触发对应的事件，具体来说就是触发对应的move，只有2和0.5
234             document.onkeydown = function(e) {  
235             
236                 //eval生成的JavaScript代码，在这里就被执行了
237                 eval(keycom[(e ? e : event).keyCode]);  
238             };
239               
240             //这样看来的话，这几乎是一个递归。。。
241             start();
242 
243             //设置俄罗斯方块下落定时器，500毫秒触发一次，调节这里的数字可以调整游戏之中俄罗斯方块下落的快慢
244             run = setInterval("down()", 500);
245         </script>
246     </body>
247 </html>

下面给出原作者代码，60行

 1 <!doctype html><html><head></head><body>
 2 <div id="box" style="width:252px;font:25px/25px 宋体;background:#000;color:#9f9;border:#999 20px ridge;text-shadow:2px 3px 1px #0f0;"></div>
 3 <script>
 4 var map=eval("["+Array(23).join("0x801,")+"0xfff]");
 5 var tatris=[[0x6600],[0x2222,0xf00],[0xc600,0x2640],[0x6c00,0x4620],[0x4460,0x2e0,0x6220,0x740],[0x2260,0xe20,0x6440,0x4700],[0x2620,0x720,0x2320,0x2700]];
 6 var keycom={"38":"rotate(1)","40":"down()","37":"move(2,1)","39":"move(0.5,-1)"};
 7 var dia, pos, bak, run;
 8 function start(){
 9     dia=tatris[~~(Math.random()*7)];
10     bak=pos={fk:[],y:0,x:4,s:~~(Math.random()*4)};
11     rotate(0);
12 }
13 function over(){
14     document.onkeydown=null;
15     clearInterval(run);
16     alert("GAME OVER");
17 }
18 function update(t){
19     bak={fk:pos.fk.slice(0),y:pos.y,x:pos.x,s:pos.s};
20     if(t) return;
21     for(var i=0,a2=""; i<22; i++)
22         a2+=map[i].toString(2).slice(1,-1)+"<br/>";
23     for(var i=0,n; i<4; i++)
24         if(/([^0]+)/.test(bak.fk[i].toString(2).replace(/1/g,"\u25a1")))
25             a2=a2.substr(0,n=(bak.y+i+1)*15-RegExp.$_.length-4)+RegExp.$1+a2.slice(n+RegExp.$1.length);
26     document.getElementById("box").innerHTML=a2.replace(/1/g,"\u25a0").replace(/0/g,"\u3000");
27 }
28 function is(){
29     for(var i=0; i<4; i++)
30         if((pos.fk[i]&map[pos.y+i])!=0) return pos=bak;
31 }
32 function rotate(r){
33     var f=dia[pos.s=(pos.s+r)%dia.length];
34     for(var i=0; i<4; i++)
35         pos.fk[i]=(f>>(12-i*4)&15)<<pos.x;
36     update(is());
37 }
38 function down(){
39     ++pos.y;
40     if(is()){
41         for(var i=0; i<4 && pos.y+i<22; i++)
42             if((map[pos.y+i]|=pos.fk[i])==0xfff)
43                 map.splice(pos.y+i,1), map.unshift(0x801);
44         if(map[1]!=0x801) return over();
45         start();
46     }
47     update();
48 }
49 function move(t,k){
50     pos.x+=k;
51     for(var i=0; i<4; i++)
52         pos.fk[i]*=t;
53     update(is());
54 }
55 document.onkeydown=function(e){
56     eval(keycom[(e?e:event).keyCode]);
57 };
58 start();
59 run=setInterval("down()",400);
60 </script></body></html>

事件回调函数传参

<!DOCTYPE html>

<head>

<title>Document</title>

<style>

html , body {

width: 100%;

height: 100%;

background: green;

}

</style>

</head>

<body>

</body>

//在开发一个应用的时候用到事件的回调函数传参，并且需要接收到默认event事件，记录如下笔记

//使用bind将要传入的参数传入，注意第一个参数设置成undefined,要传入的参数一次往后填入

//执行的函数的最后一个参数为默认event事件

var oBody = document.getElementsByTagName(‘body’)[0];

//事件的回调函数传参

//oBody.addEventListener(“click”,start(undefined,2));

function start(num1, num2, ev) {

console.log(ev);

console.log(num1);

console.log(num2);

}

var start = start.bind(undefined,1, 2)

// 使用bind传参；

oBody.onclick = start;

</script>

</html>

在webapp上使用input:file, 指定capture属性调用默许相机，摄像，录音功能

在webapp上使用input:file, 指定capture属性调用默认相机，摄像，录音功能

在iOS6下开发webapp，使用inputz之file，很有用

<input type="file" accept="image/*" capture="camera">
<input type="file" accept="video/*" capture="camcorder">
<input type="file" accept="audio/*" capture="microphone">

capture表示，可以捕获到系统默认的设备，比如：camera–照相机；camcorder–摄像机；microphone–录音。

accept表示，直接打开系统文件目录。

其实html5的input:file标签还支持一个multiple属性，表示可以支持多选，如：

<input type="file" accept="image/*" multiple>

加上这个multiple后，capture就没啥用了，因为multiple是专门yong用来支持多选的。

CSS居中

水平居中

行内或类行内元素（比如文本和链接）

在块级父容器中让行内元素居中，只需使用 text-align: center;：

这种方法可以让 inline/inline-block/inline-table/inline/flex 等类型的元素实现居中。

块级元素

让块级元素居中的方法就是设置 margin-left 和 margin-right 为 auto（前提是已经为元素设置了适当的 width 宽度，否则块级元素的宽度会被拉伸为父级容器的宽度）。常见用法如下所示：

.center-me {
  margin: 0 auto;
}

无论父级容器和块级元素的宽度如何变化，都不会影响块级元素的居中效果。

请注意，float 属性是不能实现元素居中的。

多个块级元素

如果要让多个块级元素在同一水平线上居中，那么可以修改它们的 display 值。这里有两个示例，其中一个使用了 inline-block 的显示方式，另一个使用了 flexbox 的显示方式：

如果你想让多个垂直堆栈的块元素，那么仍然可以通过设置 margin-left 和 margin-right 为 auto 来实现：

垂直居中

使用 CSS 实现垂直居中需要一些技巧。

行内或类行内元素（比如文本和链接）

单行

对于单行行内或者文本元素，只需为它们添加等值的 padding-top 和 padding-bottom 就可以实现垂直居中：

.link {
  padding-top: 30px;
  padding-bottom: 30px;
}

如果因为某些原因我们不能使用 padding 属性来实现垂直居中，而且已知文本不会换行，那么就可以让 line-height 和 center 相等，从而实现垂直居中：

.center-text-trick {
  height: 100px;
  line-height: 100px;
  white-space: nowrap;
}

多行

对于多行文本，同样可以使用等值 padding-top 和 padding-bottom 的方式实现垂直居中。如果你在使用过程中发现这种方法没见效，那么你可以通过 CSS 为文本设置一个类似 table-cell 的父级容器，然后使用 vertical-align 属性实现垂直居中：

此外，你还可以使用 flexbox 实现垂直居中，对于父级容器为 display: flex 的元素来说，它的每一个子元素都是垂直居中的：

.flex-center-vertically {
  display: flex;
  justify-content: center;
  flex-direction: column;
  height: 400px;
}

值得注意的是，上述方法只适用于父级容器拥有确定高度的元素。

如果上述方法都不起作用，那么你就需要使用被称为幽灵元素（ghost element）的非常规解决方式：在垂直居中的元素上添加伪元素，设置伪元素的高等于父级容器的高，然后为文本添加 vertical-align: middle; 样式，即可实现垂直居中。

.ghost-center {
  position: relative;
}
.ghost-center::before {
  content: " ";
  display: inline-block;
  height: 100%;
  width: 1%;
  vertical-align: middle;
}
.ghost-center p {
  display: inline-block;
  vertical-align: middle;
}

块级元素

已知元素的高度

无法获知元素的具体高度是非常常见的一种状况，比如：视区宽度变化，会触发布局重绘，从而改变高度；对文本施加不同的样式会改变高度；文本的内容量不同会改变高度；当宽度变化时，对于宽高比例固定的元素（比如图片），也会自动调整高度……

如果我们知道元素的高度，可以这样来实现垂直居中：

.parent {
  position: relative;
}
.child {
  position: absolute;
  top: 50%;
  height: 100px;
  margin-top: -50px; /* account for padding and border if not using box-sizing: border-box; */
}

未知元素的高度

如果我们不知道元素的高度，那么就需要先将元素定位到容器的中心位置，然后使用 transform 的 translate 属性，将元素的中心和父容器的中心重合，从而实现垂直居中：

.parent {
  position: relative;
}
.child {
  position: absolute;
  top: 50%;
  transform: translateY(-50%);
}

flexbox

使用 flexbox 实现垂直居中非常简单：

.parent {
  display: flex;
  flex-direction: column;
  justify-content: center;
}

水平且垂直居中

通过组合水平居中和垂直居中的技巧，可以实现非常完美的居中效果。我觉得可以将它们分为三种类型：

宽高固定元素

设定父级容器为相对定位的容器，设定子元素绝对定位的位置 position: absolute; top: 50%; left: 50%，最后使用负向 margin 实现水平和垂直居中，margin 的值为宽高（具体的宽高需要根据实际情况计算 padding）的一半。

.parent {
  position: relative;
}
.child {
  width: 300px;
  height: 100px;
  padding: 20px;
  position: absolute;
  top: 50%;
  left: 50%;
  margin: -70px 0 0 -170px;
}

宽高不固定元素

如果无法获取确定的宽高，同样需要设定父级容器为相对定位的容器，设定子元素绝对定位的位置 position: absolute; top: 50%; left: 50%。不同的是，接下来需要使用 transform: translate(-50%, -50%); 实现垂直居中：

.parent {
  position: relative;
}
.child {
  position: absolute;
  top: 50%;
  left: 50%;
  transform: translate(-50%, -50%);
}

使用 transform 有一个缺陷，就是当计算结果含有小数时（比如 0.5），会让整个元素看起来是模糊的，一种解决方案就是为父级元素设置 transform-style: preserve-3d; 样式：

.parent-element {
  -webkit-transform-style: preserve-3d;
  -moz-transform-style: preserve-3d;
  transform-style: preserve-3d;
}

.element {
  position: relative;
  top: 50%;
  transform: translateY(-50%);
}

flexbox

使用 flexbox 实现水平和垂直居中，只需使用两条居中属性即可：

.parent {
  display: flex;
  justify-content: center;
  align-items: center;
}

js判断输入字符串是否为空、空格、null的方法总结

判断字符串是否为空

var strings = ''; 
if (string.length == 0) 
{ 
alert('不能为空'); 
}

判断字符串是否为“空”字符即用户输入了空格

var strings = ' '; 
if (strings.replace(/(^s*)|(s*$)/g, "").length ==0) 
{ 
alert('不能为空'); 
}

判断输入字符串是否为空或者全部都是空格?

function isNull( str ){
if ( str == "" ) return true;
var regu = "^[ ]+$";
var re = new RegExp(regu);
return re.test(str);
}

如果有null时上面代码就无法正常判断了，下面代码是判断为null的情况

var exp = null; 
if (exp == null) 
{ 
alert("is null"); 
}

exp 为 undefined 时，也会得到与 null 相同的结果，虽然 null 和 undefined 不一样。

注意：要同时判断 null 和 undefined 时可使用本法。代码如下

var exp = null; 
if (!exp) 
{ 
alert("is null"); 
}

如果 exp 为 undefined，或数字零，或 false，也会得到与 null 相同的结果，虽然 null 和二者不一样。注意：要同时判断 null、undefined、数字零、false 时可使用本法。代码如下

var exp = null; 
if (typeof exp == "null") 
{ 
alert("is null"); 
}

为了向下兼容，exp 为 null 时，typeof null 总返回 object，所以不能这样判断。

<script type="text/javascript">
function testuser(){
var i= document.getElementByIdx_x("aa");
if (i.value=="null")
{
alert("请登录后再发表留言!")
return false;
}
else
{
alert(i.value)
return true;
}
}
</script>