奇怪的JavaScript成语 - 什么是“/xyz/.test（function（）{xyz;}）”做？ [英] Strange JavaScript idiom - what does "/xyz/.test(function(){xyz;})" do?

问题描述

John Resig写了一个漂亮的类功能，时髦。我试图弄清楚发生了什么事情，几乎所有的事情都想通了，除了一行：

  fnTest = /xyz/.test(function（）{xyz;}）？ / \b_super\b /：/.*/; 
  

一对夫妇立即想起，首先 xyz 从不被初始化为变量;那么为什么这样做呢？其次，为什么它对 / xyz / 进行测试，以防止任何不返回任何内容（无返回语句）。除非有一些JavaScript的漂亮属性，我不知道（这是可能的，我觉得自己相当擅长JS，并且可以解释我所遇到的大部分代码，但是，这意味着我在相同的Mt 。John Resig称之为珠穆朗玛峰大小的山脉）。

对于那些好奇的人来说，这里是来自john resigs site的完整未经编辑的代码 John Resig简单的Javascript继承：

 （function（）{
 var initializing = false，fnTest = /xyz/.test(function(){xyz;}）？/ \b_super\b /：/.*/; 
 
 //基类的实现（什么都不做）
 this.Class = function（）{}; 
 
 //创建一个从这个类继承的新类
 Class.extend = function（prop）{
 var _super = this.prototype; 
 
 //实例化一个基类（但只创建实例，
 // don运行init构造函数）
 initializing = true; 
 var prototype = new this（）; 
 initializing = false; 
 
 //将属性复制到新原型
中（var name in prop）{
 //检查是否覆盖现有函数
 prototype [name] = typeof prop [name] ==function&& 
 typeof _super [name] ==function&& fnTest.test（prop [name]）？ 
（function（name，fn）{
 return function（）{
 var tmp = this._super; 
 
 //添加一个新的._super（）方法这是相同的方法
 //但在超类
 this._super = _super [name]; 
 
 //该方法只需要被临时绑定，所以我们
 //完成
 var ret = fn.apply（this，arguments）; 
 this._super = tmp; 
 
 return ret; 
}; 
}）（name，prop [name]）：
 prop [name]; 
} 
 
 //伪类构造函数
函数Class（）{
 //所有构造实际上都是在init方法中完成
 if（！初始化&& this.init）
 this.init.apply（this，arguments）; 
} 
 
 //填充我们构建的原型对象
 Class.prototype = prototype; 
 
 //强制构造函数成为我们期望的
 Class.constructor = Class; 
 
 //使这个类可扩展
 Class.extend = arguments.callee; 
 
返回类; 
}; 
 
}）（）; 
  

解决方案

这只是一个快速&
$ b

RegExp.prototype.test 方法将采用参数并将其转换为字符串，函数内的 xyz 引用永远不会被评估。

你需要检查吗？

因为 Function.prototype.toString 方法返回一个<在某些实现中，这些较旧的Safari版本，Mobile Opera和一些Blackberry浏览器，他们实际上并没有返回任何有用的东西。

John Resig wrote a nifty Class function, swanky. I'm trying to figure out what is going on, and have pretty much everything figured out except a single line:

fnTest = /xyz/.test(function () {xyz;}) ? /\b_super\b/ : /.*/;

A couple things immediately jump to mind, first xyz is never initialized as a variable; so why then does this work? Second, why is it testing /xyz/ against something that is not returning anything (no return statement). Unless there is some nifty properties of javascript I'm unaware of (which is possible, I fancy myself rather good at JS and can interpret most the code I come across it doesn't, however, mean I'm eve on the same Mt. Everest sized mountain that John Resig calls home).

For those curious, here is the full unedited code from john resigs site John Resig Simple Javascript Inheritance:

(function () {
  var initializing = false, fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;

  // The base Class implementation (does nothing)
  this.Class = function(){};

  // Create a new Class that inherits from this class
  Class.extend = function(prop) {
    var _super = this.prototype;

    // Instantiate a base class (but only create the instance,
    // don't run the init constructor)
    initializing = true;
    var prototype = new this();
    initializing = false;

    // Copy the properties over onto the new prototype
    for (var name in prop) {
      // Check if we're overwriting an existing function
      prototype[name] = typeof prop[name] == "function" &&
        typeof _super[name] == "function" && fnTest.test(prop[name]) ?
        (function(name, fn){
          return function() {
            var tmp = this._super;

            // Add a new ._super() method that is the same method
            // but on the super-class
            this._super = _super[name];

            // The method only need to be bound temporarily, so we
            // remove it when we're done executing
            var ret = fn.apply(this, arguments);       
            this._super = tmp;

            return ret;
          };
        })(name, prop[name]) :
        prop[name];
    }

    // The dummy class constructor
    function Class() {
      // All construction is actually done in the init method
      if ( !initializing && this.init )
        this.init.apply(this, arguments);
    }

    // Populate our constructed prototype object
    Class.prototype = prototype;

    // Enforce the constructor to be what we expect
    Class.constructor = Class;

    // And make this class extendable
    Class.extend = arguments.callee;

    return Class;
  };

})();

解决方案

It is just a quick & dirty way to check if "function decompilation" works.

The RegExp.prototype.test method will take the argument and it will convert it to String, the xyz reference inside the function is never evaluated.

Why would you have to check this?

Because the Function.prototype.toString method returns an implementation-dependent representation of a function, and in some implementation, such older Safari versions, Mobile Opera, and some Blackberry browsers, they don't actually return anything useful.

这篇关于奇怪的JavaScript成语 - 什么是“/xyz/.test（function（）{xyz;}）”做？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！