如果你认为此贴还没有背弃广大网友.就回个帖，也算是对我的支持~！~本人平时没什么爱好，就喜欢玩远控，虽然不懂编程、但随着时间流逝小问题还是可以应付的，我把心德跟大家分享下，就算是给新手们个建议吧.

这几年手里暂了不少远控，大多都是收费的，从最早的灰鸽子，到现在的红黑远控(前身红黑)。每一个牌子、版本都有用，到目前为止，相信我们菜鸟中能用到我这么全的，真没几个.我以下举例6种，相信在互联网能拿得出手的也就这几个，什么GH0ST、IS、、、等等都拿不行.其他版本的，大家就不要去想了，要嘛残次品、要嘛挂羊头卖狗肉.远控这个东西你不能看他什么时候出现的。有的人认为新出来的东西就是好的，“错”-或者说“不一定”，那要看在什么前提下出现的.当然，我举这几个例子里也有假的（后话谈）…

这里我给大家举几个网上流传已久的有关软件形容词，叫他“形容词”也好，叫他“专业术语”也行，反正就是为了笼统一点，能让大家明白。

1：专业个人版=什么叫专业个人版？

意思就是说某一款软件在这个世界上它的软件源码内部特征是全球唯一的。

打个比喻，人类的DNA，人类的DNA在全球是没有重复的，但是大家都长着脑袋、手、脚、都能干活。。。。

这就是专业个人版软件的基本特征，那它到底有什么用呢？其实很多，权威性、张杨性。。。。。              

但在黑客软件类，它的目的就不一样了，是为了躲避杀软的查杀，因为你是唯一的，并没有人你软件的DNA 公布出去，杀软也就不知道，所以它就不认识你，不能杀你…明白了？

现在很多软件都提供这种人性化的“量身打造”，但大多数都是糊弄你玩的，为什么？因为你只要露出想买个人版的欲望时，人家就已经知道了你是个外行。会想了尽的办法忽悠你。包括现在比较流行的远控版本，有的更是打出“再加100元，免费定制个人版”或“XX元定做个人版灰鸽子”……统统都是假的，效果要说没有，也不一定，但效果并没有你想的那么简单，我认识一个朋友，他告诉我，就是在源码生成里稍稍动动手脚就OK。

再有就是拿普通版本充当个人版的办法，就是给你提供一个更新假象，让你感觉你的待遇好，认为个人版有另外一个特殊的更新渠道，我就告诉你“屁”，实际上人家就是把普通版的简单变一下种，在你生成出来的木马里加了一种不知名的“壳”，给你加个“壳”，就这么简单，明儿里，你还耀武扬威：“我是个人版，我是特殊渠道更新，我的是世界唯一的”实际上，就是普通的“免杀壳”。 CAO死这帮WBD骗子。

除非遇到那种真正有必要的时候，否则不会那么麻烦处理这个的。你们知道修改一次源码有多费事吗？要想让这个版本世界唯一性有多费劲吗？要想让这个世界唯一性的东西出现N个供大家来买有更多费事吗？几百块钱？我是不愿意，这下你明白了？

2：徒弟、shifu=真不想探讨这个话题，就像路边算卦占卜一样，你可以了解，但别深陷其中。

敢问现在收徒的哪个不要报酬？哪个不是为了途利？当然这个世界上都这样，小学老师也得领薪水不是。但人家正了八经的老师能教你有用的东西啊，网络上流传的那些“收徒传授挂马、抓鸡、盗号、入侵….” 。你大胆的问问他，他敢保证自己是个“手儿”不？他们跟那些专门收费帮人预测彩票中奖的有什么区别？有500万中的机会他会因为你给了他几百块钱就让给你？黑客文化孕育了数十年的技术就能在百十块钱的前提下被你学到了？那是专门糊弄你们这群TMD沙但的…你们看那些个抓鸡的视频教程，说不定是谁抓了几天、甚至几个月才找到得那么几个零子儿，拿出来骗你说“一晚抓上万肉鸡”，我靠。。。

3：XXX木马=“螳螂捕蝉黄雀在后”，这个道理你们懂吧？

木马、后门程序只适合拿来看看，新鲜一下。如果你拿来当个工具用，那你可就“彪”到家了。不过一些专业人士如果想用这些程序，肯定不会去网上DOWN那种万人骑的东西，要嘛自己开发、要嘛找人花钱写一套出来，私底下秘密使用。

木马中捆木马，当你拿这个东西区做坏事的时候，你同样也被木马中的那个木马所窥探。如果你用木马盗取了1个QQ号，那么你背后的那只黑手就盗取了2个QQ号，其中一个是你的。远程控制也一样，除非经营它的作者长着一颗“唐三藏”的心。   

黑鸽子www. heigezi. org

他与黑防不同，黑防是稳扎稳打,同样是翻版，但某些时候你的脸皮不要那么厚.，不要那么无耻.黑鸽子-纯粹就是个骗子.突然间冒出来，骗俩钱，完事马上就撤。

