话说最新的编辑器让我非常郁闷。。。缺少了代码的所见即所得的部分。。。。

http://blog.kaourantin.net/  之 http://www.kaourantin.net/2010/03/timing-it-right.html 及 http://blog.kaourantin.net/?p=83

受影响的 API和类：

EI   LC  Timer  EnterFrame   throw 等

新的Trine计划有待测试

using   System;   
  using   System.Security.Cryptography;   
    
  namespace   YNIT.Components   
  {   
  ///   <summary>   
  ///   生成随机字符串的密封类，不能被继承   
  ///   </summary>   
  public   sealed   class   RandomStr     
  {   
  private   static   readonly   int   defaultLength   =   8;   
    
  private   static   int   GetNewSeed()   
  {   
  byte[]   rndBytes   =   new   byte[4];   
  RNGCryptoServiceProvider   rng   =   new   RNGCryptoServiceProvider();   
  rng.GetBytes(rndBytes);   
  return   BitConverter.ToInt32(rndBytes,0);   
  }   
    
  private   static   string   BuildRndCodeAll(int   strLen)     
  {   
  System.Random   RandomObj   =   new   System.Random(GetNewSeed());     
  string   buildRndCodeReturn   =   null;   
  for(int   i=0;   i<strLen;   i++)     
  {   
  buildRndCodeReturn   +=   (char)RandomObj.Next(33,125);   
  }   
  return   buildRndCodeReturn;   
  }   
    
  #region   输出随机字符串   
  ///   <summary>   
  ///   输出长度为8的随机字符串   
  ///   </summary>   
  ///   <returns>长度为8的随机字符串</returns>   
  public   static   string   GetRndStrOfAll()     
  {   
  return   BuildRndCodeAll(defaultLength);   
  }   
    
  ///   <summary>   
  ///   输出指定长度的随机字符串   
  ///   </summary>   
  ///   <param   name="LenOf">长度</param>   
  ///   <returns>指定长度的随机字符串</returns>   
  public   static   string   GetRndStrOfAll(int   LenOf)     
  {   
  return   BuildRndCodeAll(LenOf);   
  }   
  #endregion   
        
  private   static   string   sCharLow   =   "abcdefghijklmnopqrstuvwxyz";   
  private   static   string   sCharUpp   =   "ABCDEFGHIJKLMNOPQRSTUVWXYZ";   
  private   static   string   sNumber   =   "0123456789";   
    
  private   static   string   BuildRndCodeOnly(string   StrOf,int   strLen)     
  {   
  System.Random   RandomObj   =   new   System.Random(GetNewSeed());     
  string   buildRndCodeReturn   =   null;   
  for(int   i=0;   i<strLen;   i++)   
  {   
  buildRndCodeReturn   +=   StrOf.Substring(RandomObj.Next(0,StrOf.Length-1),1);   
  }   
  return   buildRndCodeReturn;   
  }   
    
  #region   输出指定范围随机字符串   
  ///   <summary>   
  ///   输出长度为8的小写字母加数字的字符串   
  ///   </summary>   
  ///   <returns>长度为8的小写字母加数字的字符串</returns>   
  public   static   string   GetRndStrOnlyFor()     
  {   
  return   BuildRndCodeOnly(sCharLow   +   sNumber,defaultLength);   
  }   
    
  ///   <summary>   
  ///   输出指定长度的小写字母加数字的字符串   
  ///   </summary>   
  ///   <param   name="LenOf">长度</param>   
  ///   <returns>指定长度的小写字母加数字的字符串</returns>   
  public   static   string   GetRndStrOnlyFor(int   LenOf)     
  {   
  return   BuildRndCodeOnly(sCharLow   +   sNumber,LenOf);   
  }   
    
  ///   <summary>   
  ///   输出长度为8的指定字符串   
  ///   </summary>   
  ///   <param   name="bUseUpper">是否含有大写字母</param>   
  ///   <param   name="bUseNumber">是否含有数字</param>   
  ///   <returns>长度为8的指定字符串</returns>   
  public   static   string   GetRndStrOnlyFor(bool   bUseUpper,bool   bUseNumber)     
  {   
  string   strTmp   =   sCharLow;   
  if   (bUseUpper)   strTmp   +=   sCharUpp;   
  if   (bUseNumber)   strTmp   +=   sNumber;   
    
  return   BuildRndCodeOnly(strTmp,defaultLength);   
  }   
        
  ///   <summary>   
  ///   输出指定长度的指定字符串   
  ///   </summary>   
  ///   <param   name="LenOf">长度</param>   
  ///   <param   name="bUseUpper">是否含有大写字母</param>   
  ///   <param   name="bUseNumber">是否含有数字</param>   
  ///   <returns>指定长度的指定字符串</returns>   
  public   static   string   GetRndStrOnlyFor(int   LenOf,bool   bUseUpper,bool   bUseNumber)     
  {   
  string   strTmp   =   sCharLow;   
  if   (bUseUpper)   strTmp   +=   sCharUpp;   
  if   (bUseNumber)   strTmp   +=   sNumber;   
    
  return   BuildRndCodeOnly(strTmp,LenOf);   
  }   
  #endregion   
  }    

• 有关多种版本控制软件的优劣势，请参看多种版本控制软件的比较。
• 深入了解 Distributed Revision Control with Mercurial， 请参考http://hgbook.red-bean.com/。

        Mercurial 是一个轻量级的分布式版本控制系统，它以方便的控制、极强的扩展性赢得了众多开放源代码项目的青睐。本文从版本控制系统中的基本概念、操作和扩展性等方面，有侧重的介绍了 Mercurial。此外本文列出了几个其他常用的分布式版本控制系统，并和 Mercurial 作了简单的比较。通过阅读本文，读者可以了解基础的Mercurial操作，进而熟悉这个备受青睐的工具。

• 更轻松的管理。传统的版本控制系统使用集中式的 repository，一些和 repository相关的管理就只能由管理员一个人进行。由于采用了分布式的模型，Mercurial 中就没有这样的困扰，每个用户管理自己的 repository，管理员只需协调同步这些repository。
• 更健壮的系统。分布式系统比集中式的单服务器系统更健壮，单服务器系统一旦服务器出现问题整个系统就不能运行了，分布式系统通常不会因为一两个节点而受到影响。
• 对网络的依赖性更低。由于同步可以放在任意时刻进行，Mercurial 甚至可以离线进行管理，只需在有网络连接时同步。

---

从 repository 开始

版本控制系统中的 repository 就像一个仓库一样，用来存储被管理的数据文件，包含数据文件的不同版本。传统的版本控制系统中，这样的repository 是集中式的。除了这样一个集中式的 repository 之外，每个用户会有一份自己的工作版本拷贝。用户通过命令同步自己的拷贝和集中式的repository。

分布式版本控制系统中的 repository 则采用的是对等网络式的方式。传统集中式的管理中，只有一份 repository，其他的只是工作拷贝，不包含额外的版本。分布式的管理当中，每个用户所持有的都是一个真实的 repository，当中存储有不同的版本信息和维护一个 repository 的必要的辅助元数据。这样一个对等工作模式当中，用户通过交换下文即将提到的 changeset 来完成同步。

这样做的一些优点在于，工作的并行度将大大的提高。每个用户都可以带着这样的repository，从这里他可以把当前的工作拷贝切换到 repository 里面存储的任何一个版本。这个版本可以是之前正在工作的版本，现在需要合并进一些别人的意见，也可以是用户私有的一个版本，当前正在做很多前瞻性的工作，还没有能同步给其他用户使用。也同样是因为这样的模式，每个用户可以任意把自己的 repository 当中的一个版本交换给其他用户，而不需要对自己手头正在工作的版本进行回退。下图是这样一个灵活的工作模式的演示。

图 1. 工作模式的演示
 

---

Mercurial 里的元素

Revision

在使用 Mercurial 的系统中每个改动隔离在各自的 repository 里，既避免把不相关的代码混杂起来， 又便于一个接一个的测试每一部分工作，用户做的每个改动称为一个 revision。一般会有一个所有用户都可以访问得到的 repository 保存了项目的“主要”版本，工作repository 是用户自己做事情的地方，实现新的特性，修改漏洞，重构，实验等，当完成改变后，你可以 push 到共用的 repositor y中，即完成了一个 revision。

Changeset

一个或多个文件的改变集合在一起形成一个逻辑单元，称为 changeset。每一个 changeset由两部分内容描述，版本号和 changeset 标识，例如：

changeset: 207:58e4906e69e3

冒号前面的数字代表版本号，它用来标识本地 changeset。这个版本号只有在用户的本地repository 中才有意义。冒号后面的那个很长的十六进制串是 changeset标识, 它是确定changeset的全局唯一标识符, 在所有包含这个 changese 的 repository 中都相同。多个用户之间讨论changeset，一般使用这个 changeset 标识，而不是上面说的版本号，因为完全有可能每个用户的 repository 中同样的 changeset 版本号不同。

Head

Head 表示 repository 中每个分支最新的 revision，通常在合并几个分支时会用到这个概念。

Tip

Tip 是最新的一个 changeset 的版本号的一个别名。在命令中任何使用版本号的地方都可以使用 tip 来代替最新的 changeset的版本号。Tip在各个repository中是不同的，同时一个repository 中只有一个 tip。

Log

Log 命令按时间顺序从近到远的记录着在 repository 中发生的每一次事件。可以通过指定-v诊断输出选项来获得更多更详细的历史信息，或者指定—debug选项来获得历史信息中的一切细节。

---

动手操作起来

以下是一些实际使用 Mercurial 中常用的例子。Mercurial 的原意是元素周期表当中的汞元素，但是 Mercurial 这样的单词显然不太适合日常使用。事实上 Mercurial 的命令取了元素周期表当中汞元素的化学符号：hg，所有的 Mercurial 命令都以 hg 开始。

$ hg command [options]

其中 command 是 Mercurial 的命令。每个命令的具体的命令行选项可以使用：

$ hg help command

来获得。

克隆一个 repository

我们使用 clone 命令克隆一个 repository，它生成一个完整的 repository 复本，这样我们就有一个本地私有的 repository 来工作。

例如：

$ hg clone http://foo.com/hg/project1

如果所有都没问题，clone 命令输出：

destination directory: project1 requesting all changes adding changesets adding manifests adding file changes added 127 changesets with 448 changes to 143 files 139 files updated, 0 files merged, 0 files removed, 0 files unresolved

此时，我们应该在当前目录下发现一个目录叫 project1，目录下的文件是我们刚克隆的 repository 的精确复本。在 Mercurial 中，每一个 repository 是自包含的。当你克隆一个repository 后，新 repository 变成克隆时它的精确复本，但是后续的两个 repository 当中任一方改变都不会在对方显示，除非用户使用 pull 或 push 命令明确地传递改变，这个将在后面介绍。

另外，每个用户可以使用 init 命令将本地的一个目录初始化为一个 Mercurial 的 repository，只需要在那个目录下运行：

$ hg init

如果设置好了同步共享的发布方式，其他用户就可以来克隆该用户的 repository 了。

发布你的改动

进入工作目录，使用我们喜欢的编辑软件修改，例如我们要修改 main.py 让它增加打印一行输出：

def main(): print "I'm in the a function." print "Great joy of using Mercurial!" #新加的一行 if __name__ == "__main__": sys.exit(main())

完成之后退出编辑器，任务完成。有了刚才的修改我们就可以创建一个changeset。

在创建 changeset 之前如果想确认一下哪些文件被改动了，可以使用 status 命令。

$ hg status M main.py

使用 diff 命令可以检查实际文件内容的改变：

diff -r a58db6f0e482 main.py --- a/main.py Thu Nov 29 13:38:38 2007 +0800 +++ b/main.py Thu Nov 29 13:46:10 2007 +0800 @@ -1,5 +1,6 @@ def main(): def main(): print "I'm in the a function." + print "Great joy of using Mercurial!" #新加的一行 if __name__ == "__main__": sys.exit(main())

diff 命令的默认输出是通用的补丁格式，易于在各种系统之间交换和讨论。

创建一个 changeset 后我们就可以用 commit 命令提交了。

$ hg commit

这个命令把我们带到一个编辑器内，缺省的编辑器是 vi，同时给我们展示了几行如下的文字：

HG: user: Guolian Yun <yunguol@cn.ibm.com> HG: changed main.py

第一行是空的，接下来的几行表明哪些文件将进入本 changeset。为了改变 changeset，我们必须描述它的原因，这通常称为 changeset注释。让我们输入一些：

I’m using Mercurial! HG: user: Guolian Yun <yunguol@cn.ibm.com> HG: changed main.py

接着，保存并退出编辑器，如果一切正常，commit 命令将没有任何提示地输出。

让我们看看status命令现在告诉我们什么？

$ hg status

什么也没有！我们的改动已经提交到changeset里了，那里没有修改的文件需要提交的。Repository 中内容和当前工作目录的内容一致了。

现在可以检查以下最新的改动是不是包含刚才所添加的 changeset 注释，使用 tip 命令就可以显示了：

$ hg tip: changeset: 2:2874393e3d9c tag: tip user: Guolian Yun <yunguol@cn.ibm.com> date: Thu Nov 29 10:10:39 2007 +0800 summary: I'm using Mercurial!

目前新的 changeset 只存在本地 repository 中，如果想和其它 repository 分享改动，我们需要使用 push。

$ hg push project2

project2 为你想要 push 的目标 repository 的名字。

引入他人的改动

想要得到所有在别的 repository中而在本地repository中没有的改动，可以采用 pull命令。

$ hg pull project3

project3为我们想要得到更新的目标repository的名字。

在 Pull 后，缺省情况下Mercurial不更新工作目录。这意味着虽然repository现在有changeset，但在工作目录中的 main.py 文件仍然是 pull 之前老的内容。

如果只想从hg clone的 repository 中更新当前 revision 到最新版，可以直接采用：

$ hg pull -u

Repository 之间的同步

上文当中的 push 和 pull 的操作，是处于不同位置的 repository 之间的同步。之前给出的两个例子是本地目录 repository 之间的同步。Mercurial 还支持以下形式的 repository 之间的同步：

file://local/filesystem/path http://[user@]host[:port]/[path] https://[user@]host[:port]/[path] ssh://[user@]host[:port]/[path]

其中 file 协议和本地目录相同。在 http 和 https 协议上使用push命令，需要在远端的服务器上启用相关的属性。ssh协议是众多系统中支持的shell。

标准的 Mercurial 发行包中还附带一个 Python CGI 脚本 hgweb.cgi, 可以用来参考搭建一个多用户可以集中式的同步改动的界面，如下图所示：

图 2. 界面

---

图 3. 层次关系
 

[extensions]
hgext.patchbomb =
[email]
method = smtp # 还可以在这里指定/usr/sbin/sendmail
from = Zhengang Li <lizg@cn.ibm.com>
to = groupmail@foo.com
[smtp]
host = smtp.foo.com

[extensions]
hgext.mq=

 对于input框，在定义高度后在ie下会出现各种很怪异的问题，所以我们一般不定义input框的高度，通过padding值来控制

--------来自团队的总结

 http://ejohn.org/apps/learn/

我终于这个优雅且几乎完美的JavaScript OOP 实现——轻便，简洁，并且有效。(暂且命名为emop)
Finally I've found the elegant implementation of almost-perfect OOP framework implementation in Javascript. It's light, clear, and, effective.(temporarily named emop)

var Class; 
void function() { 
var mgBaseGen = function(bcl, original) { 
return function(nname) { 
var c = bcl, rv; 
while (c && !c.prototype.hasOwnProperty(nname)) c = c.baseConstructor; 
if (!c) throw new Error('Cannot find base class with specific methods'); 
this.base = mgBaseGen(c.baseConstructor, this.base); 
try { 
rv = c.prototype[nname].apply(this, Array.prototype.slice.call(arguments, 1)); 
} finally { 
this.base = original; 
}; 
return rv; 
}; 
}; 
// Token 
var CHECK = {}; 
// Empty function 
var NULLFUNC = function() {}; 
// hasOwnProperty checker 
var HOPCHECKER = {}; 
// protected properties name 
var protectedName = '..protected..'; 
 
var registerProtecteds = function(o) { 
var protecteds = []; 
var p = function(checker, name, value) { 
if (checker !== CHECK) throw new Error('access denied'); 
if (arguments.length > 2) return protecteds[name] = value; 
else if (HOPCHECKER.hasOwnProperty.call(protecteds, name)) return protecteds[name]; 
}; 
p.length = 0; 
p.toString = function() { 
throw new Error('access denied') 
}; 
 
o[protectedName] = p; 
}; 
 
 
 
var bound = null; 
var priv = function(n, v) { 
if (!HOPCHECKER.hasOwnProperty.call(bound, protectedName)) { 
if (protectedName in bound) { 
registerProtecteds(bound); 
} else { 
return new Error('access denied'); 
} 
} 
if (arguments.length > 1) return bound[protectedName](CHECK, n, v); 
else return bound[protectedName](CHECK, n); 
}; 
 
var wrapProtected = function(method) { 
return function() { 
var hold = bound; 
bound = this; 
try { 
var ret = method.apply(this, arguments); 
} finally { 
bound = hold; 
return ret; 
} 
} 
} 
 
// catalogs 
var NClassBase = null; 
var NAttachments = []; 
 
Class = function(Definition, proto) { 
 
// stack backup 
var BClassBase = NClassBase; 
var BAttachments = NAttachments; 
 
// clear attachments array 
NAttachments = []; 
 
try { 
// constructor 
var ctor, def = new Definition(priv); 
if (def.initalize instanceof Function) { 
ctor = wrapProtected(def.initalize); 
} else { 
ctor = NULLFUNC; 
}; 
delete def.initalize; 
 
// create class 
var Clz = function() { 
registerProtecteds(this); 
return ctor.apply(this, arguments); 
}; 
 
//bind prototype 
if (proto instanceof Function || NClassBase instanceof Function) { 
if (proto instanceof Function) { 
Clz.prototype = new proto; 
Clz.baseConstructor = proto; 
} else if (NClassBase instanceof Function) { 
Clz.prototype = new NClassBase; 
Clz.baseConstructor = NClassBase; 
}; 
Clz.prototype.base = function(name) { 
var c = Clz.baseConstructor, rv, cler = arguments.callee.caller.caller; 
var original = this.base; 
this.base = mgBaseGen(c, original); 
try { 
rv = this.base.apply(this, arguments); 
} finally { 
this.base = original; 
}; 
return rv; 
}; 
} else { 
if (proto) Clz.prototype = proto; 
else Clz.prototype = {}; 
Clz.baseConstructor = Object; // need to be fixed; 
}; 
 
proto = Clz.prototype; 
 
//attachments 
for (var i = 0; i < NAttachments.length; i++) { 
var item = NAttachments[i][0]; 
var args = [proto].concat(NAttachments[i][1]); 
item.apply(proto, args); 
} 
 
//reflect methods 
for (var each in def) if (def.hasOwnProperty(each)) { 
if (def[each] instanceof Function) { 
var f = wrapProtected(def[each]); 
f.toString = function() { 
return def[each].toString() 
}; 
f.length = def[each].length; 
proto[each] = f; 
} else { 
proto[each] = def[each]; 
} 
}; 
 
} finally { 
NClassBase = BClassBase; 
NAttachments = BAttachments; 
return Clz; 
}; 
}; 
 
Class.base = function(f) { 
NClassBase = f; 
}; 
Class.attach = function(attachment, _args_) { 
NAttachments.push([attachment, Array.prototype.slice.call(arguments, 1)]); 
}; 
 
Function.prototype.derive = function(definition) { 
return Class(definition, this); 
}; 
Function.prototype.asClass = function(base) { 
return Class(this, base); 
} 
 
}(); 
 
//Usage 
var Greeter = function() { 
this.greet = function() { 
alert('hello!'); 
} 
} 
 
var A = function(priv) { 
Class.attach(Greeter); 
this.f = function(t) { 
priv('y', t); 
alert(priv('y')); 
}; 
}.asClass(); 
 
var B = A.derive( function(priv) { 
var Point = function(p) { 
this.initalize = function(x, y) { 
p('x', x); 
p('y', y); 
}; 
this.abs = function() { 
var x = p('x'); 
var y = p('y'); 
return Math.sqrt(x * x + y * y); 
}; 
}.asClass(); 
this.g = function(p, q) { 
alert((new Point(p, q)).abs()); 
}; 
this.f = function(t) { 
this.base('f', t); 
alert('-- ' + t); 
} 
this.inter = function(obj, t) { 
obj.f(t) 
}; 
}); 
 
var foo = new B(); 
foo.greet(); 
foo.f(2); 
var foo2 = new B(); 
foo2.g(5, 5); 
foo2.inter(foo, 3); 

这是什么？
What is it?

长期以来JavaScript程序员感到JavaScript的诸多掣肘之一就是它没有“完整的”OOP支持。尽管JavaScript利用原型系 统提供了OOP功能，但它没有提供这些特性：保护成员和基类方法调用。这段代码就是为了解决此问题。
For a long time, one of its limits which JavaScript programmers found is that it cannot provide "complete" OOP support. Although OOP was provided by the prototype system, the following charactics are absent: protected members and base method invocation. The target of this code is to solve this problem.

基本思想
Basic concepts

• 使用闭包独立环境
  Isolate environments by using closures
• 运行时覆写
  Runtime overwriting
• 使用try-finally的异常处理
  Exception handling via try-catch

定义类
Defining class

定义类的是一个函数，和传统的JavaScript构造器类似：
What defines a class is a function, written in thetraditional way:

function(priv) { 
this.g = function(t) { 
priv('x', t); 
alert(priv('x')); 
}; 
this.f = function(t) { 
this.base('f', t); 
alert('-- ' + t); 
} 
} 

你可以看见类似传统“构造器”的东西——用this.methodName定义方法。不过，这里有一个很奇怪的priv参 数——它就是保护乘员的读写器。类定义将会传入Class函数，经过一系列复杂的转化后，返回我们需要的构造器。获得这个类只 要通过下面一句：
You can see something like traditional JavaScript constructors--defineing methods via "this.methodName". But, a strange method named "priv" appears here.It's the accessor of protected members. Such class definition will be sent into Class, and after a series of complicated transformation, the constructor we need yields.Getting this class can even use only one statement:

A = Class(definition, base) 

第一个参数是定义，第二个是其基类。
The first argument is the definition, the second is its base class.

emop还有两个语法糖：一个是Function.prototype.asClass，另一个是Function.prototype.derive。 它们分别定义为：
There are also 2 syntax sugars in emop: one is Function.prototype.asClass, the other is Function.prototype.derive. Their definitions are:

Function.prototype.derive = function(definition) { 
return Class(definition, this); 
}; 
Function.prototype.asClass = function(base) { 
return Class(this, base); 
} 

细节
In depth

你已经看到了，一个类定义很像一个构造器，但事实上不是。类定义是个函数，而且真的会运行，但只会运行一次。事实上构造器是由其定义的initalize方 法描述：
You have seen that a class definition looks like a constructor, but it in't. Class definition is a function, and it will be invoked, but only once. Actually, the exact constructor is described by initalize method which the definition defines:

var Point = Class(function(p) { 
this.initalize = function(x, y) { 
p('x', x); 
p('y', y); 
}; 
this.abs = function() { 
var x = p('x'); 
var y = p('y'); 
return Math.sqrt(x * x + y * y); 
}; 
}); 

上面的Point是一个极好的例子。当我们要构造一个点的时候，虽然代码像下面的这样：
The Point above is a good example. When we need to construction a point, the following code appears:

var p1 = new Point(0, 0); 

特性
Charactics

你可能已经发现第一段代码中有几个很有趣的方法：
Maybe you've found some interesting methods in the first code paragraph:

• Class.attach
• Class.base
• “priv”
• (instance).base

上面几个“特殊”方法的用途分别是：
Usages of the "special" methods are:

• 附加相关的“附件”（混入类）
  Attach specific "Attachments"(mixins)
• 指定基类
  Define base class
• 存取“保护成员”
  Access "protected members"
• 调用“基类”方法
  Invoke base methods

priv

因为类定义是一个函数，它的第一个参数就是存取保护成员的读写器。在emop中一个对象拥有一般成员（和JavaScript中的一样）和保护成员 （只能用这个读写器访问）。因为方法定义总是包含在类定义中，所以priv可以被访问到，对象方法可以使用priv读 写保护成员：
Because class definition is a function, it's first paramater is the accessor of protected memners. Objects in emop contains normal members (like that in native JavaScript object) and protected members(only accessable by this accessor). Because the method definition is always contained by class definition, priv can be accessed and methods can use it to access protected members:

this.m = function() { 
priv('x'); // get 
priv('x', 1); // set 
} 

在这个例子中，m方法可以自由读写'x'保护成员。但priv在 类定义外就不能访问了，所以外界不能经过priv读写保护成员。
In this example, method m can access protected member 'x' freely. But priv is not accessable outside the class definiton, so outside program cannot access protected members via priv.

priv有两种调用方法：
There are two ways to invoke priv:

priv('x'); // get 
priv('x', 1); // set

传入一个参数意味着读取，传入两个参数就是写入。
Passing one argument means reading, two means writing.

因为是保护成员，所以基类定义的方法和派生类定义的方法都可以使用priv访问。
Because it is protected members, base methods and derived methods can both access it via priv.

var A = Class( function(p) { 
this.f = function() { 
p('x', 1) 
} 
}); 
var B = Class( function(p) { 
this.g = function() { 
return p('x') 
} 
},A); 
 
var obj = new B(); 
obj.f(); 
obj.g(); // --> 1  

Class.base and Class.attach

emop规定一个类只有一个基类，Class.base就描述基类。而Class.attch则 描述了混入类。混入类定义类似类定义，但它是直接apply到某类的prototype上。显然， 混入类不能拿到保护成员读写器priv。上面的那段代码可以改写成：
emop declared that a class have only one base class, and it is defined by Class.base. Class.attach describes mixins. Mixin definition looks like class definition, but it is directly apply-ed to the prototype of some class. Obviously, mixins cannot get protected member acceessor "priv". Code above can be written like:

var A = Class( function(p) { 
this.f = function() { 
p('x', 1) 
} 
}); 
var B = Class( function(p) { 
Class.base(A); 
this.g = function() { 
return p('x') 
} 
}); 
 
var obj = new B(); 
obj.f(); 
obj.g(); // 1  

因此，定义派生类有两种方法：
So, derived class can be defined in two ways:

Derived = Class( function() {...... 
},Base) 
Derived = Class( function() { 
Class.base(Base);...... 
}) 

下面的情况下，Base1是Derived的基类。另一个被抛弃：
Under the following situation, Base1 is the base class of Derived, Not Base2

Derived = Class( function() { 
Class.base(Base2);...... 
},Base1) 

混入类可以参数化——当调用Class.attach(mixin,a,b,c)时，传入mixin的 第一个参数是被定义类的prototype，接着是a,b,c。传入的this指 针也是那个prototype：
Mixins can be parameterized -- When invoking Class.attach(mixin,a,b,c), First argument passed into mixin is the prototype of defined class, following arguments are a,b and c. this pointer passed is also that prototype.

Mix = function(proto, a) { 
this.f = function() { 
return a 
} 
}; 
 
var Thing = Class( 
function() { 
Class.attach(Mix, 1); 
}); 
 
var t = new Thing; 
t.f() // --> 1 

(instance).base

每个用Class创建的类构造的对象都有一个base用于调用基类方法。类似这样：
Each object constructed by a Class-defined class contains the base as a base-method invoker. Like this:

var A = Class( function(p) { 
this.f = function(t) { 
return t 
} 
}); 
var B = Class( function(p) { 
Class.base(A); 
this.f = function(t) { 
return 'x' + this.base('f', t) 
}; 
}); 
 
var obj = new B(); 
obj.f(1); // --> x1 

传入给base的第一个参数是要调用的基方法名，接着是参数。base会搜索其基类，如果它定义了 指定的方法，就执行之，否则继续向上，直到确认在所有基类中都找不到为止。
First argument passed into base is the method name we want to invoke, then "actual" arguments. base will search its base class, invoke the specified method if the base class defined it, or continue going up until it confirmed the method is absent in all base class definitions.

var A = Class( function(p) { 
this.f = function(t) { 
return t 
} 
}); 
var B = Class( function(p) { 
Class.base(A); 
}); 
 
var C = Class( function(p) { 
Class.base(B); 
this.f = function(t) { 
return 'x' + this.base('f', t) 
} 
this.g = function() { 
return this.base('g') 
} 
}); 
 
var obj = new C(); 
obj.f(1); // --> x1 
obj.g(); // --> Error: Method "g" absent 

实现技术
Implementation Techniques

运行时覆写
Runtime Overwriting

回溯法的例子
Examples in backtracking algorithms

想象一下我们在书写一个迷宫程序。迷宫由若干cell组成，我们的目的是看有没有去出口的路径。这种问题很适合用回溯 法，算法的框架大体如下：
Imagine that we're writing a maze program. A maze consists of some cell, and we're going to find out whether the way to the exit exists. This problem is suit for backtracking. The algorithm looks like this:

var found = false, steps = 0; 
 
function searchCell(position) { 
position.visited = true; 
if (position == maze.exit) { 
found = true; 
return 
}; 
steps += 1; 
var neighbors = position.getNeighbors(); 
for (var each in neighbors) if (!neighbors[each].visited) { 
searchCell(neighbors[each]); 
if (found) return; 
} 
steps -= 1; 
} 
 
searchCell(maze.start) 

steps很好地说明了运行时覆写的原理——当搜索一个未访问的cell时，把它加1，表示 “走一步”；而回溯的时候，则把它减1，表示“退回”。这样，如果你搜索地图无果，那么steps还是0。
steps explained the mechanism of runtime overwriting well -- when searching one unvisited cell, increase it, means "one step"; when backtracking, decrease it, means "go back". Therefore, if the way does not exist, steps equals to 0.

运行时覆写的基本思路就是——当进入方法，修改某个东西；当退出方法，则把它改回来。
Basic principles of Runtime overwritting is Change something when enter the method, and change it back when exit.

priv

你肯定很好奇调用priv的时候是怎么知道要取那个对象的保护成员的。要知道我们压根没有给priv传this指 针。实际上，priv取的是一个叫bound的对象的保护成员——bound则 是在调用对象方法的时候覆写成传入那个方法的this指针的。
You will be curious about how priv knows which object's protected members will be accessed. We never pass this pointer to priv. Actually, priv accesses the protected members of an object named "bound". "bound" is overrited to this pointer when invoking a method.

emop中，每个类定义的方法都被包裹，秘密在wrapProtected中。它的代码是：

var bound; 
 
// ........ 
var wrapProtected = function(method) { 
return function() { 
var hold = bound; 
bound = this; 
try { 
var ret = method.apply(this, arguments); 
} finally { 
bound = hold; 
return ret; 
} 
} 
} 
// ........ 
Clz.prototype[each] = wrapProtected(def[each]); 

因为不能给priv直接传this（否则要他还有何意义），wrapProtected就 做了一个有趣的事情——在对象调用方法之前，把bound设置成传入的this指针，同时做备份； 而当退出时，则把bound再改回来。这么一来二去，method调用时priv可 以正确找到保护成员，而结束后则像什么都没发生一样。
Because we can't pass this to priv explicitly, wrapProtected did something interesting. Before the "real" method's invocation, change bound to passed this pointer, also backup it; After the method invoked, change bound back. With this process, when the "real" method is running, priv works correctly, and, when it ended, it seems nothing happened to priv and bound.

try ... finally保证了即使method发生异常，bound也 能改回来。当然，这会造成一点性能损失。
try ... finally ensured that even method throws an exception, bound will be changed back. Obviously, it will slow down the progeam a little.

Class.base和Class.attach的原理相似，这里就不深究了。各位可以看代 码研究。
Class.base and Class.attach works in the same mechanism. You can read the code above.

base

base中使用的技术最为复杂——因为这次覆写的就是它自己。this.base在它自己调 用时，基类方法调用前覆写，基类方法调用后改回。
Techniques used in base is the most complicated, becaust it will overwrite itself. this.base overwrites itself after it is invoked, and before base method's invocation; and change it back after base method exits.

base搜索基方法依赖在类上维护的baseConstructor属性，它直接指向基类。用于覆写的base由一个叫mgBaseGen的函数生 成，代码是：
base's searching depends on the baseConstructor property of classes, which points to it's class. bases used to overwrite is generated by function mgBaseGen:

var mgBaseGen = function(bcl, original) { 
return function(nname) { 
var c = bcl, rv; 
while (c && !c.prototype.hasOwnProperty(nname)) c = c.baseConstructor; 
if (!c) throw new Error('Cannot find base class with specific method'); 
this.base = mgBaseGen(c.baseConstructor, this.base); 
try { 
rv = c.prototype[nname].apply(this, Array.prototype.slice.call(arguments, 1)); 
} finally { 
this.base = original; 
}; 
return rv; 
}; 
}; 

mgBaseGen接受两个参数，一个是搜索方法的起点bcl，另一个是备份original。 在3-5行，沿着baseConstructor链搜索某个合适的类c，包含nname指 定的方法；接着，把this.base覆写成以c的基类为起点的新base。 然后，调用基类方法。调用完毕，则把this.base改回original，清除痕迹；最后，返 回值。
mgBaseGen accepts two parameters, ont is the searching start, bcl, the other is the backup, original. In line 3-5, generated base method searches the class c defines specified method method; then overwrite the this.base method by a new base with c.baseConstructor as searching start. Then, invoke the found base method and change this.base back.

这样，this.base就以一种神奇的方式工作——如果基类方法还要调用更“基类”的方法的话，this.base就 会站在更深的地方搜索方法。而当基类方法调用完成时，this.base就像没改过一样。
In this way, this.base works magically --  if the base method needs to invoke a "baser" method, this.base will start searching the method at a "deeper" place. But when the base method is exited, this.base looks unchanged.

this.base加入到原型中使用下面的代码——这几乎不用解释：
Adding this.base into prototype uses following code -- explaining is needless:

Clz.prototype.base = function(name) { 
var c = Clz.baseConstructor, rv, cler = arguments.callee.caller.caller; 
var original = this.base; 
this.base = mgBaseGen(c, original); 
try { 
rv = this.base.apply(this, arguments); 
} finally { 
this.base = original; 
}; 
return rv; 
}; 

类定义的实现
Implementation of class definition

在类定义中我们用“this.method = function(){...}”定义方法，但是，这种定义法是如何变 成一个构造器的呢？事实上在Class中，我们把定义给new了一次：
In class definitions, we use "this.method = function(){...}" to define methods. But how did the class definition come into a constructor. In fact, we constructed the definition once in Class:

Class = function(definition, proto) { 
// ... 
var ctor, def = new Definition(priv); 
if (def.initalize instanceof Function) { 
ctor = wrapProtected(def.initalize); 
} else { 
ctor = NULLFUNC; 
}; 
delete def.initalize; 
 
// create class 
var Clz = function() { 
registerProtecteds(this); 
return ctor.apply(this, arguments); 
}; 
// ... 
} 

def对象是“new”定义的产物，接着，如果它包含initalize方 法，则把包裹它作为“初始化器”，否则，就用空函数。生成的构造器Clz实际上包含了两步，一个是注册保护成员（见下一节）， 另一个则是执行初始器。
The def object is the result of constructing definition, and then, if def contains initalize method, wrap it by wrapProtected and set the initalizer (ctor) to it; if not, set it to the empty function. Generated constructor Clz contains 2 steps: registering protected menber (see the selection below), and executing ctor.

原型的绑定在下一步：
Prototype is bound in the next:

//bind prototype 
if (proto instanceof Function || NClassBase instanceof Function) { 
if (proto instanceof Function) { 
Clz.prototype = new proto; 
Clz.baseConstructor = proto; 
} else if (NClassBase instanceof Function) { 
Clz.prototype = new NClassBase; 
Clz.baseConstructor = NClassBase; 
}; 
Clz.prototype.base = function(name) { 
var c = Clz.baseConstructor, rv, cler = arguments.callee.caller.caller; 
var original = this.base; 
this.base = mgBaseGen(c, original); 
try { 
rv = this.base.apply(this, arguments); 
} finally { 
this.base = original; 
}; 
return rv; 
}; 
} else { 
if (proto) Clz.prototype = proto; 
else Clz.prototype = {}; 
Clz.baseConstructor = Object; 
}; 
 
proto = Clz.prototype; 

这里检查了两处，一个是显式传入的proto，另一个是用Class.base注册的基类NClassBase。 如果proto是函数，则构造一个对象做原型，NClassBase同理。如果proto是 一个对象，则把Clz的原型直接赋予它。
We checked explicitly passed argument proto and NClassBase registered by Class.base. If proto is a function, the prototype of Clz will be the object constructed by proto. NClassBase is processed in like manner. If proto is an object, but not a function, then directly set Clz.prototype to it.

保护成员的实现
Implementation of protected members

现在我们要深入priv，了解保护成员是如何实现的。
Now we will see the detail of priv, to know how protected members implemented.

var priv = function(n, v) { 
if (!bound.hasOwnProperty('__protected')) return new Error('access denied'); 
if (arguments.length > 1) return bound.__protected(CHECK, n, v); 
else return bound.__protected(CHECK, n); 
}; 

priv的实现异常简单——它调用……对象的__protected方法。等等，这个方法会不会把 保护成员泄密？实际上不会，因为有CHECK。CHECK是一个围在闭包里的“令牌”，外界几乎无 法获取。__protected方法是在这里注册的：
The implementation of priv looks very simple. It invokes ...... the __protected method of the object. But will this method betray its protected methods? Actually no, because there is a check. The constant CHECK is an token object contained in the outer closure and it's unaccessable outside. __protected was registered here:

// Token 
var CHECK = {}; 
// Empty function 
var NULLFUNC = function() {}; 
// hasOwnProperty checker 
var HOPCHECKER = {}; 
var registerProtecteds = function(o) { 
var protecteds = []; 
var p = function(checker, name, value) { 
if (checker !== CHECK) throw new Error('access denied'); 
if (arguments.length > 2) return protecteds[name] = value; 
else if (HOPCHECKER.hasOwnProperty.call(protecteds, name)) return protecteds[name]; 
}; 
p.length = 0; 
p.toString = function() { 
throw new Error('access denied') 
}; 
 
o.__protected = p; 
}; 

函数p的第一行干的就是检查CHECK，如果“令牌”不对，对不起，access denied。接下来的内容就很简单了，基本的hash操作。这里使用了一个小技巧，用HOPCHECKER的hasOwnProperty检 查protecteds的属性有无，防止覆写hasOwnProperty造成检测的错误。
What the first line of function p did is checking CHECK. if the token is wrong, then throw an access denied exception. Following contents are easy, basic hashtable operations.There is a small technique:  checking property existance of protecteds by HOPCHECKER's hasOwnProperty, in order to avoid mistakes made by overwriting hasOwnProperty.

那么，registerProtecteds是何时“注册”到对象上的呢？答案在这里：
So, when does registerProtecteds "registers" to the object? The answer is here:

var Clz = function() { 
registerProtecteds(this); 
return ctor.apply(this, arguments); 
}; 

优势
Advantages

• 仍可以使用原生的Clz.prototype.method = function(){}定义方法
  Native Clz.prototype.method = function(){...} is still avliable
• base在不用Class定义的派生类中仍可使用，只需维护baseConstructor
base is still avaliable in derived classes not defined by Class, only keeping baseConstructor needed.
• 支持嵌套类
  Nested classes supported

待改进
To do

• 使用try ... finally造成调试不便
  try ... finally will make debugging unconvient
• 性能损失
  Preformance lack
• 不支持ECMA v5定义的读写器，稍加修改即可
  Accessor defined in ECMA v5 is not supported, but it can be supported after a little modification.

基本方法如下：

if (typeof navigator.plugins !="undefined" && typeof navigator.plugins["Shockwave Flash"] == "object") { 
//非IE 已安装Flash 
}else if (typeof window.ActiveXObject != "undefined") { 
//IE   已安装Flash 
} 

经典的垂直问题中，img 的父容器如果 float 了，那么其 display table-cell 将失效，table-cell 只能在 display static 的时候有效，因此解决方案是给 img 再加个包装容器，原来的父容器 float，包装器 table-cell

--------来自团队总结

 每日Tip：尽量向 setTimeout() 和 setInterval()传送函数名，而不要传送字串。setTimeout() 和 setInterval() 方法近似于 eval。如果传进参数是字符串，则在一段时间之后，会和 eval一样执行字符串值，当然其低效率也和 eval 一样。但这些方法也可以接受函数作为第一个参数。在一段时间后将调用此函数，但此函数可在编译时被解释和优化，也就是说会有更好的性能。

-------来自团队总结

chrome://browser/content/browser.xul 

 SharedObject.getLocal() 如果要在2个同时运行的应用中实现本地数据同步。则需要将SharedObject变量对象声明为局部变量而非全局变量。

----来自一次项目的总结

https://wiki.mozilla.org/Audio_Data_API

推荐系统最早在亚马逊的网站上应用，根据以往用户的购买行为，推荐出购买某种产品同时可能购买的其他产品。

直接打分需要用户的参与程度比较高，很多网站都在内容页中留一个打分的按钮，从1～5选一 个，我可能喜欢这篇文章，可我哪里知道我喜欢的程度是几分啊，还要我去思考，而网站设计中一条很重要的原则是:Do not let me think!，于是我就胡打一个分数或者不打，而隐性的打分则不同，只有你喜欢的图书你才会购买，只有你喜欢的歌曲才会听多次。

最近邻搜索算法一般是皮尔森相关系数（Person Correlation Coefficient）、余弦相似性（Cosine-based Similarity）以及调整余弦相似性（Adjusted Cosine Similarity）。关于余弦定理在数据挖掘中的应用，google黑白报有过介绍，可以参考数学之美 系列 12 - 余弦定理和新闻的分类。

基本原理

用户	对事物A打分	对事物B打分
X	3	4
Y	2	4
Z	4	?

用户Z对事物B的打分可能是多少呢？股票上有个说法是平均值可以掩盖一切异常波动，所以股票上的各个技术指标收拾不同时间段的平均值的曲线图或者柱 状图等。同样的，Slope one算法也认为：平均值也可以代替某两个未知个体之间的打分差异，事物A对事物B的平均很差是：((3 - 4) + (2 - 4)) / 2 = -1.5，也就是说人们对事物B的打分一般比事物A的打分要高1.5，于是Slope one算法就猜测Z对事物B的打分是4 + 1.5 = 5.5

加权算法

有n个人对事物A和事物B打分了，R(A->B)表示这n个人对A和对B打分的平均差（A-B）,有m个人对事物B和事物C打分 了，R（C->B）表示这m个人对C和对B打分的平均差（C-B），注意都是平均差而不是平方差，现在某个用户对A的打分是ra，对C的打分是 rc，那么A对B的打分可能是：

rb = (n * (ra - R(A->B)) + m * (rc - R(C->B)))/(m+n)

 
# This is the code in plain text out of the technical report. 
# 
# Daniel Lemire, Sean McGrath, Implementing a Rating-Based Item-to-Item 
# Recommender System in PHP/SQL, Technical Report D-01, January 2005. 
# 
# http://www.ondelette.com/lemire/abstracts/TRD01.html 
# 
# This code is in the public domain, use at your own risks. 
# It is assumed that you looked at the report and know some SQL and PHP. 
# 
# Daniel Lemire, February 3rd 2005 
# 
# First part is sample SQL code. 
#########CUT HERE#################### 
 
CREATE TABLE rating ( 
    userID INT PRIMARY KEY, 
    itemID INT NOT NULL, 
    ratingValue INT NOT NULL, 
    datetimestamp TIMESTAMP NOT NULL 
); 
 
 
CREATE TABLE dev ( 
  itemID1 int(11) NOT NULL default '0', 
  itemID2 int(11) NOT NULL default '0', 
  count int(11) NOT NULL default '0', 
  sum int(11) NOT NULL default '0', 
  PRIMARY KEY  (itemID1,itemID2) 
); 
 
 
# simple query to output 10 most liked items 
# by people who rated item 1 
SELECT itemID2, ( sum / count ) AS average 
FROM dev 
WHERE count > 2 AND itemID1 = 1 
ORDER  BY ( sum / count ) DESC 
LIMIT 10; 
 
# Next part is sample PHP code. 
#########CUT HERE#################### 
 
// This code assumes $itemID is set to that of  
// the item that was just rated.  
// Get all of the user's rating pairs 
$sql = "SELECT DISTINCT r.itemID, r2.ratingValue - r.ratingValue  
            as rating_difference 
            FROM rating r, rating r2 
            WHERE r.userID=$userID AND  
                    r2.itemID=$itemID AND  
                    r2.userID=$userID;"; 
$db_result = mysql_query($sql, $connection); 
$num_rows = mysql_num_rows($db_result); 
//For every one of the user's rating pairs,  
//update the dev table 
while ($row = mysql_fetch_assoc($db_result)) { 
    $other_itemID = $row["itemID"]; 
    $rating_difference = $row["rating_difference"]; 
    //if the pair ($itemID, $other_itemID) is already in the dev table 
    //then we want to update 2 rows. 
    if (mysql_num_rows(mysql_query("SELECT itemID1  
    FROM dev WHERE itemID1=$itemID AND itemID2=$other_itemID", 
    $connection)) > 0)  { 
        $sql = "UPDATE dev SET count=count+1,  
    sum=sum+$rating_difference WHERE itemID1=$itemID  
    AND itemID2=$other_itemID"; 
        mysql_query($sql, $connection); 
    //We only want to update if the items are different                 
        if ($itemID != $other_itemID) { 
            $sql = "UPDATE dev SET count=count+1,  
        sum=sum-$rating_difference  
        WHERE (itemID1=$other_itemID AND itemID2=$itemID)"; 
            mysql_query($sql, $connection); 
        } 
    } 
    else { //we want to insert 2 rows into the dev table 
        $sql = "INSERT INTO dev VALUES ($itemID, $other_itemID, 
        1, $rating_difference)"; 
        mysql_query($sql, $connection);  
    //We only want to insert if the items are different        
        if ($itemID != $other_itemID) {          
            $sql = "INSERT INTO dev VALUES ($other_itemID,  
        $itemID, 1, -$rating_difference)"; 
            mysql_query($sql, $connection); 
        } 
    }     
} 
 
 
function predict($userID, $itemID) { 
    global $connection;     
    $denom = 0.0; //denominator 
    $numer = 0.0; //numerator     
    $k = $itemID;     
    $sql = "SELECT r.itemID, r.ratingValue  
    FROM rating r WHERE r.userID=$userID AND r.itemID <> $itemID"; 
    $db_result = mysql_query($sql, $connection);         
    //for all items the user has rated 
    while ($row = mysql_fetch_assoc($db_result))  { 
        $j = $row["itemID"]; 
        $ratingValue = $row["ratingValue"];         
        //get the number of times k and j have both been rated by the same user 
        $sql2 = "SELECT d.count, d.sum FROM dev d WHERE itemID1=$k AND itemID2=$j"; 
        $count_result = mysql_query($sql2, $connection);         
        //skip the calculation if it isn't found 
        if(mysql_num_rows($count_result) > 0)  { 
            $count = mysql_result($count_result, 0, "count"); 
            $sum = mysql_result($count_result, 0, "sum");             
            //calculate the average 
            $average = $sum / $count;             
            //increment denominator by count 
            $denom += $count;             
            //increment the numerator 
            $numer += $count * ($average + $ratingValue); 
        }         
    }     
    if ($denom == 0) 
        return 0; 
    else 
        return ($numer / $denom); 
} 
 
 
function predict_all($userID ) { 
    $sql2 = "SELECT d.itemID1 as 'item', sum(d.count) as 'denom',  
    sum(d.sum + d.count*r.ratingValue) as 'numer' FROM item i, rating r, 
    dev d WHERE r.userID=$userID  
    AND d.itemID1<>r.itemID  
    AND d.itemID2=r.itemID GROUP BY d.itemID1"; 
    return mysql_query($sql2, $connection); 
} 

