Функции в JavaScript. Классический способ создания

Александр Мальцев
Александр Мальцев
34K
27
Содержание:
  1. Что такое функция?
  2. Объявление и вызов функции
  3. Параметры и аргументы
  4. Возвращаемое значение (return)
  5. Новые возможности, которые появились в ES6+ для функций
  6. Комментарии

Статья, в которой рассмотрим, что такое функция и зачем она нужна. Разберём классический способ её объявления, параметры, аргументы и оператор return.

Что такое функция?

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

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

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

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

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

  • Function Declaration;
  • Function Expression;
  • Arrow Function.

В этой статье разберём первый классический способ, т.е. Function Declaration.

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

Операции с функцией в JavaScript можно разделить на 2 этапа:

  • объявление (создание) функции;
  • вызов (выполнение) этой функции.

1. Объявление функции. Написание функции посредством Function Declaration начинается с ключевого слова function. После этого указывается имя функции, круглые скобки, внутри которых при необходимости описываются параметры, и тело функции, заключённое в фигурные скобки.

function имя (параметры) {
  // тело функции
}

Например:

// объявление функции someName
function someName() {
  alert('Вы вызвали функцию someName!');
}
// function – ключевое слово, которое означает, что хотим создать функцию
// someName – имя функции
// () – круглые скобки, внутри которых описываются параметры
// { ... } – тело функции
JavaScript - Синтаксис объявления функции

При составлении имени функции необходимо руководствоваться такими же правилами, что для переменной. Т.е. можно использовать буквы, цифры (0 – 9), знаки «$» и «_». В качестве букв рекомендуется использовать английский алфавит (a-z, A-Z). Имя функции, также как и имя переменной не может начинаться с цифры.

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

Пример функции с двумя параметрами:

function fullname(firstname, lastname) {
  console.log( `${firstname} ${lastname}` );
}

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

Тело функции – это код, заключенный в фигурные скобки, который необходимо выполнить при её вызове.

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

// объявление функции someName
function someName() {
  alert('Вы вызвали функцию someName!');
}
// выполнение функции someName
someName();
JavaScript - Синтаксис вызова функции

Параметры и аргументы

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

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

userFirstName и userLastName – это параметры (userFirstName будет иметь значение первого аргумента, а userLastName соответственно второго)
function sayWelcome (userFirstName, userLastName) {
  console.log( `Добро пожаловать, ${userLastName} ${userFirstName} `);
}
// 'Иван' и 'Иванов' – это аргументы
sayWelcome('Иван', 'Иванов');
// 'Петр' и 'Петров' – это аргументы
sayWelcome('Петр', 'Петров');

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

let a = 7;
let b = 5;

function sum (a, b) {
  a = a * 2; // 14
  console.log( a + b ); // 19
}
sum(a, b);
console.log ( a ); // 7

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

const user = {
  firstname: 'Петр',
  lastname: 'Петров'
}
// объявляем функцию
function showUser(user) {
  user.firstname = 'Александр';
}
// вызываем функцию
showUser(user);
// выводим значение свойства firstname в консоль
console.log(user.firstname); // Александр

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

function sayWelcome (userFirstName, userLastName) {
  console.log( `Добро пожаловать, ${userLastName} ${userFirstName} `);
}
// с одним аргументом
sayWelcome('Иван'); // Добро пожаловать, undefined Петр
// без передачи аргументов
sayWelcome(); // Добро пожаловать, undefined undefined

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

let a = 7;

function sum(a) {
  // локальная переменная функции
  let b = 8;
  console.log( a + b );
}
sum(a);
console.log ( b ); // Error: b is not defined

При этом, когда мы обращаемся к переменной и её нет внутри функции, она берётся снаружи. Такие переменные называются внешними.

// внешние переменные
let a = 7;
let b = 3;
function sum() {
  // локальная переменная
  let a = 8;
  // изменение значения внешней переменной (т.к. b нет внутри функции)
  b = 4;
  console.log( a + b );
}
sum(); // 12

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

arguments

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

Внутри функции доступен специальный массивоподобный объект arguments. С помощью него можно получить все переданные аргументы, а также их количество.

function f() {
  // проверим является ли arguments обычным массивом
  console.log(Array.isArray(arguments));
  // количество аргументов
  console.log( arguments.length );
}

f(); // false

Доступ к аргументам через arguments выполняется точно также как к элементам обычного массива, т.е. по порядковому номеру.

Таким образом:

  • arguments[0] – позволяет получить первый аргумент;
  • arguments[1] – второй аргумент и т.д.
