Вы знакомы с арифметикой? Умеете складывать и вычитать числа? JavaScript тоже умеет складывать и вычитать. В JavaScript есть такие операторы: сложения +, вычитание -, деление /, умножение *, деление с возвратом остатка %.
Var one = 121;
var two = 13;
alert(one + two);
alert(one - two);
alert(one * two);
alert(one / two);
alert(one % two);
Усложним пример 1
Var answer = ((121 - 12) * 103) + 200;
alert(answer);
Усложним пример 2
Var PI = 3.14;
alert(answer);
И третий пример усложним
Var PI = 3.14;
var answer = ((121 - 12) * 103) + PI;
var answerEnd = (2 * answer * PI) + (-100);
alert(answerEnd);
И даже так можно сделать
Var answer = 101 + (-(-100));
alert(answer);
Но это ерунда, по сравнению с тем, что еще умеет JavaScript. Для этого есть стандартный объект Math с множеством свойств (свойства и есть операции, в данном контексте).
Math.pow(2, 53) /* -> 2 в степени 53 */
Math.round(0.6) /* -> 1.0 - округление до ближайшего целого */
Math.ceil(0.6) /* -> 1.0 - округление вверх */
Math.floor(0.6) /* -> 0.0 - округление вниз */
Math.abs(-5) /* -> 5 - модуль, абсолютное значение */
Math.max(x, y, z) /* -> Возвращает наибольший аргумент */
Math.min(x, y, z) /* -> Возвращает наименьший аргумент */
Math.random(); /* -> Где число на выходи больше 0, но меньше 1 */
Math.PI /* -> Число Пи */
Math.E /* -> Основание натурального логарифма */
Math.sqrt(3) /* -> Корень квадратный из 3 */
Math.pow(3, 1/3) /* -> Корень кубический из 3 */
Math.sin(0) /* -> Тригонометрия: имеются так же Math.cos, Math.atan и другие */
Math.log(10) /* -> Натуральный логарифм 10 */
Math.log(100) / Math.LN10 /* -> Логарифм 100 по основанию 10 */
Math.log(512) / Math.LN2 /* -> Логарифм 512 по основанию 2 */
Math.exp(3) /* -> Math.E в кубе */
Как использовать объект Math?
/* Первый пример */
var twoInPow = Math.pow(2, 53);
alert(twoInPow);
/* Второй пример */
var valueRaund = 0.1312;
var answerRaunt = Math.round(valueRaund);
alert(answerRaunt);
/* Третий пример */
var valueRaund = 0.1312;
alert(Math.round(valueRaund));
/* Четвертый пример: поиск наибольшего из трех чисел */
var a = 12, b = 11, c = 10;
alert(Math.max(a, b, c));
В случае выхода из диапазона, потери значащих разрядов или деления на ноль, JavaScript не выдает ошибку. Если результат будет слишком большой и выйдет из диапазона, то будет возвращено специальное значение «бесконечность», выглядит оно так « Infinity ».
Потеря значащих разрядов: результат арифметической операции оказывается очень близким к нулю. Если все же потеря была, то будет возвращен 0 (ноль).
Глобальная переменная NaN означает «не число». Есть одна особенность у этой переменной, операция проверки на равенство (==) всегда возвращает отрицательный результат и даже если его сравнивать с самим собой.
/* Так писать нельзя */
if (x == NaN) { ... }
Чтобы определить, является ли значение переменной x значением NaN, нужно использовать конструкцию, которая ниже. Эта проверка будет иметь значение true только тогда, когда x будет равен NaN
Напоминаю, что это вводный курс по JavaScript для начинающих . Сегодня мы рассмотрим, какие операторы существуют в JavaScript . Пристегните ремни! Букаф будет много.
Когда у вас есть кучка данных, то с ними нужно что-то сделать. Делами-то как раз и заняты операторы. Они вечно что-то складывают, перемножают, делят, отнимают, сравнивают, присваивают и еще черти чем занимаются. Без операторов в программировании просто каши не сваришь.
В языке JavaScript используются следующие виды операторов:
- Арифметические операторы
- Операторы присваивания
- Операторы сравнения
- Логические операторы
- Строковые операторы
- Условные операторы
Это далеко не полный список, но для начала хватит и этого за глаза. Разберем каждый вид представленных операторов, зачем они нужны и с чем их едят. Поехали!
Арифметические операторы в JavaScriptС арифметическими операторами все вы знакомы еще со школы. Это обычные знаки сложения, вычитания, деления и умножения: + , - , / , * . Соответственно, выполняют они в программировании те же самые функции, что и в обычной математике. Сложностей с этим у вас не возникнет.
Данные, с которыми работают операторы, называются операндами .
2 + 3 // здесь числа 2 и 3 - операнды, а знак + - оператор сложения
Как и в математике у арифметических операторов есть свои приоритеты: умножение и деление имеют более высокий приоритет, чем сложение и вычитание.
2 + 3 * 4 // здесь сначала выполняется умножение, а уже потом сложение
И так же, как в математике, активно используются скобки, чтобы изменить приоритет:
(2 + 3) * 4 // здесь сначала выполняется сложение, а потом умножение
Кстати, знак = тоже оператор. Как мы уже выяснили в статье про , это оператор присваивания, а вовсе не знак равенства. Не забывайте об этом!
Оператор деления по модулюА теперь рассмотрим более интересные арифметические операторы. И первым станет значок процентов - % . В JavaScript это не проценты от слова совсем. Так в программировании обозначается деление по модулю. Результатом такой операции будет остаток от деления. Например:
100 % 22 // остаток будет равен 12
100 % 10 // остаток будет равен 0
При вычислениях этот оператор имеет тот же приоритет, что и умножение с делением, так что не забывайте ставить скобочки.
Совмещение операторовОператор = можно и нужно совмещать с другими операторами, чтобы сократить запись. Пример:
var n = 2; // присваиваем переменной n значение 2
n = n + 3; // присваиваем переменной n новое значение n + 2, получаем 5
То же самое можно записать так:
var n = 2;
n += 3; // равносильно записи n = n + 3
Среди арифметических операторов есть парочка весьма любопытных - инкремент и декремент . Обозначаются соответственно ++ и –– . Первый увеличивает переменную на единицу, а второй уменьшает. Эта фишка очень часто используется в программировании, так как предоставляет массу удобств. Чаще всего ее можно встретить в условных выражениях, но об этом позже.
У обоих операторов есть определенное местоположение в записи. Они могут быть как в префиксной форме (перед переменной) ++n , так и в постфиксной (после переменной) n++ . Разница огромна! Никогда не путайте эти формы и хорошенько запомните их. Если эти операторы стоят перед переменной, то в результате увеличивают ее значение на 1. Но! Если они стоят после переменной, то возвращают исходное значение. Пример:
var n = 2, m = 0;
m = ++n // увеличивает n на 1 (n = 3) и присваивает m тоже значение 3
var n = 2, m = 3;
m = n++ // увеличивает n на 1 (n = 3), но присваивает m предыдущее значение n = 2
С первым примером, уверен, вы легко разберетесь. А вот со вторым могут возникнуть проблемы. Чтобы легче было понять эту штуку и не запутаться, просто представьте, что вы сначала присвоили переменной m значение переменной n , а уже после этого увеличили значение n на единицу. В первом же примере вы сначала увеличили значение n на единицу, а потом уже присвоили это значение переменной m .
На этом с арифметическими операторами все. Разумеется, есть еще куча вариаций и тонкостей использования этих простых операторов, но для начала вам этого будет более чем достаточно.
Операторы сравненияИ снова вспоминаем математику. Знаки знакомы всем и каждому. В программировании они называются операторами сравнения . В JavaScript используются следующие операторы сравнения:
< меньше
> больше
= больше или равно
== равно
!= не равно
=== строго равно
!== строго не равно
Обратите внимание, что знак «больше или равно» пишется именно так >= , а не => . То есть, стрелка стоит перед знаком равно, а не после него.
Операторы сравнения позволяют сравнивать значения переменных и результатом этой операции всегда выступает булево значение true или false . Обычно их применяют в условных выражениях. От того, что дает результат сравнение зависит, какая часть кода будет выполняться дальше.
В JavaScript можно сравнивать разные типы данных одновременно, например, число и строку:
12345 == "12345" // true
Просто в этом случае строка автоматически преобразуется в число. Строгое же равенство === или неравенство!== используются только при сравнении переменных одинакового типа.
Логические операторыЛогические операции в JavaScript - это одна из довольно мудреных тем для начинающих. С ней стоит хорошенько разобраться, чтобы успешно идти дальше в освоении языка. Они чаще всего применяются вместе с операциями сравнения и выдают булево значение true или false .
Логических операторов три:
&& (И)
|| (ИЛИ)
! (НЕ)
Оператор && выполняет операцию «логическое И» над двумя значениями. При этом он возвращает true тогда и только тогда, когда оба операнда имеют значение true . Если же один или оба операнда имеют значение false , то оператор возвращает false . Примеры:
2 < 3 && 4 < 5 // true
2 < 3 && 5 < 4 // false
3 < 2 && 5 < 4 // false
У логических операторов приоритет меньше, чем у операторов сравнения, поэтому в приведенных примерах мы обходимся без скобок. Понятно, что сначала мы сравниваем числа между собой, а уже потом применяем логику.
Логический оператор || (ИЛИ)С логическим оператором || (ИЛИ) другая песня. Оператор || выполняет операцию «логическое ИЛИ» над двумя операндами. Если один или оба операнда имеют истинное значение, он возвращает истинное значение. Если оба операнда имеют ложные значения, он возвращает ложное значение. Примеры:
2 < 3 || 4 < 5 // true
2 < 3 || 5 < 4 // true
3 < 2 || 5 < 4 // false
У логических операторов есть одна хитрость. Они не любят лишней работы. Как, впрочем, и я. Свои вычисления они всегда начинают слева направо. И если первая часть выражения соответствует их условиям, то остальную часть выражения они даже не вычисляют.
К примеру, если оператор || находит истинное значение в самом начале, то сразу дает истинное значение, а остальное уже не проверяет. Также и оператор && , если находит в самом начале ложное выражение, то сразу дает ложный результат, а остальную часть не проверяет.
И еще одна фишка: приоритет у оператора И && больше, чем у ИЛИ || , поэтому он выполняется раньше:
2 < 3 || 4 < 5 && 5 < 6 // здесь сначала будет выполнено вычисление в правой части, а потом уже в левой
Логический оператор! (НЕ)Логический оператор! обозначает «логическое НЕ». Он используется только с одним операндом и меняет значение этого операнда на противоположное. Если значение n истинно, то значение!n будет ложным. Так как этот оператор можно прикрутить лишь к одному операнду, то чтобы инвертировать целое выражение, его надо взять в скобки!(n && m) .
Строковые операторыПро строковые операторы мы уже говорили ранее. Это тот самый плюс + что используется для соединения строковых переменных, или иначе - для конкатенации (сложения строк). Пример:
"Игорь " + "Квентор" == "Игорь Квентор"
Обратите внимание, что в первом слове добавлен пробел перед закрывающей кавычкой. Если его не добавить, то строки сольются в одно слово "ИгорьКвентор" .
У этого оператора есть одна особенность: если в выражении есть хоть одна строка, то он и все остальные аргументы приводит к строковому типу. Например:
Остальные арифметические операторы работают только с числами и всегда приводят аргументы к числу.
Условные операторыВ JavaScript есть два условных оператора if и?: Хотя, если быть точным, то if - это вообще-то управляющая инструкция и довольно обширная, с кучей плюшек и интересных особенностей. Поэтому о ней будет отдельная статья. Пока же рассмотрим более простой условный оператор?:
Обычно этот оператор записывается как?: Но в программах он выглядит иначе. Он имеет три операнда. Первый операнд предшествует символу? , второй стоит между символами? и: третий - после:
условие? значение 1: значение 2
Смысл его работы прост: если выполняется поставленное условие, то возвращается значение 1, если же нет - значение 2. Этот условный оператор часто служит более простой заменой инструкции if , когда в последней нет особой необходимости. При этом и сама запись сокращается и ее легче прочесть.
Пока на этом все!
Надеюсь, с операторам в JavaScript вы теперь немного разобрались. А чтобы мозг не закипел, вот вам короткий мульт для расслабления - Программист может все! :)
Последнее обновление: 1.11.2015
Математические операцииJavaScript поддерживает все базовые математические операции:
Сложение :
Var x = 10; var y = x + 50;
Вычитание :
Var x = 100; var y = x - 50;
Умножение :
Var x = 4; var y = 5; var z = x * y;
Деление :
Var x = 40; var y = 5; var z = x / y;
Деление по модулю (оператор %) возвращает остаток от деления:
Var x = 40; var y = 7; var z = x % y; console.log(z); // 5
Результатом будет 5, так как наибольшее целое число, которое меньше или равно 40 и при этом делится на 7 равно 35, а 40 - 35 = 5.
Инкремент :
Var x = 5; x++; // x = 6
Оператор инкремента ++ увеличивает переменную на единицу. Существует префиксный инкремент, который сначала увеличивает переменную на единицу, а затем возвращает ее значение. И есть постфиксный инкремент, который сначала возвращает значение переменной, а затем увеличивает его на единицу:
// префиксный инкремент var x = 5; var z = ++x; console.log(x); // 6 console.log(z); // 6 // постфиксный инкремент var a = 5; var b = a++; console.log(a); // 6 console.log(b); // 5
Постфиксный инкремент аналогичен операции:
A = a + 1; // a++
Декремент уменьшает значение переменной на единицу. Также есть префиксный и постфиксный декремент:
// префиксный декремент var x = 5; var z = --x; console.log(x); // 4 console.log(z); // 4 // постфиксный декремент var a = 5; var b = a--; console.log(a); // 4 console.log(b); // 5
Как и принято в математике, все операции выполняются слева направо и различаются по приоритетам: сначала операции инкремента и декремента, затем выполняются умножение и деление, а потом сложение и вычитание. Чтобы изменить стандартный ход выполнения операций, часть выражений можно поместить в скобки:
Var x = 10; var y = 5 + (6 - 2) * --x; console.log(y); //41
Операции присваиванияПриравнивает переменной определенное значение: var x = 5;
Сложение с последующим присвоением результата. Например:
Var a = 23; a += 5; // аналогично a = a + 5 console.log(a); // 28
Вычитание с последующим присвоением результата. Например:
Var a = 28; a -= 10; // аналогично a = a - 10 console.log(a); // 18
Умножение с последующим присвоением результата:
Var x = 20; x *= 2; // аналогично x = x * 2 console.log(x); // 40
Деление с последующим присвоением результата:
Var x = 40; x /= 4; // аналогично x = x / 4 console.log(x); // 10
Получение остатка от деления с последующим присвоением результата:
Var x = 10; x %= 3; // аналогично x = x % 3 console.log(x); // 1, так как 10 - 3*3 = 1
Как правило, для проверки условия используются операторы сравнения. Операторы сравнения сравнивают два значения и возвращают значение true или false:
Оператор равенства сравнивает два значения, и если они равны, возвращает true, иначе возвращает false: x == 5
Оператор тождественности также сравнивает два значения и их тип, и если они равны, возвращает true, иначе возвращает false: x === 5
Сравнивает два значения, и если они не равны, возвращает true, иначе возвращает false: x != 5
Сравнивает два значения и их типы, и если они не равны, возвращает true, иначе возвращает false: x !== 5
Сравнивает два значения, и если первое больше второго, то возвращает true, иначе возвращает false: x > 5
Сравнивает два значения, и если первое меньше второго, то возвращает true, иначе возвращает false: x < 5
Сравнивает два значения, и если первое больше или равно второму, то возвращает true, иначе возвращает false: x >= 5
Сравнивает два значения, и если первое меньше или равно второму, то возвращает true, иначе возвращает false: x 50 && percent < 12; console.log(result); //true
Возвращает true, если хотя бы одна операция сравнения возвращают true, иначе возвращает false:
Var income = 100; var isDeposit = true; var result = income > 50 || isDeposit == true; console.log(result); //true
Возвращает true, если операция сравнения возвращает false:
Var income = 100; var result1 = !(income > 50); console.log(result1); // false, так как income > 50 возвращает true var isDeposit = false; var result2 = !isDeposit; console.log(result2); // true
Строки могут использовать оператор + для объединения. Например:
Var name = "Том"; var surname = "Сойер" var fullname = name + " " + surname; console.log(fullname); //Том Сойер
Если одно из выражений представляет строку, а другое - число, то число преобразуется к строке и выполняется операция объединения строк:
Var name = "Том"; var fullname = name + 256; console.log(fullname); //Том256
В конце напишем небольшую программу, которая продемонстрирует работу с операциями над переменными. Для этого определим следующую веб-страницу index.html:
JavaScript var sum = 500; // сумма вклада var percent = 10; // процент по вкладу var income = sum * percent / 100; // доход по вкладу sum = sum + income; // определяем новую сумму console.log("Доход по вкладу: " + income); console.log("Сумма вклада после первого года: " + sum);
В скрипте объявляются три переменных: sum, percent и income. Переменная income вычисляется по остальным двум переменным с помощью операций умножения и деления. И в конце ее значение суммируется с значением переменной sum.
Выражения в JavaScript представляют собой комбинации операндов и операторов .
Операции в выражениях выполняются последовательно в соответствии со значением приоритета (чем больше значение приоритета, тем он выше). Возвращаемый результат не всегда имеет значение того же типа, что и тип обрабатываемых данных. Например, в операциях сравнения участвуют операнды различных типов, но возвращаемый результат всегда будет логического типа.
Рис. 1. Структура выражения в JavaScriptОперанды — это данные, обрабатываемые сценарием JavaScript. В качестве операндов могут быть как простые типы данных, так и сложные, а также другие выражения.
Операторы — это символы языка, выполняющие различные операции с данными. Операторы могут записываться с помощью символов пунктуации или ключевых слов.
В зависимости от количества операндов различают следующие типы операторов:
унарный
— в операции участвует один операнд;
бинарный
— в операции участвуют два операнда;
тернарный
— комбинирует три операнда.
Простейшая форма выражения — литерал — нечто, вычисляемое само в себя, например, число 100 , строка "Hellow world" . Переменная тоже может быть выражением, так как она вычисляется в присвоенное ей значение.
Выражения и операторы в JavaScript 1. Арифметические операторыАрифметические операторы предназначены для выполнения математических операций, они работают с числовыми операндами (или переменными, хранящими числовые значения), возвращая в качестве результата числовое значение.
Если один из операндов является строкой, интерпретатор JavaScript попытается преобразовать его в числовой тип, а после выполнить соответствующую операцию. Если преобразование типов окажется невозможным, будет получен результат NaN (не число).
+ Сложение | Складывает числовые операнды. Если один из операндов — строка, то результатом выражения будет строка. | 12 |
- Вычитание | Выполняет вычитание второго операнда из первого. | 12 |
- Унарный минус | Преобразует положительное число в отрицательное, и наоборот. | 14 |
* Умножение | Умножает два операнда. | 13 |
/ Деление | Делит первый операнд на второй. Результатом деления может являться как целое, так и число с плавающей точкой. | 13 |
% Деление по модулю (остаток от деления) | Вычисляет остаток, получаемый при целочисленном делении первого операнда на второй. Применяется как к целым числам, так и числам с плавающей точкой. | 13 |
Операторы присваивания используются для присваивания значений переменным. Комбинированные операторы позволяют сохранить первоначальное и последующее значение в одной переменной.
var a = 5; // присваиваем переменной a числовое значение 5 var b = "hellow"; // сохраняем в переменной b строку hellow var m = n = z = 10; // присваиваем переменным m, n, z числовое значение 10 x += 10; // равнозначно x = x + 10; x -= 10; // равнозначно x = x - 10; x *= 10; // равнозначно x = x * 10; x /= 10; // равнозначно x = x / 10; x %= 10; // равнозначно x = x % 10; 3. Операторы инкремента и декрементаОперации инкремента и декремента являются унарными и производят увеличение и уменьшение значения операнда на единицу. В качестве операнда может быть переменная, элемент массива, свойство объекта. Чаще всего такие операции используются для увеличения счетчика в цикле.
var x = y = m = n = 5, z, s, k, l; z = ++x * 2; /* в результате вычислений вернет значение z = 12, x = 6, т.е. значение x сначала увеличивается на 1, а после выполняется операция умножения */ s = y++ * 2; /* в результате вычислений вернет значение s = 10, y = 6, т.е. сначала выполняется операция умножения, а после в переменной y сохраняется увеличенное на 1 значение */ k = --m * 2; // вернет значение k = 8, m = 4 l = n-- * 2; // вернет значение l = 10, n = 4 4. Операторы сравненияОператоры сравнения используются для сопоставления операндов, результатом выражения может быть одно из двух значений — true или false . Операндами могут быть не только числа, но и строки, логические значения и объекты. Однако сравнение может выполняться только для чисел и строк, поэтому операнды, не являющиеся числами или строками, преобразуются.
Если оба операнда не могут быть успешно преобразованы в числа или строки, операторы всегда возвращают false .
Если оба операнда являются строками/числами или могут быть преобразованы в строки/числа, они будут сравниваться как строки/числа.
Если один операнд является строкой/преобразуется в строку, а другой является числом/преобразуется в число, то оператор попытается преобразовать строку в число и выполнить сравнение чисел. Если строка не является числом, она преобразуется в значение NaN и результатом сравнения будет false .
Чаще всего операции сравнения используются при организации ветвлений в программах.
== Равенство | Проверяет две величины на совпадение, допуская преобразование типов. Возвращает true , если операнды совпадают, и false , если они различны. | 9 |
!= Неравенство | Возвращает true , если операнды не равны | 9 |
=== Идентичность | Проверяет два операнда на «идентичность», руководствуясь строгим определением совпадения. Возвращает true , если операнды равны без преобразования типов. | 9 |
!== Неидентичность | Выполняет проверку идентичности. Возвращает true , если операнды не равны без преобразования типов. | 9 |
> Больше | Возвращает true , если первый операнд больше второго, в противном случае возвращает false . | 10 |
>= Больше или равно | Возвращает true , если первый операнд не меньше второго, в противном случае возвращает false . | 10 |
Возвращает true , если первый операнд меньше второго, в противном случае возвращает false . | 10 | |
Возвращает true , если первый операнд не больше второго, в противном случае возвращает false . | 10 |
Логические операторы позволяют комбинировать условия, возвращающие логические величины. Чаще всего используются в условном выражении if .
(2 < 3) && (3===3); // вернет true, так как выражения в обеих скобках дают true (x < 10 && x > 0); // вернет true, если значение x принадлежит промежутку от 0 до 10 !false; // вернет true 6. Побитовые операторыПобитовые операторы работают с операндами как с 32-битной последовательностью нулей и единиц и возвращают числовое значение, означающее результат операции, записанное в десятичной системе счисления. В качестве операндов рассматриваются целые числа, дробная часть операнда отбрасывается. Побитовые операции могут использоваться, например, при шифровании данных, для работы с флагами, разграничения прав доступа.
& Побитовый И | Если оба бита равны 1 , то результирующий бит будет равен 1 . В противном случае результат равен 0 . | 8 |
| Побитовый ИЛИ | Если один из операндов содержит в позиции 1 , результат тоже будет содержать 1 в этой позиции, в противном случае результат в этой позиции будет равен 0 . | 6 |
^ Исключающее ИЛИ | Если одно, и только одно значение содержит 1 в какой-либо позиции, то и результат будет содержать 1 в этой позиции, в противном случае результат в этой позиции будет равен 0 . | 7 |
~ Отрицание | Выполняется операция побитового отрицания над двоичным представлением значения выражения. Любая позиция, содержащая 1 в исходном выражении, заменяется на 0 . Любая позиция, содержащая 0 в исходном выражении, становится равной 0 . Положительные числа начинаются с 0 , отрицательные - с -1 , поэтому ~ n == -(n+1) . | 14 |
Оператор сдвигает биты первого операнда влево на число битовых позиций, установленных вторым операндом. Для заполнения позиций справа используются нули. Возвращают результат того же типа, что левый операнд. | 11 | |
>> Побитовый сдвиг вправо | Оператор сдвигает биты первого операнда вправо на число битовых позиций, установленных вторым операндом. Цифры, сдвинутые за пределы диапазона, удаляются. Самый старший бит (32й) не меняется, чтобы сохранить знак результата. Если первый операнд положителен, старшие биты результата заполняются нулями; если первый операнд отрицателен, старшие биты результата заполняются единицами. Сдвиг значения вправо на одну позицию эквивалентен делению на 2 (с отбрасыванием остатка), а сдвиг вправо на две позиции эквивалентен делению на 4 и т. д. | 11 |
>>> Побитовый сдвиг вправо без учета знака | Оператор сдвигает биты первого операнда вправо на число битовых позиций, установленных вторым операндом. Слева добавляются нули независимо от знака первого операнда. Цифры, сдвинутые за пределы диапазона, удаляются. | 11 |
Существует несколько операторов, которые работают со строками особым образом.
"1" + "10"; // вернет "110" "1" + 10; // вернет "110" 2 + 5 + " цветных карандашей"; // вернет "7 цветных карандашей" "Цветных карандашей " + 2 + 5; // вернет "Цветных карандашей 25" "1" > "10"; // вернет false "10" 10 ? x * 2: x / 2; // возвращает значение x * 2, если x > 10, в противном случае x / 2 9. Комментарии в JavaScriptОднострочный комментарий: перед текстом комментария нужно поставить символы // .