Java：

import java.util.*; 
/** 
* Daniel Lemire 
* A simple implementation of the weighted slope one 
* algorithm in Java for item-based collaborative  
* filtering.  
* Assumes Java 1.5. 
* 
* See main function for example. 
* 
* June 1st 2006. 
* Revised by Marco Ponzi on March 29th 2007 
*/ 
 
public class SlopeOne { 
   
  public static void main(String args[]){ 
    // this is my data base 
    Map<UserId,Map<ItemId,Float>> data = new HashMap<UserId,Map<ItemId,Float>>(); 
    // items 
    ItemId item1 = new ItemId("       candy"); 
    ItemId item2 = new ItemId("         dog"); 
    ItemId item3 = new ItemId("         cat"); 
    ItemId item4 = new ItemId("         war"); 
    ItemId item5 = new ItemId("strange food"); 
     
    mAllItems = new ItemId[]{item1, item2, item3, item4, item5}; 
     
    //I'm going to fill it in 
    HashMap<ItemId,Float> user1 = new HashMap<ItemId,Float>(); 
    HashMap<ItemId,Float> user2 = new HashMap<ItemId,Float>(); 
    HashMap<ItemId,Float> user3 = new HashMap<ItemId,Float>(); 
    HashMap<ItemId,Float> user4 = new HashMap<ItemId,Float>(); 
    user1.put(item1,1.0f); 
    user1.put(item2,0.5f); 
    user1.put(item4,0.1f); 
    data.put(new UserId("Bob"),user1); 
    user2.put(item1,1.0f); 
    user2.put(item3,0.5f); 
    user2.put(item4,0.2f); 
    data.put(new UserId("Jane"),user2); 
    user3.put(item1,0.9f); 
    user3.put(item2,0.4f); 
    user3.put(item3,0.5f); 
    user3.put(item4,0.1f); 
    data.put(new UserId("Jo"),user3);     
    user4.put(item1,0.1f); 
    //user4.put(item2,0.4f); 
    //user4.put(item3,0.5f); 
    user4.put(item4,1.0f); 
    user4.put(item5,0.4f); 
    data.put(new UserId("StrangeJo"),user4);     
    // next, I create my predictor engine 
    SlopeOne so = new SlopeOne(data); 
    System.out.println("Here's the data I have accumulated..."); 
    so.printData(); 
    // then, I'm going to test it out... 
    HashMap<ItemId,Float> user = new HashMap<ItemId,Float>(); 
    System.out.println("Ok, now we predict..."); 
    user.put(item5,0.4f); 
    System.out.println("Inputting..."); 
    SlopeOne.print(user); 
    System.out.println("Getting..."); 
    SlopeOne.print(so.predict(user)); 
    // 
    user.put(item4,0.2f); 
    System.out.println("Inputting..."); 
    SlopeOne.print(user); 
    System.out.println("Getting..."); 
    SlopeOne.print(so.predict(user)); 
  } 
   
