# Условия, Boolean, Логические операторы 

## **Присвоение**

## Типы данных JS

### Числа.

Вы уже знакомы с числами:

```javascript
var b = 5
var c = 6.57
var myPi = Math.PI
```
В JS для целых и дробных существует единый тип `Number`. Так же этот тип имеет специальные значения `NaN` (Not A Number) и `Infinity` (бесконечность).

```javascript
4/"asdf" // бессмысленное выражение, как результат - NaN
```

```javascript
15/0 // на ноль делить нельзя, но в высшей математике - можно :-)
```

### Строки

Строка - тип `String`. Некое множество символов. Для перевода строки в число используйте `+` или `parseInt` ( для целых ) или `parseFloat` ( для чисел
с дробной частью )

```javascript
var someString = "foo";
var concatenatedString = someString + " bar";
var stringWithNumberInside = "123";
var integerNumberByString  = +stringWithNumberInside;
var floatNumberByString    = parseFloat("-15.15");
```

### Boolean

`true` (правда) или `false` (ложь)

В основном используется для двух задач:
- Та или иная переменная-флаг для внутреннего использования. Например `isLoggedIn` может показывать залогинен пользователь на сайте или нет:

```javascript
var IsLoggedIn = true
var IsLoggedIn = false
```
- Как результат той или иной логической операции:

```javascript
var isLoggedIn = (password == rightPassword) && (login == rightLogin) //пользователь залогинен, если пароль и логин совпадают с верными
var isUserOldEnoughToSeeTheAdultVideos = age > 18 // пользователь может смотреть видео, если ему больше 18 лет.
```

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

### Object

Объект. Сложная структура данных, которая в одной переменной может объединять данные других типов и операции над ними. Будет рассмотрено на следующих
занятиях.

```javascript
var person = {
    name: "Ivan",
    surname: "Ivanov",
    age: 25
}
```

### `undefined`

Если что-то в Javascript не определено, то это, обычно, `undefined`:

```javascript
var a; //значение a - undefined
```

`undefined` - это и тип, и единственное его значение.

### `null`

`null` - в целом аналогичен `undefined`, но предназначен для использования его программистом. Т. е. если вы хотите пометить переменную как *пустую* -
используйте `null`

## Операции сравнения и булевы операции.

Каждая переменная или *литеральное значение* могут быть предметом сравнения с другими значениями:

### Равенство
```javascript
1 == 2
1 != 2
1 == 1
1 != 1
"text" == 5
"text" != 5
"text" == "Text"
"text" == "text"
true   == "true"
true   == false
false  == 0
false  === 0
""     == false
""     !== false
```

### Больше, меньше...
```javascript
5 > 6
6 > 5
5.0 >= 5
"a" < "b"
"b" <= "a"
```

Результатом таких операций является значение типа `Boolean`, то есть `true` или `false`

### Логические операции

#### **Не** `!`

```javascript
5 == 5
5 != 5
!true
!false
!(5 == 5)
!(5 != 5)
!!0
```

Как видите, **не** позволяет инвертировать булево значение. *Двойное не* позволяет получить *приведенное к типу* `Boolean` значение переменной.

#### **Или** `||`

**Или** позволяет объединять несколько булевых значений в одно, по следующей логике: **Если A или B истинно**, то результат - истина. Иначе - результат
ложный:

```javascript
var isDrunk = isDrunkByBeer || isDrunkByVodka //если пили или водку, или пиво, все равно пьяные :-)
var isFlyable = isFly || isBird || isAircraft //что-то может летать, если это нечто - самолет, муха или птица, не важно что это.
```

Таблица истинности:

|    A   |   B   |  результат  |
| ------ | ----- | --- |
| false  | false | false |
| **true**  | false | **true** |
| false  | **true** | **true** |
| **true**  | **true** | **true** |

#### **И** `&&`

**И** требует что бы ВСЕ операнды были истинны, иначе результат ложен:

```javascript
var isBodun   = isDrunkByBeer &&  isDrunkByVodka //если пили и водку, и пиво, то бодун :-)
var isYoung   = age > 16 && age < 30 // человек молод от 16 до 30.
```

Таблица истинности:

|    A   |   B   |     |
| ------ | ----- | --- |
| false  | false | false |
| **true**   | false | false |
| false  | **true**  | false |
| **true**   | **true**  | **true**  |

### Порядок выполнения логических выражений

Логические выражения выполняются *оптимальным способом* слева направо. То есть, если в **ИЛИ** попался `true`, то следующая часть выражения даже не
будет обрабатываться. **ИЛИ** ищет `true`, и, когда находит, экономит ресурсы компьютера, *сразу же* возвращая true как результат выражения.

**И**, напротив, "ищет" `false`. То есть, если найден `false`, то нет смысла далее обрабатывать выражение - оно, так или иначе, будет `false`.