谁都明白，鸽子是过街老鼠-太招风。谁都不愿意用它去拉人.太费力，今天的免杀做好了-明天就被杀…灰鸽子1.2源码被公布已经很久了，相信众多的版本都是由此而来，懂编程的人都明白这里边的猫拟.黑鸽子也如此，不过也有例外，兴许背后真的是那些所谓的“葛军团队”在捣鬼，但质量差的太远了。虽然外观做的不错、功能看上去很多，扎眼一看“太T M牛了。。。但实际上，孙猴子一个跟头的距离.

我手里有一个VIP会员版，生成的服务端免杀效果特差，国内的杀软能过一半就很HAPPY了（表面），当你一问为什么这么差的时候客服就告诉你：“谁让你买会员版了，你买个人版的就好了”，我K，那以后你是不是还要叫我买XX钻石版、XX白金版…….？谁T M不知道那所谓的个人版是怎么回事.太T M D无耻了，我实话说吧，软件不稳定，有时候自己都无法上线，一连接肉鸡就容易断开，远程命令也不怎么好使，屏幕传送不稳定，经常无响应。。。。。等等，太多了实话告诉你，只要你买了，不管多少钱，保证毁青你肠子.

黑鹰基地www.3800hk.com

如果不告诉我那是HACK站，还真看不出来.如果你进了他的VIP，就知道什么叫XXX，哎！我只能用X号来表示，因为大家都是文明人，不能说脏话。他们站的教程内容很广，但质量低，什么意思呢？就是说，黑鹰从外表看：什么都教、什么都会、什么都有…但适用的很少，讲师很烂（那个什么烂CEO），说话错字连篇、明明一个简单的意思，他要说的相当复杂（有些时候例子越举，越迷糊）不过他的软实力还是有一点点的（以量压质），有些VIP软件还是不错的，特别是抓鸡方面。不过大家不要被他的外表迷惑，看主页、 VIP，站长公开讲话，不知道的还以为这地方有多好呢…最无助的就是“黑鹰远控”，呵呵我想读者们也应该有人在用，他这个远控-不能说是一般-只能说他确实是个“软件”,免杀就不用提了，你买了就后悔.好东西有，但是轮到你手里就不是什么新鲜玩意了。怎么说呢，黑鹰的商业目地和重心偏移，有点过头了。

红黑远控www.7747.net

软件虽然功能上还不是很全，但稳定性较08年有了那么“一丁点儿”的提升.现在价钱升到90了，我感觉还行！为什么说呢？

1：价钱不贵，大家可以到处转转，看看哪一款远控（某些站公开销售VIP版）能把价钱压到100以下. 有的网站是拐了弯的整你俩钱，说什么免费赠送，废话，你要是不花3-4百块钱他能免费送你吗？

2：免杀稳定，定期更新：我用了那么多远控，能够坚持不断更新到几年、免杀过国内主流的唯独红黑.是，有时候大家会发现卡巴过不去了，360过不去了。这也是正常. 你用脑袋想一想，你用的这是什么？黑客软件啊，黑客软件就会被杀的，相比其他版本来说 知足吧你！

注意问题：你们要记着，有些东西是不能轻易往软件里加的. -比如“键盘记录、远程文件删除”（起码目前来说比较渺茫）

现在是什么时候？国家相关政策如何？在政策与现实处于敏感时期，你脑袋消尖往前冲，找死嘛！软件的类别定位很难，但软件具备的某些功能可以让人很明朗的把你归类.  你不具备哪些功能，你就不违法，但某一天你一旦具备了哪些功能，你就是违法。对于一个想长足发展的团体来说，不在必要时候，是不会冒这个险的.  所以大家顺其自然，别着急…

缺陷：不稳定,上线速度还可以，但连接操作的延迟比较大，经常无反应（新版也一样）主机列表对应的“连接速度”不准，本地127.0.0.1时常超过300.，再就是列表那块能不能把“偏好”去掉，给人的感觉怎么，那么二呢！

警告：有些投机取巧的网友会耍点小聪明，认为自己下个免费版，然后叫其他VIP会员帮着生成“服务端”，供自己使用。难道你没发现无法上线吗？郁闷！！！

pcsharewww.pcshare.cn

大家还是把它忘了吧，或者在网上下一个脱壳破解版 -自己改，自己弄，那样能好一点.整体来说软件不错，但官方人员的大脑就有点问题了，头脑简单、四肢发达.有时间大家去看看他的站，冷清到极点了.进论坛看看，连个人影都没有.敢问声誉这么好的东西，官方怎么这么冷淡？我告诉你答案…* pcshare软件很不错，网上很多人都在用，都在自己私下做免杀.所以大家1传10-10传100.

                  不懂行的人还以为这是pcshare官方的功劳，其实不是. 真正吧软件做大，做好的都是民间的其他人，而官方只靠这些傻乎乎的民间人给他做广告，然后自己收钱.举个例子，张三在用一款pcshare .但他用的是经过别人破解、免杀升级的.结果被李四看到了，由于李四不知情，还以为这个是官方VIP版呢，所以就会去找软件的官方买，买到手才知道哦！天呢，不是这样的.