  Map<UserId,Map<ItemId,Float>> mData; 
  Map<ItemId,Map<ItemId,Float>> mDiffMatrix; 
  Map<ItemId,Map<ItemId,Integer>> mFreqMatrix; 
   
  static ItemId[] mAllItems; 
   
  public SlopeOne(Map<UserId,Map<ItemId,Float>> data) { 
    mData = data; 
    buildDiffMatrix();     
  } 
   
  /** 
  * Based on existing data, and using weights, 
  * try to predict all missing ratings. 
  * The trick to make this more scalable is to consider 
  * only mDiffMatrix entries having a large  (>1) mFreqMatrix 
  * entry. 
  * 
  * It will output the prediction 0 when no prediction is possible. 
  */ 
  public Map<ItemId,Float> predict(Map<ItemId,Float> user) { 
    HashMap<ItemId,Float> predictions = new HashMap<ItemId,Float>(); 
    HashMap<ItemId,Integer> frequencies = new HashMap<ItemId,Integer>(); 
    for (ItemId j : mDiffMatrix.keySet()) { 
      frequencies.put(j,0); 
      predictions.put(j,0.0f); 
    } 
    for (ItemId j : user.keySet()) { 
      for (ItemId k : mDiffMatrix.keySet()) { 
        try { 
        float newval = ( mDiffMatrix.get(k).get(j).floatValue() + user.get(j).floatValue() ) * mFreqMatrix.get(k).get(j).intValue(); 
        predictions.put(k, predictions.get(k)+newval); 
        frequencies.put(k, frequencies.get(k)+mFreqMatrix.get(k).get(j).intValue()); 
        } catch(NullPointerException e) {} 
      } 
    } 
    HashMap<ItemId,Float> cleanpredictions = new HashMap<ItemId,Float>(); 
    for (ItemId j : predictions.keySet()) { 
        if (frequencies.get(j)>0) { 
          cleanpredictions.put(j, predictions.get(j).floatValue()/frequencies.get(j).intValue()); 
        } 
    } 
    for (ItemId j : user.keySet()) { 
         cleanpredictions.put(j,user.get(j)); 
    } 
    return cleanpredictions; 
  } 
   
