Как передать параметры в функцию javascript
Перейти к содержимому

Как передать параметры в функцию javascript

  • автор:

JavaScript: Параметры и аргументы функции

Параметры функции играют роль локальных переменных в теле функции. При указании параметров функции ключевое слово var или let использовать не нужно, JavaScript объявляет их в качестве локальных переменные автоматически. Параметров может быть указано любое количество:

function foo(a, b, c) < . >// a, b, c – параметры функции

При вызове функции, ей могут передаваться значения, которыми будут инициализированы параметры. Значения, которые передаются при вызове функции называются аргументами . Аргументы, указываются через запятую:

function foo(a, b) < var sum = a + b; alert(sum); >foo(5, 7); // 12

Когда при вызове функции ей передаётся список аргументов, эти аргументы присваиваются параметрам функции в том порядке, в каком они указаны: первый аргумент присваивается первому параметру, второй аргумент – второму параметру и т. д.

Если число аргументов отличается от числа параметров, то никакой ошибки не происходит. В JavaScript подобная ситуация разрешается следующим образом:

    Если при вызове функции ей передаётся больше аргументов, чем задано параметров, «лишние» аргументы просто не присваиваются параметрам. Допустим, имеется следующее объявление функции:

function foo(a, b, c) < // . >

Все функции имеют два неявных параметра: arguments и this . Под словом неявный подразумевается, что эти параметры не перечисляются явно в объявлении функции. Эти параметры также неявно инициализируются при вызове функции. К ним можно обращаться в самой функции так же, как и к любым другим явно установленным параметрам.

Значения параметров по умолчанию

Параметры функции можно инициализировать значениями по умолчанию, которые будут использоваться в том случае, если параметры не были инициализированы аргументами при вызове функции:

function foo(greeting = "Привет", name = "Гость") < console.log(greeting + ", " + name + "!"); >foo(); // "Привет, Гость!"

Передача значения undefined в качестве аргумента воспринимается как отсутствие аргумента:

function foo(greeting = "Привет", name = "Гость") < console.log(greeting + ", " + name + "!"); >foo(undefined, "Гомер"); // "Привет, Гомер!"

Функция, в которой используются параметры со значениями по умолчанию, всегда работает как в строгом режиме, даже если он не был включен:

function foo(a, b = 2) < console.log(a === arguments[0]); console.log(b === arguments[1]); >foo(1); // true // false

Так как в функцию передаётся только один аргумент, arguments[1] имеет значение undefined , поэтому сравнение console.log(b === arguments[1]); в результате даёт false .

Если в функции используются параметры со значениями по умолчанию, то использование объявления строгого режима внутри функции приведёт к синтаксической ошибке:

function foo(a = 1) < "use strict"; // Ошибка >

Значением по умолчанию может быть как простое, так и сложное выражение:

function foo(a = 1, b = 2 + 2) < console.log(a, b); >foo(1); // 1 4

Значение предыдущего параметра можно использовать в качестве значения по умолчанию для любого из последующих параметров:

function foo(a, b = a) < console.log(a, b); >foo(1); // 1 1

Попытка использовать значение последующего параметра в качестве значения по умолчанию для предшествующего параметра вызовет ошибку:

function foo(a = b, b) < console.log(a, b); >foo(undefined, 1); // Ошибка

Параметры создаются в момент вызова функции в том порядке, в котором они следуют в определении функции. Каждый параметр создаётся по аналогии объявления переменной с помощью ключевого слова let. Это означает, что использование параметра до того как он был создан вызовет ошибку.

Попытка использовать значение переменной, объявленной в теле функции, в качестве значения по умолчанию для параметров функции, также вызовет ошибку:

function foo(a = b) < var b = 5; console.log(a); >foo(); // Ошибка

Дополнительный параметр

Параметр с префиксом . называется дополнительным (или необязательным). Дополнительный параметр указывается в качестве последнего параметра. Дополнительный параметр – это массив, в который сохраняются лишние аргументы, когда количество переданных аргументов превышает количество параметров:

function foo(a, b, . args) < console.log(args); >foo(1, 2, 3, 4, 5); // 3, 4, 5

С этой темой смотрят:

  • Объявление и вызов функции
  • arguments и this
  • Инструкция return
  • Рекурсия

Копирование материалов с данного сайта возможно только с разрешения администрации сайта
и при указании прямой активной ссылки на источник.
2011 – 2024 © puzzleweb.ru | razumnikum.ru

Курсы javascript

Можно ли к событию onclick для span#val_1 привязать что-то, что будет передавать во второй аргумент функции AddIntoCart значение innerHTML вышеуказанного span ?