所以从头到尾，大家都在给pcshare做各种免费广告，而他这个官方根本什么也不用做。软件也不用更新，就等着吃现成的.pcshare我现在也在用（就是在那摆着），最新版本是“20080613vip(今天是2009-11-27日，这版依然是他的VIP最新版)”.

它限制你生成次数，也就是说你每天只能生成1次服务端.每个月最多生成30次.而每天生成都被国内97%的杀软查杀，基本不存在所谓的“免杀”问题.官方的答复就是：“1-你买的是会员版、改个人版就好了。2-被会员传到杀毒网所致。”我仔细琢磨了一下，这确实是个合理的借口。但仔细想一想，敢问作为一次正确的免杀，起码要能坚持几小时。再起码你那刚更新完，我这一生成就应该是免杀的，后来被追杀那是后话，但你刚更新完，我生成后这照样杀，那还算个“鸟”更新呢？什么卡巴、江民、瑞星、NOD32、360、麦咖啡，没有一个能坚持住的.无语了，

有一次我在VIP群里侦测了一下在线会员的IP（特殊方法：说简单、也不简单、现成的工具遍地都是），发现VIPQQ群里在线会员的IP 都和管理员在同一省市、城市。我换到其他QQ群就可以探测到全国各地的IP.这TM也太假了吧.如果有会员问及免杀问题，人家管理员就告诉你，找另外一个群友，交钱给你免杀.K~~~我T M花钱买了VIP，不但不免杀（过得去也行啊），还要另外花钱去做免杀..那我还不如在网上随便下载个玩得了.

上兴远控www.98exe.com

还是一样，想玩的朋友。去下载个免费、破解版，然后自己学着做免杀.如果不会做，你就别玩…我是为你好，花了钱什么都得不到，那你可就爽了.怎么说呢，上兴远控我感觉从远控技术角度来说，他仅次于灰鸽子（原版）。但现在上兴官方也不怎么更新了，我手里是2009 VIP的.可能是人家钱赚够了吧…..更新时间不稳定，效果不好，有时候很长时间更新一次，客服态度蛮横、什么都不管。杀软主动除了金山，其他的都过不了.（我测试只能过金山）2009版其实就是把前年的版改了下名字、换个主题而已，不信你们懂免杀、脱壳的研究一下就明白了（细节地方比一下,完全一样,生成大小不一样那是作弊做出来的）所以对于上兴远控，不建议购买。

其他“XXX版鸽子” 

其他版本灰鸽子大多数都是2007黑防版–改下名称、换张图片、调下启动窗口。很多网站、论坛都这么干，然后做个免杀就充当自己的VIP专版.都是骗小孩子的。

再有就是“山寨版”灰鸽子，什么意思呢，就是仿造。PS张好看的启动画面，然后换个主题。用现在比较流行的语言、工具来写一套类似的软件。部分版本从表面上看难辨真假，但用起来性能上感觉根本不是一个档次。意思就是说，照着灰鸽子的样儿，重新编译一款一模一样远程控制，这种东西，只能看不能用，因为根本就是垃圾. 2009版的冒牌货都比不上2005原版鸽子稳定。

总结语：

对任何站点、被别人说的再好不过的软件都不要抱太大的希望。比如：我加入VIP快1年了，怎么还不会入侵、盗号、远控、编程…….？？？其实这种东西不是靠花那么百十块钱就能学到的，敢问一个整天在学校、有老师教的地方你都学不会何况网络了.就花那么俩个钱，买个VIP，就能学到本事了？好好想想吧…..不过话说回来，如果你就是想玩，想接触这个领域、甚至说就想单纯的会那么一点儿…花点钱，买个VIP，看个教程也够了。不过一定要去在档次上过得去的站，起码每天都有教程看、起码在群、论坛里发个帖子能有人回的地方。黑基、红黑、黑鹰都可以。

至于远控-花点小钱百十元左右买个玩玩，即使被杀了也属正常。就是别抱太大期望. 另外我给你们讲一个道理：你把钱存在某银行，突然有一天银行的工作人员告诉你，你存在银行里的钱被盗了,原因是你没购买他们提供的“个人版金库”，所以就丢了。你说？你是怎么想的？目前就这么多……………大家如果觉得有理，回个贴、奉上那么1个豆豆，我就开心了，太开心了……….

BTW： 脱壳免杀制作工具 MYCCL + OD + C32

初步结论：

读取性能    Raid0 > Raid5 >> NoRaid > Raid 1

写入性能    NoRaid >> Raid0 >> Raid1 > Raid0

测试服务器均是HP DL 380 ，Smary Array 5，没有写缓存

下载：Kometo's Raid Testing

