чем они отличаются от инструкций по охране труда

  
   number  number

  
  theObjectmake  


 mycar         
 x y

x  mycarmake // x получает значение "Honda"

mycar
y  mycarmake // y получает значение "Toyota"
// (свойство было изменено функцией)

     
   number  number

 x   // x получает значение 16

     
   n      n  n  


console

  
   result   // Создаём новый массив
    i
   i   i  alength i resulti  ai
   result

  
   result   // Создаём новый массив
   i // Объявляем переменную
   i   i  alength i resulti  ai
   result

     
   x  x  x

 numbers      
 cube  f numbers
consolecube

 myFunc
 num   
      
    theObjectmake  
  

console

  
   n  n

consolesquare // square поднят со значением undefined.
console // TypeError: square is not a function
     
   n  n

  
   n    n    
    n  n  

 a b c d e
a   // a получает значение 1
b   // b получает значение 2
c   // c получает значение 6
d   // d получает значение 24
e   // e получает значение 120

// Следующие переменные объявленны в глобальном scope
 num1  
  num2  
  name  

// Эта функция объявленна в глобальном scope
  
   num1  num2


 // вернёт 60

// Пример вложенной функции
  
   num1  
    num2  

    
     name  " scored "  num1  num2
  

   


 // вернёт "Chamahk scored 5"

     
  // здесь будут выражения

 x  
 x   
  // "x < 10" — это условие для цикла
  // что-то делаем
  x

  
   x   
    // "x >= 10" — это условие для конца выполнения (тоже самое, что "!(x < 10)")
    
  
  // делать что-то
  x   // рекурсионный вызов

  
   node   
  // что-то делаем с элементами
    i   i  nodechildNodeslength i 
    nodechildNodesi
  

  
   i   
  console  i
  i  
  console  i





// begin: 3
// begin: 2
// begin: 1
// begin: 0
// end: 0
// end: 1
// end: 2
// end: 3

  
    
     x  x
  
   a  b

a    // возвращает 13
b    // возвращает 25
c    // возвращает 41

  
    
     x  y
  
   inside

fn_inside   // Думайте об этом как: дайте мне функцию,
// которая добавляет 3 к любому введенному значению

result   // возвращает 8

result1   // возвращает 8

  
    
      
      consolex  y  z
    
    
  
  

 // в консоле выводится 6 (1 + 2 + 3)

  
   x  
    
     x  
  
   inside


 // возвращает 20 вместо 10

     
  // Внешняя функция объявила переменную "name"
       
     name // Вложенная функция имеет доступ к "name" внешней функции
  
   getName // Возвращаем вложенную функцию, тем самым сохраняя доступ
  // к ней для другого scope

myPet  

 // Возвращается "Vivie",
// т.к. даже после выполнения внешней функции
// name сохранился для вложенной функции

     
   sex

   
       
      name  newName
    

       
       name
    

       
       sex
    

       
       
         newSex   
        newSex    newSex  
       
        sex  newSex
      
    
  


 pet  
pet 

pet
pet
pet 
pet 

 getCode    
   apiCode   

     
     apiCode
  


 // Возвращает apiCode

     
  // Внешняя функция определяет переменную с именем "name".
   
       
      // Внутренняя функция также определяет переменную с именем "name".
      name  name // Как мы можем получить доступ к "name", определённой во внешней функции?
    
  

  
   result  
   i

  // iterate through arguments
   i   i  argumentslength i 
    result  argumentsi  separator
  
   result

// возвращает "red, orange, blue, "
   

// возвращает "elephant; giraffe; lion; cheetah; "
    

// возвращает "sage. basil. oregano. pepper. parsley. "
     

  
  b   b    b  

   a  b


 

 a b   
   a  b


 

  
   theArgs  multiplier  x


 arr     
consolearr 

 a     

 a2  a  
   slength


consolea2 

 a3  a  slength

consolea3 

  
  // Конструктор Person() определяет `this` как самого себя.
  age  

    
    // Без strict mode функция growUp() определяет `this`
    // как global object, который отличается от `this`
    // определённого конструктором Person().
    age
   


 p   

  
   self   // Некоторые выбирают `that` вместо `self`.
  // Выберите что-то одно и будьте последовательны.
  selfage  

    
    // Колбэк ссылается на переменную `self`,
    // значением которой является ожидаемый объект.
    selfage
   

  
  age  

    
    age 
   


 p   

Тестирование по охране труда в ЕИСОТ. Порядок прохождения и примеры реальных вопросов

Тестирование по охране труда в ЕИСОТ. Порядок прохождения и примеры реальных вопросов

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

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

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

Примеры встроенных функций вы уже видели – это

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

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

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

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

Вначале идёт ключевое слово

function имя(параметры) {
  ...тело...
}

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

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

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 ); // Петя, значение внешней переменной было изменено функцией

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

let userName = 'Вася';

function showMessage() {
  let userName = "Петя"; // объявляем локальную переменную

  let message = 'Привет, ' + userName; // Петя
  alert(message);
}

// функция создаст и будет использовать свою собственную локальную переменную userName
showMessage();

alert( userName ); // Вася, не изменилась, функция не трогала внешнюю переменную

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

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

Параметры

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

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

function showMessage(from, text) { // параметры: from, text
  alert(from + ': ' + text);
}

showMessage('Аня', 'Привет!'); // Аня: Привет! (*)
showMessage('Аня', "Как дела?"); // Аня: Как дела? (**)

Когда функция вызывается в строках

Вот ещё один пример: у нас есть переменная

function showMessage(from, text) {

  from = '*' + from + '*'; // немного украсим "from"

  alert( from + ': ' + text );
}

let from = "Аня";

showMessage(from, "Привет"); // *Аня*: Привет

// значение "from" осталось прежним, функция изменила значение локальной переменной
alert( from ); // Аня

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

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

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

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

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

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

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

Например, вышеупомянутая функция

Это не приведёт к ошибке. Такой вызов выведет

Если мы хотим задать параметру

function showMessage(from, text = "текст не добавлен") {
  alert( from + ": " + text );
}

showMessage("Аня"); // Аня: текст не добавлен

Теперь, если параметр

В данном случае

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

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

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

В приведённом выше примере, функция

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

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

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

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

function showMessage(from, text) {
  if (text === undefined) {
    text = 'текст не добавлен';
  }

  alert( from + ": " + text );
}

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

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

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

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

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

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

Современные движки JavaScript поддерживают

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

Директива

Вызовов

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

let age = prompt('Сколько вам лет?', 18);

if ( checkAge(age) ) {
  alert( 'Доступ получен' );
} else {
  alert( 'Доступ закрыт' );
}

Возможно использовать

function showMovie(age) {
  if ( !checkAge(age) ) {
    return;
  }

  alert( "Вам показывается кино" ); // (*)
  // ...
}

В коде выше, если

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

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

function doNothing() { /* пусто */ }

alert( doNothing() === undefined ); // true

Пустой

function doNothing() {
  return;
}

alert( doNothing() === undefined ); // true

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

Для длинного выражения в

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

Код не выполнится, потому что интерпретатор JavaScript подставит точку с запятой после

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

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

Если мы хотим, чтобы возвращаемое выражение занимало несколько строк, нужно начать его на той же строке, что и

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

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

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

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

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

Например, функции, начинающиеся с

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

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

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

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

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

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

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

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

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

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

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

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

Например, фреймворк

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

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

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

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

Например, сравним ниже две функции

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

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 ); // простое
  }
}

Второй вариант использует дополнительную функцию

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;
}

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

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

Итого

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

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

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

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

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

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

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