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

问题描述

John Resig 写了一个漂亮的 Class 函数，很时髦.我试图弄清楚发生了什么，除了一行之外，几乎所有的东西都弄清楚了:

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;}) ? /_super/ : /.*/;

立即想到一些事情，首先 xyz 永远不会被初始化为变量；那么为什么这样做呢?其次，为什么要针对不返回任何内容的内容(无返回语句)测试 /xyz/ .除非有我不知道的 javascript 的一些漂亮的属性(这是可能的，我认为自己相当擅长 JS 并且可以解释我遇到的大多数代码，但是，这并不意味着我在同一个山上. John Resig 称之为家的珠穆朗玛峰大小的山.

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).

对于那些好奇的人，这里是来自 john resigs 站点的完整未编辑代码 John Resig Simple Javascript Inheritance:

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;}) ? /_super/ : /.*/;

  // 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.

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

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.

你为什么要检查这个?

因为 Function.prototype.toString 方法返回一个函数的实现依赖表示，并且在某些实现中，例如较旧的 Safari 版本、Mobile Opera 和一些黑莓浏览器，它们实际上不会返回任何有用的东西.

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屋！