电信为默认路由，使用mangle 添加 Routing Mark 的方式来配置路由选择，AL.CNC是一个下载的网通地址表

 chain=prerouting action=mark-routing new-routing-mark=R.CNC
 passthrough=yes dst-address-list=AL.CNC

然后建立策略路由表，如下，看着比较多行，其实主要相关的是行号1：

 0 A S  0.0.0.0/0                          reachable     58.57.XXX.XX                       1        E.WAN.CTC[V3003]
 ; routing mark - R.CNC
 1 A S  0.0.0.0/0                          reachable     218.56.XXX.XX                      1        E.WAN.CNC[V3001]
 2 A S  10.0.0.0/8                         reachable     10.5.159.189                       1        E.LAN.OF
 3 ADC  10.5.159.188/30    10.5.159.190                                                     0        E.LAN.OF
 4 ADC  58.57.XX.XXX/30    58.57.XX.XXX                                                     0        E.WAN.CTC[V3003]
 7 ADC  192.168.68.0/24    192.168.68.1                                                     0        E.LAN.HOME#1[V1001]
 8 ADC  218.56.XXX.XX/30   218.56.XXX.XX                                                    0        E.WAN.CNC[V3001]

按照正常完成上面的配置后遇到一个奇怪的现象：

客户端无法Ping通网通段的IP地址，当然其它对网通地址段的访问也都不通，然后反复排查，查资料，头痛…..

中间发现：如果在R.CNC路由表中添加客户端的路由后客户端就可以正常访问了，但这不应该是解决问题的根本方法，有些连接路由或动态路由是无法手动处理的。

然后又尝试很多种处理方式，和可能出问题的地方，头真的很痛。。。

直接说原因吧：

上述配置中使用的AL.CNC地址表中包含了我的网通接口地址，（按情理来说当然应该包含的，我的网通接口地址当然在网通IP地址表范围内）

但是造成问题的原因就在这里，只要从地址表中去掉我的网通接口地址，一切就都正常了，可以直接修改AL.CNC地址表，也可以简单修改mangle排除掉接口地址，像这样：

chain=prerouting action=mark-routing new-routing-mark=R.CNC passthrough=yes
dst-address=!218.56.XXX.XX dst-address-list=AL.CNC

?仍然存在的疑问?

这种情况应该在配置网通电信策略路由时经常遇到，但在问题排查过程中，没有从网络上看到类似的讨论！为什么？

这种意外情况是ROS设计的本意还是它的一个BUG？我使用的版本是4.22

我真的找到了问题的根源了吗？

BTW

发现，当配置好网通、电信自动路由选择后，线路负载分配很大程度上受DNS设定影响，当使用网通的DNS服务器是，大部分访问会解析到网通的服务器上，电信的也同理。

到了Vista 和 Windows 7，系统默认安装的字体是 仿宋 和 楷体 ，这两个实际上是支持 Unicode的字体

这样就给我们排版带来了兼容性问题：

    所有以前在XP下排版的文件，指定使用的仿宋 GB2321 和 楷体 GB2321和字体，到Vista和Win7下都变成了微软雅虎。

    同样所有在Vista和Win7下排版指定的仿宋和楷体到XP下又变成了宋体。

原因就是字体的缺失，知道原因，解决起来也就简单了，比较通行的方法是在Vista和Win7下安装仿宋 GB2321 和 楷体 GB2321两种字体，你可以从XP系统下自己拷贝，或者使用文后的下载。

    随便提一下按有关国家公文规定，通常正文使用仿宋，附件使用楷体

下载：仿宋 GB2321 和 楷体 GB2321

1. 需要手动下载 openGFX open SFX

2.配置文件 openttd.cfg默认创建在用户目录，可以复制到TTD的运行目录，然后 OPENTTD就会忽略用户目录的文件和设置了，在U盘和多机共享游戏目录时特别有用

3.字体设置，OpenTTD不能直接使用中文字体名，所以必须是用文件名来指定字体，推荐把字体文件复制到OpenTTD的运行目录，然后编辑CFG文件

A;复制微软雅黑字体文件到游戏目录

B 编辑CFG文件，如下：

 

small_font = msyh.ttf

medium_font = msyh.ttf

large_font = msyhbd.ttf

small_size = 12

medium_size = 14

large_size = 18

small_aa = 1

medium_aa = 1

large_aa = 1

• 默认情况下闪光灯的控制方式是：E-TTL II，TTL的意思是（Through The Lens 通过镜头），既闪光灯测光是通过镜头来测量的。
• E-TTL，当快门释放的一瞬间，闪光灯会发出一束预闪光，用来监测环境光和计算所需的闪光量，然后闪光灯发出正确的闪光量
• 闪光量的计算是不受曝光补偿控制的，它总是通过某种算法计算，试图使曝光主体获得正确的曝光，唯一控制闪光量的方法是指定闪光补偿。也就是说不管你怎么控制曝光量（手动，曝光补偿负值），闪光灯总是试图是曝光主体获得正确的曝光
• 但是使用P模式或是自动模式，拍摄光线又比较暗时，相机默认使用最大光圈，1/60的快门，ISO400的曝光设置，然后点亮闪光灯，主体曝光的控制实际是由闪光灯控制了。如果光线环境比较亮，相机可能会使用较快的曝光设定，而闪光灯同样会点亮，以进行主体曝光的检测。
• 原则上使用闪光灯时：根据背景进行曝光设定，通过手动、或者自动EV锁，注意打开闪光灯开关后，自动曝光锁可能不能正确工作；然后用闪光灯来对主体进行补偿曝光，这时，闪光曝光锁就特别有用。

读《阿凡达》 需要向魔兽世界敬礼之评论有感：

为什么会有这么多人对WOW反应如此强烈呢，一夸WOW，就有人说2，还有人叫喊着要禁，真是疯狂的莫名其妙，游戏而已。

我部分同意博主的观点，西方魔幻史我不能说很熟，但西方魔幻游戏史我是绝对熟，我是从使用5英寸软盘看书玩游戏的，到现在为止，单机游戏叫的响的基本都摸过，网游到没完几个。WOW从公测开始玩，不过现在已经有1年多没玩了，主要是没时间。

我说WOW绝对是经典，是里程碑，当然不是起源，毕竟年龄再哪里了。

反到是那些说玩WOW玩傻的人，你们叫嚣着别人不了解魔幻史，那么你们了解WOW吗？美的东西确实会很容易让人傻的，而且也会让不了解她的人感到恐惧，WOW就是个狐狸精。

如果你准备在JavaScript中写类，那么你必需对关键字 this 的使用有深刻的理解：

这是JavaScript手册中对 this的简单解释：

this:指当前对象。

对于 JScript 的客户版本，如果在其他所有对象的上下文之外使用 this，则它指的是 window 对象。

在全局环境下的 this

通常我们认为，Javascript 不在任何函数，不在任何类中，直接书写运行的代码的环境，称为直接运行环境，或者全局环境。实际上这个环境并不是一个真正意义上全局环境,

运行下面的代码：

dump(this,'Global This');

我们可以得到输出结果：

可以看到，在这个环境下，this 等于 浏览器的原生对象 window ,它是原生类 Window 的实例。

事实上，当我们在浏览器中运行JavaScript代码时，windows 是所有代码的根节点，所有的代码都是存储并挂接于这个节点的，当然多窗口的环境下会有多个window对象。

function Car(){

}
dump(Car);
dump(window.Car);

输出结果：

