<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>Physure.com</title>
	<atom:link href="http://physure.com/blog/index.php?feed=rss2" rel="self" type="application/rss+xml" />
	<link>http://physure.com/blog</link>
	<description>关注开发与交互设计</description>
	<lastBuildDate>Fri, 02 Apr 2010 03:32:56 +0000</lastBuildDate>
	<generator>http://wordpress.org/?v=2.9.1</generator>
	<language>en</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
			<item>
		<title>JavaScript中new String和&#8221;&quot;的区别</title>
		<link>http://physure.com/blog/?p=189</link>
		<comments>http://physure.com/blog/?p=189#comments</comments>
		<pubDate>Fri, 02 Apr 2010 03:32:56 +0000</pubDate>
		<dc:creator>webphoenix</dc:creator>
				<category><![CDATA[未分类]]></category>

		<guid isPermaLink="false">http://physure.com/blog/?p=189</guid>
		<description><![CDATA[]]></description>
		<wfw:commentRss>http://physure.com/blog/?feed=rss2&amp;p=189</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>[转]评论：程序员，不止干到35岁</title>
		<link>http://physure.com/blog/?p=183</link>
		<comments>http://physure.com/blog/?p=183#comments</comments>
		<pubDate>Thu, 11 Mar 2010 12:13:27 +0000</pubDate>
		<dc:creator>webphoenix</dc:creator>
				<category><![CDATA[技术文章]]></category>
		<category><![CDATA[程序员]]></category>
		<category><![CDATA[管理]]></category>
		<category><![CDATA[评论]]></category>

		<guid isPermaLink="false">http://physure.com/blog/?p=183</guid>
		<description><![CDATA[　　在中国，程序员不能超过35岁，似乎已经是不争的事实，软件开发工作就是青春饭，顶多靠毕业这十年的时间，超过这个年龄，要不成功跃身成为管理者，要不转行进入其他领域，好像再没有更好的选择，即使偶有继续坚持作开发的，也被看成另类一族。老外却不是这样，40，50岁仍然作开发工作的大有人在，甚至很多牛人，包括获得康柏最佳软件奖的Robber，仍在埋头作着他所喜欢的编码工作，为何如此差异。我仔细想了一下，特别是这一年参加了太多的技术培训，基本有了一些结论。
　　首先，国内软件开发工作的性质决定这一切，我们所作的产品开发，真正技术含量并不高，高等院校毕业的学生，经过几年的培训和实践，基本都能掌握这些技能，而我们现有产品开发设计水平有限，对于软件开发的理解还仅限于编码，完成功能这些基本的需求，产品进度是第一驱动力，特别是一些小公司，把快速开发出产品作为最高目标，软件设计质量差，很少考虑可维护性，可扩展性这些重要的软件质量属性，仅仅追求功能和进度，产品以最快的速度完成设计，编码，少有测试甚至没有测试，就直接交付给客户，在客户那里暴露出各种各样的问题出来，开发人员就开始不断得为客户解决这样那样的问题，软件做到最后，很多人都会陷入自己不断挖掘出来的陷阱里走不出来，步入在复杂的系统中查找BUG，解决BUG，增加功能，引入新的BUG，再解决BUG，这样永无休止的恶性循环中，从事的都是一些低级开发工作，对于软件开发的理解无法上升到更高的层次，每天都疲于救火和拼命打补丁，软件维护成本居高不小，即使最终摆脱了这样的厄运项目结束，下一次软件开发又是同样过程的重复，这些无休止的低级开发和维护工作，会耗光一个人所有的激情和精力，随着年龄的增大，热情和体力都在衰减，而这些工作，只要毕业生经过培训，同样可以胜任，有着廉价的，并且充满热情的毕业生作竞争，身心疲惫的老程序员必然面对更大的竞争压力，做到最后，连他们自己都会失去对软件开发的兴趣，甚至会产生厌倦的情绪，对于这样的快速开发模式，十年开发经验和五年开发经验有很大区别吗？干吗不使用更经济便宜的开发人员。
　　另一个原因，是我们中国人一向的官本位思想，开发人员始终处于一种很尴尬的境界，听起来从事的是高级技术工作，说起来也是以人为本，但是，有多少企业管理者真正重视和认可开发人员的，哪怕是硕士，博士，这些开发人员在大官，小官面前，都只是普通劳动者而已。程序员是一个没有未来的行业，哪怕资历再深，能力在强，也还是一个劳动者而已，只有当上领导，走上管理才是最终的出路，否则，薪水上不去，地位上不去，只能面对被淘汰的命运。
　　实际不然，之所以出现这种问题，是国内对软件开发的一种错误理解。如果软件开发仅仅是代码编写，查找BUG，可以说，那实在是一些低级的软件行为，做了十年的开发人员，确实不见得比作了3年的人更强多少，反正是简单重复的工作，工作3年的一样可以作，而且有更大的热情和精力。但是，应该跳出这个怪圈，走向更高的领域，对软件开发重新进行认识。要明白，软件开发要融入工程化的思想，要有高度的设计能力，关注更多的软件运行属性和设计质量属性，同样的系统，不同的软件人员会做出完全不同的软件，正规，高效的开发团队要比游击队开发团队不只高出几十倍。软件开发，不仅仅关注功能，性能，更应该去研究可维护性，可扩展性等质量属性，不仅仅只关注代码，而更要上升为设计，复用等。软件开发不仅仅是写出C语言的代码，单元测试，同行评审，培训与学习，这同样是开发人员基本的素质，也是提高软件质量的最基本手段。举例来说，单元测试做好了，就可以让开发效率大大提高，也能让软件的维护成本降下来。把开发人员解放出来。同行评审可以让开发人员之间更多的交流和沟通，在设计，编码阶段严格控制软件质量，培训则是提高自身技术水平，从理论上提升自己的最好方法。先前这些主要的质量行为都被忽略了，而这恰恰是走出低级开发的最好途径。同时，还有更高层次的设计开发，软件重构，模块化，系统构架，搭建统一软件平台，度量软件质量等等，有了重构，就会写出可读性好，可维护性好的软件，甚至因此提高自己的软件设计能力，减少出错的几率；模块化，让软件最大程度的实现复用，提高软件开发效率和开发质量。软件构架设计，从技术层次上最早决定了软件的命运，而这里又有太多的技术，设计模式，软件规划等，让软件开发从编码上升到设计的层次，搭建统一软件平台，是大产品，系列化开发的必然之路，对于软件质量的度量，会让我们的软件开发变得更加透明，清晰，让我们更清楚的把握到软件开发过程，从各个环节去控制软件质量，而不是仅仅凭着感性的认识到了最后才去补救。
　　以上这些知识，一个人，哪怕勤奋学习一辈子，也不可能完全具备所有的技能。35岁算什么，做到70岁都不晚。当然，你需要真正的热爱它，并且不断得学习和进修。所以说，软件开发人员，要作的事情太多了，软件实在是一个浩大的脑力工程，甚至会让人觉得这是一个投入/产出比最低的行业，因为要学习的知识实在太多了，每时每刻都要处于不断的学习和更新当中，呵呵，既然选择了，既然喜欢了，就投入进去，享乐于此了。最重要的是，我们自己能并且愿意去认识到这一点，跳出低级开发的怪圈，走向更高的层次
　　同时，要意识到，一个资深开发人员的作用绝不亚于一个管理人员，高明的企业应该给予相同的待遇，要把培养和储备高级技术人才作为高科技企业的重点发展方向，这样才能让企业在人才领域得到不断积累，资深开发人员才会带出高效的开发团队，从而开发出高质量，高效率的软件，让企业在不断激烈的竞争中取胜。要明白，不是每个人都适合或者乐于转向管理的，很多人就是适合做开发工作，他们可以走得更深入，成为专家，应该充分发挥出他们的能力，让整个团队高效运作起来。
　　所以说，开发人员，决不只是35岁，只要你愿意，可以作一生的开发，从中获得更多的快乐。
　　本文转自：CSDN
]]></description>
		<wfw:commentRss>http://physure.com/blog/?feed=rss2&amp;p=183</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>VC8.0中使用JavaScript引擎V8</title>
		<link>http://physure.com/blog/?p=164</link>
		<comments>http://physure.com/blog/?p=164#comments</comments>
		<pubDate>Mon, 01 Feb 2010 10:52:02 +0000</pubDate>
		<dc:creator>webphoenix</dc:creator>
				<category><![CDATA[技术文章]]></category>
		<category><![CDATA[chrome]]></category>
		<category><![CDATA[google]]></category>
		<category><![CDATA[JavaScript]]></category>
		<category><![CDATA[V8]]></category>
		<category><![CDATA[VC8]]></category>
		<category><![CDATA[脚本引擎]]></category>

		<guid isPermaLink="false">http://physure.com/blog/?p=164</guid>
		<description><![CDATA[1.获取V8的最新源代码，Google上有详细的获取方法
2.编译V8，这个Google上也有详细的教程，在这里提醒一下，你可以使用VC8编译V8，也可以使用scons命令编译，最好是编译两个版本，一个Debug版，一个Release版，这样可以方便调试时使用
3.新建VC8工程，在工程的目录下新建一个include目录，然后把 v8/include下的v8.h文件复制到自己建立的include目录下
4.工程目录下新建lib目录，将编译出来的v8的debug和Release版本的lib文件复制到这里
5.资源视图下右键单击项目，选择属性，弹出工程的属性对话框，选择“配置属性” -> “链接器” -> “输入” 在“附加依赖项”处输入v8的lib文件，如 lib/v8_release.lib，注意这里你需要根据你的程序模式输入不同的lib文件，如果你是Debug模式，你必须输入debug版的v8.lib，否则可能会引起异常。
6.在程序的.h或.cpp文件的输入下面这段：

#include "include/v8.h"
using namespace v8;

7.在你需要的地方添加上相关的v8调用代码
8.编译运行

注意如果编译的时候出现：
v8_debug.lib(platform-win32.obj) : error LNK2019: 无法解析的外部符号 __imp__timeGetTime@0，该符号在函数 &#8220;public: void __thiscall v8::internal::Time::SetToCurrentTime(void)&#8221; (?SetToCurrentTime@Time@internal@v8@@QAEXXZ) 中被引用
请在using namespace v8前加上对 winmm.lib 的调用，代码如下：

#include "include/v8.h"
#pragma comment(lib,"winmm.lib")
using namespace v8;


基本步骤就是这么多，暂时还没有出现什么异常
]]></description>
		<wfw:commentRss>http://physure.com/blog/?feed=rss2&amp;p=164</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>[转]JavaScript的陷阱</title>
		<link>http://physure.com/blog/?p=142</link>
		<comments>http://physure.com/blog/?p=142#comments</comments>
		<pubDate>Sun, 17 Jan 2010 06:24:15 +0000</pubDate>
		<dc:creator>webphoenix</dc:creator>
				<category><![CDATA[技术文章]]></category>
		<category><![CDATA[bug]]></category>
		<category><![CDATA[JavaScript]]></category>
		<category><![CDATA[陷阱]]></category>

		<guid isPermaLink="false">http://physure.com/blog/?p=142</guid>
		<description><![CDATA[　　这本来是翻译Estelle Weyl的《15 JavaScript Gotchas》，里面介绍的都是在JavaScript编程实践中平时容易出错或需要注意的地方，并提供避开这些陷阱的方法，总体上讲，就是在认清事物本质的基础样要坚持好的编程习惯，其实这就是Douglas Crockford很久以前提出的JavaScript风格要素问题了，有些内容直接是相同的，具体请看《Javascript风格要素（1）》和《Javascript风格要素（2）》。在翻译的过程中，我又看到了贤安去年翻译的《JavaScript的9个陷阱及评点》，其内容又有些交叉在一起，所以我就在现有翻译的基础上做了一个简单的拼合，并依据自己的理解增加了一些注释和解释。

区分大小写：变量名、属性和方法全部都区分大小写
不匹配的引号、圆括号或花括号将抛出错误
条件语句：3个常见陷阱
换行：一直用分号结束语句来避免常见的换行问题
标点法：在对象声明的尾部逗号将导致出错
HTML id 冲突
变量作用域：全局变量对局部变量
函数重载：当重载不存在时，覆盖函数
区分string.replace()函数不是全局的
parseInt应该包含两个参数
“this”和绑定问题
为参数设置默认值，以免你遗漏它们
for each循环是用于对象而不是数组
switch语句需要点技巧
如果你要检查null，应该先检查undefined
时间处理陷阱

区分大小写
　　变量名和函数名都是区分大小写的。就像配错的引号一样，这些大家都知道。但是，由于错误是不作声的，所以这是一个提醒。为自己选择一个命名规则，并坚持它。而且，记住JavaScript中的原生函数和CSS属性都是骆驼拼写法（camelCase）。
getElementById('myId') != getElementByID('myId'); //它应该是“Id”而不是“ID”
getElementById('myId') != getElementById('myID'); // “Id”也不等于“ID” 

document.getElementById('myId').style.Color; //返回 "undefined"

不匹配的引号、圆括号或花括号
　　避免陷入不匹配的引号、圆括号或花括号陷阱的最好方式是编码时一直同时写出打开和关闭这两个元素符号，然后在其中间加入代码。开始：
var myString = ""; //在输入字符串值之前写入这对引号
function myFunction(){
 if(){//关闭每个打开的括弧
 }
}
//统计所有的左括号和右括号数量，并且确保它们相等
alert(parseInt(var1)*(parseInt(var2)+parseInt(var3)));
//关闭每个打开的圆括号

　　每当你打开一个元素，请关闭它。当你添加了关闭圆括号后，你再把函数的参数放进圆括号中。如果有一串圆括号，统计所有打开的圆括号和所有关闭的圆括号，并且确保这两个数字相等。
条件语句（3个陷阱）

所有的条件语句都必须位于圆括号中。执行语句主体不管是一句还是多句都强烈建议用花括号包围起来，这样能避免很多因修改或嵌套而产生的潜在错误。

if(var1 == var2){
//statement
}

不要犯无意地使用赋值运算符的错误：把第二个参数的值赋给第一个参数。因为它是一个逻辑问题，它将一直返回true且不会报错。
if(var1 = var2){} // 返回true。把var2赋值给var1

JavaScript是弱类型，除了在switch语句中。当JavaScript在case比较时，它是非弱类型。
var myVar = 5;
if(myVar == '5'){ //返回true，因为JavaScript是弱类型
 alert("hi");  //这个alert将执行，因为JavaScript通常不在意数据类型
}
switch(myVar){
 case '5':
 alert("hi"); //这个alert将不会执行，因为数据类型不匹配
}



换行
　　当心JavaScript中的硬换行。换行被解释为表示行结束的分号。即使在字符串中，如果在引号中包括了一个硬换行，那么你会得到一个解析错误（未结束的字符串）。
var bad  = '&#60;ul id="myId"&#62;
  &#60;li&#62;some text&#60;/li&#62;
  &#60;li&#62;more text&#60;/li&#62;
 [...]]]></description>
		<wfw:commentRss>http://physure.com/blog/?feed=rss2&amp;p=142</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>[转]Javascript风格要素</title>
		<link>http://physure.com/blog/?p=140</link>
		<comments>http://physure.com/blog/?p=140#comments</comments>
		<pubDate>Sun, 17 Jan 2010 05:59:02 +0000</pubDate>
		<dc:creator>webphoenix</dc:creator>
				<category><![CDATA[技术文章]]></category>
		<category><![CDATA[JavaScript]]></category>
		<category><![CDATA[编程风格]]></category>

		<guid isPermaLink="false">http://physure.com/blog/?p=140</guid>
		<description><![CDATA[　　程序设计是困难的，其核心是管理的复杂性。计算机程序是人类做出的最复杂的东西。质量是不可靠的且隐蔽的。
　　好的体系架构是必需给程序足够的结构使其健壮而不会陷入混乱的泥淖，但我们表达一个程序细节的方式是同等重要的。一个程序的本质会被不良的编码所隐藏。只有当一个程序的表达清晰时，我们才能有希望正确的推理出它的效率、安全和正确性。
　　William Strunk的《风格要素》(The Elements of Style)是关于文学风格的经典著作，它是一本关于英文写作的薄手册，在用法、组织和形式上提出忠告。风格的理念应用于编程，在1972年Kreitzberg和Shneiderman的《FORTRAN风格要素》（The Elements of FORTRAN Style）中是不成功的，但在1978年的Kernighan和Plauger的《编程风格要素》（The Elements of Programming Style）中是非常成功的：
好的编程不能通过笼统的说教。学习编程的好方法是一次又一次的思考：真正的编程是如何通过一些良好实践的原则和一点常识来进行改进的。

　　他们从他们批评和改进的其他的编程教科书中筛选程序。
　　当我们在这里谈论风格时，我们谈论的不是潮流或者时尚，也不是CSS、布局惯例或排版。我们正在谈论的是能真正提高代码价值的表达式的永恒品质。对于公司来说，他们的评估和他们的代码是息息相关的，风格应该是一个至关重要的受关注内容。
　　我们使用许多编程语言，但在某一方面，Javascript是最重要的，它是浏览器的语言。当人们访问我们的站点时，他们将邀请我们的Javascript程序在他们的机器中执行。我们有义务使那些程序执行好。
　　没有好的关于Javascript编程的课本。在网页使用Javascript的大多数人学习它是通过从糟糕的书、糟糕的站点和糟糕的工具中复制相当糟糕的例子。我们这里有极好的Javascript程序员社区，但我们依旧能从较好的风格实践中获益。
　　为了证明这个问题，我将从公共网站中抽取一些程序，展示它们如何能被改进。这并不是我有意为难任何人。我的意图仅是通过例子展示风格的价值。我不会保留任何秘密：我展示给你的是我们已经传送给世界上的每一个人。
淘汰过时结构
　　下面的例子是2005-09-19摘自www.yahoo.com：
&#60;script language=javascript&#62;&#60;!--
     lck='',
     sss=1127143538,
     ylp='p.gif?t=1127143538&#38;_ylp=A0Je5ipy2C5D54AAwVX1cSkA',
     _lcs='';
--&#62;&#60;/script&#62; 
　　这个脚本块用了language属性。这个特性是微软为了支持VBScript引入的。然而Netscape采用它是为了支持非标准偏差。W3C不采取这个language属性，倾向使用MIME类型的type属性取代。不幸的是，MIME类型未得到标准化，所以它有时是&#8221;text/javascript&#8221;、&#8221;application/ecmascript&#8221;或其他。幸运的是所有的浏览器都选择Javascript作为默认的编程语言，所以简单的写&#60;script&#62;是最好的。它最小，且工作在最多的浏览器。在脚本中使用HTML的注释的时间要回溯到Netscape Navigator和Netscape Navigator 2的兼容问题上来。后者引入了&#60;script&#62;标签。然而，前者的用户能像文本一样看到脚本，因为在HTML惯例中不能识别的标签被忽略。&#60;!&#8211;注释hack在Netscape Navigator 3出现的时候是需要的，现在它不被需要了。它是丑陋的且浪费空间的。
　　逗号运算符像Javascript语法的大多数一样从C语言中借用。逗号运算符获得两个值，且返回第二个。在语言的定义中它的存在易于掩盖一定的编码错误，编译器也易于对一些错误视而不见。最好避免逗号运算符，并以分号运算符代替。
　　在这个案例里，我们定义了一些全局变量。当指定一个未知（匿名）的变量时，Javascript会创建一个新的全局变量来替代产生的错误。事后看来，这是一个错误。即使当他们是一个标准错误，这是避免错误的最好办法。我们应该明确的声明变量。它花费我们四个字符，但是它正是要做的正确的事。
&#60;script&#62;
var lck = '3ek6b0i2he2a5eh3/o',
    sss = 1126894256,
    ylp = 'p.gif?t=1126894256&#38;_ylp=A0Je5iOwCitDw2YBX331cSkA',
 [...]]]></description>
		<wfw:commentRss>http://physure.com/blog/?feed=rss2&amp;p=140</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>[转]Javascript的匿名函数</title>
		<link>http://physure.com/blog/?p=138</link>
		<comments>http://physure.com/blog/?p=138#comments</comments>
		<pubDate>Sun, 17 Jan 2010 05:38:10 +0000</pubDate>
		<dc:creator>webphoenix</dc:creator>
				<category><![CDATA[技术文章]]></category>
		<category><![CDATA[JavaScript]]></category>
		<category><![CDATA[匿名函数]]></category>

		<guid isPermaLink="false">http://physure.com/blog/?p=138</guid>
		<description><![CDATA[一、什么是匿名函数？
　　在Javascript定义一个函数一般有如下三种方式：
　　函数关键字(function)语句：
function fnMethodName(x){alert(x);}
　　函数字面量(Function Literals)：
var fnMethodName = function(x){alert(x);}
　　Function()构造函数：
var fnMethodName = new Function('x','alert(x);')
　　上面三种方法定义了同一个方法函数fnMethodName，第1种就是最常用的方法，后两种都是把一个函数复制给变量fnMethodName，而这个函数是没有名字的，即匿名函数。实际上，相当多的语言都有匿名函数。
二、函数字面量和Function()构造函数的区别
　　虽然函数字面量是一个匿名函数，但语法允许为其指定任意一个函数名，当写递归函数时可以调用它自己，使用Function()构造函数则不行。
var f = function fact(x) {
  if (x < = 1) return 1;
  else return x*fact(x-1);
};
　　Function()构造函数允许运行时Javascript代码动态的创建和编译。在这个方式上它类似全局函数eval()。
　　Function()构造函数每次执行时都解析函数主体，并创建一个新的函数对象。所以当在一个循环或者频繁执行的函数中调用Function()构造函数的效率是非常低的。相反，函数字面量却不是每次遇到都重新编译的。
　　用Function()构造函数创建一个函数时并不遵循典型的作用域，它一直把它当作是顶级函数来执行。

var y = "global";
function constructFunction() {
    var y = "local";
    return new Function("return y");  //  无法获取局部变量
}
alert(constructFunction()());  // 输出 "global"
　　和函数关键字定义相比Function()构造器有自己的特点且要难以使用的多，所以这项技术通常很少使用。而函数字面量表达式和函数关键字定义非常接近。考虑前面的区别，虽然有消息说字面量的匿名函数在OS X [...]]]></description>
		<wfw:commentRss>http://physure.com/blog/?feed=rss2&amp;p=138</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>JavaScript中call方法的使用</title>
		<link>http://physure.com/blog/?p=132</link>
		<comments>http://physure.com/blog/?p=132#comments</comments>
		<pubDate>Fri, 15 Jan 2010 12:02:15 +0000</pubDate>
		<dc:creator>webphoenix</dc:creator>
				<category><![CDATA[技术文章]]></category>
		<category><![CDATA[call]]></category>
		<category><![CDATA[JavaScript]]></category>

		<guid isPermaLink="false">http://physure.com/blog/?p=132</guid>
		<description><![CDATA[
　　今天在看Mootools JavaScript Framework时，看到了N个地方都调用了call这个方法，虽然知道call是JS里内置的，但是由于平常很少用到，几乎不了解它的功能。今天google一下，这个call功能的确很强，出乎我的意料。现把学到的知识分享一下，介绍call的同时也同时说下其他几个相关的方法和属性 callee,caller,apply。
1.call方法
　　微软的JScript帮助文档里这么说的:

call 方法
调用一个对象的一个方法，以另一个对象替换当前对象。
call([thisObj[,arg1[, arg2[,   [,.argN]]]]])
参数
thisObj 可选项。将被用作当前对象的对象。
arg1, arg2, , argN 可选项。将被传递方法参数序列。 
说明
call 方法可以用来代替另一个对象调用一个方法。call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisObj 指定的新对象。
如果没有提供 thisObj 参数，那么 Global 对象被用作 thisObj。
要求
版本 5.5
请参阅
应用于：Function 对象

　　刚开始看到了“调用一个对象的一个方法，以另一个对象替换当前对象”这句话时，我就傻了，实在没搞懂，谁调用谁替换谁啊。看到后面，也没一个例子，后来还是google一下，终于找到了一篇【javaScript 中 call 函数的用法说明】，这篇文章里说的还是蛮清楚的，我在这基础上“提炼”扩展了一下
1.1：只有方法才call方法，其他对象或属性没有
这里指的方法即typeof(any)==&#8217;function&#8217;,其他typeof非function的都没有call方法

//如方法funcA
function funcA()
{
//codes
}
//对象objB
var objB = {
/* property */
};
var strC = "12345";
//那么只有 funcA有call方法，objB, strC都没有call方法

请看执行下面这段代码

var Natives = [
	['String',String],
	['Math',Math],
	['Object',Object],
	['Array',Array],
	['Date',Date],
	['Number',Number],
	['RegExp',RegExp],
	['Boolean',Boolean],
	['Error',Error]
];

var str = [];
for(var i=0,length=Natives.length;i&#60;length;i++)
{
	var str = 'typeof('+Natives[i][0]+')=';
	str += typeof(Natives[i][1])+',ttypeof(';
	str += Natives[i][0]+'.call)=';
	str += [...]]]></description>
		<wfw:commentRss>http://physure.com/blog/?feed=rss2&amp;p=132</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>谨慎使用IE下特有的CSS属性expression</title>
		<link>http://physure.com/blog/?p=166</link>
		<comments>http://physure.com/blog/?p=166#comments</comments>
		<pubDate>Tue, 05 Jan 2010 02:30:43 +0000</pubDate>
		<dc:creator>webphoenix</dc:creator>
				<category><![CDATA[技术文章]]></category>
		<category><![CDATA[CSS]]></category>
		<category><![CDATA[expression]]></category>
		<category><![CDATA[HTML]]></category>
		<category><![CDATA[JavaScript]]></category>

		<guid isPermaLink="false">http://physure.com/blog/?p=166</guid>
		<description><![CDATA[　　最近在写一个基于IE内核浏览器的程序的HTML时候，发现程序占用的CPU很多，Process Explorer发现 IERAME.DLL占用CPU最多，于是跟踪，最后到样式表的一个expression属性，代码如下：

.NO-SELECT {
	script:expression(
		this.onselectstart = function() {
			return false;
		}
	);
}

　　原来的意图是加了这个样式后就不能选中某个层，跟踪发现这个样式的效率超低，很消耗CPU资源，还不如直接在脚本里加上onselectstart事件，如果使用的是IE，强烈建议不要使用IE下特有的CSS属性 expression
]]></description>
		<wfw:commentRss>http://physure.com/blog/?feed=rss2&amp;p=166</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>[转]用函数式编程技术编写优美的 JavaScript</title>
		<link>http://physure.com/blog/?p=144</link>
		<comments>http://physure.com/blog/?p=144#comments</comments>
		<pubDate>Sat, 02 Jan 2010 07:03:40 +0000</pubDate>
		<dc:creator>webphoenix</dc:creator>
				<category><![CDATA[技术文章]]></category>
		<category><![CDATA[JavaScript]]></category>
		<category><![CDATA[函数式编程]]></category>

		<guid isPermaLink="false">http://physure.com/blog/?p=144</guid>
		<description><![CDATA[简介
　　函数式编程语言在学术领域已经存在相当长一段时间了，但是从历史上看，它们没有丰富的工具和库可供使用。随着 .NET 平台上的 Haskell 的出现，函数式编程变得更加流行。一些传统的编程语言，例如 C++ 和 JavaScript，引入了由函数式编程提供的一些构造和特性。在许多情况下，JavaScript 的重复代码导致了一些拙劣的编码。如果使用函数式编程，就可以避免这些问题。此外，可以利用函数式编程风格编写更加优美的回调。

函数式编程
　　函数式编程只描述在程序输入上执行的操作，不必使用临时变量保存中间结果。重点是捕捉 “是什么以及为什么”，而不是 “如何做”。与将重点放在执行连续命令上的过程性编程相比，函数式编程的重点是函数的定义而不是状态机（state machine）的实现。
　　大型知识管理系统应用程序从使用函数式编程风格上受益颇多，因为函数式编程简化了开发。

　　因为函数式编程采用了完全不同的组织程序的方式，所以那些习惯于采用命令式范例的程序员可能会发现函数式编程有点难学。在这篇文章中，您将了解一些关于如何采用函数式风格，用 JavaScript 编写良好的、优美的代码的示例。我将讨论：

函数式编程概念，包括匿名函数、调用函数的不同方法，以及将函数作为参数传递给其他函数的方式。
函数式概念的运用，采用的示例包括：扩展数组排序；动态 HTML 生成的优美代码；系列函数的应用。

函数式编程概念
　　在那些通过描述 “如何做” 指定解决问题的方法的语言中，许多开发人员都知道如何进行编码。例如，要编写一个计算阶乘的函数，我可以编写一个循环来描述程序，或者使用递归来查找所有数字的乘积。在这两种情况下，计算的过程都在程序中进行了详细说明。清单 1 显示了一个计算阶乘的可能使用的 C 代码。
　　清单 1. 过程风格的阶乘

int factorial (int n)
{
	if (n &#60;= 0)
		return 1;
	else
		return n * factorial (n-1);
}

　　这类语言也叫做过程性 编程语言，因为它们定义了解决问题的过程。函数式编程与这个原理有显著不同。在函数式编程中，需要描述问题 “是什么”。 函数式编程语言又叫做声明性 语言。同样的计算阶乘的程序可以写成所有到 n 的数字的乘积。计算阶乘的典型函数式程序看起来如 清单 2 中的示例所示。
　　清单 2. 函数式风格的阶乘

factorial n, where n &#60;= 0 	:= 1
factorial n  [...]]]></description>
		<wfw:commentRss>http://physure.com/blog/?feed=rss2&amp;p=144</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>JavaScript中日期时间函数的扩展</title>
		<link>http://physure.com/blog/?p=33</link>
		<comments>http://physure.com/blog/?p=33#comments</comments>
		<pubDate>Sun, 13 Dec 2009 11:09:21 +0000</pubDate>
		<dc:creator>webphoenix</dc:creator>
				<category><![CDATA[技术文章]]></category>
		<category><![CDATA[JavaScript]]></category>
		<category><![CDATA[日期函数]]></category>

		<guid isPermaLink="false">http://physure.com/blog/?p=33</guid>
		<description><![CDATA[JS中的日期时间的函数就那么几个，用起来还是有点不方便，我很久之前写了几个，个人感觉还不错，供大家参考

/*******************************************************************
* 功能: 在当前时间的基础增加或减少一个时间值，变成另一个日期，类似VBS里的DateAdd
* 输入: flag:标识, yyyy表示年,q表示季度,ww表示周,m表示月,d表示天,h表示小时,n表示分,s表示秒, num:差值
* 输出: 增减之后的日期值 Date类型
*******************************************************************/
Date.prototype.dateAdd = function(flag,num) {
	var year = this.getFullYear();
	var month = this.getMonth();
	var day = this.getDate();
	var hour = this.getHours();
	var minute = this.getMinutes();
	var second = this.getSeconds();
	var milliSecond = this.getMilliseconds();
	num = isNaN(num=parseInt(num))?0:num;
	switch(flag) {
		case &#34;yyyy&#34;:
			return new Date(year+num,month,day,hour,minute,second,milliSecond);
		case &#34;q&#34;:
			return new Date(year,month+4*num,day,hour,minute,second,milliSecond);
		case &#34;m&#34;:
			return new Date(year,month+num,day,hour,minute,second,milliSecond);
		case &#34;d&#34;:
			return new Date(year,month,day+num,hour,minute,second,milliSecond);
		case &#34;ww&#34;:
			return new Date(year+num,month,day+7*num,hour,minute,second,milliSecond);
		case &#34;h&#34;:
			return new Date(year,month,day,hour+num,minute,second,milliSecond);
		case [...]]]></description>
		<wfw:commentRss>http://physure.com/blog/?feed=rss2&amp;p=33</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
	</channel>
</rss>