// объявление функции sum
function sum() {
  const num1 = arguments[0] // получаем значение 1 аргумента
  const num2 = arguments[1] // получаем значение 2 аргумента

  console.log(num1 + num2);
}

sum(7, 4); // 11

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

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

function sum() {
  let sum = 0;
  // arguments.length - число аргументов
  for (let i = 0, length = arguments.length; i < length; i++) {
    if (typeof arguments[i] === 'number') {
      sum += arguments[i];
    }
  }

  console.log(sum);
}

sum(4, 20, 17, -6); // 35
sum('', 3, -5, 32, null); // 30

Через цикл for...of этот пример можно записать так:

function sum() {
  let sum = 0;
  for (argument of arguments) {
    if (typeof argument === 'number') {
      sum += argument;
    }
  }

  console.log(sum);
}

При необходимости arguments можно преобразовать в обычный массив.

function names() {
  // превращаем arguments в полноценный массив
  var argsArr = Array.from(arguments);
  console.log(argsArr);
}

names('Даша', 'Маша', 'Нина'); // ["Даша", "Маша", "Нина"]

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

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

function fa(a, b) {
  const c = 4;
  function fb(d) {
    console.log(a + b + c + d);
  }
  fb(1);
}
fa(3, 5); // 13
fa(4, 7); // 16

// параметр a не доступен за пределами функции fa
console.log(a); // Uncaught ReferenceError: a is not defined

При этом внешняя переменная или функция будет доступна внутри неё.

const a = 10;
function fa(b) {
  console.log(a + b);
}

fa(7); // 17

Передачи одной функции в другую. Колбэки

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

// функция, которая будет выводить в консоль то, что ей передали в виде аргумента
function outputResult(result) {
  console.log(result);
}

// функция, которая принимает на вход 2 аргумента и колбэк
function sum(num1, num2, callback) {
  // вычислим сумму 2 значений и сохраним его в result
  const result = num1 + num2;

  // вызовем колбэк
  callback(result);
}

sum (5, 11, outputResult);

В JavaScript это возможно, т.к. функция в этом языке является значением. Её можно передавать в другие функции в виде аргументов. По сути, функция в JavaScript - это определённый тип объектов, который можно вызывать.

Узнать является ли некоторый идентификатор функцией можно с помощью typeof:

function myfunc() {};

console.log(typeof myfunc); // function

Например, проверим является ли колбэк функцией перед тем как его вызвать:

function sum(num1, num2, callback) {
  const result = num1 + num2;

  if (typeof callback === 'function') {
    callback(result);
  }
}

Возвращаемое значение (return)

Оператор return предназначен для возвращения значения выражения в качестве результата выполнения функции. Значение выражения должно быть указано после ключевого слова return.

function f() {
  return выражение;
}

Если оно не указано, то вместо этого значения будет возвращено undefined.

Без использования return:

function sum(a, b) {
  const result = a + b;
}

// вызовем функцию и сохраним её результат в константу result
const result = sum(4, 3);
// выведем результат функции sum(4, 3) в консоль
console.log(result); // undefined

С использованием return:

function sum(a, b) {
  // вернём в качестве результата сумму a + b
  return a + b;
}

// вызовем функцию и сохраним её результат в константу result
const result = sum(4, 3);
// выведем результат функции sum(4, 3) в консоль
console.log(result); // 7

Инструкции, расположенные после return никогда не выполняются:

function sum(a, b) {
  // вернём в качестве результата сумму a + b
  return a + b;
  // код, расположенный после return никогда не выполняется
  console.log('Это сообщение не будет выведено в консоль');
}

sum(4, 90);

Функция, которая возвращает функцию

В качестве результата функции мы можем также возвращать функцию.

Например:

function outer(a) {
  return function(b) {
    return a * b;
  }
}

// в one будет находиться функция, которую возвращает outer(3)
const one = outer(3);
// в two будет находиться функция, которую возвращает outer(4)
const two = outer(4);

// выведем в консоль результат вызова функции one(5)
console.log(one(5)); // 15
// выведем в консоль результат вызова функции two(5)
console.log(two(5)); // 20

Вызовы функции outer(3) и outer(4) возвращают одну и туже функцию, но первая запомнила, что a = 3, а вторая - что a = 4. Это происходит из-за того, что функции в JavaScript «запоминают» окружение, в котором они были созданы. Этот приём довольно часто применяется на практике. Так как с помощью него мы можем, например, на основе одной функции создать другие, которые нужны.

В примере, приведённом выше, мы могли также не создавать дополнительные константы one и two. А вызвать сразу после вызова первой функции вторую.

