JavaScript: что делает Function.call.apply(…)?

call изменяет this внутри вызываемой функции.
пример
var obj = {};
Array.push.call( obj, 1 );

Вызовется метод push у обьекта Array но внутри этого метода this будет указывать на обьект который я указал первым параметром, тоесть мой obj;

Зачем он и как его использовать?
Например, функции setTimeout и setInterval когда вызывают метод, то они вызывают этот метод без привязки к родителю, соответственно в вызывамых методах будет this = window
С помошью call это можно изменить и насильно указать что хочется. Это как простейший пример

В примере они сделали так, чтобы не отделять первый элемент массива — сделать красиво.

В свое время сломал мозг когда разбирал, вот примеры, которые все объясняет:

Function.prototype.call.apply(function(a,b){console.log([this,a,b])}, [NaN,{},4], {}, 0);
(function(a,b){console.log([this,a,b])}).apply(NaN, [{},4], {}, 0);
// Оба выдают [NaN {}, Object {}, 4]
// NaN будет объектом т.к. был передан в качестве первого параметра

Function.prototype.call.call(function(a,b){console.log([this,a,b])}, [NaN,{},4], {}, 0);
(function(a,b){console.log([this,a,b])}).call([NaN,{},4], {}, 0);
// Оба выдают [[NaN, Object {}, 4], Object {}, 0]
// Массив [NaN,{},4] уже объект поэтому не преобразуется в объект

Зачем: для создания метода объекта, принимающего подстановку «this» как первый параметр.
Function.apply.apply даст другой эффект ввиду того, что apply и call принимают разные параметры.

Зачем на более высоком уровне: приходит в голову только как вариант для построения библиотеки утилит для организации «красивого» вызова и незамусоривания пространства имён

При вызове происходит следующее, если кому интересно:

// в контексте примера
var a={ toString:function(){return 'a'} };
Foo.method(a,1,2,3);

1. в apply передается: объект «Foo.prototype.method», параметры [a,1,2,3]
2. вызывается Foo.prototype.method.call(a, 1,2,3), т.е. Foo.prototype.method от имени объекта a
3. вызывается console.log(a, 1,2,3); т.к. this===a

P.S. исходный пример целиком:
Another trick is to use both call and apply together to create fast, unbound wrappers.

function Foo() {}

Foo.prototype.method = function(a, b, c) {
    console.log(this, a, b, c);
};

// Create an unbound version of "method" 
// It takes the parameters: this, arg1, arg2...argN
Foo.method = function() {
    // Result: Foo.prototype.method.call(this, arg1, arg2... argN)
    Function.call.apply(Foo.prototype.method, arguments);
};