社区

.NET,

Ruby

主题

动态语言,

变更,

.NET框架,

Ruby on Rails

你是一位资深的.NET程序员，而且已经用ASP.NET构建过许多Web应用。

无数个不眠之夜，为了让ASP.NET控件生命周期中的事件驱动模型按你想要的方式执行，你费尽心血，深入细节。

你精通于使用诸如Presentation Model、Model View Presenter这类设计模式对你的应用进行分层，以使其更易测试和维护。

你认为Ruby on Rails只不过是众多被吹嘘的技术中的一员。在它还没有获得可观的市场份额之前，你不会给予它过多的关注。

欢迎来到我的世界。如果你还在读这篇文章，我向你致敬。对于我下面的说法，你可能会充满了好奇。为什么我——一名资深的.NET程序员，在经历了一 个月的Ruby on Rails学习后会认为：只有在我了解了Ruby on Rails之后，才能以较少的时间和编码完成以前开发过的许多应用？

老实说，我仍然认为.NET很棒。它为我提供了一个平台，能让我向客户源源不断地提供巨大的商业价值。但我时刻提醒自己：一个简单的问题，有大量不 同的方法和技术可以解决它，并且总有一些比其它更好。衷情于某种技术，必然会产生一些无意识的偏见，这最终会阻碍我为客户提供商业价值的能力。例如，对像 Ruby这样的动态脚本语言的了解，使我以为：与使用编译型的语言相比，我可以花费更少的时间去编写简单的自动处理的Batch/Shell脚本。

为什么不呢？

下面这几件事，是我（一个.NET程序员）学习Ruby时，发现的一些典型的不同。希望你能喜欢。

不需要编译

动态增加类的行为——不使用Decorator模式

（译者注：mixin在面向对象编程语言中是一种提供某些功能给子类继承的类，但mixin并不能实例化。从 某个mixin继承并不是什么特殊的形式，而它更适于收集功能。某个子类甚至可以通过继承一个或者多个mixin选择继承它的全部或者多数功能。一个 mixin能延期到运行时定义和绑定方法，而属性和实例参数也可在编译时才被定义。这不同于我们常见的方式，比如先定义所有的属性、方法，并在编译时进行 初始化等。）

通过去除所有的类型声明和接口声明，将代码库“瘦身”10-20%

及时Ajax化

使用Rails，不需要专门的O/R映射

用Ruby脚本构建、部署或发布应用，比使用NAnt更好。

不劳无获

译者简介：戴强斌，拥有三年的Web开发经验，武汉大学Google Camp技术团队成员，目前关注垂直搜索引擎领域的应用发展。

Arguments

该对象代表正在执行的函数和调用它的函数的参数。

[function.]arguments[n]

参数
function ：选项。当前正在执行的 Function 对象的名字。 
n ：选项。要传递给 Function 对象的从0开始的参数值索引。 

说明

Arguments是进行函数调用时，除了指定的参数外，还另外创建的一个隐藏对象。Arguments是一个类似数组但不是数组的对象，说它类似数组是因为其具有数组一样的访问性质及方式，可以由arguments[n]来访问对应的单个参数的值，并拥有数组长度属性length。还有就是arguments对象存储的是实际传递给函数的参数，而不局限于函数声明所定义的参数列表，而且不能显式创建 arguments 对象。arguments 对象只有函数开始时才可用。下边例子详细说明了这些性质:
callee

在此添加了一个说明arguments不是数组(Array类)的代码:

运行代码你会发现第一个alert显示1，这表示数组对象拥有selfvalue属性，值为1，而当你调用函数testAguments时，你会发现显示的是“undefined”，说明了不是arguments的属性，即arguments并不是一个数组对象。

 caller
  返回一个对函数的引用，该函数调用了当前函数。
  functionName.caller
  functionName 对象是所执行函数的名称。
说明
对于函数来说，caller 属性只有在函数执行时才有定义。如果函数是由顶层调用的，那么 caller 包含的就是 null 。如果在字符串上下文中使用 caller 属性，那么结果和 functionName.toString 一样，也就是说，显示的是函数的反编译文本。
下面的例子说明了 caller 属性的用法：

    返回正被执行的 Function 对象，也就是所指定的 Function 对象的正文。

[function.]arguments.callee

可选项 function 参数是当前正在执行的 Function 对象的名称。

说明

callee 属性的初始值就是正被执行的 Function 对象。

callee 属性是 arguments 对象的一个成员，它表示对函数对象本身的引用，这有利于匿名
函数的递归或者保证函数的封装性，例如下边示例的递归计算1到n的自然数之和。而该属性
仅当相关函数正在执行时才可用。还有需要注意的是callee拥有length属性，这个属性有时候
用于验证还是比较好的。arguments.length是实参长度，arguments.callee.length是
形参长度，由此可以判断调用时形参长度是否和实参长度一致。

