JS

  • Преобразование типов

  • Структура кода

  • Операторы

  • Операторы сравнения

  • Структура кода

  • use strict

Преобразование типов

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

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

Например, alert(value) преобразует значение к строке.

Также мы можем использовать функцию String(value)

let value = true;
console.log(typeof value); // boolean

value = String(value); // теперь value это строка "true"
console.log(typeof value); // string
let value = 10;
value = String(value); 

console.log(typeof value);

console

String

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

Number(value)

let str = "123";

console.log(typeof str); // string

let num = Number(str); // становится числом 123

console.log(typeof num); // number
let age = Number("Любая строка вместо числа");

console.log(age); // NaN, преобразование  не удалось
console.log( "6" / "2" );
console.log( "6" / "два" );
console.log( "6" * "2" );

console

console

console

3

Nan

12

Неявное приведение типов

console.log( "6" + "2" );

console

62

console.log( Number("   123   ") ); // 123
console.log( Number("123z") );      // NaN
console.log( Number(true) );        // 1
console.log( Number(false) );       // 0

console.log( Number(null) );        // 0

console.log( Number(undefined) );   // NaN

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

console.log( Boolean(1) );         // true
console.log( Boolean(0) );         // false

console.log( Boolean("Привет!") ); // true
console.log( Boolean("") );        // false

 

 

console.log( Boolean("  ") ); 
// true

?

Операторы

Что такое оператор?

Сложение +, умножение *, вычитание - и так далее.

Что такое операнд?

Операнд – то, к чему применяется оператор. Например, в умножении 5 * 2 есть два операнда: левый операнд равен 5, а правый операнд равен 2. Иногда их называют «аргументами» вместо «операндов».

Унарный оператор

let x = 1;

x = -x;
console.log( x ); // -1

Бинарный оператор

let x = 1, y = 3;
console.log( y - x ); // 2, бинарный минус

Преобразование к числу, унарный плюс +

// Не влияет на числа
let x = 1;
console.log( +x ); // 1

let y = -2;
console.log( +y ); // -2

// Преобразует не-числа в число
console.log( +true ); // 1
console.log( +"" );   // 0

Унарный, то есть применённый к одному значению, плюс + ничего не делает с числами. Но если операнд не число, унарный плюс преобразует его в число.

let a, b, c;

a = b = c = 2 + 2;

console.log( a ); // 4
console.log( b ); // 4
console.log( c ); // 4

Давайте отметим, что в таблице приоритетов также есть оператор присваивания =. У него один из самых низких приоритетов: 3.

Именно поэтому, когда переменной что-либо присваивают, например, x = 2 * 2 + 1, то сначала выполнится арифметика, а уже затем произойдёт присваивание =.

Остаток от деления %

console.log( 5 % 2 ); // 1, остаток от деления 5 на 2
console.log( 8 % 3 ); // 2, остаток от деления 8 на 3
console.log( 6 % 3 ); // 0, остаток от деления 6 на 3

Возведение в степень **

console.log( 2 ** 2 ); // 4  (2 * 2)
console.log( 2 ** 3 ); // 8  (2 * 2 * 2)
console.log( 2 ** 4 ); // 16 (2 * 2 * 2 * 2)

Инкремент/декремент

let counter = 2;
counter++;        // работает как counter = counter + 1
console.log( counter ); // 3
let counter = 2;
counter--;

1

  • Когда оператор идёт после переменной – это «постфиксная форма»: counter++.
  • «Префиксная форма» – это когда оператор идёт перед переменной: ++counter.

Разница между постфиксной и префиксной формами:

let counter = 1;
let a = ++counter; // (*)

console.log(a); // 2
let counter = 1;
let a = counter++; // (*) меняем ++counter на counter++

console.log(a); // 1

В первом случае в переменную a запишется сразу увеличенное число. Во втором же случае в a запишется старое значение, т.к counter увеличится после присваивания! (a = counter++)

Сокращённая арифметика с присваиванием

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

console.log( n ); // 14
let n = 2;

n *= 3 + 5;

console.log( n ); // 16  
//(сначала выполнится правая часть, превратив выражение в n *= 8)

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

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

  • Больше/меньше: a > b, a < b.
  • Больше/меньше или равно: a >= b, a <= b.
  • Равно: a == b. Обратите внимание, для сравнения используется двойной знак равенства =. Один знак равенства a = b означал бы присваивание.
  • Не равно. В математике обозначается символом ≠. В JavaScript записывается как знак равенства с предшествующим ему восклицательным знаком: a != b.

Результат сравнения имеет логический тип

Операторы сравнения, как и другие операторы, возвращают значение. Это значение имеет логический тип.

  • true – означает «да», «верно», «истина».
  • false – означает «нет», «неверно», «ложь».
console.log( 2 > 1 );  // true (верно)
console.log( 2 == 1 ); // false (неверно)
console.log( 2 != 1 ); // true (верно)
let result = 5 > 4; 
// результат сравнения присваивается переменной result
console.log( result ); // true

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

Чтобы определить, что одна строка больше другой, JavaScript использует «алфавитный» или «лексикографический» порядок.

Другими словами, строки сравниваются посимвольно.

console.log( 'Я' > 'А' ); // true
console.log( 'Кот' > 'Код' ); // true
console.log( 'Сонный' > 'Сон' ); // true

Алгоритм сравнения двух строк:

  1. Сначала сравниваются первые символы строк.
  2. Если первый символ первой строки больше (меньше), чем первый символ второй, то первая строка больше (меньше) второй.
  3. Если первые символы равны, то таким же образом сравниваются уже вторые символы строк.
  4. Сравнение продолжается, пока не закончится одна из строк.
  5. Если обе строки заканчиваются одновременно, то они равны. Иначе, большей считается более длинная строка.

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

При сравнении значений разных типов, JavaScript приводит каждое из них к числу.

console.log( '2' > 1 ); // true, строка становится числом 2
console.log( 'f' == 1 ); // true, строка становится числом 1
console.log( true == 1 ); // true
console.log( false == 0 ); // true

Логическое значение true становится 1, а false – 0.

Забыли      ==

Запомнили   ===

!!!!

console.log( 0 == false ); // true

Использование обычного сравнения == может вызывать проблемы. Например, оно не отличает 0 от false:

Та же проблема с пустой строкой:

console.log( '' == false ); // true

Это происходит из-за того, что операнды разных типов преобразуются оператором == к числу. В итоге, и пустая строка, и false становятся нулём.

Оператор строгого равенства === проверяет равенство без приведения типов.

Если переменные a и b имеют разные типы, то проверка a === b немедленно возвращает false без попытки их преобразования.

console.log( 0 === false ); 
// false, так как сравниваются разные типы (число !== логический)

Ещё есть оператор строгого неравенства !==, аналогичный !=

Забыли:        !=

Запомнили:    !==

Структура кода и рекомендации по стилю

Немного правил, как писать красивый код. Пользуйтесь этой картинкой, как шпаргалкой!

Пригодится в будущем

Короткая статья. Прочитайте ее!

https://learn.javascript.ru/structure

JS_3

By Techno School

Made with Slides.com

JS_3

  • 18

More from Techno School