Учтите, что `||` и `&&` возвращают **не** `true` или `false` (значение булевского типа), а значения подвыражения как оно есть:
Как `false` интерпретируются:
- `false` 
- `0` // 0 как число
- `""` //пустая строка
- `null`
- `undefined`
- `NaN`

Как `true` интерпретируются все остальные значения, в том числе:
- `Infinity`
- `-Infinity`
- `"0"` //строка не пуста. однако +"0" уже 0 как число, а значит false
- `{}` //пустой объект - всё равно `true`
- `[]` //пустой массив `[] == false`, но в остальных случаях работает как true

**Для проверки используйте** `!!`, двойное отрицание: `!!null` равен `false`, таким образом мы можем почти всегда проверить как интерпретируется
то или иное значение.

В общем случае объект является `true`, за исключением `null` и `[] == false`

Рассмотрим на [примерах](https://jsfiddle.net/qrjarv4m/13/)

### `if` `else`


Любое значение, которое может быть приведено к типу `Boolean` может стать условием для условного оператора `if-else`:

Синтаксис:

```javascript

if (cond){
    //if cond is true
}
else {
    //if cond is false
}


var age = prompt("Сколько вам лет?","");
if (+age < 18){
    alert("Рано вам еще");
}
else {
    alert("Смотрите на здоровье");
}

//если у вас ОДИН оператор в блоке if или else, вы можете не использовать фигурные скобки:

if (+age < 18) alert("Рано вам еще");
else alert("Смотрите на здоровье");

//но учтите: ";" - тоже оператор:


if (+age < 18) alert("Рано вам еще");
else; alert("Смотрите на здоровье");

//эквивалентно:

if (+age < 18) alert("Рано вам еще");
else{
    ;
}
alert("Смотрите на здоровье");
// т.е. последний alert будет срабатывать ВСЕГДА.
```
Ставьте фигурные скобки **всегда**, и избавите себя от лишней траты времени на отладку :-)

`if` может быть так же применен без `else`:
```javascript
var answer = confirm("будешь кексик?");
if (answer){
    alert("кушай на здоровье");
}
alert("пока");
```


```javascript
var age = +prompt("Сколько вам лет?","");
if (age < 18){
    alert("школьник");
}
else if (age > 18 && age < 30){
    alert("молодеж");
}
else if (age > 30 && age < 45){
    alert("зрелость");
}
else if (age > 45 && age < 60){
    alert("закат");
}
else if (age > 60){
    alert("как пенсия?");
}
else {
    alert("то ли киборг, то ли ошибка"); 
}
```

**Задание**: Добавьте условие отрицательного возраста в пример выше.
Расставьте недостающие (но *синтаксически* необязательные) фигурные скобки. 

```javascript
var str = prompt("Поговори со мной!!!!","");
if (str){
    alert("Ты такой милый " + str);
}
else {
    alert("Козёл!!!!!11");
}
```

### Тернарный оператор

Данный оператор позволяет сократить пару `if-else` в некоторых ситуациях:

```javascript
var text = confirm("Нажмите что-нибудь") ? "Вы нажали Yes" : "Вы нажали No";
alert(text);
var text = confirm("Да, Нет, Наверное") ? "Да" : (confirm ("Нет или Наверное?") ? "Нет" :  "Наверное") // вложенный тернарный оператор
alert(text);
```

### `switch`

`switch` позволяет выполнять определенные блоки кода в зависимости от значения выражения:

```javascript
var color = prompt("Введите цвет","");
switch (color){
    case "red": document.write("<div style='background-color: red;'>красный</div>");
                break;
    case "black": document.write("<div style='background-color: black; color: white;'>черный</div>");
                break;
    case "blue": document.write("<div style='background-color: blue;'>синий</div>");
                break;
    case "green": document.write("<div style='background-color: green;'>зеленый</div>");
                break;
    default: document.write("<div style='background-color: gray;'>Я не понял</div>");
}
```

`break` в `switch` обеспечивает переход на конец конструкции `switch` (т. е. на код, следущий за `}`). Если `break` не поставить, то можно объединить
несколько `case` в один:

```javascript
var color = prompt("Введите цвет","");
switch (color){
    case "red": document.write("<div style='background-color: red;'>красный</div>");
    case "black": document.write("<div style='background-color: black; color: white;'>черный</div>");
                break;
    case "blue": document.write("<div style='background-color: blue;'>синий</div>");
    case "green": document.write("<div style='background-color: green;'>зеленый</div>");
                break;
    default: document.write("<div style='background-color: gray;'>Я не понял</div>");
}
```

В примере выше "red" будет рисовать и "red" и "black", "blue" так же объединится с "green". Однако "black" и "green" будут работать так же как и ранее.