Объединение строк

'one string ' + ' another string'

Объединение строк еще называется конкатенация

var name = "Dave";
var message = "Hello " + name;

Если хотя бы один аргумент является строкой, то второй будет также преобразован к строке!

alert( '1' + 2 ); // "12"
alert( 2 + '1' ); // "21"

Объединение длинных строк

var visitorName = promt('Как вас зовут?', 'Буряк');
var message = "Привет " + visitorName + '. Добро пожаловать на урок по JavaScript. ' + 'Рад наблюдать за твоими успехами';

message = message + '...';
message += "...."

Основные операторы

Справка на MDN

Все любят математику! :)

Приоритет операторов

Инкремент/декремент: ++, --

Постфиксность

var i = 2;

i++;
alert(i) //3

i--;
alert(i) //2

Префиксность.

var i = 1;
alert( 2 * ++i ); // 4

Инкремент/декремент можно использовать в любых выражениях

var i = 2;

++i;
alert(i) //3

--i;
alert(i) //2

Постфиксная форма i++ отличается от префиксной ++i тем, что возвращает старое значение, бывшее до увеличения.

Сокращенная арифметика

var n = 2;
n = n + 5;
n = n * 2;

var n = 2;
n += 5; // теперь n=7 (работает как n = n + 5)
n *= 2; // теперь n=14 (работает как n = n * 2)

alert( n ); // 14

Оператор запятая

var a = (5, 6);

alert( a );

// три операции в одной строке
for (a = 1, b = 3, c = a*b; a < 10; a++) {
 ...
}

Запятая позволяет перечислять выражения, разделяя их запятой ','. Каждое из них – вычисляется и отбрасывается, за исключением последнего, которое возвращается.

Сравнение строк

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

alert( 'Б' > 'А' ); // true

'a'.charCodeAt(0); //97

Сравнение разных типов

При сравнении значений разных типов, используется числовое преобразование. Оно применяется к обоим значениям.

'2' > 1; // true, сравнивается как 2 > 1
'01' == 1; // true, сравнивается как 1 == 1
false == 0; // true, false становится числом 0
true == 1; // true, так как true становится числом 1.

Строгое равенство

Для проверки равенства без преобразования типов используются операторы строгого равенства

=== (тройное равно) и !==.

0 === false; // false, т.к. типы различны

Сравнение с null и undefined

1. Значения null и undefined равны == друг другу и не равны чему бы то ни было ещё. Это жёсткое правило буквально прописано в спецификации языка.
2. При преобразовании в число null становится 0, а undefined становится NaN.

null > 0; // false       undefined > 0; // false
null == 0; // false      undefined < 0; // false
null >= 0; // true      undefined == 0; // false

Значение undefined вообще нельзя сравнивать:

alert( undefined > 0 ); // false (1)
alert( undefined < 0 ); // false (2)
alert( undefined == 0 ); // false (3)

Несколько условий, else if

Бывает нужно проверить несколько вариантов условия. Для этого используется блок else if.
JavaScript сначала проверит первое условие, если оно ложно — перейдет ко второму — и так далее, до последнего else.

var year = 2015;
if (year < 2015) {
  alert('Это слишком рано...');
} else if (year > 2015) {
  alert('Это поздновато...');
} else {
  alert('OK!');
}

«Тернарный оператор»
вопросительный знак '?'

Вопросительный знак — единственный оператор, у которого есть аж три аргумента, в то время как у обычных операторов их один-два. Поэтому его называют «тернарный оператор».
Последовательность операторов '?' позволяет вернуть значение в зависимости не от одного условия, а от нескольких.

var count = 2;
var text = count == 1 ? 'Apple' : 'Apples';

Что возвращают и как работаю

логические операторы

1. || запинается на «правде», && запинается на «лжи».
2. || - возвращает то значение, на котором остановились вычисления. Причём, не преобразованное к логическому типу.
   Если все значения «ложные», то || возвратит последнее из них.
3. && - Если левый аргумент – false, оператор И возвращает его и заканчивает вычисления. Иначе – вычисляет и возвращает правый аргумент.

Приоритет оператора И && больше, чем ИЛИ ||, так что он выполняется раньше.

alert( 5 || 1 && 0 ); // 5

Строковое преобразование

Строковое преобразование происходит, когда требуется представление чего-либо в виде строки.

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

alert( true + "test" ); // "truetest"
alert( "123" + undefined ); // "123undefined"

alert( String(null) === "null" ); // true

Численное преобразование

Значение

undefined

null

true / false

Строка

Преобразуется в…

NaN

0

1 / 0

Пробельные символы по краям обрезаются. Далее, если остаётся пустая строка, то 0, иначе из непустой строки «считывается» число, при ошибке результат NaN.

var a = +"123"; // 123
var a = Number("123"); // 123, тот же эффект

Логическое преобразование

Значение

undefined, null

Числа

Строки

Объекты

Преобразуется в…

false

Все true, кроме 0, NaN — false.

Все true, кроме пустой строки "" — false

Всегда true

Boolean(null); // false
Boolean("string"); // false

Итого

В JavaScript есть три преобразования:

1. Строковое: String(value) – в строковом контексте или при сложении со строкой. Работает очевидным образом.
2. Численное: Number(value) – в численном контексте, включая унарный плюс +value. Происходит при сравнении разных типов, кроме строгого равенства.
3. Логическое: Boolean(value) – в логическом контексте, можно также сделать двойным НЕ: !!value.

