当点亮下面节拍器的按钮，就能发出相应的声音来，感觉非常好玩
主要是基于不用flash，文件JS实现声音播放的原理做的
function startWav(uri) {
stopWav();
embedEl = document.createElement(”embed”);
embedEl.setAttribute(”src”, uri);
embedEl.setAttribute(”hidden”, true);
embedEl.setAttribute(”autostart”, true);document.body.appendChild(embedEl);
}
通过embed来实现的
我从来都没有直接的做过团队管理的岗位,主要是我人比较内向,以前还有点木讷,(呵呵,不过现在好多了).但是做过的项目不少,碰到管理上的问题也不少,但是主要问题是,计划定制,沟通和时间的问题,一直都没有好的处理方法.有的时候,不仅没有方法,连方向都找不到,很多返工,最后一拖再拖,磨的人都没有什么锐气了,慵懒的频于应付交差.所以,完成的根本不是我们起初想要的.这样,带来两个负面影响,首先,对于项目而言成本会剧增,东西的质量也不是很好,还有就是对于团队的士气和凝聚力也会下降.
再回过头来看看互联网的开发,在讲方法之前,拜托,先把方向明确了.这个是主要的,然后去讲方法,再然后对于这个方向再分析,产生计划,落实去做,测试,上线.
有了方向,就有了核,然后产生凝聚力.
再谈方法,我觉得底气就足了.
负责人:”我们要做一个什么什么东西,可行不?”
成员:”不错,好主意!” “没前途,不好” ”….”
(可行性分析) #%$#@#$^
————————————-
负责人:”大家看看要怎么做?”
成员:”用用Scrum的敏捷开发方法不错吧?” “还是像我们以前一样,会比较好吧(内心独白:这个人老喜欢新概念,烦不烦阿)”
负责人:”好吧,Scrum可以借鉴下,我们分解下任务吧,大家认领下”(内心独白:不要再散开话题了,抓紧时间,准备在19:30搞定,20:00还有另一个会议要开呢.)
(计划)
—————————————-
之前得测试过
里程碑到了…
负责人:我来过下大家做的怎么样?都提交了吧.
(检查)
—————————————-
不行,改!
ok,迭代就开始了.
以上的开发次序有问题吗?未必,但是大部分小团队基本上都是这样的.
如果每一步都做到位了,我想这一切都会往一开始订下的方向走.
如果不行可以及时的微调方法,逐渐形成自己团队管理模式.
总结下:
1.方向明确
2.计划清晰,职责明确,任务分工到位(落实)
3.及时的团队沟通(讨论,会议,走查)
4.落实测试审查,确保质量
之前都没有系统学习过闭包，对于闭包的概念也比较迷糊。今天搜了下关于闭包的资料和文档，有的说的很复杂，也许是翻译的问题吧。之后还是找的了一个比较简单的笔记性说明文档来自于never-online的一篇不错的文章：在Javascript中，什么是闭包(Closure)？
这篇文章的英文原创来自于：http://blog.morrisjohns.com/javascript_closures_for_dummies
于是我对照了原著看了下，更加深了印象，感觉闭包使用的恰当，效果很好的。
首先，闭包是什么？
function sayHello(name) {
var text = 'Hello ' + name;
var sayAlert = function() { alert(text); }
sayAlert();
}
以上的代码就表示了闭包的最基本的形式，在一个函数里面包含一个内部函数。
闭包有一个好处，就是变量作用域控制，和内部函数作用域的控制，是外界没法访问内部函数，使代码安全性提高，形成代码的单元。
其实，我还是看到never-online的另一篇
eval解闭包
里面说道：
[edit] Syntax
eval(string [, object])[edit] Parameters
string
A string representing a JavaScript expression, statement, or sequence of statements. The expression can include variables and properties of existing objects.
object
Non-standard
An optional argument; if specified, the evaluation is restricted to the context of the specified object.
呵呵，这么看来对于JavaScript私有的概念十分的弱了。eval是一个危险的方法，虽然灵活，但是得小心的用，就像goto语句一样有争议了。
最后总结下：
Final points:
* Whenever you use function inside another function, a closure is used.
每当你在一个函数里有另一个函数，表示已使用了闭包。
* Whenever you use eval() inside a function, a closure is used. The text you eval can reference local variables of the function, and within eval you can even create new local variables by using eval(’var foo = …
每当你使用函数里使用eval()，也表示使用了闭包。你执行的文本能够应用这个函数里的局部变量，甚至在eval里创建新的这个函数的局部变量，像这样：eval(’var foo =…
* When you use Function() inside a function, it does not create a closure. (The new function cannot reference the local variables of the function calling Function()).
当你在一个函数里使用Function()，并不会创建一个闭包。（当调用这个新建的函数并不能引用函数的局部变量）
* A closure in JavaScript is like keeping a copy of the all the local variables, just as they were when a function exited.
当一个函数退出时，在JavaScript里一个闭包就像是保持了所有局部变量的拷贝。
——————————————————————–
下面偷懒了，不翻译了，发现翻译措辞很痛苦，虽然看懂了，却不知道咋么表达好，大家一起看e文吧，或者有哪个达人帮忙翻译下。
* It is probably best to think that a closure is always created just on entry to a function, and the local variables are added to that closure.
* A new set of local variables is kept every time a function with a closure is called (Given that the function contains a function declaration inside it, and a reference to that inside function is either returned or an external reference is kept for it in some way).
* Two functions might look like they have the same source text, but have completely different behaviour because of their ‘hidden’ closure. I don’t think JavaScript code can actually find out if a function reference has a closure or not.
* If you are trying to do any dynamic source code modifications ( for example: myFunction = Function(myFunction.toString().replace(/Hello/,’Hola’)); ), it won’t work if myFunction is a closure (Of course, you would never even think of doing source code string substitution at runtime, but…).
* It is possible to get function declarations within function declarations within functions - and you can get closures at more than one level.
* I think normally a closure is the term for both the function along with the variables that are captured. Note that I do not use that definition in this article!
* I suspect that closures in JavaScript differ from those normally found in functional languages.
下午，在忙完事后，大家讨论起最近发起的博客模板的活动来，于是就做了《懒》的博客主题，纯粹搞笑，主要目的是雷人的。
下面是网址：http://i.yoho.cn/lan
主要是适用于浏览，且无语的潜水者看的。
刚来到一个互联网应用团队，团队的技术leader对我说，你既然是专做web前端的，以后开发尽量少用js框架，应该多自己去写点东西，虽然我们现在使用了prototype的。
我想了想，就问那为什么之前还要用prototype框架呢？回答总结三点，一是时间紧，二是跨浏览器兼容问题，三是没有专业前端开发。这么一来，我就是专业的，所以要在解决跨浏览器兼容性的同时，要在时间足够里，不使用框架开发目前web前端的开发工作，想想要求的确不是很高。
而我主要是在想为什么要用框架，其实代表是一种进步，使用框架并没有什么不好的，常说不要重复去发明轮子一样，可以省的为什么要去不断的去重复，关键不是不使用框架，而是如何理解编写的前人为什么要这么写框架，如果不理解，就不能真正去用好它，使代码会乱，虽然快速实现了功能，但是在维护或复用该功能时发现问题多多。所以，写出有质量的代码才是主要的，至于是否使用框架，而是相对你所要实现的功能或需求而言的，按需开发，需要什么就使用什么技术，什么框架。
例如，你需要写一个，在页面上每隔10秒钟显示一条友好提示，就相当“你知道吗？”这样的功能。
可以这么写：
var tips=
{
msg:["你可以点击右键打开浏览器的其他选项！","使用“F1”可以获取帮助。","“F5”刷新页面。"],
current:0,
show:function()
{
document.body.innerHTML=tips.msg[tips.current];
if(tips.current
tips.current++;
else
tips.current=0;
setTimeout(tips.show,2000);
}
};
window.onload=function()
{
tips.show();
}
以上代码就没有使用任何的框架，因为简单，而且也没有必要去使用框架之类的，一样可以完美的实现这个功能的。
但是如果功能增加了一些要求，如tips的内容需要服务端动态加载，则需要Ajax的支持，另外需要淡入淡出效果，这两要求非常通用，则可以通过框架的支持来实现，可以重构以上的代码，加入框架的应用。例如，prototype或其他什么框架，基本上目前主流框架都有类似的支持，没有必要重新去开发这些，但是对于框架依赖可以抽离出来写，这样就方便解耦。这样代码结构就清晰很多了，便于维护。
所以说，使用框架是站在巨人肩膀上的一种行为，代表一种进步，前提是你要理解它。
在JavaRanch Journal看到一片不错的JavaScript的入门文章，感觉不错，十分易懂，决定把它翻译下，一来方便不懂e文的同志分享，二来可以巩固下关于JavaScript对于对象的理解。
原文地址： http://www.javaranch.com/journal/2008/10/Journal200810.jsp
作者 Stoyan Staefanov
Java 和JavaScript是两种完全不同的语言，但是名称和都是类C的语法很容易却让人混淆。让我们来看看JavaScript不同于Java中如何创建对象的。在Java里，你得先有类，然后再有对象的，又叫做实例化，创建对象要基于那些类的。但是在JavaScript里，是没有类、对象，而是更像是哈希表中的键值对。但是在JavaScript中是如何实例化对象的呢？好，一步步的来讲。
JavaScript 对象
当你在思考关于一个JavaScript对象时，其实就是在思考一个哈希。这里所有的对象就像是一个键值对的集合，那些值则可以包括是任何的对象和函数。当一个对象的其中一个属性是函数时，你就可以称其为方法。
这个就是一个空方法：
Var myobj = {};
现在你可以添加一些有意义的功能到这个对象了：
myobj,name = “My precious”;
myobj.getName = function() {return this.name};
这里要注意的事项：
正如所预期的那样，内部方法是当前对象的应用
你可以添加、调整、删除属性在任何时候，不只是在创建的时候
另一种创建对象的方式是，在创建对象的同时创建属性和方法，就像这样：
Var another = {
name: ‘My other precious’,
getName:function() {
return this.name;
}
};
这些语法被称之谓文字符号对象，你总之把一切都放在大括号内{}，属性则通过逗号隔开。键：值对通过分号隔开。尽管这个不是唯一创建对象的方法。
另一种创建JavaScript对象的方法是使用构造函数的方法。这个是构造函数的例子：
Function ShinyObject(name){
this.name = name;
this.getName = function(){
return this.name;
}
}
现在创建一个对象就很想Java 一样了：
var my = new ShinyObject(’ring’);
Var myname = my .getName();//”ring”
构造函数的语法没有相对于其他任何函数有所不同，而不同是在在于用法不同。如果你以new的方式调用一个函数，那就会创建并返回一个对象，通过这个，你就有权限在它返回之前修改它。通过约定，构造函数不同于普通函数和方法，名称首字母要大写。
对象直接创建和构造函数创建，哪个更好呢？嗯，那就取决于你要做的特定的任务。例如，你要创建很多不同的近似的对象，选择使用类构造的方式是个不错的选择。但是如果你创建不会多于一个的单例的话，则可以使用直接对象创建就显得比较简洁了。
好，那么没有里类，是如何实现继承的呢？在讨论这个之前，这里有些小小的惊喜–在JavaScript里函数是正真的对象。
（实际上在JavaScript里大部分分所有的都是对象，除一些原始数据类型-string，boolean，number 和undefined。函数是对象，数组是对象，甚至null也是对象。此外，这些私有的数据类型也可以转化后使用作对象，就像 “string”.length 是有效的。）
Function 对象和prototype 属性
在JavaScript里，函数就是对象，可以赋给变量，你可以添加属性和方法等到上面。这里是一个例子：
var myfunc = function(param) {
alert(param);
};
就和这一样：
function myfunc(param) {
alertparam);
}
不管如何你创建的这个函数，你最终可以访问 myfunc里的属性和方法。
alert(myfunc.length); // 提示1, 数字型的参数
alert(myfunc.toString()); // 提示函数的源代码
每一个function对象都有一个有趣的特性：都有prototype（原型）这个属性。
当你创建一个function的同时，将自动获取一个指向一个空对象的prototype属性。当然，你能修改这个空对象的属性。
alert(typeof myfunc.prototype); // 提示“Object”
myfunc.prototype.test = 1; // 完全可以这么做
有个问题，prototype有什么用呢？prototype仅可以用在当你引用一个function作为构造函数方式来创建的对象上。当你这么做，这对象就自动获取一个秘密的链接到prototype的属性，然后使之成为自己的属性。真的吗？
让我们来看看这个实例。
一个新的function：
function ShinyObject(name) {
this.name = name;
}
给这个function的prototype属性传参数来添加一些功能：
ShinyObject.prototype.getName = function() {
return this.name;
};
使用function像构造函数的方式来创建的对象：
var iphone = new ShinyObject(’my precious’);
iphone.getName(); // 返回”my precious”
就像你看到的那样，一个新的对象自动获取这个有权限的prototype属性。然后当有些“免费”获取功能，开始闻到有点像继承和reusability 代码的味道了。
以原型的模式继承
现在让我们看看你将如何prototype来实现继承。
这里是一个做为父类的构造函数：
function NormalObject() {
this.name = ‘normal’;
this.getName = function() {
return this.name;
};
}
第二个构造函数：
function PreciousObject(){
this.shiny = true;
this.round = true;
}
现在继承的部分：
PreciousObject.prototype = new NormalObject();
啊哈！你可以创建precious对象了，并且将获取所有Normal对象的功能：
var crystal_ball = new PreciousObject();
crystal_ball.name = ‘Ball, Crystal Ball.’;
alert(crystal_ball.round); // true
alert(crystal_ball.getName()); // “Ball, Crystal Ball.”
注意为什么我们创建一个对象要通过prototype的方式新建或赋予，因为prototype就是一个对象。它不像一个构造函数继承自其他，事实上我们继承是从一个对象的。JavaScript是没有类继承自类的说法，这里只有对象继承自对象。
如果你有一些构造函数继承自NormalObject对象，你或许每次都要new NormalObject()的，但是那是不必要的。甚至整个NormalObject结构体也是不必要的。另一种方式一样做到通过创建一个（单例）的normal object然后使用它就像使用其他的对象。
var normal = {
name: ‘normal’,
getName: function() {
return this.name;
}
};
然后PreciousObject能够像这样来继承：
PreciousObject.prototype =normal;
自从继承者将全部调用代码，已经简单复制属性通过另一种方法来实现。
设想你有以下的对象
var shiny = {
shiny: true,
round: true
};
var normal = {
name: ‘name me’,
getName: function() {
return this.name;
}
};
如何让shiny获取mormal的属性？这里是一个简单的extend()函数，用来循环迭代和复制属性：
function extend(parent, child) {
for (var i in parent) {
child[i] = parent[i];
}
}
extend(normal, shiny); // 继承
shiny.getName(); // “name me”
现在看来这种属性拷贝有一定的开销而感觉不是很好，但是事实上，对于完成大多数任务还不错。你也可以把这个看做实现组合和多重继承的简单途径。
Crockford的由父级对象产生对象的方法
Douglas Crockford,是一位JavaScript的宗师和JSON的创始人，他提出了这个有趣的begetObject()方式来实现继承：
function begetObject(o) {
function F() {}
F.prototype = o;
return new F();
}
在这里你创建一个临时的构造函数，这样以至于可以使用prototype（原型）的功能，原理是创建一个对象同时继承已存在对象的一些功能。
父级对象：
var normal = {
name: ‘name me’,
getName: function() {
return this.name;
}
};
一个新创建继承自父级对象的对象：
var shiny = begetObject(normal);
给这个对象新增更多的功能：
Shiny.round = true;
YUI的extend()
让我们再来看另一个实现继承的方式，这个更接近于Java，因为在这个方式下，看起来构造函数像是继承自另一个构造函数，因此有点像一个类继承自另一个类。
这个方式在非常流行的 YUI JavaScript library（Yahoo! User Interface）这里一个简单版本：
function extend(Child, Parent) {
var F = function(){};
F.prototype = Parent.prototype;
Child.prototype = new F();
}
通过这个方法，你传递两个构造函数，第一个（子类）将会通过原型（prototype）属性得到第二个（父类）的所有属性和方法。
总结
让我们快速总结下关于JavaScript刚才所学习的:
没有类的概念
对象继承自对象
对象枚举的方式：var o ={};
构造函数提供类似Java的语法 var o = new Object();
函数和对象的概念
所有函数对象都有一个原型属性
最后，还有讲了一些实现继承的方式，你可以任意的挑选，可以说是手头的任务，个人癖好，团队偏好，或是当前的月相。
作者和声明
Stoyan Stefanov 是一位资深的Yahoo！开发者， YSlow tool的主导者，开源贡献者，博客作者和技术撰稿人，最近是Packet出版的“Object-Oriented JavaScript”一书 的作者。
shiny对象的例子的灵感来自于 Jim Bumgardner撰写的Theory of the Precious Object一书。
Douglas Crockford的 beget object - 文章点击这里
最近 工作上要做一个可编辑的界面拖动层的功能，于是处于不想重新发明轮子的原则，网上搜搜，发现了这个网站，并且也找到了一个轮子，resizedrag的组件，发现这个网站所有的组件都没有使用当前流行Js框架。但是写的，也很优雅，而且跨浏览器的，代码一看就懂，方便我hack下，嘿嘿。也学习到了不错的东西。
该网站的链接在：twinhelix
以下是他的一些js的项目（ 组件）
前一阵子的酝酿，终于下手买了，13200买进的，也许有点贵，但是咬牙还是买了，很漂亮，别的我就不说了，先用本本发个博文，炫耀下。
呵呵，还是第一次使用自己的mac系统，还是真有点不习惯，特别是没了右键，脑子里还是固有的windows的操作习惯。
以后，慢慢改，毕竟苹果不是很难学，而且也很漂亮。
还是，就是无线联网，貌似对于特殊的无线路由设置还是有点不会设置，学习ing。。。
在‘帕兰映像’上看到了一个不错的域名查询工具。
异步加载查询结果，红色表示已注册，蓝色表示可以注册的，采用结果累加的方式，并且而还会简单的单词联想。真的不错，比起以前只能查一个域名的查询方式，方便了很多。
我比较喜欢，keyup的事件触发，以及联想，累加查询结果的方式，简单实用。
最近，研究了下中国google下面的导航的动画，觉得挺好奇，怎么实现的，看了下代码，唉，串串的Javascript看得累，仔细一看IE临时文件里那个导航图片，呵呵，总算明白到底是怎么实现的。大家看下这个图片
原来是逐帧翻转，就是不停位移background的background-position。
下面附上代码，代码比较简单，只实现了图片动画的功能，使用了prototype的PeriodicalExecuter，点击这里下载
