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

Js передать функцию как параметр

  • автор:

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

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

const sayHello = () =>  console.log('Hello!'); >; const execFunc = (func) =>  func(); >; execFunc(sayHello); // => Hello!

Частая ошибка, когда новички передают не саму функцию, а вызов функции. Будьте внимательны, при таком подходе, сначала вычислиться то, что мы передаём, затем это значение попадёт в функцию:

const sayHello = () =>  console.log('Hello!'); >; const execFunc = (func) =>  func(); >; execFunc(sayHello()); // => TypeError: func is not a function

Ошибка возникает, потому что в функцию execFunc() передаётся не функция, а вызов функции sayHello() .

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

Параметры по умолчанию позволяют задавать формальным параметрам функции значения по умолчанию в случае, если функция вызвана без аргументов, или если параметру явным образом передано значение 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 . Это было исправлено в Firefox bug 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 27 нояб. 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– 2024 by individual mozilla.org contributors. Content available under a Creative Commons license.


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


Ошибка возникает из-за некорректного определения. В этом коде вы определяете новую функцию 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);


Функции


Зачастую нам надо повторять одно и то же действие во многих частях программы.








Например, необходимо красиво вывести сообщение при приветствии посетителя, при выходе посетителя с сайта, ещё где-нибудь.


Чтобы не повторять один и тот же код во многих местах, придуманы функции. Функции являются основными «строительными блоками» программы.


Примеры встроенных функций вы уже видели – это alert(message) , prompt(message, default) и confirm(question) . Но можно создавать и свои.


Объявление функции


Для создания функций мы можем использовать объявление функции.


Пример объявления функции:


function showMessage()


Вначале идёт ключевое слово function , после него имя функции, затем список параметров в круглых скобках через запятую (в вышеприведённом примере он пустой) и, наконец, код функции, также называемый «телом функции», внутри фигурных скобок.


function имя(параметры)


Наша новая функция может быть вызвана по своему имени: showMessage() .








function showMessage() < alert( 'Всем привет!' ); >showMessage(); showMessage();


Вызов showMessage() выполняет код функции. Здесь мы увидим сообщение дважды.


Этот пример явно демонстрирует одно из главных предназначений функций: избавление от дублирования кода.


Если понадобится поменять сообщение или способ его вывода – достаточно изменить его в одном месте: в функции, которая его выводит.


Локальные переменные


Переменные, объявленные внутри функции, видны только внутри этой функции.


function showMessage() < let message = "Привет, я JavaScript!"; // локальная переменная alert( message ); >showMessage(); // Привет, я JavaScript! alert( message ); // 


Внешние переменные


У функции есть доступ к внешним переменным, например:


let userName = 'Вася'; function showMessage() < let message = 'Привет, ' + userName; alert(message); >showMessage(); // Привет, Вася


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








let userName = 'Вася'; function showMessage() < userName = "Петя"; // (1) изменяем значение внешней переменной let message = 'Привет, ' + userName; alert(message); >alert( userName ); // Вася перед вызовом функции showMessage(); alert( userName ); // Петя, значение внешней переменной было изменено функцией


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


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


let userName = 'Вася'; function showMessage() < let userName = "Петя"; // объявляем локальную переменную let message = 'Привет, ' + userName; // Петя alert(message); >// функция создаст и будет использовать свою собственную локальную переменную userName showMessage(); alert( userName ); // Вася, не изменилась, функция не трогала внешнюю переменную


Глобальные переменные


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


Глобальные переменные видимы для любой функции (если только их не перекрывают одноимённые локальные переменные).


Желательно сводить использование глобальных переменных к минимуму. В современном коде обычно мало или совсем нет глобальных переменных. Хотя они иногда полезны для хранения важнейших «общепроектовых» данных.








Параметры


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


В нижеприведённом примере функции передаются два параметра: from и text .


function showMessage(from, text) < // параметры: from, text alert(from + ': ' + text); >showMessage('Аня', 'Привет!'); // Аня: Привет! (*) showMessage('Аня', "Как дела?"); // Аня: Как дела? (**)


Когда функция вызывается в строках (*) и (**) , переданные значения копируются в локальные переменные from и text . Затем они используются в теле функции.


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


function showMessage(from, text) < from = '*' + from + '*'; // немного украсим "from" alert( from + ': ' + text ); >let from = "Аня"; showMessage(from, "Привет"); // *Аня*: Привет // значение "from" осталось прежним, функция изменила значение локальной переменной alert( from ); // Аня


Значение, передаваемое в качестве параметра функции, также называется аргументом.


    

  • Параметр – это переменная, указанная в круглых скобках в объявлении функции.
    • 

  • Аргумент – это значение, которое передаётся функции при её вызове.
    • 



Мы объявляем функции со списком параметров, затем вызываем их, передавая аргументы.








Рассматривая приведённый выше пример, мы могли бы сказать: "функция showMessage объявляется с двумя параметрами, затем вызывается с двумя аргументами: from и "Привет" ".


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


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


Например, вышеупомянутая функция showMessage(from, text) может быть вызвана с одним аргументом:


showMessage("Аня");


Это не приведёт к ошибке. Такой вызов выведет "*Аня*: undefined" . В вызове не указан параметр text , поэтому предполагается, что text === undefined .


Если мы хотим задать параметру text значение по умолчанию, мы должны указать его после = :


function showMessage(from, text = "текст не добавлен") < alert( from + ": " + text ); >showMessage("Аня"); // Аня: текст не добавлен


Теперь, если параметр text не указан, его значением будет "текст не добавлен"








В данном случае "текст не добавлен" это строка, но на её месте могло бы быть и более сложное выражение, которое бы вычислялось и присваивалось при отсутствии параметра. Например:


function showMessage(from, text = anotherFunction()) < // anotherFunction() выполнится только если не передан text // результатом будет значение text >


Вычисление параметров по умолчанию


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


В приведённом выше примере, функция anotherFunction() не будет вызвана вообще, если указан параметр text .


С другой стороны, функция будет независимо вызываться каждый раз, когда text отсутствует.


Использование параметров по умолчанию в ранних версиях JavaScript








Ранние версии JavaScript не поддерживали параметры по умолчанию. Поэтому существуют альтернативные способы, которые могут встречаться в старых скриптах.


Например, явная проверка на undefined :


function showMessage(from, text) < if (text === undefined) < text = 'текст не добавлен'; >alert( from + ": " + text ); >


…Или с помощью оператора || :


function showMessage(from, text) < // Если значение text ложно, тогда присвоить параметру text значение по умолчанию // заметим, что при этом пустая строка text === "" будет также считаться отсутствующим значением text = text || 'текст не добавлен'; . >


Альтернативные параметры по умолчанию


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


Во время выполнения функции мы можем проверить, передан ли параметр, сравнив его с undefined :


function showMessage(text) < // . if (text === undefined) < // если параметр отсутствует text = 'пустое сообщение'; >alert(text); > showMessage(); // пустое сообщение


…Или мы можем использовать оператор || :








function showMessage(text) < // если значение text ложно или равняется undefined, тогда присвоить text значение 'пусто' text = text || 'пусто'; . >


Современные движки JavaScript поддерживают оператор нулевого слияния ?? . Его использование будет лучшей практикой, в случае, если большинство ложных значений, таких как 0 , следует расценивать как «нормальные».


function showCount(count) < // если count равен undefined или null, показать "неизвестно" alert(count ?? "неизвестно"); >showCount(0); // 0 showCount(null); // неизвестно showCount(); // неизвестно


Возврат значения


Функция может вернуть результат, который будет передан в вызвавший её код.


Простейшим примером может служить функция сложения двух чисел:


function sum(a, b) < return a + b; >let result = sum(1, 2); alert( result ); // 3


Директива return может находиться в любом месте тела функции. Как только выполнение доходит до этого места, функция останавливается, и значение возвращается в вызвавший её код (присваивается переменной result выше).


Вызовов return может быть несколько, например:


function checkAge(age) < if (age >= 18) < return true; >else < return confirm('А родители разрешили?'); >> let age = prompt('Сколько вам лет?', 18); if ( checkAge(age) ) < alert( 'Доступ получен' ); >else


Возможно использовать return и без значения. Это приведёт к немедленному выходу из функции.








function showMovie(age) < if ( !checkAge(age) ) < return; >alert( "Вам показывается кино" ); // (*) // . >


В коде выше, если checkAge(age) вернёт false , showMovie не выполнит alert .


Результат функции с пустым return или без него – undefined


Если функция не возвращает значения, это всё равно, как если бы она возвращала undefined :


function doNothing() < /* пусто */ >alert( doNothing() === undefined ); // true


Пустой return аналогичен return undefined :


function doNothing() < return; >alert( doNothing() === undefined ); // true


Никогда не добавляйте перевод строки между return и его значением


Для длинного выражения в return может быть заманчиво разместить его на нескольких отдельных строках, например так:








return (some + long + expression + or + whatever * f(a) + f(b))


Код не выполнится, потому что интерпретатор JavaScript подставит точку с запятой после return . Для него это будет выглядеть так:


return; (some + long + expression + or + whatever * f(a) + f(b))


Таким образом, это фактически стало пустым return .


Если мы хотим, чтобы возвращаемое выражение занимало несколько строк, нужно начать его на той же строке, что и return . Или, хотя бы, поставить там открывающую скобку, вот так:


return ( some + long + expression + or + whatever * f(a) + f(b) )


И тогда всё сработает, как задумано.


Выбор имени функции


Функция – это действие. Поэтому имя функции обычно является глаголом. Оно должно быть кратким, точным и описывать действие функции, чтобы программист, который будет читать код, получил верное представление о том, что делает функция.


Как правило, используются глагольные префиксы, обозначающие общий характер действия, после которых следует уточнение. Обычно в командах разработчиков действуют соглашения, касающиеся значений этих префиксов.








Например, функции, начинающиеся с "show" обычно что-то показывают.


Функции, начинающиеся с…


    

  • "get…" – возвращают значение,
    • 

  • "calc…" – что-то вычисляют,
    • 

  • "create…" – что-то создают,
    • 

  • "check…" – что-то проверяют и возвращают логическое значение, и т.д.
    • 



