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

Передача параметров в функцию JavaScript

Ну не знаю, можно и без этого конечно обойтись. Просто как то так привык ещё с плюсов — например если необходимо вернуть несколько значений из функции. Передал по ссылке несколько параметров и готово)

30 авг 2021 в 8:43

Ну так и тут так же. Передал массив. Функция изменила значения внутри массива. Если вам так будет проще, то можно считать что в JS параметры функции всегда передаются по значению. Просто для непримитивных объектов этим значением является ссылка на объект.

Параметры по умолчанию

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

Интерактивный пример

Синтаксис

function [name]([param1[ = defaultValue1 ][, . paramN[ = defaultValueN ]]])

Описание

В JavaScript параметры функции, которым при её вызове не передаются значения, принимают по умолчанию значение undefined . Однако в некоторых случаях может быть полезно задать иное значение по умолчанию. Именно для таких случаев предназначены параметры по умолчанию.

В прошлом для проверки параметров и задания их значений по умолчанию использовался код в теле функции, в котором проверялось, не равны ли значения параметров undefined .

В приведённом ниже примере, в случае если при вызове функции значение для параметра b не передавалось, его значением становилось undefined , и результатом вычисления a * b в функции multiply получалось значение NaN .

function multiply(a, b)  return a * b; > multiply(5, 2); // 10 multiply(5); // NaN ! 

Чтобы такого не происходило, в теле функции использовался код подобный тому, что находится во второй строчке, где в случае, если функция multiply вызывалась только c одним аргументом, параметру b присваивалось значение 1 :

function multiply(a, b)  b = typeof b !== "undefined" ? b : 1; return a * b; > multiply(5, 2); // 10 multiply(5); // 5 

С появлением в ES2015 параметров по умолчанию стало возможным обходиться без проверки параметров в теле функции. Так, в приведённом выше примере достаточно в заголовке функции указать 1 в качестве значения по умолчанию для параметра b :

function multiply(a, b = 1)  return a * b; > multiply(5, 2); // 10 multiply(5); // 5 multiply(5, undefined); // 5 

Примеры

Передача значения undefined в сравнении с передачей других «ложных» значений

Значение по умолчанию присваивается формальному параметру только если при вызове функции значение для данного параметра не было передано или было явным образом передано undefined . Если формальному параметру при вызове передано любое значение, отличное от undefined , в том числе одно из «ложных» значений, таких как false , 0 , «» , » , « , null , NaN , то в этом случае значение по умолчанию присвоено параметру не будет. Это иллюстрирует следующий пример:

function test(num = 1)  console.log(typeof num); > // num не передано, или передано undefined: test(); // 'number' (num получил значение 1) test(undefined); // 'number' (и здесь num получил значение 1) // num передано значение null или другое "ложное" значение: test(""); // 'string' (num получил значение '') test(null); // 'object' (num получил значение null) 

Параметры по умолчанию вычисляются в момент вызова функции

В Javascript параметры по умолчанию вычисляются в момент вызова функции. В отличие от языка Python, при каждом вызове функции создаётся новое лексическое окружение функции.

function append(value, array = [])  array.push(value); return array; > append(1); // [1] append(2); // [2], а не [1, 2] 

Это верно и для функций, и для переменных:

function callSomething(thing = something())  return thing; > let numberOfTimesCalled = 0; function something()  numberOfTimesCalled += 1; return numberOfTimesCalled; > callSomething(); // 1 callSomething(); // 2 

Параметры по умолчанию доступны в следующих параметрах по умолчанию

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

function greet(name, greeting, message = greeting + " " + name)  return [name, greeting, message]; > greet("David", "Hi"); // ["David", "Hi", "Hi David"] greet("David", "Hi", "Happy Birthday!"); // ["David", "Hi", "Happy Birthday!"] 

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