示例
比较一般的递归函数：调用时：alert(sum(100));
其中函数内部包含了对sum自身的引用，函数名仅仅是一个变量名，在函数内部调用sum即相当于调用
一个全局变量，不能很好的体现出是调用自身，这时使用callee会是一个比较好的方法。

apply and call

   它们的作用都是将函数绑定到另外一个对象上去运行，两者仅在定义参数方式有所区别：

    apply(thisArg,argArray);

    call(thisArg[,arg1,arg2…] ]);

即所有函数内部的this指针都会被赋值为thisArg，这可实现将函数作为另外一个对象的方法运行的目的

apply的说明

如果 argArray 不是一个有效的数组或者不是 arguments 对象，那么将导致一个 TypeError。
如果没有提供 argArray 和 thisArg任何一个参数，那么 Global 对象将被用作 thisArg，
并且无法被传递任何参数。

call的说明

call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisArg指定的新对象。
如果没有提供 thisArg参数，那么 Global 对象被用作 thisArg

相关技巧：

应用call和apply还有一个技巧在里面，就是用call和apply应用另一个函数（类）以后，当前的
函数（类）就具备了另一个函数（类）的方法或者是属性，这也可以称之为“继承”。看下面示例:call之后，extend可以继承到base的方法和属性。

上面的例子可以看出，通过

顺便提一下，在javascript框架prototype里就使用apply来创建一个定义类的模式，

其实现代码如下：

解析：从代码看,该对象仅包含一个方法：Create，其返回一个函数，即类。但这也同时是类的
构造函数，其中调用initialize，而这个方法是在类创建时定义的初始化函数。通过如此途径，
就可以实现prototype中的类创建模式

示例：prototype信息请到其官方网站查看。

更详细的关于

通过一个例子说明apply()的用法：
//针对各种浏览器建立一个http request的对象

function getHttpRequest(){
  http_request = null;
  if (window.XMLHttpRequest) { 

     http_request = new XMLHttpRequest();
  } else if (window.ActiveXObject) {
      http_request = new ActiveXObject("Microsoft.XMLHTTP");
  }
  return http_request;
}

var ajax_request;

functiong getPerson(){

  ajax_request = getHttpRequest();    //建立一个http request

  ajax_request.onstatechange = handleResponse;  //指定回调函数

  ajax_request.open("GET", "http://myhost.com/sample.xml", null);

  ajax_request.send();

}

 

function handleResponse(){

  if(ajax_request.readyState != 4) return;

  if(ajax_request.status == 200){

    var xml = ajax_request.responseXML;

    /* 对获得的xml的处理 */

  }

}

 

调用的时候可以直接在页面里调用

getPerson();

 

这个函数会建立一个httpRequest对象，然后发送请求，在请求返回的时候会自动调用handleResponse函数来完成操作。

在简单的环境上，上述代码会工作得很好，但是如果在一个页面中要执行多次这种操作就比较麻烦了，需要写多个函数，看一下上面的定义：

var ajax_request; 表示这是个全局变量，多次请求的时候每个请求都要用到这个对象，ajax又是异步的，无法事先确定哪个请求先返回。

 

如果把ajax_request作为函数内的局部变量呢？那样如果在handleResponse里能看到ajax_request对象就可以解决这个问题了。

可以考虑把ajax_request作为一个参数传递给handleResponse，现在的问题是，对handleResponse的调用是自动的，怎么能在参数列表中添加这个参数呢？我们想到了this变量，在javascript中，所有的东西都是对象，this表示当前对象，在函数中this就表示当前的函数。

javascript提供了一种可以改变this的方法——apply()。

javascript对apply的解释是：使用指定对象替换当前对象并调用函数。比如：

 

function test_apply(){

  alert(this);

}

test_apply.apply(document, []);

 

就表示调用函数test_apply，并用document对象来替换test_apply中的this。

 

回到刚刚的问题，为了修改当前对象，需要在指定handleResponse的时候就修改this对象。ajax_request.onstatechange是一个函数的句柄，只要我把一个函数的句柄赋值给它就可以了，同时函数也是一种对象，Function对象，因此我们为函数对象添加一个方法：

Function.prototype.setThis(){

  var curr_function = this;

  var to_this_object = arguments[0];

  return function(){

    currFunc.apply(to_this_object, []);

  };

}

 

下面，修改getPerson为：


functiong getPerson(){

  var tmp_request = getHttpRequest();    //建立一个http request

  tmp_request.onstatechange = handleResponse.setThis(tmp_request);  //指定回调函数

  tmp_request.open("GET", "http://myhost.com/sample.xml", null);

  tmp_request.send();

}

 