  /** 
  * Based on existing data, and not using weights, 
  * try to predict all missing ratings. 
  * The trick to make this more scalable is to consider 
  * only mDiffMatrix entries having a large  (>1) mFreqMatrix 
  * entry. 
  */ 
  public Map<ItemId,Float> weightlesspredict(Map<ItemId,Float> user) { 
    HashMap<ItemId,Float> predictions = new HashMap<ItemId,Float>(); 
    HashMap<ItemId,Integer> frequencies = new HashMap<ItemId,Integer>(); 
    for (ItemId j : mDiffMatrix.keySet()) { 
      predictions.put(j,0.0f); 
      frequencies.put(j,0); 
    } 
    for (ItemId j : user.keySet()) { 
      for (ItemId k : mDiffMatrix.keySet()) { 
        //System.out.println("Average diff between "+j+" and "+ k + " is "+mDiffMatrix.get(k).get(j).floatValue()+" with n = "+mFreqMatrix.get(k).get(j).floatValue()); 
        float newval = ( mDiffMatrix.get(k).get(j).floatValue() + user.get(j).floatValue() ) ; 
        predictions.put(k, predictions.get(k)+newval); 
      } 
    } 
    for (ItemId j : predictions.keySet()) { 
        predictions.put(j, predictions.get(j).floatValue()/user.size()); 
    } 
    for (ItemId j : user.keySet()) { 
      predictions.put(j,user.get(j)); 
    } 
    return predictions; 
  } 
 
 
  public void printData() { 
        for(UserId user : mData.keySet()) { 
          System.out.println(user); 
          print(mData.get(user)); 
        } 
        for (int i=0; i<mAllItems.length; i++) { 
            System.out.print("\n" + mAllItems[i] + ":"); 
            printMatrixes(mDiffMatrix.get(mAllItems[i]), mFreqMatrix.get(mAllItems[i])); 
        } 
      } 
 
