Ответы:
const args = ['p0', 'p1', 'p2'];
call_me.apply(this, args);Смотрите MDN документы для Function.prototype.apply().
Если среда поддерживает ECMAScript 6, вы можете использовать вместо этого аргумент распространения :
call_me(...args);Почему бы вам не передать весь массив и не обработать его как нужно внутри функции?
var x = [ 'p0', 'p1', 'p2' ];
call_me(x);
function call_me(params) {
for (i=0; i<params.length; i++) {
alert(params[i])
}
}call_meфункции. Ему просто не хватает точки с запятой в конце.
В стандарте ES6 есть новый оператор распространения, ... который делает именно это.
call_me(...x)Он поддерживается всеми основными браузерами, кроме IE.
Оператор распространения может сделать много других полезных вещей, и связанная документация действительно показывает это.
Как ответил @KaptajnKold
var x = [ 'p0', 'p1', 'p2' ];
call_me.apply(this, x);И вам не нужно определять все параметры для функции call_me. Вы можете просто использоватьarguments
function call_me () {
// arguments is a array consisting of params.
// arguments[0] == 'p0',
// arguments[1] == 'p1',
// arguments[2] == 'p2'
}Обратите внимание на это
function FollowMouse() {
for(var i=0; i< arguments.length; i++) {
arguments[i].style.top = event.clientY+"px";
arguments[i].style.left = event.clientX+"px";
}
};// ---------------------------
HTML-страница
<body onmousemove="FollowMouse(d1,d2,d3)">
<p><div id="d1" style="position: absolute;">Follow1</div></p>
<div id="d2" style="position: absolute;"><p>Follow2</p></div>
<div id="d3" style="position: absolute;"><p>Follow3</p></div>
</body>может вызывать функцию с любым аргументом
<body onmousemove="FollowMouse(d1,d2)">или
<body onmousemove="FollowMouse(d1)">function foo([a,b,c], d){
console.log(a,b,c,d);
}
foo([1,2,3], 4)function foo(a, b, c, d){
console.log(a, b, c, d);
}
foo(...[1, 2, 3], 4)При использовании оператора распространения мы должны отметить, что это должен быть последний или единственный переданный параметр. Иначе это не удастся.
function callMe(...arr){ //valid arguments
alert(arr);
}
function callMe(name, ...arr){ //valid arguments
alert(arr);
}
function callMe(...arr, name){ //invalid arguments
alert(arr);
}Если вам нужно передать массив в качестве начального аргумента, вы можете сделать:
function callMe(arr, name){
let newArr = [...arr];
alert(newArr);
}Вы можете использовать оператор распространения в более простой форме
[].concat(...array)в случае функций, которые возвращают массивы, но ожидают передачи в качестве аргументов
Пример:
function expectArguments(...args){
return [].concat(...args);
}
JSON.stringify(expectArguments(1,2,3)) === JSON.stringify(expectArguments([1,2,3]))
Ответ уже дан, но я просто хочу дать свой кусок пирога. То, чего вы хотите достичь, называется method borrowingв контексте JS, когда мы берем метод из объекта и вызываем его в контексте другого объекта. Весьма распространено брать методы массива и применять их к аргументам. Позвольте привести пример.
Итак, у нас есть «супер» хеш-функция, которая принимает два числа в качестве аргумента и возвращает «супер-безопасную» хэшированную строку:
function hash() {
return arguments[0]+','+arguments[1];
}
hash(1,2); // "1,2" whoaaПока все хорошо, но у нас небольшая проблема с вышеуказанным подходом, он ограничен, работает только с двумя числами, который не является динамическим, давайте сделаем так, чтобы он работал с любым числом, и плюс вам не нужно передавать массив (вы можете если вы все еще настаиваете). Хорошо, хватит говорить, давай драться!
Естественным решением было бы использовать arr.joinметод:
function hash() {
return arguments.join();
}
hash(1,2,4,..); // Error: arguments.join is not a functionО чувак. К сожалению, это не сработает. Поскольку мы вызываем хеш (аргументы) и аргументы, объект является итеративным и похожим на массив, но не реальным массивом. Как насчет подхода ниже?
function hash() {
return [].join.call(arguments);
}
hash(1,2,3,4); // "1,2,3,4" whoaaТрюк называется method borrowing.
Мы заимствуем joinметод из обычного массива [].join.и используем его [].join.callдля запуска в контексте arguments.
Почему это работает?
Это потому, что внутренний алгоритм нативного метода arr.join(glue) очень прост.
Взято из спецификации почти «как есть»:
Let glue be the first argument or, if no arguments, then a comma ",".
Let result be an empty string.
Append this[0] to result.
Append glue and this[1].
Append glue and this[2].
…Do so until this.length items are glued.
Return result.Итак, технически он берет это и соединяет это [0], это [1] ... и т.д. вместе. Он намеренно написан так, что допускает любой массив, подобный этому (не случайно, многие методы следуют этой практике). Вот почему это также работает сthis=arguments.