■ function function Car() {  …

■ function function Car() { …

可以看到 Car 和 window.Car 是完全相同的东西

在类中使用 this

现在我们来看看当使用类的时候，this会发生什么样的变化。下面是一段典型的类定义代码，我们来逐步分析：

function Car(color,doors){
    //用构造模式定义属性
    this.color = color;
    this.doors = doors;
    this.dispThis = function(){
    	dump(this,'this');
    };
    dump(this,'this');
}

//原型方法
Car.prototype.dispThis2 = function(){
	dump(this,'this');
};

//静态方法
Car.dispThis3 = function(){
	dump(this,'this');
};

aCar = new Car('red',4);
aCar.dispThis();
aCar.dispThis2();
Car.dispThis3();
Car('red',4);

输出结果：

■ this: object – [object Object]                                                       //构造函数 new Car()

– color ■ string red

– doors ■ number 4

– dispThis ■ function function () { dump(this, "this"); }…

– dispThis2 ■ function function () { dump(this, "this"); }…

■ this: object – [object Object]                                                        //构造方法 aCar.dispThis();

– color ■ string red

– doors ■ number 4

– dispThis ■ function function () { dump(this, "this"); }…

– dispThis2 ■ function function () { dump(this, "this"); }…

■ this: object – [object Object]                                                       //原型方法 aCar.dispThis2()

– color ■ string red

– doors ■ number 4

– dispThis ■ function function () { dump(this, "this"); }…

– dispThis2 ■ function function () { dump(this, "this"); }…

 

■ this: function function Car(color, doors) { this.co…               //静态方法 Car.dispThis3()

■ this: object – [object Window]                                                   //直接运行构造函数 Car()

[The window Object]

可以看到在构造函数、构造方法、原型方法中的都可以获取到this对象，它们指向同一个实例对象aCar，该对象由 new Car() 语句生成。

在Car的静态方法 Car.dispThis4（其实就是Car的一个直接的function属性）中，this 就是Car 本身，

当不使用new 关键字，而直接运行类的构造函数Car（其实现在它就是一个普通函数）时，在函数内部 this 就是当前运行环境的window对象

注意：比较一下 aCar.dispThis() 和 静态方法 Car.dispThis3() 输出结果就可以发现：Car 和 Car 生成的对象是2个完全不同的概念；Car是一个函数对象，继承与原生的 Function ；而Car的实例aCar则是一个单纯的对象，它继承与JavaScript原生的 Object

比较一下：

通过这个表格特别是1、2、3行，我们可以清晰的得到一个规律：this 其实就等于调用代码时的调用的节点，即：aCar. 和 Car. 。这个调用节点也就是参考文档中所提到的上下文环境。

那么如何解释4、5的结果呢？

new Car();使用了一个特殊关键字 new ，这个关键字的作用就是生成一个新的对象，并赋值给 this 。所以 this = aCar

Car();没有通过任何节点调用，实际上通过了默认节点window 来调用，通过上一节我们也可以看出 Car 实际上就是 window.Car 。所以 this = window

总结和结论：

JavaScript中所有的东西都是对象，包括数字、字符、函数以及对象的属性，函数总是存在（挂接）于某个对象中（默认存在于window对象），并通过某个对象调用的。在函数中总是有一个可用的的 this 变量，脚本引擎对 this 的解析是动态的，运行时的；它指向函数被调用时所挂接的对象。

我们可以通过一系列函数对象来进一步明晰这个过程，这些函数对象我们有时也称之为类的静态方法，实际上类的静态方法本身也是一个类，也是一个对象，明白了这一点，你就可以深刻理解Javascript的对象机制了。

function Car(){
	this.name = 'car';
	e(this);
};

Car.Wheel = function(){
	this.name = 'wheel';
	e(this);

};

Car.Wheel.Size = function(){
	this.name = 'wheel.size';
	e(this);
}

Car();
Car.Wheel();
Car.Wheel.Size();

输出结果

■ object – [object Window]

■ function function Car() { this.name = "car"; …

■ function function () { this.name = "wheel"; …

当 this 遇到事件

当我们在事件函数中使用到 this 时，this 有时会很不听话，经常会取值为意料之外的对象。先来看一段示例代码：

我们定义一个类的方法函数 Car.prototype.show();

function Car(){
	this.name = 'Class Car';
}

Car.prototype.show = function(){
	echo('On Car.show');
	dump(this,'this');
};

aCar = new Car;

然后使用两个按钮的分别用两种方式触发 aCar.show;

<input id="btn1" type="button" value="Press Me call car.show"/>
<input id="btn2" type="button" value="Press Me call car.show #2"/>

<script type='text/javascript'>
   document.getElementById("btn1").onclick = aCar.show;
   document.getElementById("btn2").onclick = function(){aCar.show();}
</script>

输出结果

//btn1 click

■ this: object – [object HTMLInputElement]

– tagName ■ string INPUT

– value ■ string Press Me call car.show

– id ■ string btn1

– className ■ string

…….

//btn2 click

■ this: object – [object Object]

– name ■ string Class Car

– show ■ function function () { echo("On Car.show"); …

我们看到btn1的click事件中 this 的输出结果是 Input元素，

btn2的Click事件中，this 的输出结果是 aCar。

为什么会出现这一结果呢？

造成不同的主要原因是事件的绑定方式的不同，我们来看看事件的绑定过程：

btn1使用 document.getElementById("btn1").onclick = aCar.show  这条语句进行了事件绑定。
我们把 btn1.click 指向（引用）了 aCar.show，当事件触发时 btn1.click 被调用（回调），也就是调用了 aCar.show  的代码；看起来一切正常，唯一需要注意的是： aCar.show  的内部代码不是以节点名称 aCar 来调用的，而是以节点 btn1 来调用的，也就是说此时 show()  的运行时节点是 btn1，那么 this 也就成为了 btn1。

btn2 使用 document.getElementById("btn1").onclick = function(){aCar.show();} 。
和btn1唯一的区别就是它使用了一个匿名函数把 aCar.show();包裹起来了。就是这样简单一个包裹引起根本性的变化，当事件触发时 btn1.click 被调用（回调），运行代码并不直接是 aCar.show ，而是通过匿名函数又再次调用 aCar.show ；此时调用的节点是 aCar ,所以 this = aCar 。

有些文章用事件函数的复制和引用来解释btn1和btn2结果的不同，这种解释实际是错误的，流于表象的，虽然很多文章还做了很多图来解释… JavaScript 的所有赋值语句都应该理解为引用，这又是另外一个话题，不扯远了…

我们来进一步比较不同事件函数绑定方式所带来的 this 的变化：

function Car(){
	this.name = 'Class Car';
}

Car.prototype.show = function(){
	dump(this,'this');
};

aCar = new Car;

element.onclick = aCar.show;                       // this = element
element.addEventListener('click',aCar.show, false) // this = element

element.onclick = function () {aCar.show();}      // this = aCare
lement.attachEvent('onclick',aCar.show)           // this = aCare
<element onclick="aCar.show();">                  // this = aCare

element.onclick = function () {this.style.color = '#cc0000';}     //this = element
<element onclick="this.style.color = '#cc0000';">                 //this = element

总结：this 指向函数被调用时所挂接的对象。当事件函数被调用时，this 总是等于事件所在的节点，因此我们应该使用匿名函数作为事件函数，并在匿名函数中二次调用可能需要的其它函数。以此来避免可能的 this 混乱。

现在我们来看一段示范代码，这是一段典型的既能获取函数本身所在节点，又能获取触发对象的代码模式

function Car(){
	this.name = 'Class Car';
}

Car.prototype.doSomethin = function(obj){
  dump(this,'this');  //this = aCar
  dump(obj,'obj');    //obj = element
};

aCar = new Car();

<element onclick="aCar.doSomething(this)">                //方法1
element.onclick = function() {aCar.doSomething(this)}     //方法2

在类中进行事件绑定操作

当我们在类代码中进行事件绑定操作时，对this的使用会遇到新的困难，我们知道所有的事件函数中 this 都必然等于事件函数所在的对象（即上例中的btn1)，那么我们如何在一个类中书写一段匿名事件函数，并在匿名事件函数中调用当前类的对象呢？

看代码：

<input id="btn1" type="button" value="Press Me call car.show"/>

<script type='text/javascript'><!--

function Car(){
	this.name = 'Class Car';
}
Car.prototype.showThis = function(obj){
	dump(this,'this');
	dump(obj,'obj');
};
Car.prototype.bind = function(){
	document.getElementById("btn1").onclick = function(){ this.showThis(this); };
};

aCar = new Car;
aCar.bind();

--></script>

如果你看到这里对 this 已经有了深刻的理解，那么就会发现这段代码实际使用的话会出错的，问题就出在这一行代码：

document.getElementById("btn1").onclick = function(){this.showThis(this);};

这行代码的本身是在aCar.bind中运行，然后这行代码又写了一个匿名函数：function(){this.showThis(this);} 。匿名函数中我们希望调用当前对象 aCar 的方法 showThis ,同时又想把事件触发对象btn1 传递给 showThis。我们用了2个 this ，这里的 this 到底应该等于什么呢？两个 this 都应该等于 btn1 ,因为这个匿名函数将会以节点 btn1.click 来运行的。this.showThis 将会无法调用到我们希望的目标 aCar.showThis ；

那么如何改写这段代码，来正确的调用aCar.showThis 呢？似乎目前只有这个方法，使用一个临时变量来传递 this ：

var _this = this;

document.getElementById("btn1").onclick = function(obj){_this.showThis(obj);};

其实这样代码看起来有点让人难以理解，如果想更深入的解释这段代码，就需要进一步解释JavaScript的编译和解释运行机制，我对此也没有深入的研究，但是可以推测出的原因是：JavaScript的脚本引擎对变量的编译和解释是根据代码书写环境（书写节点）来进行的，而对this 似乎总是根据运行环境（运行节点）来赋值的。

回调函数和 this 使用的总结

关于 this 的使用似乎很让人头晕，特别是当 this 和事件和类混在一起使用的时候，如果你需要一个简单的方法来处理这个，我们可以归纳出几条规则

1. 事件处理函数又可以称为回调函数(CallBack Function)，回调函数不仅仅用于界面事件（Click,Moueover等等）的处理，很多异步处理需要大量的回调函数。
2. 总是使用匿名函数作为回调函数，并在匿名函数中再调用其它命名函数，使用 event = function(){ somefunction(); }  的方式，不要使用 event = somefunction 的方式
3. 命名并传递默认参数，同时也可以把回调函数中的 this 传递给其它被调用函数。如：event = function(params){ somefunction(this,params); }
4. 如果在类中书写匿名回调函数，并且需要在函数中调用当前类的当前对象，使用一个临时变量来引用 function(){_this.showThis();};

最后来看看常见的Jquery的事件绑定方式：

<input id="btn1" type="button" value="Press Me call car.show"/>
<input id="btn2" type="button" value="Press Me call car.show #2"/>

<script type='text/javascript'><!--

function Car(){
	this.name = 'Class Car';
}
Car.prototype.show = function(){
	echo('On Car.show');
	dump(this,'this');
};
aCar = new Car;

$("#btn1").click(function(){aCar.show()});  //通过匿名函数2次调用 this = aCar
$("#btn2").click(aCar.show);                // this = btn2

--></script>

输出结果

On Car.show //这个是引用方式 this = aCar

■ this: object – [object Object]

– name ■ string Class Car

– show ■ function function () { echo("On Car.show"); …

On Car.show //这个是复制方式 this = btn2

■ this: object – [object HTMLInputElement] 

– tagName ■ string INPUT

– value ■ string Press Me call car.show #2

– id ■ string btn2

– className ■ string

…….

这里的Node,HTMLElement,HTMLAnchorElement其实就是HTML元素对象的类声明，我们可以通过修改这些类的原型来修改所有相关的HTML元素特性。

但是，HTMLElement和Node在IE中是虽然存在的，但是IE屏蔽了它，我们是无法访问到它的。

所有的Node实例有个标准属性 nodeType,有时它可以帮助我们判断一个NODE的属性

nodeType values chart 列表

比如判断一个对象是否为 HTMLElement的实例：

Oobj instanceof HTMLElement;         //这行代码在IE中会报错的
Oobj .nodeType == Node.ELEMENT_NODE; //这行代码在IE中会报错的
Oobj .nodeType == 1;                 //Node.ELEMENT_NODE=1 在IE中只能直接使用数字

//一段完整判断函数
function isElement(Oobj ){
    return !!(Oobj && Oobj.nodeType == 1);
} 

参考：

DOM对象参考手册 http://www.navioo.com/DOMReference/HTML/reference/api/htmldom2.index.php

这个站关于JavaScript的参考资料很好，很强大 http://www.navioo.com

JavaScript中所有的东西都是对象，包括函数、字符、数字等等等。但是JavaScript没有Class这个概念。

JavaScript使用Function来模拟类，任何一个function都有一个对应的prototype对象来存储和扩展这个function的定义，也就是说原型对象是关联于函数的

我们计划使用new关键字来调用并生成新对象的函数，我们称为“构造函数”

一个基本的函数分析

function Car(){
	color = 'red';
};

echo(Car);
echo(Car.constructor);
echo(Car.prototype);
echo(Car.prototype.constructor);

输出结果

function Car() { color = "red"; }

function Function() { [native code] }

[object Object]

function Car() { color = "red"; }

1. Car本身是一个函数
2. 它的constructor是原生对象（Native Function）
3. 在函数Car定义解析的同时，会系统生成一个对象 Car.prototype，它将会是所有由Car生成(new)的实例对象的原型对象，注意它是对象，这不同于常见的Class概念。默认的原型对象没有任何属性
4. Car的原型对象的Constructor就是Car自己，这也说明了原型对象是在函数定义的同时产生的。

原型对象

函数的原型对象是在脚本引擎解析每个函数代码时自动生成的，而不是执行时才生成

//function Car 是显式定义的，Car.prototype已经在代码解析时自动生成了，此时可以访问
echo(Car.prototype);
function Car(){};

//function Plan 是赋值定义的，Plan.prototype没有自动生成了，此时不能访问
echo(Plan.prototype);
Plan = function(){};
//现在才可以访问
echo(Plan.prototype); 

原型对象实际的工作方式是一种链式查找，脚本运行时，脚本引擎首先在当前实例对象中查找指定的属性，如果有就直接使用，如果没有就到原型对象中找，如果原型对象也没有，就到原型对象的原型对象中查找，这是一个递归的查找链。所有的JavaScript对象的查找链最终都会归结到原生函数Object的原型对象中去。

function Car(){
	this.color = 'red';
};

Car.prototype.color = 'blue';
Car.prototype.doors = 4;
Object.prototype.wheels = 4;

aCar = new Car;
echo(aCar.color);
echo(aCar.doors);
echo(aCar.wheels);

输出结果：

red  //注意：这里构造函数中定义的属性color覆盖了原型中的color定义

4 //从原型中查找到了doors

4 //从根原型中查找到了wheels

实例对象的原型对象关系链是有脚本引擎内部维护的，我们不能操作和修改它，但是可以通过定义和修改构造函数的prototype属性来影响的以后生成(new)的实例对象的原型对象，而JavaScript的继承关系正是通过这一方式来模拟的。

类的继承

JavaScript所有原生函数(Function,Array..)的Prototype对象指针是只读的，不能修改。你可以改变原型的内容，但不能改变原型对象本身。

而非原生函数的的原型对象是可以修改，如果把一个函数（A）的原型定义(prototype)指向另一个函数函数（B）的实例，这样可以就模拟出A继承B的效果

其实际效果是：把B的原型对象插入到了A的实例对象的原型链中去：

new A > A.prototype > B.prototype > …. > Object.prototype

//这样的代码是不能执行的
Array.prototype = new String('');

function Car(){}
function RaceCar(){}
//RaceCar 现在继承了 Car 的定义
RaceCar.prototype = new Car;

考虑到修改函数原型对象时可能会造成修改前的原型定义丢失，所有应该仅可能早的指定原型对象。

同时你也许需要修改新原型对象的constructor，使其指向当前构造函数，典型的继承关系处理代码如下：

function Car(){
	Car.prototype.color = 'blue';
	this.doors = 4;
}

function RaceCar(){
	RaceCar.prototype.color = 'red';
	this.doors = 2;
}
RaceCar.prototype = new Car; //RaceCar 现在继承了 Car 的定义
RaceCar.prototype.constructor = RaceCar;  //修改constructor

aCar = new RaceCar();

Car.prototype.wheels = 4;

echo(aCar.color);
echo(aCar.wheels);

输出结果为：

red

4

11

建模结构图

我们使用一段代码及其对应的建模结构图来进一步说明JavaScript的继承处理方式：

代码：

function A(){

}

B.prototype = new A;
B.prototype.constructor = B;

function B(){

}

结构图：

参考：http://mckoss.com/jscript/object.htm