javascript - jquery oop 覆盖方法函数

Question

您好，我想知道如果我的方法声明如下，我该如何覆盖方法函数:

(function ($) {
    $.extend({
        tablesorter: new
        function () {
            function buildHeaders(table) {
                console.log('ORIGINAL HEADERS');
            }

            this.construct = function (settings) {
                return this.each(function () {
                    $headers = buildHeaders(this);
                });
            }
        }
    });

    $.fn.extend({
        tablesorter: $.tablesorter.construct
    });
})(jQuery);

我的目标是完全重写 tablesorter buildHeaders 函数。

(function ($) {
    var originalMethod = $.fn.tablesorter;
    $.fn.tablesorter = function() {
        console.log('overiding');

        function buildHeaders(table) {
            console.log('OVERRIDE HEADERS');
        }
        originalMethod.apply(this, arguments);
    }
})(jQuery);

这行不通...任何帮助都会很棒。谢谢!

Answer 1

简短回答:不，你不能。

函数内部的函数(即 buildHeaders 是另一个函数内部的函数)是私有(private)的，不能被覆盖。以这个简单的例子为例，猜猜输出:

// A very simple function inside a function
test = function() {
  function buildHeaders() {
    alert("original buildHeaders called");
  }

  buildHeaders();
}

// Now lets take a backup of the "test" function
oldTest = test;

// And try to override a private function
test = function() {
  function buildHeaders() {
    alert("duplicate buildHeaders called");
  }

  oldTest.apply(this, arguments);
}

// Call
test();

Guess the output?

为什么？

我认为您是在 Java(或类似)背景下进行尝试的，您在其中覆盖了实际方法。在 Javascript 中，您不会覆盖函数，而是替换它们。即

function x() { }    // Original function
oldX = x            // Original function is now oldX
x = function() { }  // x is now a **NEW** function
                    // we did not override, we replaced

// At this point, oldX and x are two different functions
// You just swapped their names, but x is no longer the original x

这部分很清楚。现在进入第二部分，私有(private)/局部变量:

function x() {
  var y = 0;
}
x();
alert(y); // No, you cannot access "y" from outside

但是让我们来看看:

function x() {
  y = 0;  // Without "var"
}
x();
alert(y); // Alerts "0"!!

如果你给 var y = 0 它在那个函数中变成私有(private)的。如果你不这样做，它就会变成全局范围(技术上是上层范围，但我们暂时不考虑它)。

第三部分，函数内部的函数默认是私有(private)的。以同样的例子为例，

function x() {
  function y() { }
  // this is the same as saying:
  var y = function() { }
  // note "var y", so you can't override this from outside
}

因此，如果您通常在函数内部定义一个函数，例如 function x() { function y() { } }，那么 y 对 是私有(private)的x。再加上你永远无法覆盖 javascript 中的函数，你只能替换。因此，您将永远无法访问或修改该 y，除非是在原始 x 函数内。

唯一选择

只有您有权访问某个函数，您才可以用您的自定义实现替换该函数。因此，您必须编辑原始函数，或者必须以某种方式保存对 buildHeaders 函数的引用。即您必须执行以下操作之一:

// ...
tablesorter: new function() {
  this.buildHeaders = function() { }
  // ...
}

// and later, you can replace this:
tablesorter.buildHeaders = function() { // alternative code }

您将能够覆盖该函数，因为它不是私有(private)的，并且您有访问它的句柄。

编辑:小语法