14.02.2013, 12:27
Регистрация: 08.11.2011
Сообщений: 806

 function f(param) 1000 

14.02.2013, 12:38
Регистрация: 24.10.2010
Сообщений: 46

не понял. по клику на span запускается функция f, которая в параметры для f передает значение из span. и? мне-то нужно, чтобы значение из span передавалось вторым аргументом в AddIntoCart и ждало своего часа, пока я не запущу AddIntoCart, щелкнув по ссылке.

14.02.2013, 12:42
Регистрация: 08.11.2011
Сообщений: 806

запиши в функции f это значение в какую-нибудь переменную, которая доступна и функции AddIntoCart

а функция AddIntoCart при вызове пусть проверяет эту переменную

14.02.2013, 12:45
Регистрация: 11.09.2010
Сообщений: 8,804

 1000 

Решение «в лоб». Очень плохой вариант, не стоит так делать..

Как передать параметры в функцию javascript

Функция в JavaScript может принимать параметры. Параметры представляют способ передачи в функцию данных. Параметры указываются в скобках после названия функции.

Например, определим простейшую функцию, которая принимает один параметр:

function print(message) < console.log(message); >print("Hello JavaScript"); print("Hello METANIT.COM"); print("Function in JavaScript");

Функция print() принимает один параметр — message. Поэтому при вызове функции мы можем передать для него значение, например, некоторую строку:

print("Hello JavaScript");

Передаваемые параметрам значения еще называют аргументами.

При этом в отличие от ряда других языков программирования мы в принципе можем не передавать значения параметрам. Например:

function print(message) < console.log(message); >print();

Если параметру не передается значение, тогда он будет иметь значение undefined .

Если функция принимает несколько параметров, то они перечисляются через запятую:

function sum(a, b) < const result = a + b; console.log(result); >sum(2, 6); // 8 sum(4, 5); // 9 sum(109, 11); // 120

При вызове функции с несколькими параметрами значения передаются параметрам по позиции. То есть первое значение передается первому параметру, второе значение — второму и так далее. Например, в вызове:

sum(2, 6);

Число 2 передается параметру a , а число 6 — параметру b .

Передача массива в качестве параметра и spread-оператор

Какие-то связанные данные удобно держать в виде массива. И, возможно, у нас возникнет необходимость передать весь этот набор данных в функцию. В общем случае мы можем передавать массив в качестве параметра и внутри функции обращаться к его отдельным элементам:

function printPerson(person) < console.log("Name:", person[0]); console.log("Age:", person[1]); console.log("Email:", person[2]); console.log("========================="); >const tom = ["Tom", 39, "tom@example.com"]; const bob = ["Bob", 43, "bob@example.com"]; printPerson(tom); printPerson(bob);

В данном случае функция printPerson принимает массив, который, как предполагается, имеет три элемента. И внутри функции происходит обращение к этим элементам.

Но рассмотрим другую ситуацию, когда функция принимает данные в виде отдельных параметров. И в этом случае удобнее использовать spread-оператор :

function printPerson(username, age, email) < console.log("Name:", username); console.log("Age:", age); console.log("Email:", email); console.log("========================="); >const tom = ["Tom", 39, "tom@example.com"]; const bob = ["Bob", 43, "bob@example.com"]; printPerson(. tom); printPerson(. bob);

Чтобы последовательно передать элементы массива параметрам функции перед именем массива указывается spread-оператор:

printPerson(. tom);

Это все равно, что если бы мы написали

printPerson(tom[0], tom[1], tom[2]);

только spread-оператор позволяет сделать передачу значений лаконичней.

Необязательные параметры и значения по умолчанию

Функция может принимать множество параметров, но при этом часть или все параметры могут быть необязательными. Если для параметров не передается значение, то по умолчанию они имеют значение «undefined». Однако иногда бывает необходимо, чтобы параметры обязательно имели какие-то значения, например, значения по умолчанию. До стандарта ES6 необходимо было проверять значения параметров на undefined:

function sum(x, y) < if(y === undefined) y = 5; if(x === undefined) x = 8; const z = x + y; console.log(z); >sum(); // 13 sum(6); // 11 sum(6, 4) // 10

Здесь функция sum() принимает два параметра. При вызове функции мы можем проверить их значения. При этом, вызывая функцию, необязательно передавать для этих параметров значения. Для проверки наличия значения параметров используется сравнение со значением undefined .

Также мы можем напрямую определять для параметров значения по умолчанию:

function sum(x = 8, y = 5) < const z = x + y; console.log(z); >sum(); // 13 sum(6); // 11 sum(6, 4) // 10