修改handleResponse为：


function handleResponse(){

  if(this.readyState != 4) return;

  if(this.status == 200){

    var xml = this.responseXML;

    /* 对获得的xml的处理 */

  }

}

即可。

具体的变化就在于tmp_request.onstatechange = handleResponse.setThis(tmp_request);  

因为handleResponse是一个函数，因此它具有Function新添加的方法setThis，

下面来看setThis方法：

var curr_function = this;  //获得当前的函数本身
var to_this_object = arguments[0];  //获得要指定的新的this对象

return function(){

    currFunc.apply(to_this_object, []);

  };

 

这里的返回值是一个函数，即当tmp_request的onstatechange事件的时候会触发这个函数，该函数中只有一句

currFunc.apply(to_this_object, []);即用to_this_object替换当前对象并调用currFunc，在这里currFunc即代表了handleResponse，因此调用handleResponse，因为已经修改了其this对象，因此在handleResponse中用this即代表了tmp_request对象。

用这种方法可以减化代码，并使代码更具可重用性。
源文地址：http://www.cublog.cn/opera/showart.php?blogid=21787&id=140549

附注：
应用某一对象的一个方法，用另一个对象替换当前对象。

apply([thisObj[,argArray]])参数thisObj可选项。将被用作当前对象的对象。
argArray
可选项。将被传递给该函数的参数数组。
说明
如果 argArray 不是一个有效的数组或者不是 arguments 对象，那么将导致一个 TypeError。如果没有提供 argArray 和 thisObj 任何一个参数，那么 Global 对象将被用作 thisObj， 并且无法被传递任何参数。

Function.apply(thisArg[, argArray])   The apply method allows you to call a function and specify what the keyword this will refer to within the context of that function. The thisArg argument should be an object. Within the context of the function being called, this will refer to thisArg. The second argument to the apply method is an array. The elements of this array will be passed as the arguments to the function being called. The argArray parameter can be either an array literal or the deprecated arguments property of a function.   The apply method can be used to simulate object inheritance as in the following example. We first define the constructor for an object called Car which has three properties. Then the constructor for a second object called RentalCar is defined. RentalCar will inherit the properties of Car and add one additional property of its own - carNo. The RentalCar constructor uses the apply method to call the Car constructor, passing itself as thisArg. Therefore, inside the Car function, the keyword this actually refers to the RentalCar object being constructed, and not a new Car object. By this means,the RentalCar object inherits the properties from the Car object.   Code: function Car(make, model, year) {   this.make = make;   this.model = model;   this.year = year; }   function RentalCar(carNo, make, model, year) {   this.carNo = carNo;   Car.apply(this, new Array(make, model, year)) }   myCar = new RentalCar(2134,"Ford","Mustang",1998) document.write("Your car is a " + myCar.year + " " +   myCar.make + " " + myCar.model + ".")   Output: Your car is a 1998 Ford Mustang.   NOTE: The apply method is very similar to the call method and only differs in that, up until now, you could use the deprecated arguments array as one of its parameters 手册中的说明是 apply Allows you to apply a method of another object in the context of a different object (the calling object). Method of Function Implemented in JavaScript 1.3 Syntax apply(thisArg[, argArray]) Parameters thisArg Parameter for the calling object argArray An argument array for the object Description You can assign a different this object when calling an existing function. this refers to the current object, the calling object. With apply, you can write a method once and then inherit it in another object, without having to rewrite the method for the new object. apply is very similar to call, except for the type of arguments it supports. You can use an arguments array instead of a named set of parameters. With apply, you can use an array literal, for example, apply(this, [name, value]), or an Array object, for example, apply(this, new Array(name, value)). You can also use arguments for the argArray parameter. arguments is a local variable of a function. It can be used for all unspecified arguments of the called object. Thus, you do not have to know the arguments of the called object when you use the apply method. You can use arguments to pass all the arguments to the called object. The called object is then responsible for handling the arguments. Examples You can use apply to chain constructors for an object, similar to Java. In the following example, the constructor for the product object is defined with two parameters, name and value. Another object, prod_dept, initializes its unique variable (dept) and calls the constructor for product in its constructor to initialize the other variables. In this example, the parameter arguments is used for all arguments of the product object's constructor. function product(name, value){    this.name = name;    if(value > 1000)       this.value = 999;    else       this.value = value; } function prod_dept(name, value, dept){    this.dept = dept;    product.apply(product, arguments); } prod_dept.prototype = new product(); // since 5 is less than 100 value is set cheese = new prod_dept("feta", 5, "food"); // since 5000 is above 1000, value will be 999 car = new prod_dept("honda", 5000, "auto");