    private void printMatrixes(Map<ItemId,Float> ratings, 
                Map<ItemId,Integer> frequencies) {   
            for (int j=0; j<mAllItems.length; j++) { 
                System.out.format("%10.3f", ratings.get(mAllItems[j])); 
                System.out.print(" "); 
                System.out.format("%10d", frequencies.get(mAllItems[j])); 
            } 
        System.out.println(); 
    } 
   
  public static void print(Map<ItemId,Float> user) { 
    for (ItemId j : user.keySet()) { 
      System.out.println(" "+ j+ " --> "+user.get(j).floatValue()); 
    } 
  } 
   
  public void buildDiffMatrix() { 
    mDiffMatrix = new HashMap<ItemId,Map<ItemId,Float>>(); 
    mFreqMatrix = new HashMap<ItemId,Map<ItemId,Integer>>(); 
    // first iterate through users 
    for(Map<ItemId,Float> user : mData.values()) { 
      // then iterate through user data 
      for(Map.Entry<ItemId,Float> entry: user.entrySet()) { 
        if(!mDiffMatrix.containsKey(entry.getKey())) { 
          mDiffMatrix.put(entry.getKey(), new HashMap<ItemId,Float>()); 
          mFreqMatrix.put(entry.getKey(), new HashMap<ItemId,Integer>()); 
        } 
        for(Map.Entry<ItemId,Float> entry2: user.entrySet()) { 
          int oldcount = 0; 
          if(mFreqMatrix.get(entry.getKey()).containsKey(entry2.getKey())) 
            oldcount = mFreqMatrix.get(entry.getKey()).get(entry2.getKey()).intValue(); 
          float olddiff = 0.0f; 
          if(mDiffMatrix.get(entry.getKey()).containsKey(entry2.getKey())) 
            olddiff = mDiffMatrix.get(entry.getKey()).get(entry2.getKey()).floatValue(); 
          float observeddiff = entry.getValue() - entry2.getValue(); 
          mFreqMatrix.get(entry.getKey()).put(entry2.getKey(),oldcount + 1); 
          mDiffMatrix.get(entry.getKey()).put(entry2.getKey(),olddiff+observeddiff);           
        } 
      } 
    } 
    for (ItemId j : mDiffMatrix.keySet()) { 
      for (ItemId i : mDiffMatrix.get(j).keySet()) { 
        float oldvalue = mDiffMatrix.get(j).get(i).floatValue(); 
        int count = mFreqMatrix.get(j).get(i).intValue(); 
        mDiffMatrix.get(j).put(i,oldvalue/count); 
      } 
    } 
  } 
} 
 