Если параметрам x и y не передаются значения, то они получаются в качестве значений числа 5 и 10 соответствено. Такой способ более лаконичен и интуитивен, чем сравнение с undefined.

При этом значение параметра по умолчанию может быть производным, представлять выражение:

function sum(x = 8, y = 10 + x) < const z = x + y; console.log(z); >sum(); // 26 sum(6); // 22 sum(6, 4) // 10

В данном случае значение параметра y зависит от значения x.

Функции с произвольным количеством параметров

JavaScript позволяет определять так называемые variadic function или функции с произвольным количеством параметров. Для этого можно использовать ряд инструментов.

Объект arguments

При необходимости мы можем получить все переданные параметры через доступный внутри функции объект arguments :

function sum() < let result = 0; for(const n of arguments) result += n; console.log(result); >sum(6); // 6 sum(6, 4) // 10 sum(6, 4, 5) // 15

При этом даже не важно, что при определении функции мы не указали никаких параметров, мы все равно можем их передать и получить их значения через arguments .

Причем мы можем даже определить параметры явным образом:

function sum(a, b, c) < console.log("a =", a); console.log("b =", b); console.log("c =", c); let result = 0; for(const n of arguments) result += n; console.log("result browser">a = 6 b = 4 c = 5 result = 23

Хотя мы можем перебрать объект arguments как массив, тем не менее это не массив. Хотя мы можем получить его длину с помощью свойства length и обращаться к переданным в функцию аргументам, используя индекс:

function sum(nums)< let result = 0; // результат функции if(arguments.length >=1) // если передан как минимум один параметр < result = result + arguments[0]; // обращаемся к первому параметру >if(arguments.length >=2) // если передано как минимум два параметра < result = result + arguments[1]; // обращаемся ко второму параметру >console.log("result b">. (rest-оператор) также можно передать переменное количество значений:

function sum(. numbers) < let result = 0; for(const n of numbers) result += n; console.log(result); >sum(6, 4, 5) // 15

В данном случае параметр . numbers указывает, что вместо него можно передать разное количество значений. В самой функции numbers фактически представляет массив переданных значений, которые мы можем получить. При этом несмотря на это, при вызове функции в нее передается не массив, а именно отдельные значения.

Подобные rest-параметры можно комбинировать с обычными параметрами:

function display(season, . temps) < console.log(season); for(index in temps)< console.log(temps[index]); >> display("Весна", -2, -3, 4, 2, 5); display("Лето", 20, 23, 31);

Здесь первое значение, передаваемое в функцию, будет интерпретироваться как значение для параметра season, все остальные значения перейдут параметру temps.

Весна -2 -3 4 2 5 Лето 20 23 31
Массив как параметр

Третий способ передачи неопределенного количества данных представляет передача их через параметр-массив. Хотя формально параметр у нас один (количество параметров определено), тем не менее количество конкретных данных в этом массиве неопределенно (как и в случае с массивом arguments):

function sum(numbers) < let result = 0; for(const n of numbers) result += n; console.log("result brush:js;">function sum(x, y) < return x + y; >function subtract(x, y) < return x - y; >function operation(x, y, func) < const result = func(x, y); console.log(result); >console.log("Sum"); operation(10, 6, sum); // 16 console.log("Subtract"); operation(10, 6, subtract); // 4

Функция operation принимает три параметра: x, y и func. func - представляет функцию, причем на момент определения operation не важно, что это будет за функция. Единственное, что известно, что функция func может принимать два параметра и возвращать значение, которое затем отображается в консоли браузера. Поэтому мы можем определить различные функции (например, функции sum и subtract в данном случае) и передавать их в вызов функции operation.

Передача функции в качестве параметра другой функции

Ошибка возникает из-за некорректного определения. В этом коде вы определяете новую функцию mult. При этом в круглых скобках должны указываться формальные параметры, а не конкретные аргументы, как у вас. Конкретные аргументы (будь то обычное значение или функция) будут передаваться в будущем, во время вызова созданной вами функции. На стадии определения функции указывается формальный параметр на место которого будет подставлено конкретное значение во время вызова этой функции. При этом формальный параметр должен иметь обыкновенное имя, например, par, num или любое другое подходящее. Вы же в определении функции пытаетесь сделать вызов формального параметра sun(), что не имеет смысла и приводит к ошибке.

Если хотите иметь возможность передавать одну функцию в другую, то для начала эти функции нужно опередить, а затем уже передать при вызове, например так:

function sun() < var x = Math.floor(Math.random() * (4 - 1 + 1)) + 1; console.log(x); return x; >function mult(func) < var x = 5 + func(); console.log(x); >// при вызове на место формального параметра func будет // подставлен фактический аргумент-функция sun mult(sun);

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *