Стать программистом. Часть 8. Основы JavaScript для абсолютных новичков!

Доброго времени суток, друзья! Информация изложенная в предыдущем Уроке раскрыла для нас основы взаимодействия переменных с типами String(Строка) и Number(Число). Мы узнали, что такое строго типизируемые языки программирования и почему JavaScript к ним не относится. Приобрели знания о неявном преобразовании типов переменных, которые осуществляет JavaScript каждый раз, когда переменные разного типа решают произвести арифметические операции друг с другом. А также вывели два правила взаимодействия строковых и числовых переменных.

Однако в конце урока сделали маленькую оговорку:

Оба этих правила имеют маленькую оговорку. Они работают только в тех случаях, когда JavaScript может преобразовать число в строку, а строку в число. Вернее, загвоздка именно со строкой. Потому что число JavaScript всегда может привести к типу String (Строка).

И даже привели пример строки, к которой данная оговорка относится. В нашем сегодняшнем уроке, мы рассмотрим манипуляции с переменными типа String(Строка), для которых правила из предыдущего урока подходят частично. А также продолжим рассматривать примеры взаимодействия переменных других типов.

Начнем!

УРОК 8. Взаимодействие переменных разного типа. часть II.

Давайте для начала приготовим наши index.html и core.js файлы и завершим предыдущий урок. Установим, так сказать, опытным путем, как же все-таки будут между собой взаимодействовать переменные с типом строка и число в случае, когда строка вместо цифры будет содержать буквы. То есть как будет действовать JavaScript, например, в таких ситуациях:

var a = 'привет';
var b = 2;

var c = a + b;
var d = a - b;
var e = a * b;
var f = a / b;

Мы видим, что переменная строкового типа - "а" имеет в своем значении буквенный набор. В отличие от переменных из предыдущего урока, которые несмотря на что что имели строковый тип, несли в своем значении цифры и зачастую имели вид var a = "13";.

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

Поэтому результатом, который будет записан в переменную "с" будет строка вида "привет2". Давайте проверим это в браузере c помощью alert();

var a = 'привет';
var b = 2;

var c = a + b;
var d = a - b;
var e = a * b;
var f = a / b;

alert(c);

Обновим окно браузера и увидим, что наш вывод был абсолютно верен

А что же касательно других арифметических операций, приведённых в коде выше? Все они в своем результате получат значение "NaN", то есть "не число".

Дело в том, что для JavaScript’у не представляет никакой сложности преобразовать строку "13" в число 13, а строку "-10" - в число -10. JavaScript достаточно умен для того, чтобы понять какая именно цифра указана в данных строках. Но вот в строке "привет", или любой другой буквенной строке, нет ни малейшего намека на цифры. Поэтому JavaScript неявно присваивает такой строке тип NaN, и записи вида:

var d = 'привет' - 2;
var e = 'привет' * 2;
var f = 'привет' / 2;

JavaScript неявно преобразует в:

var d = NaN - 2;
var e = NaN * 2;
var f = NaN / 2;

На такой случай в JavaScript есть правило:

Любая арифметическая операция (за ислючением операции "сложения"), в которой участвует NaN в своем результате тоже получит NaN.

Давайте проверим это в браузере:

Как мы можем видеть - все действительно так, как мы и описали. На этом логика взаимодействия между переменными с типом String (Строка) и Number(Число) при неявном преобразовании типов заканчивается.

А мы двиагемся дальше. И на очереди у нас логический тип переменных - Boolean.

Boolean и String(Строка).

В принципе, любое взаимодействие между переменными строкового типа с переменными булевского типа становятся предельно ясны, если вспомнить ассоциацию из Урока № 6. Вот цитата:

Для того чтобы понять логику арифметических операций с переменными булевского типа нужно проделать маленький трюк - провести в уме ассоциацию значения "true" c "1", а значения "false" c "0".

Вооружённые этим знанием мы получаем почти идентичное положение дел в ситуации оперирования переменными типа String с переменными типа Boolean, тому, что мы имели в ситуации оперирования переменными типа String с переменными типа Number. Ведь по сути операции вида

var a = '12' - true;
var b = '1' * false;
var c = false - '-4';
var d = '9' / true;

При неявном преобразовании булевского типа будут иметь вид:

var a = '12' - 1;
var b = '1' * 0;
var c = 0 - '-4';
var d = '9' / 1;

Единственная разница будет заключатся в том, что в зависимости от ситуации при взаимодействии переменных типа String с переменными типa 'Number' JavaScript неявно преобразовывал либо переменную с числовым типом, либо - переменную со строковым типом.
В случаях же, приведенных выше JavaScript преобразует всех участников арифметических выражений. Поэтому окончательно, операции, описанные выше, JavaScript неявно приведет к виду:

var a = 12 - 1;
var b = 1 * 0;
var c = 0 - -4;
var d = 9 / 1;

Таким образом, переменны получать следующие значения: "a" - 11, "b" - 0, "c" - 4, "d" - 9.

Давайте проверим это на практике:

var a = '12' - true;
var b = '1' * false;
var c = false - '-4';
var d = '9' / true;

alert(a);
alert(b);
alert(c);
alert(d);

Результат выполнения кода в браузере:

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

var a = 'привет' - true;
var b = 'голосовчане' * false;
var c = false - 'хорошего вам';
var d = 'дня!' / true;

Все до единой в своих результатах получать NaN. Ибо в своём неявном преобразовании JavaScript будет читать код выше как:

var a = NaN - 1;
var b = NaN * 0;
var c = 0 - NaN;
var d = NaN / 1;

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

Давайте проверим на практике:

var a = 'привет' - true;
var b = 'голосовчане' * false;
var c = false - 'хорошего вам';
var d = 'дня!' / true;

alert(a);
alert(b);
alert(c);
alert(d);

Браузер выдает...

...ровно то, что и ожидалось.

Осталось рассмотреть всего две операции переменных типа Boolean с переменными типа String.

Первая это операция "сложения":

var a = 'привет ' + true;
var b = 'голосовчане ' + false;
var c = false + '13';
var d = true +  '10';

Операция сложения между Boolean и String протекает ровно также, как и операция сложения между String и Number. JavaScript выделит переменные с логическим типом, неявно переведет их к строковому типу и как результат склеит всех участников операции в одну строку. То есть переменные из кода выше получат следующие значения:

"a" = "привет true", "b" = "голосовчане false", "с" = "false13", "d" = "true10".

Другими словами, JavaScript неявно преобразует булевский true в строку вида "true", а булевский false соответственно в строку вида "false".

Вторая операция, на которую стоит обратить внимание имеет вид:

var a = '12' / false;

Если мы выведем результат такой операции в браузере:

var a = '12' / false;
alert(a);

то мы получим:

Почему в результате выдаётся "Infinity"? Потому, что согласно информации которую мы рассмотрели выше, операция var a = '12' / false; после неявного преобразования будет восприниматься JavaScript как var a = 12 / 0;. То есть мы имеем дело с делением на ноль, который рассматривали в предыдущих уроках.
Очевидно, что вместо строки "12" может быть любая другая строка с цифирным значением. Суть операции с делением на ноль от этого не поменяется.

А на сегодня все.

Ссылки на предыдущие уроки:

1. Урок 1.
2. Урок 2.
3. Урок 3.
4. Урок 4.
5. Урок 5.
6. Урок 6.
7. Урок 7.

Продолжение следует...