V8::Arguments中This和Holder的区别

## v8::Arguments

namespace v8 {

class Arguments {
 public:
  inline int Length() const;
  inline Local<Value> operator[](int i) const;
  inline Local<Function> Callee() const;
  inline Local<Object> This() const;
  inline Local<Object> Holder() const;
  inline bool IsConstructCall() const;
  inline Local<Value> Data() const;
  inline Isolate* GetIsolate() const;

}；

}

## 满眼都是问号

Length/operator[]:

    一眼看去，Length和operator[]好懂，基本上就是与方法参数的值相关。

Data(): 

    在创建FunctionTemplate时候,FunctionTemplate::New函数所提供的第二个参数。

This()/Holder():

    This() corresponds to JS 'this' and should be operated upon when you'd like to have a normal JS semantics.

     Holder() is the objects which is instance of your FunctionTemplate.

     This()对应的是JavaScript的this,在很多情况下Holder和This其实是一样的。

     在Google Group中的帖子提到了谈到了二者的区别：

The Holder value was introduced to deal with some corner cases that
happen because methods are just properties and can be moved around.
To explain it you need a bit of background but I'll get to the Holder
part in minute.

Consider this code:

var x = { };
x.createElement = document.createElement;
var div = x.createElement('div');

In the implementation of createElement we need to check what kind of
object we're being called on because createElement needs to use some
internal fields stored on the document object.  To implement this we
use function signatures (by passing a Signature object to
FunctionTemplate::New for all dom methods).  A signature specifies
what kind of objects a function can be called with.  In this case we
would pass a signature that specifies that the receiver must be a
document and then v8 takes case of giving an error if it isn't.

However, with this type check in place there can still be problems.
Consider this code:

var x = { }
x.__proto__ = document;
var div = x.createElement('div');

In this case createElement is actually given a document, it's there in
the prototype chain, and for compatibility reasons we have to allow
this.  However, 'This' is not a document so it's still not safe to try
to read internal fields from it.  That's where Holder comes in.  If
your function has a signature that says that it must be called on a
particular type v8 will search the prototype chain for an object of
that type when the function is called.  If it is not there we given an
error.  If it is there that's the value Holder will return to you.

In short: if you specify, through a Signature, that a function must
only be called on instances of function template T, the value returned
by Holder is guaranteed to hold an instance created from T or another
function template that directly or indirectly
"FunctionTemplate::Inherit"s from T.  No guarantees hold about the
type of This.

## References

[This() vs. Holder()](https://groups.google.com/forum/#!topic/v8-users/fK9PBWxJxtQ)

[What is the difference between Arguments::Holder() and Arguments::This()?](https://groups.google.com/forum/#!topic/v8-users/Axf4hF_RfZo)

[V8 Javascript Engine Tutorial (Part 1)](https://www.homepluspower.info/2010/06/v8-javascript-engine-tutorial-part-1.html)

[V8 Javascript Engine Tutorial (Part 2)](https://www.homepluspower.info/2010/06/v8-javascript-engine-tutorial-part-2.html)