// выведем в консоль результат вызова функции one(5)
console.log(outer(3)(5)); // 15
// выведем в консоль результат вызова функции two(5)
console.log(outer(4)(5)); // 20

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

Функцию, приведённую в коде мы можем также создать и так:

function outer(a) {
  function inner(b) {
    return a * b;
  }
  return inner;
}

Кроме этого в качестве результата мы можем также возвратить внешнюю функцию:

function fa() {
  return 'Привет!';
}

function fb() {
  return fa;
}

fb()(); // Привет!

Рекурсия

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

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

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

function fact(n) {
  // условие выхода из рекурсии
  if (n === 1) {
    return 1;
  }

  // возвращаем вызов функции fact(n - 1) умноженное на n
  return fact(n - 1) * n;
}
console.log(fact(5)); // 120

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

function counter(value) {
  // условие выхода из рекурсии
  if (value < 10) {
    console.log(value);

    // возвращаем вызов функции counter(value + 1)
    return counter(value + 1);
  }
}

counter(1); // 1, 2, 3, 4, 5, 6, 7, 8, 9
counter(7); // 7, 8, 9

Перегрузка функций в JavaScript

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

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

Например, того чтобы проверить имеет параметр значение или нет, мы можем проверить его значения на undefined. Узнать количества переданных аргументов функции можно через arguments.length. Определить значения параметра можно используя typeof или instanceof.

Например, создадим функцию bodyBgColor, которая будет иметь 2 режима работы. Если её вызвать без аргументов, то она будет возвращать цвет фона body. А если с текстовым аргументом, то она будет устанавливать цвет фона body.

// объявление функции bodyBgColor
function bodyBgColor(color) {
  // если параметр color имеет в качестве значения строку, то установим цвет фона body
  if (typeof color === 'string') {
    document.body.style.backgroundColor = color;
  }

  // вернём в качестве результата текущий цвет фона body
  return getComputedStyle(document.body).backgroundColor;
}

// получим текущий цвет body и выведем его в консоль
console.log(bodyBgColor());

// установим новый цвет фона body
bodyBgColor('green');

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

function calculateСalories(gender, height) {
  let result = gender === 'man' ? (height - 100) * 20 : (height - 105) * 19;
  if (typeof arguments[2] === 'number') {
    result *= arguments[2];
  }
  return result.toFixed(0);
}

console.log(`Оптимальное кол-во ккал: ${calculateСalories('man', 185)}`);
console.log(`Оптимальное кол-во ккал: ${calculateСalories('woman', 168, 1.2)}`);
console.log(`Оптимальное кол-во ккал: ${calculateСalories('woman', 168)}`);

Новые возможности, которые появились в ES6+ для функций

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

В языке, начиная с версии ECMAScript 6+ (2015+) параметру функции можно задать значение по умолчанию.

Например, установим параметру color значение по умолчанию '#009688':

function bodyBgColor(color = '#009688') {
  document.body.style.backgroundColor = color;
}

// при вызове функции без указания аргументов цвет фона body будет установлен, равным '#009688'
setBGColor();
// при указании аргумента цвет фона body будет установлен в соответствии с его значением
setBGColor('red'); // цвет фона будет равен red

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

function setBGColor(color) {
  // устанавливаем color значение по умолчанию '#009688', если он имеет тип undefined
  color = typeof color === 'undefined' ? '#009688' : color;
  // устанавливаем цвет фона body равным значению color
  document.body.style.backgroundColor = color;
}

Оставшиеся параметры (rest parameters)

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

// ...nums - оставшиеся параметры, к которым можно обратиться в данном случае по nums
function calculate(action, ...nums) {
  let result = 0;
  nums.forEach(function(num) {
    switch (action) {
      case 'sum':
        result += num;
        break;
      case 'multiply':
        result *= num;
        break;
    }
  });

  return result;
}

console.log(calculate('sum', 3, 4, 21, -4)); // 24
console.log(calculate('multiply', 1, 4, 3)); // 12

Что такое встроенные (стандартные) функции

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

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

// вызов функции alert
alert("Некоторый текст");
JavaScript - Вызов функции alert

Функция в JavaScript в результате своего выполнения всегда возвращает результат, даже если он явно не определён с помощью оператора return. Этот результат значение undefined.

// 1. функция, не возвращающая никакого результата
function sayWelcome (userFirstName, userLastName) {
  console.log("Добро пожаловать, " + userLastName + " " + userFirstName);
}
// попробуем получить результат у функции, которая ничего не возвращает
console.log(sayWelcome ("Иван", "Иванов"));
// 2. функция, содержащая оператор return без значения
function sayDay (day) {
  day = "Сегодня, " + day;
  return;
  //эта инструкция не выполнится, т.к. она идёт после оператора return
  console.log(day);
}
// попробуем получить результат у функции, которая содержит оператор return без значения
console.log(sayDay("21 февраля 2016г."));
JavaScript - Получить значение у функции, которая ничего не возвращает

