nodejs 默认 async（异步），有些时候快一些
适合 one page app （比如gmail那样的）我觉得的是更适合ajax所以才这样
语言统一，不用前后台换来换去，都是javascript（有人不喜欢javascript，可以学 coffee script），同时和mongodb结合比较好（相比SQL）。现在有一个MEAN stack: mongodb, express, angular and nodejs，貌似学好了很厉害。
Ruby on Rails优势
成熟，gem很好很多很全（不过nodejs现在用的人越来越多了）
会的人比较多（至少再美国）
学起来相对比nodejs要容易。nodejs的 abstraction（抽象？）比RoR少，还涉及到 callbacks（因为是异步）
移动端可能要求ajax多一些（如果你不做 native app），这个主要是前台设计（个人认为）。如果是点评网站的话，我觉得可能 Ruby on Rails 还是更合适一些。
这是javaeye上非常经典的关于线程的帖子，写的非常通俗易懂的，适合任何读计算机的同学.线程同步
我们可以在计算机上运行各种计算机软件程序。每一个运行的程序可能包括多个独立运行的线程（Thread）。
线程（Thread）是一份独立运行的程序，有自己专用的运行栈。线程有可能和其他线程共享一些资源，比如，内存，文件，数据库等。
当多个线程同时读写同一份共享资源的时候，可能会引起冲突。这时候，我们需要引入线程“同步”机制，即各位线程之间要有个先来后到，不能一窝蜂挤上去抢作一团。
同步这个词是从英文synchronize（使同时发生）翻译过来的。我也不明白为什么要用这个很容易引起误解的词。既然大家都这么用，咱们也就只好这么将就。
线程同步的真实意思和字面意思恰好相反。线程同步的真实意思，其实是“排队”：几个线程之间要排队，一个一个对共享资源进行操作，而不是同时进行操作。
因此，关于线程同步，需要牢牢记住的第一点是：线程同步就是线程排队。同步就是排队。线程同步的目的就是避免线程“同步”执行。这可真是个无聊的绕口令。
关于线程同步，需要牢牢记住的第二点是 “共享”这两个字。只有共享资源的读写访问才需要同步。如果不是共享资源，那么就根本没有同步的必要。
关于线程同步，需要牢牢记住的第三点是，只有“变量”才需要同步访问。如果共享的资源是固定不变的，那么就相当于“常量”，线程同时读取常量也不需要同步。至少一个线程修改共享资源，这样的情况下，线程之间就需要同步。
关于线程同步，需要牢牢记住的第四点是：多个线程访问共享资源的代码有可能是同一份代码，也有可能是不同的代码；无论是否执行同一份代码，只要这些线程的代码访问同一份可变的共享资源，这些线程之间就需要同步。
为了加深理解，下面举几个例子。
有两个采购员，他们的工作内容是相同的，都是遵循如下的步骤：
（1）到市场上去，寻找并购买有潜力的样品。
（2）回到公司，写报告。
这两个人的工作内容虽然一样，他们都需要购买样品，他们可能买到同样种类的样品，但是他们绝对不会购买到同一件样品，他们之间没有任何共享资源。所以，他们可以各自进行自己的工作，互不干扰。
这两个采购员就相当于两个线程；两个采购员遵循相同的工作步骤，相当于这两个线程执行同一段代码。
下面给这两个采购员增加一个工作步骤。采购员需要根据公司的“布告栏”上面公布的信息，安排自己的工作计划。
这两个采购员有可能同时走到布告栏的前面，同时观看布告栏上的信息。这一点问题都没有。因为布告栏是只读的，这两个采购员谁都不会去修改布告栏上写的信息。
下面增加一个角色。一个办公室行政人员这个时候，也走到了布告栏前面，准备修改布告栏上的信息。
如果行政人员先到达布告栏，并且正在修改布告栏的内容。两个采购员这个时候，恰好也到了。这两个采购员就必须等待行政人员完成修改之后，才能观看修改后的信息。
如果行政人员到达的时候，两个采购员已经在观看布告栏了。那么行政人员需要等待两个采购员把当前信息记录下来之后，才能够写上新的信息。
上述这两种情况，行政人员和采购员对布告栏的访问就需要进行同步。因为其中一个线程（行政人员）修改了共享资源（布告栏）。而且我们可以看到，行政人员的工作流程和采购员的工作流程（执行代码）完全不同，但是由于他们访问了同一份可变共享资源（布告栏），所以他们之间需要同步。
同步锁
前面讲了为什么要线程同步，下面我们就来看如何才能线程同步。
线程同步的基本实现思路还是比较容易理解的。我们可以给共享资源加一把锁，这把锁只有一把钥匙。哪个线程获取了这把钥匙，才有权利访问该共享资源。
生活中，我们也可能会遇到这样的例子。一些超市的外面提供了一些自动储物箱。每个储物箱都有一把锁，一把钥匙。人们可以使用那些带有钥匙的储物箱，把东西放到储物箱里面，把储物箱锁上，然后把钥匙拿走。这样，该储物箱就被锁住了，其他人不能再访问这个储物箱。（当然，真实的储物箱钥匙是可以被人拿走复制的，所以不要把贵重物品放在超市的储物箱里面。于是很多超市都采用了电子密码锁。）
线程同步锁这个模型看起来很直观。但是，还有一个严峻的问题没有解决，这个同步锁应该加在哪里？
当然是加在共享资源上了。反应快的读者一定会抢先回答。
没错，如果可能，我们当然尽量把同步锁加在共享资源上。一些比较完善的共享资源，比如，文件系统，数据库系统等，自身都提供了比较完善的同步锁机制。我们不用另外给这些资源加锁，这些资源自己就有锁。
但是，大部分情况下，我们在代码中访问的共享资源都是比较简单的共享对象。这些对象里面没有地方让我们加锁。
读者可能会提出建议：为什么不在每一个对象内部都增加一个新的区域，专门用来加锁呢？这种设计理论上当然也是可行的。问题在于，线程同步的情况并不是很普遍。如果因为这小概率事件，在所有对象内部都开辟一块锁空间，将会带来极大的空间浪费。得不偿失。
于是，现代的编程语言的设计思路都是把同步锁加在代码段上。确切的说，是把同步锁加在“访问共享资源的代码段”上。这一点一定要记住，同步锁是加在代码段上的。
同步锁加在代码段上，就很好地解决了上述的空间浪费问题。但是却增加了模型的复杂度，也增加了我们的理解难度。
现在我们就来仔细分析“同步锁加在代码段上”的线程同步模型。
首先，我们已经解决了同步锁加在哪里的问题。我们已经确定，同步锁不是加在共享资源上，而是加在访问共享资源的代码段上。
其次，我们要解决的问题是，我们应该在代码段上加什么样的锁。这个问题是重点中的重点。这是我们尤其要注意的问题：访问同一份共享资源的不同代码段，应该加上同一个同步锁；如果加的是不同的同步锁，那么根本就起不到同步的作用，没有任何意义。
这就是说，同步锁本身也一定是多个线程之间的共享对象。
Java语言的synchronized关键字
为了加深理解，举几个代码段同步的例子。
不同语言的同步锁模型都是一样的。只是表达方式有些不同。这里我们以当前最流行的Java语言为例。Java语言里面用synchronized关键字给代码段加锁。整个语法形式表现为
synchronized(同步锁) {
// 访问共享资源，需要同步的代码段
}
这里尤其要注意的就是，同步锁本身一定要是共享的对象。
… f1() {
Object lock1 = new Object()// 产生一个同步锁
synchronized(lock1){
// 代码段 A
// 访问共享资源 resource1
// 需要同步
}
}
上面这段代码没有任何意义。因为那个同步锁是在函数体内部产生的。每个线程调用这段代码的时候，都会产生一个新的同步锁。那么多个线程之间，使用的是不同的同步锁。根本达不到同步的目的。
同步代码一定要写成如下的形式，才有意义。
public static final Object lock1 = new Object()
… f1() {
synchronized(lock1){ // lock1 是公用同步锁
// 代码段 A
// 访问共享资源 resource1
// 需要同步
}
你不一定要把同步锁声明为static或者public，但是你一定要保证相关的同步代码之间，一定要使用同一个同步锁。
讲到这里，你一定会好奇，这个同步锁到底是个什么东西。为什么随便声明一个Object对象，就可以作为同步锁？
在Java里面，同步锁的概念就是这样的。任何一个Object Reference都可以作为同步锁。我们可以把Object Reference理解为对象在内存分配系统中的内存地址。因此，要保证同步代码段之间使用的是同一个同步锁，我们就要保证这些同步代码段的synchronized关键字使用的是同一个Object Reference，同一个内存地址。这也是为什么我在前面的代码中声明lock1的时候，使用了final关键字，这就是为了保证lock1的Object Reference在整个系统运行过程中都保持不变。
一些求知欲强的读者可能想要继续深入了解synchronzied(同步锁)的实际运行机制。Java虚拟机规范中（你可以在google用“JVM Spec”等关键字进行搜索），有对synchronized关键字的详细解释。synchronized会编译成 monitor enter, … monitor exit之类的指令对。Monitor就是实际上的同步锁。每一个Object Reference在概念上都对应一个monitor。
这些实现细节问题，并不是理解同步锁模型的关键。我们继续看几个例子，加深对同步锁模型的理解。
public static final Object lock1 = new Object()
… f1() {
synchronized(lock1){ // lock1 是公用同步锁
// 代码段 A
// 访问共享资源 resource1
// 需要同步
}
}
… f2() {
synchronized(lock1){ // lock1 是公用同步锁
// 代码段 B
// 访问共享资源 resource1
// 需要同步
}
}
上述的代码中，代码段A和代码段B就是同步的。因为它们使用的是同一个同步锁lock1。
如果有10个线程同时执行代码段A，同时还有20个线程同时执行代码段B，那么这30个线程之间都是要进行同步的。
这30个线程都要竞争一个同步锁lock1。同一时刻，只有一个线程能够获得lock1的所有权，只有一个线程可以执行代码段A或者代码段B。其他竞争失败的线程只能暂停运行，进入到该同步锁的就绪（Ready）队列。
每一个同步锁下面都挂了几个线程队列，包括就绪（Ready）队列，待召（Waiting）队列等。比如，lock1对应的就绪队列就可以叫做lock1 - ready queue。每个队列里面都可能有多个暂停运行的线程。
注意，竞争同步锁失败的线程进入的是该同步锁的就绪（Ready）队列，而不是后面要讲述的待召队列（Waiting Queue，也可以翻译为等待队列）。就绪队列里面的线程总是时刻准备着竞争同步锁，时刻准备着运行。而待召队列里面的线程则只能一直等待，直到等到某个信号的通知之后，才能够转移到就绪队列中，准备运行。
成功获取同步锁的线程，执行完同步代码段之后，会释放同步锁。该同步锁的就绪队列中的其他线程就继续下一轮同步锁的竞争。成功者就可以继续运行，失败者还是要乖乖地待在就绪队列中。
因此，线程同步是非常耗费资源的一种操作。我们要尽量控制线程同步的代码段范围。同步的代码段范围越小越好。我们用一个名词“同步粒度”来表示同步代码段的范围。
同步粒度
在Java语言里面，我们可以直接把synchronized关键字直接加在函数的定义上。
比如。
… synchronized … f1() {
// f1 代码段
}
这段代码就等价于
… f1() {
synchronized(this){ // 同步锁就是对象本身
// f1 代码段
}
}
同样的原则适用于静态（static）函数
比如。
… static synchronized … f1() {
// f1 代码段
}
这段代码就等价于
…static … f1() {
synchronized(Class.forName(…)){ // 同步锁是类定义本身
// f1 代码段
}
}
但是，我们要尽量避免这种直接把synchronized加在函数定义上的偷懒做法。因为我们要控制同步粒度。同步的代码段越小越好。synchronized控制的范围越小越好。
我们不仅要在缩小同步代码段的长度上下功夫，我们同时还要注意细分同步锁。
比如，下面的代码
public static final Object lock1 = new Object()
… f1() {
synchronized(lock1){ // lock1 是公用同步锁
// 代码段 A
// 访问共享资源 resource1
// 需要同步
}
}
… f2() {
synchronized(lock1){ // lock1 是公用同步锁
// 代码段 B
// 访问共享资源 resource1
// 需要同步
}
}
… f3() {
synchronized(lock1){ // lock1 是公用同步锁
// 代码段 C
// 访问共享资源 resource2
// 需要同步
}
}
… f4() {
synchronized(lock1){ // lock1 是公用同步锁
// 代码段 D
// 访问共享资源 resource2
// 需要同步
}
}
上述的4段同步代码，使用同一个同步锁lock1。所有调用4段代码中任何一段代码的线程，都需要竞争同一个同步锁lock1。
我们仔细分析一下，发现这是没有必要的。
因为f1()的代码段A和f2()的代码段B访问的共享资源是resource1，f3()的代码段C和f4()的代码段D访问的共享资源是resource2，它们没有必要都竞争同一个同步锁lock1。我们可以增加一个同步锁lock2。f3()和f4()的代码可以修改为：
public static final Object lock2 = new Object()
… f3() {
synchronized(lock2){ // lock2 是公用同步锁
// 代码段 C
// 访问共享资源 resource2
// 需要同步
}
}
… f4() {
synchronized(lock2){ // lock2 是公用同步锁
// 代码段 D
// 访问共享资源 resource2
// 需要同步
}
}
这样，f1()和f2()就会竞争lock1，而f3()和f4()就会竞争lock2。这样，分开来分别竞争两个锁，就可以大大较少同步锁竞争的概率，从而减少系统的开销。
信号量
同步锁模型只是最简单的同步模型。同一时刻，只有一个线程能够运行同步代码。
有的时候，我们希望处理更加复杂的同步模型，比如生产者/消费者模型、读写同步模型等。这种情况下，同步锁模型就不够用了。我们需要一个新的模型。这就是我们要讲述的信号量模型。
信号量模型的工作方式如下：线程在运行的过程中，可以主动停下来，等待某个信号量的通知；这时候，该线程就进入到该信号量的待召（Waiting）队列当中；等到通知之后，再继续运行。
很多语言里面，同步锁都由专门的对象表示，对象名通常叫Monitor。
同样，在很多语言中，信号量通常也有专门的对象名来表示，比如，Mutex，Semphore。
信号量模型要比同步锁模型复杂许多。一些系统中，信号量甚至可以跨进程进行同步。另外一些信号量甚至还有计数功能，能够控制同时运行的线程数。
我们没有必要考虑那么复杂的模型。所有那些复杂的模型，都是最基本的模型衍生出来的。只要掌握了最基本的信号量模型——“等待/通知”模型，复杂模型也就迎刃而解了。
我们还是以Java语言为例。Java语言里面的同步锁和信号量概念都非常模糊，没有专门的对象名词来表示同步锁和信号量，只有两个同步锁相关的关键字——volatile和synchronized。
这种模糊虽然导致概念不清，但同时也避免了Monitor、Mutex、Semphore等名词带来的种种误解。我们不必执着于名词之争，可以专注于理解实际的运行原理。
在Java语言里面，任何一个Object Reference都可以作为同步锁。同样的道理，任何一个Object Reference也可以作为信号量。
Object对象的wait()方法就是等待通知，Object对象的notify()方法就是发出通知。
具体调用方法为
（1）等待某个信号量的通知
public static final Object signal = new Object()
… f1() {
synchronized(singal) { // 首先我们要获取这个信号量。这个信号量同时也是一个同步锁
// 只有成功获取了signal这个信号量兼同步锁之后，我们才可能进入这段代码
signal.wait()// 这里要放弃信号量。本线程要进入signal信号量的待召（Waiting）队列
// 可怜。辛辛苦苦争取到手的信号量，就这么被放弃了
// 等到通知之后，从待召（Waiting）队列转到就绪（Ready）队列里面
// 转到了就绪队列中，离CPU核心近了一步，就有机会继续执行下面的代码了。
// 仍然需要把signal同步锁竞争到手，才能够真正继续执行下面的代码。命苦啊。
…
}
}
需要注意的是，上述代码中的signal.wait()的意思。signal.wait()很容易导致误解。signal.wait()的意思并不是说，signal开始wait，而是说，运行这段代码的当前线程开始wait这个signal对象，即进入signal对象的待召（Waiting）队列。
（2）发出某个信号量的通知
… f2() {
synchronized(singal) { // 首先，我们同样要获取这个信号量。同时也是一个同步锁。
// 只有成功获取了signal这个信号量兼同步锁之后，我们才可能进入这段代码
signal.notify()// 这里，我们通知signal的待召队列中的某个线程。
// 如果某个线程等到了这个通知，那个线程就会转到就绪队列中
// 但是本线程仍然继续拥有signal这个同步锁，本线程仍然继续执行
// 嘿嘿，虽然本线程好心通知其他线程，
// 但是，本线程可没有那么高风亮节，放弃到手的同步锁
// 本线程继续执行下面的代码
…
}
}
需要注意的是，signal.notify()的意思。signal.notify()并不是通知signal这个对象本身。而是通知正在等待signal信号量的其他线程。
以上就是Object的wait()和notify()的基本用法。
实际上，wait()还可以定义等待时间，当线程在某信号量的待召队列中，等到足够长的时间，就会等无可等，无需再等，自己就从待召队列转移到就绪队列中了。
另外，还有一个notifyAll()方法，表示通知待召队列里面的所有线程。
这些细节问题，并不对大局产生影响。
绿色线程
绿色线程（Green Thread）是一个相对于操作系统线程（Native Thread）的概念。
操作系统线程（Native Thread）的意思就是，程序里面的线程会真正映射到操作系统的线程，线程的运行和调度都是由操作系统控制的
绿色线程（Green Thread）的意思是，程序里面的线程不会真正映射到操作系统的线程，而是由语言运行平台自身来调度。
当前版本的Python语言的线程就可以映射到操作系统线程。当前版本的Ruby语言的线程就属于绿色线程，无法映射到操作系统的线程，因此Ruby语言的线程的运行速度比较慢。
难道说，绿色线程要比操作系统线程要慢吗？当然不是这样。事实上，情况可能正好相反。Ruby是一个特殊的例子。线程调度器并不是很成熟。
目前，线程的流行实现模型就是绿色线程。比如，stackless Python，就引入了更加轻量的绿色线程概念。在线程并发编程方面，无论是运行速度还是并发负载上，都优于Python。
另一个更著名的例子就是ErLang（爱立信公司开发的一种开源语言）。
ErLang的绿色线程概念非常彻底。ErLang的线程不叫Thread，而是叫做Process。这很容易和进程混淆起来。这里要注意区分一下。
ErLang Process之间根本就不需要同步。因为ErLang语言的所有变量都是final的，不允许变量的值发生任何变化。因此根本就不需要同步。
final变量的另一个好处就是，对象之间不可能出现交叉引用，不可能构成一种环状的关联，对象之间的关联都是单向的，树状的。因此，内存垃圾回收的算法效率也非常高。这就让ErLang能够达到Soft Real Time（软实时）的效果。这对于一门支持内存垃圾回收的语言来说，可不是一件容易的事情。
http://tieba.baidu.com/f?kz=122614929浪费分你都
我给你发的这个是百度的暗黑贴吧里面的暗黑的全部资料 还有相关的比较权威的网站 自己没事去看看去
这是公式
Diblo2 合成公式大全
克莱姆的连枷 + 克莱姆之心 + 克莱姆之眼 + 克莱姆之脑 ->超级克莱姆连枷
1个怀特的脚 ＋ 1个回城书 ->通往奶牛关的门
3 生命 药剂 + 3 魔法 药剂 + 1 普通的 宝石 ->全面恢复药剂（大紫）
3 生命 药剂 + 3 魔法 药剂 + 1 碎裂的 宝石 ->恢复药剂（小紫）
3 小紫 ->1 大紫
1 完美的 任何宝石 + 1 项链 ->多彩的(加4抗) 项链
1 戒指 + 1 完美的 红宝石 + 1 爆炸 药剂 ->深红的 戒指
1 戒指 + 1 完美的 蓝宝石 + 1 投掷 药剂->深蓝的 戒指
1 戒指 + 1 完美的 黄宝石 + 1 回复 药剂 ->珊瑚色的 戒指
1 戒指 + 1 绿宝石 + 1 解毒 药剂 ->碧玉的 戒指
1 斧头 + 1 匕首 ->投掷斧
1 长矛 + 1 箭袋 ->标枪
3 戒指 ->项链
3 项链 ->戒指
.....................................................................
1.10新增的魔法 武器合成公式,用于替代3CG公式,重要:
3 普通宝石 + 1 带孔武器 (任何类型) = 1 带孔魔法武器 (同一类型) 这个公式会随机生成一个新带孔武器，武器类型与原来相同，孔数随机生成，属性也将会改变。最大的作用是把例如一把黑色带孔武器变为蓝色武器。
3 无瑕疵宝石 + 1 魔法武器 = 带孔魔法武器给普通蓝色武器打孔，孔数方面没有具体的说明确定方法，应该是随机生成。属性将会完全改变。.
1 魔法 小盾 + 1 钉头棒 + 2 骷髅 ->刺盾
4 生命 药剂 + 1 红宝石 + 1 魔法 剑 ->吸血的剑
1 转石 + 1 短剑 + 1 长杖 + 1 腰带 ->野蛮的 长棍
1 窒息 药剂 + 1 生命 药剂 ->解毒 药剂
2 箭袋 ->矢袋
2 矢袋 ->箭袋
.....................................................................
宝石的合成公式,没有变化.
3 碎裂的 红宝石 ->有瑕的 红宝石
3 有瑕的 红宝石 ->普通的 红宝石
3 普通的 红宝石 ->无暇的 红宝石
3 无暇的 红宝石 ->完美的 红宝石
其他宝石的合成方法同上
.....................................................................
10符文以前符文的合成公式,没有变化.
3 符文01 ->符文02
3 符文02 ->符文03
3 符文03 ->符文04
3 符文04 ->符文05
3 符文05 ->符文06
3 符文06 ->符文07
3 符文07 ->符文08
3 符文08 ->符文09
3 符文09 ->符文10
.....................................................................
09魔法的经典合成公式,3PG仍有效,3CG被取消.
3 完美的 宝石 + 1 魔法 物品 ->魔法 物品
.....................................................................
09黄金的相关合成公式,未变.
6 完美的 骷髅 + 1 黄金 物品 ->低等级 黄金 物品
1 完美的 骷髅 + 1 黄金 物品 + 乔丹之石->高等级 金 物品
3 完美的 骷髅 + 1 黄金 物品 + 乔丹之石->给黄金 物品打1个孔
.....................................................................
09的所有橙色物品合成公式仍然有效,未有新增公式.
......................................................................
1.10新增的11符文以上符文的合成公式.
3 符文10 + 1 碎裂的 黄宝石 ->符文11
3 符文11 + 1 碎裂的 紫宝石 ->符文12
3 符文12 + 1 碎裂的 蓝宝石 ->符文13
3 符文13 + 1 碎裂的 红宝石 ->符文14
3 符文14 + 1 碎裂的 绿宝石 ->符文15
3 符文15 + 1 碎裂的 转石 ->符文16
3 符文16 + 1 有瑕的 黄宝石 ->符文17
3 符文17 + 1 有瑕的 紫宝石 ->符文18
3 符文18 + 1 有瑕的 蓝宝石 ->符文19
3 符文19 + 1 有瑕的 红宝石 ->符文20
3 符文20 + 1 有瑕的 绿宝石 ->符文21
2 符文21 + 1 有瑕的 转石 ->符文22
2 符文22 + 1 普通的 黄宝石 ->符文23
2 符文23 + 1 普通的 紫宝石 ->符文24
2 符文24 + 1 普通的 蓝宝石 ->符文25
2 符文25 + 1 普通的 红宝石 ->符文26
2 符文26 + 1 普通的 绿宝石 ->符文27
2 符文27 + 1 普通的 转石 ->符文28
2 符文28 + 1 无暇的 黄宝石 ->符文29
2 符文29 + 1 无暇的 紫宝石 ->符文30
2 符文30 + 1 无暇的 蓝宝石 ->符文31
2 符文31 + 1 无暇的 红宝石 ->符文32
2 符文32 + 1 无暇的 绿宝石 ->符文33
......................................................................
1.10新增的打孔公式,强.
符文07 + 符文10 + 1 完美的 黄宝石 + 普通 盔甲 ->有孔的 盔甲
符文08 + 符文11 + 1 完美的 紫宝石 + 普通 武器 ->有孔的 武器
符文08 + 符文10 + 1 完美的 蓝宝石 + 普通 头盔 ->有孔的 头盔
符文07 + 符文11 + 1 完美的 红宝石 + 普通 盾牌 ->有孔的 盾牌
.....................................................................
1.10新增物品升级公式,适用于Uniq/黄金的Wepon/盔甲,重要.
符文02 + 1 碎裂的 宝石 + 低级 武器 ->普通 武器
符文01 + 1 碎裂的 宝石 + 低级 盔甲 ->普通 盔甲
符文08 + 符文12 + 完美的 绿宝石 + 基本级 暗金 武器 ->扩展级 暗金 武器
符文07 + 符文13 + 完美的 转石 + 基本级 暗金 盔甲 ->扩展级 暗金 盔甲
*符文17 + 符文21 + 完美的 绿宝石 + 扩展级 暗金 武器 ->精英级 暗金 武器
*符文18 + 符文20 + 完美的 转石 + 扩展级 暗金 盔甲 ->精英级 暗金 盔甲
以上2个公式之据说只在ladder或单机游戏有效，有待验证
符文09 + 符文11 + 完美的 蓝宝石 + 基本级 黄金 武器 ->扩展级 黄金 武器
符文08 + 符文10 + 完美的 紫宝石 + 基本级 黄金 盔甲 ->扩展级 黄金 盔甲
符文19 + 符文22 + 完美的 蓝宝石 + 扩展级 黄金 武器 ->精英级 黄金 武器
符文18 + 符文21 + 完美的 紫宝石 + 扩展级 黄金 盔甲 ->精英级 黄金 盔甲
.....................................................................
1.10新增的修理公式,适用于符文之语等修理费昂贵的物品.但对无形的装备无效.
符文09 + 武器 ->完全修好
符文08 + 盔甲 ->完全修好
.....................................................................
1.10新增的除孔公式,镶上的东西将会消失.
符文15 + 回城卷轴 + 任何 镶嵌过的 物品 ->未镶嵌宝石的物品 (宝石被毁坏消失)
.....................................................................
1.10新增的其他公式,官方尚未作任何说明,估计是给Mod的设计者们准备的.
符文08 + 珠宝 + 超强的 盔甲 ->特定属性的 盔甲
符文08 + 珠宝 + 超强的 武器 ->特定属性的 武器
符文08 + 珠宝 + 魔法 戒指 ->特定属性的 戒指
符文08 + 珠宝 + 魔法 项链 ->特定属性的 项链
符文01 + gcv(这个应该是碎裂的紫宝石) + 特定属性的 武器 ->+30-50
这个是符文的号码名称对应 还有出处 就是打什么怪掉的几率高
1# El 艾尔
2# Eld 艾德
3# Tir 特尔
4# Nef 那夫
5# Eth 爱斯
6# Ith 伊司
7# Tal 塔尔
8# Ral 拉尔
9# Ort 欧特
10# Thul书尔
11# Amn 安姆
12# Sol 索尔
13# Shael 沙尔
14# Dol 多尔 15# Hel 海尔
16# Io 埃欧
17# Lum 卢姆
18# Ko 科
19# Fal 法尔
20# Lem 蓝姆
21# Pul 普尔
22# Um 乌姆
23# Mal 马尔
24# Ist 伊司特
25# Gul 古尔
26# Vex 伐克斯
27# Ohm 奥姆
28# Lo 罗
29# Sur 瑟
30# Ber 贝
31# Jah 乔
32# Cham查姆
33# Zod 萨德
稀有神符掉落机率
神符 掉落率最高的前六名怪物 难度 掉落率(%) 备注
Lem蓝姆(20#) The Countess 地狱 0.05209431 Act I - 女伯爵 (高塔地牢第五层)
Andariel (第一次杀) 地狱 0.00108671 Act I - 安达利尔 (地下墓穴第四层)
Council Member 噩梦 0.00081162 Act III - 议会成员 (崔凡克)
Ismail Vilehand 噩梦 0.00081162 Act III - 邪恶之手 伊斯梅尔 (崔凡克)
Geleb Flamefinger 噩梦 0.00081162 Act III - 火焰之指 吉列布 (崔凡克)
Toorc Icefist 噩梦 0.00081162 Act III - 冰拳 托克 (崔凡克)
Pul普尔（21#) The Countess 地狱 0.03920640 Act I - 女伯爵 (高塔地牢第五层)
Andariel (第一次杀) 地狱 0.00081786 Act I - 安达利尔 (地下墓穴第四层)
Council Member 噩梦 0.00061083 Act III - 议会成员 (崔凡克)
Ismail Vilehand 噩梦 0.00061083 Act III - 邪恶之手 伊斯梅尔 (崔凡克)
Geleb Flamefinger 噩梦 0.00061083 Act III - 火焰之指 吉列布 (崔凡克)
Toorc Icefist 噩梦 0.00061083 Act III - 冰拳 托克 (崔凡克)
Um乌姆(22#) The Countess 地狱 0.02613760 Act I - 女伯爵 (高塔地牢第五层)
Andariel (第一次杀) 地狱 0.00054524 Act I - 安达利尔 (地下墓穴第四层)
Council Member 噩梦 0.00040722 Act III - 议会成员 (崔凡克)
Ismail Vilehand 噩梦 0.00040722 Act III - 邪恶之手 伊斯梅尔 (崔凡克)
Geleb Flamefinger 噩梦 0.00040722 Act III - 火焰之指 吉列布 (崔凡克)
Toorc Icefist 噩梦 0.00040722 Act III - 冰拳 托克 (崔凡克)
Mal马尔(23#) The Countess 地狱 0.02244255 Act I - 女伯爵 (高塔地牢第五层)
Andariel (第一次杀) 地狱 0.00046816 Act I - 安达利尔 (地下墓穴第四层)
Council Member 地狱 0.00034899 Act II - 召唤者 (神秘庇难所)
Ismail Vilehand 地狱 0.00034899 Act III - 议会成员 (崔凡克)
Geleb Flamefinger 地狱 0.00034899 Act III - 邪恶之手 伊斯梅尔 (崔凡克)
Toorc Icefist 地狱 0.00034899 Act III - 火焰之指 吉列布 (崔凡克)
Ist伊司特(24#) The Countess 地狱 0.01496170 Act I - 女伯爵 (高塔地牢第五层)
Andariel (第一次杀) 地狱 0.00031211 Act I - 安达利尔 (地下墓穴第四层)
The Summoner 地狱 0.00023266 Act II - 召唤者 (神秘庇难所)
Council Member 地狱 0.00023259 Act III - 议会成员 (崔凡克)
Ismail Vilehand 地狱 0.00023259 Act III - 邪恶之手 伊斯梅尔 (崔凡克)
Geleb Flamefinger 地狱 0.00023259 Act III - 火焰之指 吉列布 (崔凡克)
Gul古尔(25#) Andariel (第一次杀) 地狱 0.00026779 Act I - 安达利尔 (地下墓穴第四层)
作者： 街头小舰人 2006-10-1 15:12 回复此发言
--------------------------------------------------------------------------------
2 暗黑符文中英文对照表（新手必备）
The Summoner 地狱 0.00019962 Act II - 召唤者 (神秘庇难所)
Council Member 地狱 0.00019956 Act III - 议会成员 (崔凡克)
Ismail Vilehand 地狱 0.00019956 Act III - 邪恶之手 伊斯梅尔 (崔凡克)
Geleb Flamefinger 地狱 0.00019956 Act III - 火焰之指 吉列布 (崔凡克)
Toorc Icefist 地狱 0.00019956 Act III - 冰拳 托克 (崔凡克)
Vex伐克斯(26#) Andariel (第一次杀) 地狱 0.00017852 Act I - 安达利尔 (地下墓穴第四层)
The Summoner 地狱 0.00013308 Act II - 召唤者 (神秘庇难所)
Council Member 地狱 0.00013304 Act III - 议会成员 (崔凡克)
Ismail Vilehand 地狱 0.00013304 Act III - 邪恶之手 伊斯梅尔 (崔凡克)
Geleb Flamefinger 地狱 0.00013304 Act III - 火焰之指 吉列布 (崔凡克)
Toorc Icefist 地狱 0.00013304 Act III - 冰拳 托克 (崔凡克)
Ohm奥姆(27#) Andariel (第一次杀) 地狱 0.00015311 Act I - 安达利尔 (地下墓穴第四层)
The Summoner 地狱 0.00011413 Act II - 召唤者 (神秘庇难所)
Council Member 地狱 0.00011410 Act III - 议会成员 (崔凡克)
Ismail Vilehand 地狱 0.00011410 Act III - 邪恶之手 伊斯梅尔 (崔凡克)
Geleb Flamefinger 地狱 0.00011410 Act III - 火焰之指 吉列布 (崔凡克)
Toorc Icefist 地狱 0.00011410 Act III - 冰拳 托克 (崔凡克)
Lo罗(28#) Andariel (第一次杀) 地狱 0.00010207 Act I - 安达利尔 (地下墓穴第四层)
The Summoner 地狱 0.00007609 Act II - 召唤者 (神秘庇难所)
Council Member 地狱 0.00007607 Act III - 议会成员 (崔凡克)
Ismail Vilehand 地狱 0.00007607 Act III - 邪恶之手 伊斯梅尔 (崔凡克)
Geleb Flamefinger 地狱 0.00007607 Act III - 火焰之指 吉列布 (崔凡克)
Toorc Icefist 地狱 0.00007607 Act III - 冰拳 托克 (崔凡克)
Sur瑟(29#) Council Member 地狱 0.00006522 Act III - 议会成员 (崔凡克)
Ismail Vilehand 地狱 0.00006522 Act III - 邪恶之手 伊斯梅尔 (崔凡克)
Geleb Flamefinger 地狱 0.00006522 Act III - 火焰之指 吉列布 (崔凡克)
Toorc Icefist 地狱 0.00006522 Act III - 冰拳 托克 (崔凡克)
Bremm Sparkfist 地狱 0.00006522 Act III - 火花之拳 布瑞姆 (憎恨的囚牢第三层)
Wyand Voidbringer 地狱 0.00006522 Act III - 空虚之指 维恩 (憎恨的囚牢第三层)
Ber贝(30#) Council Member 地狱 0.00004348 Act III - 议会成员 (崔凡克)
Ismail Vilehand 地狱 0.00004348 Act III - 邪恶之手 伊斯梅尔 (崔凡克)
Geleb Flamefinger 地狱 0.00004348 Act III - 火焰之指 吉列布 (崔凡克)
Toorc Icefist 地狱 0.00004348 Act III - 冰拳 托克 (崔凡克)
Bremm Sparkfist 地狱 0.00004348 Act III - 火花之拳 布瑞姆 (憎恨的囚牢第三层)
Wyand Voidbringer 地狱 0.00004348 Act III - 空虚之指 维恩 (憎恨的囚牢第三层)
Jah乔(31#) Council Member 地狱 0.00003728 Act III - 议会成员 (崔凡克)
Ismail Vilehand 地狱 0.00003728 Act III - 邪恶之手 伊斯梅尔 (崔凡克)
Geleb Flamefinger 地狱 0.00003728 Act III - 火焰之指 吉列布 (崔凡克)
Toorc Icefist 地狱 0.00003728 Act III - 冰拳 托克 (崔凡克)
Bremm Sparkfist 地狱 0.00003728 Act III - 火花之拳 布瑞姆 (憎恨的囚牢第三层)
Wyand Voidbringer 地狱 0.00003728 Act III - 空虚之指 维恩 (憎恨的囚牢第三层)
Cham查姆(32#) Council Member 地狱 0.00002485 Act III - 议会成员 (崔凡克)
Ismail Vilehand 地狱 0.00002485 Act III - 邪恶之手 伊斯梅尔 (崔凡克)
Geleb Flamefinger 地狱 0.00002485 Act III - 火焰之指 吉列布 (崔凡克)
Toorc Icefist 地狱 0.00002485 Act III - 冰拳 托克 (崔凡克)
Bremm Sparkfist 地狱 0.00002485 Act III - 火花之拳 布瑞姆 (憎恨的囚牢第三层)
Wyand Voidbringer 地狱 0.00002485 Act III - 空虚之指 维恩 (憎恨的囚牢第三层)
Zod萨德(33#) Hephasto The Armor 地狱 0.00000651 Act IV - 海法斯特盔甲制作者 (火焰之河)
Nihlathak 地狱 0.00000651 Act V - 尼拉赛克 (瓦特之厅)
Baal (第一次杀) 地狱 0.00000558 Act V - 巴尔 (世界之石大殿)
Diablo (第一次杀) 地狱 0.00000558 Act IV - 暗黑破坏神 (混沌庇难所)
Baal 地狱 0.00000488 Act V - 巴尔 (世界之石大殿)
Diablo 地狱 0.00000488 Act IV - 暗黑破坏神 (混沌庇难所)