Цикл for

var i;

for (i = 0; i < 3; i++) {
  alert( i );
}

Прерывание цикла: break

var sum = 0;
var value = 0;
while (true) {
  if (!value) break;

  sum += value;
}

Следующая итерация: continue

for (var i = 0; i < 10; i++) {

  if (i % 2 == 0) continue;

  alert(i);
}

// Строки
var str = 'Hello world!';
alert(str.length); // 12
alert(str.toUpperCase()); // "HELLO WORLD!"

// Числа
var n = 12.345;
alert(n.toFixed(2)); // "12.35"
alert(n.toFixed(0)); // "12"
alert(n.toFixed(5)); // "12.34500"

alert(12.toFixed(1)); // ошибка!
alert(12..toFixed(1)); // 12.0

// Длина и доступ к символам

var str = "jQuery";

alert(str.length); // 6

alert(str.charAt(0)); // "j"
alert(str[0]); // "j"

// Смена регистра

alert('Javascript'.toUpperCase()); // JAVASCRIPT
alert('USSR'.toLowerCase()); // ussr

// Поиск подстроки

alert(str.indexOf("j") ); // 0
alert(str.indexOf("Query") ); // 1
alert(str.indexOf("query") ); // -1

Взятие подстроки

var string = 'check it out';

alert(string.substring(1)); // 'heck it out'
alert(string.substring(0, 3)); // 'che'

alert(string.substr(1)); // 'heck it out'
alert(string.substr(0, 3)); // 'che'

• substring(start [, end]) - возвращает подстроку с позиции start до, но не включая end. (slice)

• substr(start [, length]) - аналогично, только второй параметр не коне, а количество символов.

Infinity

alert(12345 / 0); // Infinity
alert(Infinity > 1234567890); // true
alert(Infinity + 5 == Infinity); // true
alert(-1 / 0); // -Infinity

NaN

alert(0 / 0); // NaN
alert(NaN == NaN); // false
alert(NaN === NaN); // false

var n = 0 / 0;
alert(isNaN(n)); // true

// Забавный способ проверки на NaN
alert(n !== n) // true

• Значение NaN «прилипчиво». Любая операция с NaN возвращает NaN.
• Математические операции в JS безопасны.

Преобразование к числу

alert(+"12"); // 12
alert(+"12test"); // NaN
alert(+"  -12"); // -12
alert(+" \n34  \n"); /* 34, перевод строки \n 
                        является пробельным символом */
alert(+""); // 0, пустая строка становится нулем
alert(+"1 2"); // NaN, пробел посередине числа - ошибка

alert("12.34" / "-2"); // -6.17

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

parseInt и parseFloat

alert(parseInt('12px')); // 12
alert(parseFloat('12.3.4')) /* 12.3, ошибка 
                               на второй точке */
alert(parseInt('a123')); // NaN

Функция parseInt и ее аналог parseFloat преобразуют строку символ за символом, пока это возможно.​

Округление

alert(Math.floor(3.1));  // 3
alert(Math.ceil(3.1));   // 4
alert(Math.round(3.1));  // 3
alert(Math.round(3.5));  // 4

Math.floor

Округляет вниз

Math.ceil

Округляет вверх

Math.round

Округляет до ближайшего целого

Округление до заданной точности

var n = 9.34;
alert( n.toFixed(1) ); // "9.3"


var n = 13.36;
alert( n.toFixed(1) ); // "13.4"


var n = 8.24;
alert( n.toFixed(5) ); // "8.24000", добавлены нули до 5 знаков после запятой

Функции общего назначения

Math.sqrt(x) Возвращает квадратный корень из x.

Math.log(x) Возвращает натуральный (по основанию e) логарифм x.

Math.pow(x, exp) Возводит число в степень, возвращает xexp, например Math.pow(2,3) = 8. Работает в том числе с дробными и отрицательными степенями, например: Math.pow(4, -1/2) = 0.5.

Math.abs(x) Возвращает абсолютное значение числа

Math.exp(x) Возвращает ex, где e – основание натуральных логарифмов.

Math.max(a, b, c...) Возвращает наибольший из списка аргументов

Math.min(a, b, c...) Возвращает наименьший из списка аргументов

Math.random() Возвращает псевдо-случайное число в интервале [0,1) – то есть между 0(включительно) и 1(не включая). Генератор случайных чисел инициализуется текущим временем.

Итого

• Числа могут быть записаны в шестнадцатиричной, восьмеричной системе, а также «научным» способом.
• В JavaScript существует числовое значение бесконечность Infinity.
• Ошибка вычислений дает NaN.
• Арифметические и математические функции преобразуют строку в точности в число, игнорируя начальные и конечные пробелы.
• Функции parseInt/parseFloat делают числа из строк, которые начинаются с числа.
• Есть четыре способа округления: Math.floor, Math.round, Math.ceil и битовый оператор. Для округления до нужного знака используйте +n.toFixed(p) или трюк с умножением и делением на10p.
• Дробные числа дают ошибку вычислений. При необходимости ее можно отсечь округлением до нужного знака.
• Случайные числа от 0 до 1 генерируются с помощью Math.random(), остальные – преобразованием из них.