class UserId  { 
  String content; 
  public UserId(String s) { 
    content = s; 
  } 
   
  public int hashCode() { return content.hashCode();} 
  public String toString() { return content; } 
} 
class ItemId  { 
  String content; 
  public ItemId(String s) { 
    content = s; 
  } 
  public int hashCode() { return content.hashCode();} 
  public String toString() { return content; } 
} 

Python：

# Copyright 2006 Bryan O'Sullivan <bos@serpentine.com>. 
# 
# This software may be used and distributed according to the terms 
# of the GNU General Public License, version 2 or later, which is 
# incorporated herein by reference. 
 
class SlopeOne(object): 
    def __init__(self): 
        self.diffs = {} 
        self.freqs = {} 
 
    def predict(self, userprefs): 
        preds, freqs = {}, {} 
        for item, rating in userprefs.iteritems(): 
            for diffitem, diffratings in self.diffs.iteritems(): 
                try: 
                    freq = self.freqs[diffitem][item] 
                except KeyError: 
                    continue 
                preds.setdefault(diffitem, 0.0) 
                freqs.setdefault(diffitem, 0) 
                preds[diffitem] += freq * (diffratings[item] + rating) 
                freqs[diffitem] += freq 
        return dict([(item, value / freqs[item]) 
                     for item, value in preds.iteritems() 
                     if item not in userprefs and freqs[item] > 0]) 
 
    def update(self, userdata): 
        for ratings in userdata.itervalues(): 
            for item1, rating1 in ratings.iteritems(): 
                self.freqs.setdefault(item1, {}) 
                self.diffs.setdefault(item1, {}) 
                for item2, rating2 in ratings.iteritems(): 
                    self.freqs[item1].setdefault(item2, 0) 
                    self.diffs[item1].setdefault(item2, 0.0) 
                    self.freqs[item1][item2] += 1 
                    self.diffs[item1][item2] += rating1 - rating2 
        for item1, ratings in self.diffs.iteritems(): 
            for item2 in ratings: 
                ratings[item2] /= self.freqs[item1][item2] 
 
