generated from hexlet-basics/exercises-template
-
Notifications
You must be signed in to change notification settings - Fork 3
/
description.ru.yml
161 lines (111 loc) · 7.26 KB
/
description.ru.yml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
---
name: Результат логических выражений
theory: |
Посмотрите на код ниже и попробуйте угадать, что будет напечатано на экран?
```javascript
console.log(0 || 1);
```
Правильный ответ:
<pre class='hexlet-basics-output'>
1
</pre>
Оператор **ИЛИ** работает так, что его выполнение (слева направо) прерывается и возвращается результат первого аргумента, который можно преобразовать в `true`.
Ниже пример с оператором **И**:
```javascript
console.log(0 && 1);
```
<pre class='hexlet-basics-output'>
0
</pre>
Оператор **И** работает так, что его выполнение (слева направо) прерывается и возвращается результат первого аргумента, который можно преобразовать в `false`.
В JavaScript есть два простых правила, по которым происходят преобразования:
* `0`, `''`, `undefined`, `NaN`, `null` приводятся к `false`. Эти значения называют [falsy](https://developer.mozilla.org/ru/docs/Glossary/Falsy).
* Всё остальное приводится к `true`
Этим активно пользуются в разработке, например, для определения значения по умолчанию:
```javascript
const value = name || '';
// Примеры
234 || ''; // 234
'hexlet' || ''; // 'hexlet'
undefined || ''; // ''
```
https://replit.com/@hexlet/js-basics-logical-expressions
Если `name` примет одно из falsy-значений, константе `value` будет присвоена пустая строка. В этом случае в последующем коде мы сможем работать с `value` как со строкой.
Но здесь есть потенциальный баг. Если `name` содержит falsy-значение, а присваивание константе value значений типа `0`, `undefined`, `NaN` или `null` допустимо, то код выше начнет работать неверно:
```javascript
// Упс
false || ''; // ''
0 || ''; // ''
undefined || ''; // ''
```
В одном из уроков мы рассмотрели операторы сравнения `===` и `!==` и упомянули, что в JavaScript так же есть операторы `==` и `!=`, но их не стоит использовать. Отличия как раз заключаются в преобразовании типов:
```javascript
console.log('' === false); // => false
console.log('' == false); // => true
```
Пустая строка и `false` — это разные значения, поэтому оператор `===` говорит «ложь! они не равны!».
Но оператор `==` преобразует типы, и с его точки зрения пустая строка и `false` равны.
Это преобразование неявное, поэтому по возможности избегайте операторов `==` и `!=`.
---
Вспомните операцию отрицания:
```javascript
const answer = true;
console.log(!answer); // => false
```
Отрицание работает внутри выражений:
```javascript
!false || ''; // true
```
Если выражение обернуть в скобки и поставить перед ними `!`, то будет отрицание всего выражения:
```javascript
// Выражение обернуто в скобки
console.log(!('' === false)); // => true
console.log(!('' == false)); // => false
```
При двойном отрицании `!!` итоговое значение равно начальному:
```javascript
const answer = true;
console.log(!!answer); // => true
```
Но здесь дополнительно может происходить преобразование типа. Поэтому результатом двойного отрицания всегда будет значение типа *boolean*. Этим приемом иногда пользуются, чтобы поменять тип данных.
## Ошибка выбора
Представьте себе задачу, в которой нам нужно проверить, что значение равно либо одному, либо другому. Например переменная `value` должна содержать одно из двух значений: `first` или `second`. Начинающие разработчики иногда записывают это выражение так:
```javascript
value === ('first' || 'second')
```
В голове мы это себе примерно так и представляем, но языки работают по-другому, поэтому такой код приведет к неверному результату. Как его правильно прочитать? Мы должны вспомнить приоритет выполнения операций. Первым делом вычисляется все что указано в скобках, то есть `'first' || 'second'`. Если выполнить этот код в repl, то вывод будет таким:
```bash
node
'Welcome to Node.js v17.4.0.
> 'first' || 'second'
'first'
>
```
Теперь мы можем заменить исходное выражение, на частично вычисленное:
```javascript
value === 'first'
```
Совсем не то, что мы ожидали. А теперь вернемся к началу, и напишем проверку правильно:
```javascript
// Скобки ставить не обязательно,
// потому что приоритет === выше чем приоритет ||
value === 'first' || value === 'second'
```
instructions: |
Реализуйте функцию `getLetter()`, которая извлекает из переданной строки указанный символ (по порядковому номеру, а не по его индексу) и возвращает его наружу. Если такого символа нет, то функция возвращает пустую строку.
Примеры вызова:
```javascript
const name = 'Hexlet';
// Обычное обращение возвращает undefined
name[10]; // undefined
// 11 символ соответствует 10 индексу
getLetter(name, 11); // ''
getLetter(name, 1); // 'H'
getLetter(name, 0); // ''
getLetter(name, 6); // 't'
```
tips:
- |
[Boolean](https://ru.wikipedia.org/wiki/Логический_тип)
- |
[Извлечение символов из строки](https://ru.code-basics.com/languages/javascript/lessons/symbols)