Function.prototype.call.apply(self, arguments);Ini kelihatan agak berbelit, tetapi sebenarnya mudah difahami.
Malah, pelaksanaan kedua anda juga boleh membawa kepada pelaksanaan ketiga anti-kari: Function.prototype.call.apply(self, arguments);这个看起来有些绕，其实很好理解。
实际上，由你的第二种实现还可以推出反柯里化的第三种实现：

Function.prototype.unCurrying = function () { 
  return this.call.bind(this);
};
var push = Array.prototype.push.unCurrying(), obj = {};
push(obj, '123', '456');
console.log(obj); //Object {0: "123", 1: "456", length: 2}

接下来我会先分析下你的第二种实现，再分析第三种实现。你的实现是这样的：

Function.prototype.uncurrying = function(){
    var self = this;
    return function(){
        return Function.prototype.call.apply(self, arguments);
    };
};
var push = Array.prototype.push.uncurrying();

谁调用uncurrying，谁就等于this或self. 这意味着self就是数组的push方法.
替换掉self，最终外部的push等同如下函数：

function(){
  return Function.prototype.call.apply(Array.prototype.push, arguments);
};

函数放在这里，我们先来理解apply函数，apply有分解数组为一个个参数的作用。

推导公式：a.apply(b, arguments) 意味着把b当做this上下文，相当于是在b上调用a方法，并且传入所有的参数，如果b中本身就含有a方法，那么就相当于 b.a(arg1, arg2,…)

公式1：a.apply(b, arguments) === b.a(arg1, arg2,…)

由于call 和 apply 除参数处理不一致之外，其他作用一致，那么公式可以进一步演化得到：

公式2：a.call(b, arg) === b.a(arg)

将公式1这些代入上面的函数，有：

a = Function.prototype.call 即a等于call方法。

我们接着代入公式，有：

b = Array.prototype.push 即b等于数组的push方法

那么 Function.prototype.call.apply(Array.prototype.push, arguments)就相对于：

Array.prototype.push.call(arg1, arg2,…)，那么：

push([], 1) 就相当于 Array.prototype.push.call([], 1)，再代入公式2，相当于：

[].push(1)

答案已经呼之欲出了，就是往数组中末尾添加数字1。

接下来我来分析反柯里化的第三种实现：

对于this.call.bind(this);部分，this相当于Array.prototype.push，那么整体等同于如下：

Array.prototype.push.call.bind(Array.prototype.push)

这里的难点在于bind方法，bind的实现比较简单，如下：

Function.prototype.bind = function(thisArg){
  var _this = this;
  var _arg = _slice.call(arguments,1);
  return function(){
       var arg = _slice.call(arguments);
    arg = _arg.concat(arg);
      return _this.apply(thisArg,arg);
  }
}

想要理解必须化繁为简，理解得越简单，也就理解得越透彻。进一步简化bind的原理，等同于谁调用bind，就返回一个新的function。

我们假设函数fn调用bind方法如fn.bind([1, 2])，经过简化，忽略bind绑定参数的部分，最终返回如下：

function(){
  return fn.apply([1, 2], arguments);
}

以上，将fn替换为 Array.prototype.push.call，[1, 2]替换为 Array.prototype.push

function(){
  return Array.prototype.push.call.apply(Array.prototype.push, arguments);
}

Array.prototype.push.call === Function.prototype.call //true

function(){
  return Function.prototype.call.apply(Array.prototype.push, arguments);
}

function(){
  return Function.prototype.call.apply(self, arguments);
}

Asas
Perbezaan dan fungsi panggilan dan penggunaan tidak akan diterangkan secara terperinci

Panggil dan gunakan pelaksanaan kod sumber
Mereka sangat rapat Di sini kami hanya memperkenalkan panggilan, contohnya: a.call(b, c)

1. Keluarkan parameter pertama x = b ||

x.fn = a
Sambungkan parameter kecuali parameter pertama, dipisahkan dengan koma, hasilnya d
Buat fungsi e = Fungsi() baharu dalam persekitaran pelaksanaan bebas, dan laksanakan x.fn(d) di dalam fungsi
Laksanakan e

5. yang dicipta

Masalah panggilan dan memohon untuk mengembangkan kaedah objek tidak dipertimbangkan di sini, kerana kaedah akan dibuat secara dinamik daripada kod sumber, jadi isu ini tidak akan dibincangkan secara terperinci di bawah.

    Function.prototype.call.apply(self, arguments);
    
    var push = Array.prototype.push.uncurrying ();

sendiri menunjuk ke Array.prototype.push
(Function.prototype.call).apply(Array.prototype.push, arguments);
Gunakan kod sumber yang baru diterangkan dan ubah 2 untuk mendapatkan: Array.prototype.push.(Function.prototype.call)(argumen juga perlu ditukar di sini, bukan array, lihat 4.
argumen ialah objek seperti tatasusunan [arr, 1]. Transform 3 untuk mendapatkan: Array.prototype.push.(Function.prototype.call)(arr, 1)
Kod sumber panggilan telah dijelaskan, jadi tukar 4, dan dapatkan arr.(Array.prototype.push)(1)
Tulis dengan lebih baik, arr.push(1)