if __name__ == '__main__': 
    userdata = dict( 
        alice=dict(squid=1.0, 
                   cuttlefish=0.5, 
                   octopus=0.2), 
        bob=dict(squid=1.0, 
                 octopus=0.5, 
                 nautilus=0.2), 
        carole=dict(squid=0.2, 
                    octopus=1.0, 
                    cuttlefish=0.4, 
                    nautilus=0.4), 
        dave=dict(cuttlefish=0.9, 
                  octopus=0.4, 
                  nautilus=0.5), 
        ) 
    s = SlopeOne() 
    s.update(userdata) 
    print s.predict(dict(squid=0.4)) 

 =-========================== 延伸文章===========================

来源 ： http://my.donews.com/clickstone/2006/10/16/fktEQWUckzvGDyfjugcqcJjkaDpdjemooGTf/

本文是关于推荐系统的系列研究文章之一，其他内容将陆续发布。这些内容，大多数来自我在2004年底完成的一篇项目方案建议书。放在这里，抛砖引玉，供大家讨论之用。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

在推荐系统简介中，我们给出了推荐系统的一般框架。很明显，推荐方法是整个推荐系统中最核心、最关键的部分，很大程度上决定了推荐系统性能的优劣。目前，主要的推荐方法包括：基于内容推荐、协同过滤推荐、基于关联规则推荐、基于效用推荐、基于知识推荐和组合推荐。