Такой же результат будет получен, если для оператора return не указать возвращаемое значение.

Комментарии:

  1. Anastasiia Veselieva
    Anastasiia Veselieva
    14.06.2021, 22:51
    Пожалуйста помогите решить задачу.
    Create a my_string_formatting function which takes 3 parameters (firstname, lastname and age) and prints a string composed value.
    Formatting should be: «Hello, my name is FIRSTNAME LASTNAME, I'm AGE.»
    Make sure you are printing a newline.
    /*
    **
    ** QWASAR.IO — my_string_formatting
    **
    **
    ** @param {String} param_1
    ** @param {String} param_2
    ** @param {Integer} param_3
    **
    */

    function my_string_formatting(param_1, param_2, param_3) {

    };
    Example 00

    Input: «john» && «doe» && 37
    Output: Hello, my name is john doe, I'm 37.

    Return Value: nil
    Example 01

    Input: «Baby» && «Yoda» && 50
    Output: Hello, my name is Baby Yoda, I'm 50.

    Return Value: nil
    Example 02

    Input: «Marie» && «Curie» && 26
    Output: Hello, my name is Marie Curie, I'm 26.

    Return Value: nil
    1. Александр Мальцев
      Александр Мальцев
      18.06.2021, 13:30
      Привет! Тут вроде всё просто:
      function my_string_formatting(param_1, param_2, param_3) {
        console.log('Hello, my name is ' + param_1 + ' ' + param_2 + ', I\'m ' + param_3 + '.');
      }
      
    2. Катя
      Катя
      16.05.2021, 17:10
      Доброго дня Олександр.
      Дякую за цікаві матеріали та можливість навчання.
      Допоможіть будь ласка з таким завданням:
      Створи функцію greeter, яка приймає параметр name.
      Використовуючи параметр name, поверни з функції рядок-привітання такого формату: Hi, ${name}!..
      Результатом має бути два імені Mike, luis.
      Не розумію де маю прописати ці імена в коді.
      Мій варіант коду:
      function greeter ('name') {
      console.log(«Hi,» + $(name));
      return name;
      }
      Дякую.
      1. Александр Мальцев
        Александр Мальцев
        17.05.2021, 02:45
        Привет!
        Я это задание понимаю так:
        function greeter(name) {
          return `Hi, ${name}`;
        }
        
        console.log(greeter('Mike'));
        console.log(greeter('Iuis'));
        
        1. Катя
          Катя
          17.05.2021, 10:05
          Ура :), працює.
          Дякую.
      2. Vadim
        Vadim
        21.10.2020, 11:39
        Добрый день!
        Есть задачка
        Создай функцию double, которая принимает число num и возвращает его удвоенное значение, например:

        double (5) возвращает 10,
        double (24) возвращает 48.

        прописываю
        const double = (num) => (`2 * ${num}`);
        в описании ошибки выдает
        Function 'double' should return result of type number

        подскажите в чем ошибка?
        спасибо
        1. Александр Мальцев
          Александр Мальцев
          21.10.2020, 11:55
          Добрый день! Использовать обратный апостроф не нужно:
          const double = (num) => 2 * num;
          
          1. Vadim
            Vadim
            21.10.2020, 12:05
            спасибо

            а в этом случае?

            Создай функцию multiply, которая принимает 2 параметра a и b типа number, и возвращает произведение двух чисел. Параметр b должен иметь значение по умолчанию — 1.

            пример:

            multiply (10, 2) возвращает 20;
            multiply (10) возвращает 10,
            1. Александр Мальцев
              Александр Мальцев
              21.10.2020, 12:38
              Тут всё просто:
              const multiply = (a, b = 1) => a * b;
              
        2. Ekaterina
          Ekaterina
          28.09.2020, 12:13
          Здравствуйте, Александр!
          Проконсультируйте, пожалуйста, по решению задачи:
          Напишите функцию, которая принимает объект с полем name и возвращает 0 если длина этого поля четная и 1 если нечетная
          ПРИМЕРЫ:
          Input: {name: 'abra'}
          Actions:
          Output: 0
          Input: {name: 'cadabra'}
          Actions:
          Output: 1

          Мое решение:
          function test(obj) {
          if (obj.length === 1) {
          return 1
          } else {
          return 0
          }
          }

          Пишет ошибку: [4:10] Unnecessary 'else' after 'return'.

          1. Александр Мальцев
            Александр Мальцев
            28.09.2020, 14:27
            Здравствуйте! Так вам нужно сначала получить длину значения свойства «name» переданного объекта, а затем вычислить остаток от деления 2. И если он будет равен 0, то вернуть 0. В противном случае 1.
            function test(obj) {
              if (obj['name'].length % 2 === 0) {
                return 0;
              } else {
                return 1;
              }
            }
            
            1. Ekaterina
              Ekaterina
              28.09.2020, 15:02
              Выдал ошибку, что Name лучше писать через точки, я исправила.
              Пишет, что лишний else. [4:10] Unnecessary 'else' after 'return'.
              Как правильно его убрать?
              function test(obj) {
              if (obj.name.length % 2 === 0) {
              return 0;
              } else {
              return 1;
              }
              }
              1. Александр Мальцев
                Александр Мальцев
                28.09.2020, 15:23
                Можно без else:
                function test(obj) {
                  if (obj['name'].length % 2 === 0) {
                    return 0;
                  }
                  return 1;
                }
                
                1. Ekaterina
                  Ekaterina
                  28.09.2020, 15:37
                  Получилось! Спасибо большое!
          2. Navolokin Roman
            Navolokin Roman
            15.08.2020, 22:18
            const greeter = (name = '', partOfDay = '') => ('Good' + partOfDay + ", " + name + "!");

            Она возвращает строку «Goodmorning, Mike!»

            а должна возвращать «Good morning, Mike!» — как сделать этот пробел между Good и morning?
            1. Александр Мальцев
              Александр Мальцев
              16.08.2020, 12:11
              Так нужно просто добавить пробел в конце строки 'Good':
              const greeter = (name = '', partOfDay = '') => ('Good ' + partOfDay + ', ' + name + '!');
              
            2. Navolokin Roman
              Navolokin Roman
              15.08.2020, 11:46
              Объяви функцию-стрелку getString. Объяви внутри функции переменную randomString с любым значением типа string и верни ее, используя ключевое слово return.

              function getString(){
              const randomString = 'Name';
              return randomString;
              }

              как переделать ее в стрелочную функцию, подскажите
              1. Александр Мальцев
                Александр Мальцев
                15.08.2020, 14:18
                Будет так:
                const getString = () => {
                  const randomString = 'Name';
                  return randomString;
                };
                1. Navolokin Roman
                  Navolokin Roman
                  15.08.2020, 14:22
                  Стрелочные функции используются просто для сокращения кода?
                  1. Александр Мальцев
                    Александр Мальцев
                    15.08.2020, 14:39
                    Современный синтаксис для написания функций.
                  2. Navolokin Roman
                    Navolokin Roman
                    15.08.2020, 14:21
                    Спасибо Вам огромное!
                2. Alex
                  Alex
                  11.08.2020, 17:38
                  Здраствуйте!
                  Помогите написать код на js:

                  Объяви функцию getString, что возвращает любое значение типа string. Объяви переменную getStringResult и присвоить ей результат вызова функции getString.
                  1. Александр Мальцев
                    Александр Мальцев
                    13.08.2020, 01:40
                    Здравствуйте!
                    Решение этой задачи:
                    function getString() {
                      return 'Привет';
                    }
                    const getStringResult = getString();
                    
                    1. Alex
                      Alex
                      15.08.2020, 17:09
                      Спасибо огромное!
                  2. Ekaterina
                    Ekaterina
                    06.08.2020, 09:25
                    Благодарю Вас!
                    1. Ekaterina
                      Ekaterina
                      06.08.2020, 09:00
                      Здравствуйте, Александр!
                      Подскажите, пожалуйста, если нужно написать функцию, которая преобразует имя и фамилию в шаблон My Name Is: $Name $Surname, как это сделать без объявления переменной, то есть сразу вернуть результат?
                      1. Function test(name, surname) {
                      2. return
                      3. }
                      1. Александр Мальцев
                        Александр Мальцев
                        06.08.2020, 09:17
                        Здравствуйте!
                        Будет так:
                        function test(name, surname) {
                          return 'My Name Is: ' + name + ' ' + surname;
                        }
                        
                        Используя современный синтаксис так:
                        let test = (name, surname) => `My Name Is: ${name} ${surname}`;
                        Использовать функцию так (например, вывести результат в консоль):
                        console.log(test('John', 'Lennon'));
                        
                      Войдите, пожалуйста, в аккаунт, чтобы оставить комментарий.