JavaScript：闭包引用'；这'；关键词

下面的例子，我在Douglas Crockfords的“JavaScript-好的部分”中看到的，似乎破坏了我目前对

这个
应该如何在闭包中工作的理解：

    String.method('deentityify', function(){
          var entity = {
              quot: '"',
              lt: '<',
              gt: '>'
          };

         return function(){
                return this.replace(/&([^&;]+);/g, 
                    function(a,b){
                        var r = entity[b];
                        return typeof r === 'string' ? r : a;
                    } 
       };
}());   


//Just for reference
Function.prototype.method = function (name, func) {
    this.prototype[name] = func;
    return this;
};

String.method（'deentityify'，function（）{
var实体={
引用：“”，
lt:'
};
返回函数（）{
返回此。替换（/&（[^&；]+）；/g，
功能（a、b）{
var r=实体[b]；
返回类型r=='string'？r:a；
} 
};
}());   
//仅供参考
Function.prototype.method=函数（名称，func）{
this.prototype[name]=func；
归还这个；
};

deentityify
方法闭包中提到的
this
指的是执行此方法的字符串对象。这对我来说没有太大意义-如果我们在编写此方法时没有很好的作用域（即使用丑陋的全局变量），这里的
this
不应该指的是全局对象吗？
和方法绑定方法，您可以得到：

var entity = {
  quot: '"',
  lt: '<',
  gt: '>'
};

String.prototype.deentityify = function(){
  return this.replace(/&([^&;]+);/g, 
    function(a,b){
      var r = entity[b];
      return typeof r === 'string' ? r : a;
    }
  );
};

var s = "&lt;".deentityify();

var实体={
引用：“”，
lt:'
};
String.prototype.deentityify=函数（）{
返回此。替换（/&（[^&；]+）；/g，
功能（a、b）{
var r=实体[b]；
返回类型r=='string'？r:a；
}
);
};
var s=“.deentityify（）；

因此，
deentityify
只是
String
对象上的一个方法。当您使用点语法调用该方法时，该方法的上下文就是您调用它的字符串。
如果我们在编写该方法时没有很好的作用域（即使用难看的全局变量）和方法绑定方法，您会得到：

var entity = {
  quot: '"',
  lt: '<',
  gt: '>'
};

String.prototype.deentityify = function(){
  return this.replace(/&([^&;]+);/g, 
    function(a,b){
      var r = entity[b];
      return typeof r === 'string' ? r : a;
    }
  );
};

var s = "&lt;".deentityify();

var实体={
引用：“”，
lt:'
};
String.prototype.deentityify=函数（）{
返回此。替换（/&（[^&；]+）；/g，
功能（a、b）{
var r=实体[b]；
返回类型r=='string'？r:a；
}
);
};
var s=“.deentityify（）；

因此，
deentityify
只是
String
对象上的一个方法。当您使用点语法调用该方法时，该方法的上下文就是您调用它的字符串。
如果我们在编写该方法时没有很好的作用域（即使用难看的全局变量）和方法绑定方法，您会得到：

var entity = {
  quot: '"',
  lt: '<',
  gt: '>'
};

String.prototype.deentityify = function(){
  return this.replace(/&([^&;]+);/g, 
    function(a,b){
      var r = entity[b];
      return typeof r === 'string' ? r : a;
    }
  );
};

var s = "&lt;".deentityify();

var实体={
引用：“”，
lt:'
};
String.prototype.deentityify=函数（）{
返回此。替换（/&（[^&；]+）；/g，
功能（a、b）{
var r=实体[b]；
返回类型r=='string'？r:a；
}
);
};
var s=“.deentityify（）；

因此，
deentityify
只是
String
对象上的一个方法。当您使用点语法调用该方法时，该方法的上下文就是您调用它的字符串。
如果我们在编写该方法时没有很好的作用域（即使用难看的全局变量）和方法绑定方法，您会得到：

var entity = {
  quot: '"',
  lt: '<',
  gt: '>'
};

String.prototype.deentityify = function(){
  return this.replace(/&([^&;]+);/g, 
    function(a,b){
      var r = entity[b];
      return typeof r === 'string' ? r : a;
    }
  );
};

var s = "&lt;".deentityify();

var实体={
引用：“”，
lt:'
};
String.prototype.deentityify=函数（）{
返回此。替换（/&（[^&；]+）；/g，
功能（a、b）{
var r=实体[b]；
返回类型r=='string'？r:a；
}
);
};
var s=“.deentityify（）；

因此，
deentityify
只是
String
对象上的一个方法。当您使用点语法调用该方法时，该方法的上下文就是您调用它的字符串。
哦……我现在知道了……闭包作为deentityify方法返回，您不能通过分析函数来假定
this
的值定义。例如
var fn=String.deentityfy；fn（）；//this===window
。这是你调用函数的方式和绑定函数的方式。是的，我理解，我在这个问题中没有包括执行上下文，事后看来应该是执行上下文……实际上，我在问题的末尾描述了执行上下文。”…在其上执行此方法的string对象“执行上下文为”somestring“。deentityify（）噢…我现在得到了它…闭包作为deentityify方法返回，您不能通过分析函数定义来假定
this
的值。例如
var fn=string.deentityfy；fn（）；//this===window
。这是如何调用函数以及如何绑定函数。是的，我明白，我在这个问题中没有包括执行上下文……实际上，我在问题的末尾描述了执行上下文“…在其上执行此方法的字符串对象执行上下文是“somestring”。deentityify（）噢……我现在知道了……闭包作为deentityify方法返回，您不能通过分析函数定义来假定
this
的值。例如
var fn=String.deentityfy；fn（）；//this===window
。这是如何调用函数以及如何绑定函数。是的，我明白，我在这个问题中没有包括执行上下文……实际上，我在问题的末尾描述了执行上下文“…在其上执行此方法的字符串对象”执行上下文是“somestring”。deentityify（）噢……我现在知道了……闭包作为deentityify方法返回，您不能通过分析函数定义来假定
this
的值。例如
var fn=String.deentityfy；fn（）；//this===window
。这是如何调用函数以及如何绑定函数。是的，我明白，我在这个问题中没有包括执行上下文……实际上，我在问题的末尾描述了执行上下文“…在其上执行此方法的字符串对象”执行上下文是“somestring”。deentityify（）