function go()  return ":P"; > function withDefaults( a, b = 5, c = b, d = go(), e = this, f = arguments, g = this.value, )  return [a, b, c, d, e, f, g]; > function withoutDefaults(a, b, c, d, e, f, g)  switch (arguments.length)  case 0: a; case 1: b = 5; case 2: c = b; case 3: d = go(); case 4: e = this; case 5: f = arguments; case 6: g = this.value; default: > return [a, b, c, d, e, f, g]; > withDefaults.call( value: "=^_^ token punctuation">>); // [undefined, 5, 5, ":P", , arguments, "=^_^ token function">withoutDefaults.call( value: "=^_^ token punctuation">>); // [undefined, 5, 5, ":P", , arguments, "=^_^ инициализация_с_помощью_функций_определяемых_в_теле_функции">
Инициализация с помощью функций, определяемых в теле функции
Начиная с версии Gecko 33 функции, определяемые в теле самой функции, не могут быть использованы для инициализации параметров по умолчанию; попытка это сделать приведёт к ошибке ReferenceError. Параметры по умолчанию всегда вычисляются до обработки описаний функций, определяемых в теле функции.
 
js
// Вызовет ошибку ReferenceError! function f(a = go())  function go()  return ":P"; > > f(); // ReferenceError: go is not defined 
Параметры без инициализации, следующие после инициализируемых параметров
До появления версии Gecko 26, следующий код приводил к SyntaxError . Это было исправлено в баг 777060 и с тех пор работает корректно. Аргументы, передаваемые при вызове функции, становятся значениями формальных параметров независимо от наличия у последних инициализации по умолчанию, а также независимо от присутствия у функции других параметров, находящихся правее в списке параметров и не имеющих инициализации.
function f(x = 1, y)  return [x, y]; > f(); // [1, undefined]; f(2); // [2, undefined]; 
Инициализация по умолчанию деструктурированных параметров
При инициализации параметров по умолчанию можно использовать синтаксическую конструкцию деструктурирующего присваивания:
function f([x, y] = [1, 2],  z: z > =  z: 3 >)  return x + y + z; > f(); // 6 
Спецификации


Specification




ECMAScript Language Specification 
# sec-function-definitions



Совместимость с браузерами
BCD tables only load in the browser
Смотрите также
Found a content problem with this page?

Edit the page on GitHub.
Report the content issue.
View the source on GitHub.

This page was last modified on 7 авг. 2023 г. by MDN contributors.
Your blueprint for a better internet.
MDN
Support

Product help
Report an issue

Our communities
Developers

Web Technologies
Learn Web Development
MDN Plus
Hacks Blog


Website Privacy Notice
Cookies
Legal
Community Participation Guidelines

Visit Mozilla Corporation’s not-for-profit parent, the Mozilla Foundation.
Portions of this content are ©1998– 2023 by individual mozilla.org contributors. Content available under a Creative Commons license.
Передача параметров в функциях JavaScript

Когда Вы постоянно работаете с объектами JavaScript, то Вы можете полагать, что параметры в функции передаются по ссылке. Это не так.

В JavaScript параметры в функциях всегда передаются по значению. Однако, в переменные, представляющие собой** объекты**, записаны** ссылки на объекты**!

Поэтому если в функцию передать объект и изменить свойство этого объекта, то это изменение сохранится в объекте и при выходе из функции!
Если же изменить значение переменной, представляющей объект, это изменение** не повлияет** на объекты, находящиеся за пределами функции.

И конечно же, нечеткое понимание данного механизма приводит к ошибкам, которые не всегда легко обнаружить.

  Пример:
function addSomeLyrics(foo, bar, geez)
foo = foo * 10;
bar.item = "перемен";
geez = ;
>
addSomeLyrics(baz, obj1, obj2);
Вот что выведет этот код:
10
перемен
мы ждем перемен!
  Почему?

10 - ничего не изменилось, т.к. bazпередалась по значению.
obj1.item - значение изменилось, т.к. мы передали в функцию объект obj1 и** изменили его свойство!**
obj2.item - значение не изменилось, т.к. мы изменили** значение переменной, представляющей объект.** И это изменение не повлияло на объекты, находящиеся за пределами функции addSomeLyrics !

Коллеги, кто связан с 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 – 2023 © puzzleweb.ru | razumnikum.ru
Читать:
Как провернуть коленвал cadillac srx