Примеры таких имён:


showMessage(..) // показывает сообщение getAge(..) // возвращает возраст (получая его каким-то образом) calcSum(..) // вычисляет сумму и возвращает результат createForm(..) // создаёт форму (и обычно возвращает её) checkPermission(..) // проверяет доступ, возвращая true/false


Благодаря префиксам, при первом взгляде на имя функции становится понятным, что делает её код, и какое значение она может возвращать.


Одна функция – одно действие


Функция должна делать только то, что явно подразумевается её названием. И это должно быть одним действием.


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








Несколько примеров, которые нарушают это правило:


    

  • getAge – будет плохим выбором, если функция будет выводить alert с возрастом (должна только возвращать его).
    • 

  • createForm – будет плохим выбором, если функция будет изменять документ, добавляя форму в него (должна только создавать форму и возвращать её).
    • 

  • checkPermission – будет плохим выбором, если функция будет отображать сообщение с текстом доступ разрешён/запрещён (должна только выполнять проверку и возвращать её результат).
    • 



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


Сверхкороткие имена функций


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


Например, фреймворк jQuery определяет функцию с помощью $ . В библиотеке Lodash основная функция представлена именем _ .


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








Функции == Комментарии


Функции должны быть короткими и делать только что-то одно. Если это что-то большое, имеет смысл разбить функцию на несколько меньших. Иногда следовать этому правилу непросто, но это определённо хорошее правило.


Небольшие функции не только облегчают тестирование и отладку – само существование таких функций выполняет роль хороших комментариев!


Например, сравним ниже две функции showPrimes(n) . Каждая из них выводит простое число до n .


Первый вариант использует метку nextPrime :


function showPrimes(n) < nextPrime: for (let i = 2; i < n; i++) < for (let j = 2; j < i; j++) < if (i % j == 0) continue nextPrime; >alert( i ); // простое > >


Второй вариант использует дополнительную функцию isPrime(n) для проверки на простое:


function showPrimes(n) < for (let i = 2; i < n; i++) < if (!isPrime(i)) continue; alert(i); // простое >> function isPrime(n) < for (let i = 2; i < n; i++) < if ( n % i == 0) return false; >return true; >


Второй вариант легче для понимания, не правда ли? Вместо куска кода мы видим название действия ( isPrime ). Иногда разработчики называют такой код самодокументируемым.


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


Итого


Объявление функции имеет вид:


function имя(параметры, через, запятую) < /* тело, код функции */ >


    

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

  • Функции имеют доступ к внешним переменным. Но это работает только изнутри наружу. Код вне функции не имеет доступа к её локальным переменным.
    • 

  • Функция может возвращать значение. Если этого не происходит, тогда результат равен undefined .
    • 



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


Функция, которая получает параметры, работает с ними и затем возвращает результат, гораздо понятнее функции, вызываемой без параметров, но изменяющей внешние переменные, что чревато побочными эффектами.


    

  • Имя функции должно понятно и чётко отражать, что она делает. Увидев её вызов в коде, вы должны тут же понимать, что она делает, и что возвращает.
    • 

  • Функция – это действие, поэтому её имя обычно является глаголом.
    • 

  • Есть много общепринятых префиксов, таких как: create… , show… , get… , check… и т.д. Пользуйтесь ими как подсказками, поясняющими, что делает функция.
    • 



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


Задачи


Обязателен ли "else"?


важность: 4


Следующая функция возвращает true , если параметр age больше 18 .


В ином случае она запрашивает подтверждение через confirm и возвращает его результат:


function checkAge(age) < if (age >18) < return true; >else < // . return confirm('Родители разрешили?'); >>


Будет ли эта функция работать как-то иначе, если убрать else ?


function checkAge(age) < if (age >18) < return true; >// . return confirm('Родители разрешили?'); >


Есть ли хоть одно отличие в поведении этого варианта?


Оба варианта функций работают одинаково, отличий нет.


Перепишите функцию, используя оператор '?' или '||'


важность: 4


Следующая функция возвращает true , если параметр age больше 18 .


В ином случае она задаёт вопрос confirm и возвращает его результат.


function checkAge(age) < if (age >18) < return true; >else < return confirm('Родители разрешили?'); >>


Перепишите функцию, чтобы она делала то же самое, но без if , в одну строку.


Сделайте два варианта функции checkAge :


    

  1. Используя оператор ?
    2. 

  2. Используя оператор ||
    3. 



function checkAge(age) < return (age >18) ? true : confirm('Родители разрешили?'); >


Используя оператор || (самый короткий вариант):


function checkAge(age) < return (age >18) || confirm('Родители разрешили?'); >


Обратите внимание, что круглые скобки вокруг age > 18 не обязательны. Они здесь для лучшей читаемости кода.





Похожие публикации:
    

  1. Как перезагрузить магнитолу teyes
    2. 

  2. Как сделать анимацию в html
    3. 

  3. Как скопировать участников группы whatsapp в другую группу
    4. 

  4. Красная макита что это
    5. 









		

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