一、基于内容推荐

基于内容的推荐（Content-based Recommendation）是信息过滤技术的延续与发展，它是建立在项目的内容信息上作出推荐的，而不需要依据用户对项目的评价意见，更多地需要用机 器学习的方法从关于内容的特征描述的事例中得到用户的兴趣资料。在基于内容的推荐系统中，项目或对象是通过相关的特征的属性来定义，系统基于用户评价对象 的特征，学习用户的兴趣，考察用户资料与待预测项目的相匹配程度。用户的资料模型取决于所用学习方法，常用的有决策树、神经网络和基于向量的表示方法等。 基于内容的用户资料是需要有用户的历史数据，用户资料模型可能随着用户的偏好改变而发生变化。

基于内容推荐方法的优点是：
 1）不需要其它用户的数据，没有冷开始问题和稀疏问题。
 2）能为具有特殊兴趣爱好的用户进行推荐。
 3）能推荐新的或不是很流行的项目，没有新项目问题。
 4）通过列出推荐项目的内容特征，可以解释为什么推荐那些项目。
 5）已有比较好的技术，如关于分类学习方面的技术已相当成熟。

缺点是要求内容能容易抽取成有意义的特征，要求特征内容有良好的结构性，并且用户的口味必须能够用内容特征形式来表达，不能显式地得到其它用户的判断情况。

二、协同过滤推荐

协同过滤推荐（Collaborative Filtering Recommendation）技术是推荐系统中应用最早和最为成功的技术之一。它一般采用最近邻技术，利用用户的历史喜好信息计算用户之间的距离，然后 利用目标用户的最近邻居用户对商品评价的加权评价值来预测目标用户对特定商品的喜好程度，系统从而根据这一喜好程度来对目标用户进行推荐。协同过滤最大优 点是对推荐对象没有特殊的要求，能处理非结构化的复杂对象，如音乐、电影。

协同过滤是基于这样的假设：为一用户找到他真正感兴趣的内容的好方法是首先找到与此用户有相似兴趣的其他用户，然后将他们感兴趣的内容推荐给此用 户。其基本思想非常易于理解，在日常生活中，我们往往会利用好朋友的推荐来进行一些选择。协同过滤正是把这一思想运用到电子商务推荐系统中来，基于其他用 户对某一内容的评价来向目标用户进行推荐。

基于协同过滤的推荐系统可以说是从用户的角度来进行相应推荐的，而且是自动的，即用户获得的推荐是系统从购买模式或浏览行为等隐式获得的，不需要用户努力地找到适合自己兴趣的推荐信息，如填写一些调查表格等。

和基于内容的过滤方法相比，协同过滤具有如下的优点：
1） 能够过滤难以进行机器自动内容分析的信息，如艺术品，音乐等。
2） 共享其他人的经验，避免了内容分析的不完全和不精确，并且能够基于一些复杂的，难以表述的概念（如信息质量、个人品味）进行过滤。
3） 有推荐新信息的能力。可以发现内容上完全不相似的信息，用户对推荐信息的内容事先是预料不到的。这也是协同过滤和基于内容的过滤一个较大的差别，基于内容的过滤推荐很多都是用户本来就熟悉的内容，而协同过滤可以发现用户潜在的但自己尚未发现的兴趣偏好。
4） 能够有效的使用其他相似用户的反馈信息，较少用户的反馈量，加快个性化学习的速度。

虽然协同过滤作为一种典型的推荐技术有其相当的应用，但协同过滤仍有许多的问题需要解决。最典型的问题有稀疏问题（Sparsity）和可扩展问题（Scalability）。

三、基于关联规则推荐

基于关联规则的推荐（Association Rule-based Recommendation）是以关联规则为基础，把已购商品作为规则头，规则体为推荐对象。关联规则挖掘可以发现不同商品在销售过程中的相关性，在零 售业中已经得到了成功的应用。管理规则就是在一个交易数据库中统计购买了商品集X的交易中有多大比例的交易同时购买了商品集Y，其直观的意义就是用户在购 买某些商品的时候有多大倾向去购买另外一些商品。比如购买牛奶的同时很多人会同时购买面包。

算法的第一步关联规则的发现最为关键且最耗时，是算法的瓶颈，但可以离线进行。其次，商品名称的同义性问题也是关联规则的一个难点。

四、基于效用推荐

基于效用的推荐（Utility-based Recommendation）是建立在对用户使用项目的效用情况上计算的，其核心问题是怎么样为每一个用户去创建一个效用函数，因此，用户资料模型很大 程度上是由系统所采用的效用函数决定的。基于效用推荐的好处是它能把非产品的属性，如提供商的可靠性（Vendor Reliability）和产品的可得性（Product Availability）等考虑到效用计算中。

五、基于知识推荐

基于知识的推荐（Knowledge-based Recommendation）在某种程度是可以看成是一种推理（Inference）技术，它不是建立在用户需要和偏好基础上推荐的。基于知识的方法因 它们所用的功能知识不同而有明显区别。效用知识（Functional Knowledge）是一种关于一个项目如何满足某一特定用户的知识，因此能解释需要和推荐的关系，所以用户资料可以是任何能支持推理的知识结构，它可以 是用户已经规范化的查询，也可以是一个更详细的用户需要的表示。

六、组合推荐

由于各种推荐方法都有优缺点，所以在实际中，组合推荐（Hybrid Recommendation）经常被采用。研究和应用最多的是内容推荐和协同过滤推荐的组合。最简单的做法就是分别用基于内容的方法和协同过滤推荐方法 去产生一个推荐预测结果，然后用某方法组合其结果。尽管从理论上有很多种推荐组合方法，但在某一具体问题中并不见得都有效，组合推荐一个最重要原则就是通 过组合后要能避免或弥补各自推荐技术的弱点。

在组合方式上，有研究人员提出了七种组合思路：
1）加权（Weight）：加权多种推荐技术结果。
2）变换（Switch）：根据问题背景和实际情况或要求决定变换采用不同的推荐技术。
3）混合（Mixed）：同时采用多种推荐技术给出多种推荐结果为用户提供参考。
4）特征组合（Feature combination）：组合来自不同推荐数据源的特征被另一种推荐算法所采用。
5）层叠（Cascade）：先用一种推荐技术产生一种粗糙的推荐结果，第二种推荐技术在此推荐结果的基础上进一步作出更精确的推荐。
6）特征扩充（Feature augmentation）：一种技术产生附加的特征信息嵌入到另一种推荐技术的特征输入中。
7）元级别（Meta-level）：用一种推荐方法产生的模型作为另一种推荐方法的输入。
七、主要推荐方法的对比

各种推荐方法都有其各自的优点和缺点，见表1。

在此处可以找到原文阐述如何使用此款软件: http://www.senocular.com/flash/tutorials/starumltoas3/

关键安装方式是：

1. 下载 StrarUML http://www.staruml.com/ 。
2. 下载 AS3 代码生成模板  http://www.senocular.com/flash/tutorials/starumltoas3/downloads/StarUML_ActionScript3_Export.zip
3. 进入 StrarUML   所在的安装目录下 \modules\staruml-generator\templates 处将 模板中 ActionScript 3.0 整个文件夹放入到这里。
   最后可以得到如下2个路径： 
   <StarUML 安装目录>\modules\staruml-generator\templates\ActionScript 3.0\template description.tdf
   <StarUML 安装目录>\modules\staruml-generator\templates\ActionScript 3.0\template.cot

关键使用方式：

1. 启动StarUML 并打开你要导出代码的 UML 视图。
2. 选择  Tools > StarUML Generator
3. 勾上 模板列表（list of template）中文档名(Document Name)为 ActionScript 3.0 选项。
4. 点下 next
5. 此时面板会让你选择导出路径。自己选择吧，比如直接可以倒入到 Src中。
6. 选择完毕后点下 next
7. 此时，会等待你决定是否立即产出代码
8. 点Generate 即可。

StarUML AS3例子：
http://www.senocular.com/flash/tutorials/starumltoas3/downloads/Gallery.uml

另外再提供UML学习指南：http://www.uml.org.cn/oobject/OObject.asp