Что такое JavaScript?
JavaScript — это прототипно-ориентированный язык сценариев, поддерживающий объектно-ориентированный, императивный и функциональный стили программирования.
Вопреки популярному мнению, JavaScript не имеет ничего общего с Java. Изначально, когда язык создавался как способ программирования веб-страниц в браузере Netscape Navigator, он назывался LiveScript, но ввиду огромной популярности в то время языка программирования Java, LiveScript был переименован в JavaScript.
Области использования JavaScript
Созданный Бренданом Эйхом в 1995 году, он появился как язык, который разработчики могли бы использовать для создания интерактивных браузерных приложений. На сегодняшний же день JS имеет огромную популярность и превратился из чисто интерфейсного языка в тот, который можно использовать для “полного стека” (браузер + сервер).
JavaScript также можно использовать при тестировании программных приложений, в базах данных, и даже для решений IOT (Internet of Things). Благодаря такой эволюции он стал универсальным языком программирования и, возможно, одним из самых полезных для изучения в наши дни.
JavaScript — это язык для браузеров. Браузер понимает его благодаря встроенному движку, который считывает код JavaScript и интерпретирует его. Затем браузер действует в соответствии с “инструкциями”, будь то изменение текста элемента на экране, выполнение арифметических операций и отображение результата в браузере.
JavaScript имеет полную интеграцию с HTML и CSS, и мы можем встроить “скрипты“ — программы, написанные на JavaScript, в любой HTML-документ.
Тег
Для добавления «скриптов» на HTML-страницу используется тег script. Таких тегов на HTML-странице может быть сколько угодно. Как и в случае с CSS, к HTML-документу мы можем подключить и внешние скрипты. Для этого с помощью атрибута src нужно указать путь к файлу с расширением .js, содержащему нашу программу:
Стоит отметить, что если имеется атрибут src, программный код внутри тега script будет проигнорирован. В статье “Основы HTML“ мы научились создавать веб-страницу. Теперь подключим к ней простой скрипт:
Document
alert('Привет. ');
Открыв HTML-страницу в браузере, мы увидим данное сообщение:
Что такое инструкции?
alert(‘Привет. ‘) — это инструкция JavaScript, которая показывает диалоговое окно браузера с необязательным сообщением и кнопкой “ОК“.
JavaScript-приложения состоят из инструкций — команд, выполняющих различные действия: объявление переменной; функции; запустить или прервать цикл; выполнить условную инструкцию и т.д. Инструкций может быть столько, сколько мы захотим, и все инструкции имеют определённый синтаксис.
// Инструкция объявления и инициализации переменной
let age = 26;
Для группировки нескольких инструкций может использоваться блок инструкций. Блок отделяется парой фигурных скобок — “ <> “ и может иметь название:
Document
// Инструкция объявления функции sayHello
function sayHello () // Две инструкции заключённые в блок внутри объявленной функции
let name = 'Name';
alert(`Hello $. `);
>;
// Инструкция вызова функции sayHello
sayHello();
Инструкции отделяются друг от друга символом “ ; “. Хотя он и не обязателен, но бывают ситуации, когда игнорирование точки с запятой в конце инструкции может привести к непредвиденным ошибкам в программе, которые довольно сложно обнаружить и исправить.
Использование комментариев
Большое количество инструкций в программе может вызвать ещё большее количество путаницы при чтении кода этой программы человеком. Хорошей практикой при написании программы является оставление комментариев с пояснениями, что делает тот или иной блок кода.
Комментарии бывают двух типов: однострочные — начинаются с двойной косой черты: “ // “, и многострочные — начинаются с косой черты со звёздочкой и заканчиваются звёздочкой и косой чертой: “ /* */ “.
Document
// Я однострочный комментарий
alert('Привет. ');
/* А вот я -
многострочный */
Комментарии в JavaScript можно оставлять в любом месте. Это никак не повлияет на работу программы, поскольку интерпретатор браузера попросту проигнорирует их. Поэтому и код, заключённый в комментарий выполнен браузером не будет:
Document
// Я однострочный комментарий
alert('Привет. ');
/* alert('Эта инструкция закомментирована и браузер проигнорирует её');*/
Что такое переменные?
Компьютеры работают с информацией. Эта информация представлена в виде данных. Данные можно читать, данные можно обрабатывать, данные можно создавать или вообще ничего с ними не делать. Но также данные нужно где-то хранить.
В JavaScript для этого существуют переменные — или “именованное хранилище данных”. Однако недостаточно просто написать какое-либо название переменной. Программе нужно сказать, что это переменная, а также присвоить этой переменной данные.
До 2015 года единственным способом объявления переменной было использование ключевого слова var. С приходом более современной спецификации ECMAScript 6 на смену уже устаревшему var пришли let и const.
Все три способа объявления переменной имеют различия. Ключевым же является определение с помощью const («константы») переменной, которую в дальнейшем уже нельзя переопределить. Чтобы присвоить переменной значение, используется оператор присвоения: «=».
Вспомним пример выше:
/* С помощью ключевого слова let объявили переменную age и присвоили ей значение 26 */
let age = 26;
Существуют некоторые правила и ограничения при именовании переменной. Так, в названии можно использовать цифры, например name44, но оно не должно начинаться с цифр. Не допустимо использование знаков препинания и специальных символов, за исключением знака доллара ($) и подчеркивания ( _ ).
Также переменные нельзя называть словами со специальным значением, являющимися ключевыми и зарезервированными — например let, const, class и др. Таких ключевых слов довольно много, однако не стоит запоминать их все. Использование такого слова для названия переменной непременно приведет к синтаксической ошибке.
Так же стоит отметить, что хорошим тоном будет называть переменные понятными именами, несущими в себе определённую смысловую нагрузку.
Типы данных в JavaScript
Переменная — хранилище для данных (значений). Каждое значение имеет определённый тип. Это строковый, числовой, логический тип и т.д. Существуют языки программирования со строгой типизацией — например, такие как Java и Python.
JavaScript, в свою очередь, не строго типизированный язык. Объявленной переменной не нужно указывать её тип — он зависит от значения, которое мы ей присваиваем. Типы данных делятся на две группы: примитивные (primitive data types) и сложные (composite data types). «Примитивами» являются числовой, строковый, логический типы, а также null и underfined.
Данные с числовым типом, number, представлен как целыми, так и дробными числами. Для слишком больших или слишком маленьких чисел можно использовать запись с добавлением буквы е (экспоненциальная запись). Например: 4.556е7, что означает 4.556 * 107.
В спецификации ECMAScript 2020 представлен новый примитивный тип под названием BigInt, который позволяет представлять целые числа размером больше 253 — 1. Данный тип позволяет работать с поистине “огромными“ числами.
/* Чтобы создать значение типа BigInt, необходимо добавить n в конец числового литерала*/let bigNumber = 34384934293829382009430492n;
Также в JavaScript существуют три специальных значения, которые имеют числовой тип, но ведут себя вовсе не как числа.
«Infinity» и «-Infinity» — определяют бесконечность, положительную и отрицательную соответственно. «NaN» — означает «Not a Number» (не число). Последний можно получить, выполнив какую-либо операцию, не имеющую осмысленного результата. Например при делении 0 на 0. В JavaScript эти три значения имеют числовой тип, но ведут себя вовсе не как числа.
С числами, как правило, выполняют арифметические действия (операции): сложение, вычитание, умножение, деление, возведение в степень и т.д.
Данные со строковым типом, string, используются для представления текста. Любая строка должна быть заключена в кавычки, двойные («»), одинарные (») или обратные ( ). Не важно какой вид кавычек использовать, главное чтобы их вид в начале и в конце строки совпадал.
Двойные и одинарные ничем, кроме синтаксиса, не отличаются. Но вот «бэктики», или обратные кавычки, обладают определённой магией: в них можно заключать любые выражения, и результат этого выражения будет включён в строку:
Document
// Объявили переменную sum и присвоили ей результат сложения двух чисел
let sum = 10 + 13;
// Вывели в диалоговое окно браузера шаблонную строку с результатом выражения
alert(`Сумма двух чисел равна $`);Для использования внутри «бэктиков» любого выражения следует это выражение поместить в специальный блок — $<. >.
В виде строки мы можем представить всё,что угодно. Например, если поместить нашу предыдущую строку в двойные или одинарные кавычки, интерпретатор воспримет это как обычную строку и никакого выражения выполнено не будет:
Данные логического типа, boolean, представлены двумя значениями: истина (true) и ложь (false). Этот тип может быть получен путём операций сравнения, использования логических операторов, а также путём приведения значения к булевому типу.
/* Переменной isSmaller будет присвоен логический тип true,
как результат сравнения числа двух чисел*/
let isSmaller = 1
В JavaScript есть два специальных значения: null и undefined. Они обособлены и не относятся к вышеуказанным типам данных, и используются для описания отсутствия осмысленного значения.
null обозначает «ничего», «пусто». Например: let firstName = null
undefined же означает, что значение не определено. Например: let firstName. Мы не присвоили переменной firstName никакого значения и, соответственно, значение переменной name будет undefined.
Тип данных конкретной переменной можно получить с помощью оператора typeof. Его использование бывает полезным в некоторых ситуациях. Вызов typeof вернёт нам строку с названием типа. Синтаксис его вызова имеет две формы:
typeof x;
// или
typeof(x);
Например:
typeof 22; // вернёт "number"
typeof "name"; // вернёт "string"
typeof false; // вернёт "boolean"
typeof [14, 23, 41]; // вернёт "object"
typeof undefined; // вернёт "undefined"
typeof null; // вернёт "object"
typeof 10n // вернёт "bigint"
С ECMAScript 2015 появился тип symbol. Используется для определения уникальных неизменяемых идентификаторов в объектах.
Коллекции данных состоят из более чем одного значения. К ним относятся объекты, массивы и функции. Объекты содержат свойства и методы, массивы представляют собой индексированный набор элементов, а функции состоят из коллекции инструкций.
Почему JavaScript?
- Удобный для начинающих язык программирования, что делает его идеальным для начинающих программистов. Это естественный язык, который очень легко освоить. Он не только прост в освоении, но и очень доступен. Каждый веб-браузер уже имеет предварительно установленный JavaScript, поэтому вам не нужно устанавливать дополнительное программное обеспечение, чтобы начать его использовать.
- Этот мощный язык поддерживает объектно-ориентированное, функциональное и императивное программирование, поэтому вы можете легко адаптировать свои навыки JavaScript к другим языкам программирования, таким как Python, Java или C++.
- Очень гибкий язык программирования. Как только вы освоите его, возможности станут безграничными. Вы сможете использовать всю мощь библиотек и фреймворков, таких как Angular на стороне клиента или Node.js на стороне сервера. Вы также можете использовать React Native, React и Electron для создания мобильных, веб- и настольных приложений.
Значение символа «$» в JavaScript
Какое значение имеет символ доллара ( $ ) в JavaScript? За что он отвечает и где его уместно использовать?
Отслеживать
7,274 2 2 золотых знака 22 22 серебряных знака 45 45 бронзовых знаков
задан 7 янв 2013 в 13:38
13.6k 13 13 золотых знаков 61 61 серебряный знак 122 122 бронзовых знака
6 ответов 6
Сортировка: Сброс на вариант по умолчанию
Ничего особенного, просто этот символ может использоваться в идентификаторах, в отличие от многих других языков. То есть abc$def — законное имя переменной или функции, например.
Вы часом не спутали javascript с библиотекой jQuery? В ней $ используется под имя глобальной переменной. Снова-таки, никакой магии, просто имя переменной.
Отслеживать
ответ дан 7 янв 2013 в 13:42
206k 28 28 золотых знаков 293 293 серебряных знака 526 526 бронзовых знаков
Мне кажется товарищ путает с обозначением переменных в PHP.
7 янв 2013 в 13:46
@Lucky: или в perl, да.
7 янв 2013 в 13:46
Его можно использовать как короткое и нетривиальное имя для переменной. Это и делается во многих JavaScript-фреймворках. Например jQuery и Prototype.
Отслеживать
ответ дан 7 янв 2013 в 13:42
2,391 2 2 золотых знака 18 18 серебряных знаков 23 23 бронзовых знака
а ещё ссылки на JQuery object принято именовать начиная с этого символа: var $div = $(‘#divId’);
7 янв 2013 в 14:07
неплохо бы снабдить ответ примерами, а то как-то больно сухо
20 июл 2017 в 8:34
В JAVASCRIPT знак $ используется для интерполяции выражений:
let data = [11, 22, 33]; const str = `Number $ from data`; console.log(str); // Number 11 from data (Только замените ‘ на `)
Выражения и операторы
Эта глава описывает выражения и операторы языка JavaScript, такие как операторы присваивания, сравнения, арифметические, битовые, логические, строчные, и различные специальные операторы.
Полный и детальный список операторов и выражений также доступен в этом руководстве.
Операторы
В JavaScript есть следующие типы операторов. Данный подраздел описывает каждый тип и содержит информацию об их приоритетах друг над другом.
- Операторы присваивания
- Операторы сравнения
- Арифметические операторы
- Битовые (поразрядные) операторы
- Логические операторы
- Строковые операторы
- Условный (тернарный) оператор
- Оператор запятая
- Унарные операторы
- Операторы отношения
- Приоритет операторов
JavaScript поддерживает бинарные и унарные операторы, а также ещё один специальный тернарный оператор — условный оператор. Бинарная операция использует два операнда, один перед оператором и другой за ним:
operand1 operator operand2
Например: 3+4 или x*y .
В свою очередь унарная операция использует один операнд, перед или после оператора:
operator operand
operand operator
Например: x++ или ++x .
Операторы присваивания
В результате операции присваивания операнду слева от оператора присваивания (en-US) (знак » table-container»>
| Имя | Сокращённый оператор | Смысл |
|---|---|---|
| Присваивание (en-US) | x = y | x = y |
| Присваивание со сложением (en-US) | x += y | x = x + y |
| Присваивание с вычитанием (en-US) | x -= y | x = x — y |
| Присваивание с умножением (en-US) | x *= y | x = x * y |
| Присваивание с делением (en-US) | x /= y | x = x / y |
| Присваивание по модулю (en-US) | x %= y | x = x % y |
| Присваивание с левым сдвигом (en-US) | x | x = x |
| Присваивание с правым сдвигом (en-US) | x >>= y | x = x >> y |
| Присваивание с беззнаковым сдвигом вправо (en-US) | x >>>= y | x = x >>> y |
| Присваивание с побитовым AND (en-US) | x &= y | x = x & y |
| Присваивание с побитовым XOR (en-US) | x ^= y | x = x ^ y |
| Присваивание с побитовым OR (en-US) | x |= y | x = x | y |
Деструктуризация
Для более сложного присваивания в JavaScript есть синтаксис деструктуризации — это выражение, которое позволяет извлекать данные из массивов или объектов, используя синтаксис, который зеркалирует конструкторы массивов и литералы объектов.
var foo = ["one", "two", "three"]; // без деструктуризации var one = foo[0]; var two = foo[1]; var three = foo[2]; // с деструктуризацией var [one, two, three] = foo;
Операторы сравнения
Оператор сравнения (en-US) сравнивает свои операнды и возвращает логическое значение, базируясь на истинности сравнения. Операнды могут быть числами, строками, логическими величинами или объектами. Строки сравниваются на основании стандартного лексикографического порядка, используя Unicode-значения. В большинстве случаев, если операнды имеют разный тип, то JavaScript пробует преобразовать их в тип, подходящий для сравнения. Такое поведение обычно происходит при сравнении числовых операндов. Единственным исключением из данного правила является сравнение с использованием операторов === и !== , которые производят строгое сравнение на равенство или неравенство. Эти операторы не пытаются преобразовать операнды перед их сравнением. Следующая таблица описывает операторы сравнения в контексте следующего примера кода:
var var1 = 3, var2 = 4;
| Оператор | Описание | Примеры, возвращающие true |
|---|---|---|
| Равно ( == ) | Возвращает true, если операнды равны. | 3 == var1 «3» == var1 3 == ‘3’ |
| Не равно ( != ) | Возвращает true, если операнды не равны. | var1 != 4 var2 != «3» |
| Строго равно ( === ) | Возвращает true, если операнды равны и имеют одинаковый тип. Смотрите также Object.is и sameness in JS. | 3 === var1 |
| Строго не равно( !== ) | Возвращает true, если операнды не равны и/или имеют разный тип. | var1 !== «3» 3 !== ‘3’ |
| Больше ( > ) | Возвращает true, если операнд слева больше операнда справа. | var2 > var1 «12» > 2 |
| Больше или равно ( >= ) | Возвращает true, если операнд слева больше или равен операнду справа. | var2 >= var1 var1 >= 3 |
| Меньше ( < ) | Возвращает true, если операнд слева меньше операнда справа. | var1 < var2 "2" < 12 |
| Меньше или равно ( | Возвращает true, если операнд слева меньше или равен операнду справа. | var1 |
Примечание: (=>) не оператор, а нотация Стрелочных функций.
Арифметические операторы
Арифметические операторы (en-US) используют в качестве своих операндов числа (также литералы или переменные) и в качестве результата возвращают одно числовое значение. Стандартными арифметическими операторами являются сложение (+), вычитание (-), умножение (*), и деление (/). При работе с числами с плавающей точкой эти операторы работают аналогично их работе в большинстве других языках программирования (обратите внимание, что деление на ноль возвращает бесконечность Infinity ). Например:
.log(1 / 2); /* возвращает 0.5 */ console.log(1 / 2 == 1.0 / 2.0); /* возвращает true */
Кроме того, JavaScript позволяет использовать следующие арифметические операторы, представленные в таблице:
| Оператор | Описание | Пример |
|---|---|---|
| Остаток от деления (en-US) ( % ) | Бинарный оператор. Возвращает целочисленный остаток от деления двух операндов. | 12 % 5 вернёт 2. |
| Инкремент (en-US) ( ++ ) | Унарный оператор. Добавляет единицу к своему операнду. Если используется в качестве префикса ( ++x ), то возвращает значение операнда с добавленной к нему единицей; а в случае применения в качестве окончания ( x++ ) возвращает значение операнда перед добавлением к нему единицы. | Если x равно 3, тогда ++x установит значение x равным 4 и вернёт 4, напротив x++ вернёт 3 и потом установит значение x равным 4. |
| Декремент (en-US) ( — ) | Унарный оператор. Вычитает единицу из значения своего операнда. Логика данного оператора аналогична оператору инкремента. | Если x равно 3, тогда —x установит значение x равным 2 и вернёт 2, напротив x— вернёт 3 и потом установит значение x равным 2. |
| Унарный минус (en-US) — | Унарный оператор. Возвращает отрицательное значение своего операнда. | Если x равно 3, тогда -x вернёт -3. |
| Унарный плюс (en-US) ( + ) | Унарный оператор. Пытается конвертировать операнд в число, если он ещё не оно. | +»3″ вернёт 3 . +true вернёт 1. |
| Возведение в степень (en-US) ( ** ) Экспериментальная возможность | Возводит основание в показатель степени , как, основаниестепень | 2 ** 3 вернёт 8 . 10 ** -1 вернёт 0.1 . |
Битовые (поразрядные) операторы
Битовые операторы (en-US) обрабатывают свои операнды как последовательности из 32 бит (нулей и единиц), а не как десятичные, шестнадцатеричные или восьмеричные числа. Например, десятичное число 9 имеет двоичное представление 1001. Битовые операторы выполняют операции над таким двоичным представлением, но результат возвращают как обычное числовое значение JavaScript.
Следующая таблица обобщает битовые операторы JavaScript.
| Оператор | Использование | Описание |
|---|---|---|
| Побитовое И (en-US) | a & b | Возвращает единицу в каждой битовой позиции, для которой соответствующие биты обеих операндов являются единицами. |
| Побитовое ИЛИ (en-US) | a | b | Возвращает единицу в каждой битовой позиции, для которой один из соответствующих битов или оба бита операндов являются единицами. |
| Исключающее ИЛИ (en-US) | a ^ b | Возвращает единицу в каждой битовой позиции, для которой только один из соответствующих битов операндов является единицей. |
| Побитовое НЕ (en-US) | ~ a | Заменяет биты операнда на противоположные. |
| Сдвиг влево (en-US) | a | Сдвигает a в двоичном представлении на b бит влево, добавляя справа нули. |
| Сдвиг вправо с переносом знака (en-US) | a >> b | Сдвигает a в двоичном представлении на b бит вправо, отбрасывая сдвигаемые биты. |
| Сдвиг вправо с заполнением нулями (en-US) | a >>> b | Сдвигает a в двоичном представлении на b бит вправо, отбрасывая сдвигаемые биты и добавляя слева нули. |
Битовые логические операторы
Основной смысл работы битовых логических операторов состоит в следующем:
-
Операнды преобразуются в 32-битные целые числа и представляются в виде последовательности бит (нулей и единиц). Числа, имеющие более 32 битов будут сокращены. Например, следующее число имеет больше 32 битов и сконвертируется в 32-х битное:
До : 11100110111110100000000000000110000000000001 После : 10100000000000000110000000000001
Например, двоичным представлением числа 9 является 1001, а двоичным представлением пятнадцати — 1111. Результаты применения к этим числам битовых логических операторов выглядят следующим образом:
| Выражение | Результат | Двоичное описание |
|---|---|---|
| 15 & 9 | 9 | 1111 & 1001 = 1001 |
| 15 | 9 | 15 | 1111 | 1001 = 1111 |
| 15 ^ 9 | 6 | 1111 ^ 1001 = 0110 |
| ~15 | -16 | ~«00000000. «00001111 = «1111«1111«. «11110000 |
| ~9 | -10 | ~«00000000«. «0000«1001 = «1111«1111«. «1111«0110 |
Обратите внимание, что все 32 бита преобразуются с использованием битового оператора НЕ, и что величины с наиболее значимым (самым левым) битом равным 1 представляют собой отрицательные числа (в представлении дополнения до двух).
Битовые операторы сдвига
Битовые операторы сдвига используют два операнда: первый представляет величину, подлежащую сдвигу, а второй операнд указывает число битовых позиций на которое должен быть сдвинут первый операнд. Направление операции сдвига определяется используемым оператором.
Операторы сдвига преобразуют свои операнды в 32-битные целые числа и возвращают результат того же типа, каким является левый операнд.
Операторы сдвига перечислены в следующей таблице.
| Оператор | Описание | Пример |
|---|---|---|
| Сдвиг влево (en-US) ( | Данный оператор сдвигает первый операнд на указанное количество бит влево. Излишние биты, сдвинутые влево, отбрасываются. Справа число дополняется нулевыми битами. | 9 |
| Сдвиг вправо с переносом знака (en-US) ( >> ) | Данный оператор сдвигает первый операнд на указанное количество бит вправо. Излишние биты, сдвинутые вправо, отбрасываются. Слева число дополняется копиями крайнего слева бита. | 9>>2 равно 2, так как 1001 после сдвига на 2 бита вправо превращается в 10, что соответствует числу 2. Подобным же образом -9>>2 равно -3, так как знак сохраняется. |
| Сдвиг вправо с заполнением нулями (en-US) ( >>> ) | Данный оператор сдвигает первый операнд на указанное количество бит вправо. Излишние биты, сдвинутые вправо, отбрасываются. Слева число дополняется нулевыми битами. | 19>>>2 равно 4, так как 10011 после сдвига на 2 бита вправо превращается в 100, что соответствует числу 4. Для неотрицательных чисел сдвиг вправо с заполнением нулями и сдвиг вправо с переносом знака дают одинаковый результат. |
Логические операторы
Логические операторы (en-US) обычно используются с булевыми (логическими) значениями; при этом возвращаемое ими значение также является булевым. Однако операторы && и || фактически возвращают значение одного из операндов, поэтому, если эти операторы используются с небулевыми величинами, то возвращаемая ими величина также может быть не булевой. Логические операторы описаны в следующей таблице.
| Оператор | Использование | Описание |
|---|---|---|
| Логическое И (en-US) ( && ) | expr1 && expr2 | (Логическое И) Возвращает операнд expr1 , если он может быть преобразован в false ; в противном случае возвращает операнд expr2 . Таким образом, при использовании булевых величин в качестве операндов, оператор && возвращает true , если оба операнда true ; в противном случае возвращает false . |
| Логическое ИЛИ (en-US) ( || ) | expr1 || expr2 | (Логическое ИЛИ) Возвращает операнд expr1 , если он может быть преобразован в true ; в противном случае возвращает операнд expr2 . Таким образом, при использовании булевых величин в качестве операндов, оператор || возвращает true , если один из операндов true ; если же оба false , то возвращает false . |
| Логическое НЕ (en-US) ( ! ) | !expr | (Логическое НЕ) Возвращает false , если операнд может быть преобразован в true ; в противном случае возвращает true . |
Примерами выражений, которые могут быть преобразованы в false являются: null, 0, NaN, пустая строка («») или undefined.
Следующий код демонстрирует примеры использования оператора && (логическое И).
var a1 = true && true; // t && t возвращает true var a2 = true && false; // t && f возвращает false var a3 = false && true; // f && t возвращает false var a4 = false && 3 == 4; // f && f возвращает false var a5 = "Cat" && "Dog"; // t && t возвращает Dog var a6 = false && "Cat"; // f && t возвращает false var a7 = "Cat" && false; // t && f возвращает false
Следующий код демонстрирует примеры использования оператора || (логическое ИЛИ).
var o1 = true || true; // t || t возвращает true var o2 = false || true; // f || t возвращает true var o3 = true || false; // t || f возвращает true var o4 = false || 3 == 4; // f || f возвращает false var o5 = "Cat" || "Dog"; // t || t возвращает Cat var o6 = false || "Cat"; // f || t возвращает Cat var o7 = "Cat" || false; // t || f возвращает Cat
Следующий код демонстрирует примеры использования оператора ! (логическое НЕ).
var n1 = !true; // !t возвращает false var n2 = !false; // !f возвращает true var n3 = !"Cat"; // !t возвращает false
Сокращённая оценка
Так как логические выражения вычисляются слева направо, они проверяются на возможность выполнения сокращённой оценки с использованием следующих правил:
- false && anything — сокращение с результатом false.
- true || anything — сокращение с результатом true.
Правила логики гарантируют, что данные вычисления всегда корректны. Обратите внимание, что часть «anything» представленных выше выражений не вычисляется, таким образом удаётся избежать любых побочных эффектов вычисления данной части.
Строковые операторы
В дополнение к операторам сравнения, которые могут использоваться со строковыми значениями, оператор (+) позволяет объединить две строки, возвращая при этом третью строку, которая представляет собой объединение двух строк-операндов:
.log("my " + "string"); // в консоли выведется строка "my string".
Сокращённый оператор присваивания += также может быть использован для объединения (конкатенации) строк:
var mystring = "alpha"; mystring += "bet"; // получается значение "alphabet" и присваивается mystring.
Условный (тернарный) оператор
Условный оператор является единственным оператором JavaScript, который использует три операнда. Оператор принимает одно из двух значений в зависимости от заданного условия. Синтаксис оператора:
condition ? val1 : val2
Предупреждение: val1 и val2 обязательно должны что-то возвращать, поэтому в этой конструкции нельзя использовать continue или break
Если condition (условие) — истина, то оператор принимает значение val1 . В противном случае оператор принимает значение val2 . Вы можете использовать условный оператор во всех случаях, где может быть использован стандартный оператор.
var status = age >= 18 ? "adult" : "minor";
Данное выражение присваивает значение «adult» переменной status , если age имеет значение 18 или более. В противном случае переменной status присваивается значение «minor».
Оператор запятая
Оператор запятая ( , ) просто вычисляет оба операнда и возвращает значение последнего операнда. Данный оператор в основном используется внутри цикла for , что позволяет при каждом прохождении цикла одновременно обновлять значения нескольких переменных.
Например, если a является двумерным массивом, каждая строка которого содержит 10 элементов, то следующий код с использованием оператора запятая позволяет выполнять одновременное приращение двух переменных. Данный код выводит на экран значения диагональных элементов массива:
for (var i = 0, j = 9; i 9; i++, j--) document.writeln("a[" + i + "][" + j + "] token operator">+ a[i][j]);
Унарные операторы
Унарная операция — операция только с одним операндом.
delete
Оператор delete выполняет удаление объекта, свойства объекта, или элемента массива с заданным индексом. Синтаксис оператора:
delete objectName; delete objectName.property; delete objectName[index]; delete property; // допустимо только внутри with
где objectName представляет собой имя объекта, property — свойство объекта, а index — целое число, указывающее на положение (номер позиции) элемента в массиве.
Четвёртый вариант использования позволяет удалить свойство объекта, но допускается только внутри with .
Вы можете использовать оператор delete для удаления переменных, объявленных неявно, но вы не можете с его помощью удалять переменные, объявленные с помощью var .
После применения оператора delete свойство элемента меняется на undefined . Оператор delete возвращает true если выполнение операции возможно; оператор возвращает false , если выполнение операции невозможно.
= 42; var y = 43; myobj = new Number(); myobj.h = 4; // создаём свойство h delete x; // возвращает true (можно удалить переменную объявленную неявно) delete y; // возвращает false (нельзя удалить переменную объявленную с помощью var) delete Math.PI; // возвращает false (нельзя удалить встроенные свойства) delete myobj.h; // возвращает true (можно удалить пользовательские свойства) delete myobj; // возвращает true (можно удалить объект объявленный неявно)
Удаление элементов массива
Удаление элемента массива не влияет на длину массива. Например, если вы удалите a[3] , элемент a[4] останется a[4], a[3] станет undefined.
Когда элемент массива удаляется с помощью оператора delete , то из массива удаляется значение данного элемента. В следующем примере элемент trees[3] удалён с помощью оператора delete . Однако, элемент trees[3] остаётся адресуемым и возвращает значение undefined .
var trees = new Array("redwood", "bay", "cedar", "oak", "maple"); delete trees[3]; if (3 in trees) // условие не выполняется >
Если вы хотите, чтобы элемент оставался в массиве, но имел значение undefined, то используйте ключевое слово undefined вместо оператора delete . В следующем примере элементу trees[3] присвоено значение undefined , но элемент при этом остаётся в массиве:
var trees = new Array("redwood", "bay", "cedar", "oak", "maple"); trees[3] = undefined; if (3 in trees) // данный блок кода выполняется >
Оператор typeof
Оператор typeof используется одним из следующих способов:
typeof operand typeof (operand)
Оператор typeof возвращает строку обозначающую тип невычисленного операнда. Значение operand может быть строкой, переменной, дескриптором, или объектом, тип которого следует определить. Скобки вокруг операнда необязательны.
Предположим, вы определяете следующие переменные:
var myFun = new Function("5 + 2"); var shape = "round"; var size = 1; var today = new Date();
Оператор typeof возвращает следующие результаты для этих переменных:
typeof myFun; // возвращает "function" typeof shape; // возвращает "string" typeof size; // возвращает "number" typeof today; // возвращает "object" typeof dontExist; // возвращает "undefined"
Для дескрипторов true и null оператор typeof возвращает следующие результаты:
typeof true; // возвращает "boolean" typeof null; // возвращает "object"
Для чисел и строк оператор typeof возвращает следующие результаты:
typeof 62; // возвращает "number" typeof "Hello world"; // возвращает "string"
Для свойств оператор typeof возвращает тип значения данного свойства:
typeof document.lastModified; // возвращает "string" typeof window.length; // возвращает "number" typeof Math.LN2; // возвращает "number"
Для методов и функций оператор typeof возвращает следующие результаты:
typeof blur; // возвращает "function" typeof eval; // возвращает "function" typeof parseInt; // возвращает "function" typeof shape.split; // возвращает "function"
Для встроенных объектов оператор typeof возвращает следующие результаты:
typeof Date; // возвращает "function" typeof Function; // возвращает "function" typeof Math; // возвращает "object" typeof Option; // возвращает "function" typeof String; // возвращает "function"
Оператор void
Оператор void используется любым из следующих способов:
void (expression) void expression
Оператор void определяет выражение, которое должно быть вычислено без возвращения результата. expression — это выражение JavaScript, требующее вычисления. Скобки вокруг выражения необязательны, но их использование является правилом хорошего тона.
Вы можете использовать оператор void для указания на то, что операнд-выражение является гипертекстовой ссылкой. При этом выражение обрабатывается, но не загружается в текущий документ.
Следующий код служит примером создания гипертекстовой ссылки, которая бездействует при нажатии на неё пользователем. Когда пользователь нажимает на ссылку, void(0) вычисляется равным undefined , что не приводит ни к каким действиям в JavaScript.
a href="javascript:void(0)">Нажмите здесь, чтобы ничего не произошлоa>
Приведённый ниже код создаёт гипертекстовую ссылку, которая подтверждает отправку формы при клике на ней пользователем:
a href="javascript:void(document.form.submit())"> Нажмите здесь, чтобы подтвердить отправку формыa >
Операторы отношения
Оператор отношения сравнивает свои операнды и возвращает результат сравнения в виде булева значения.
Оператор in
Оператор in возвращает true, если указанный объект имеет указанное свойство. Синтаксис оператора:
propNameOrNumber in objectName
где propNameOrNumber — строка или числовое выражение, представляющее имя свойства или индекс массива, а objectName — имя объекта.
Некоторые примеры способов использования оператора in :
// Массивы var trees = new Array("redwood", "bay", "cedar", "oak", "maple"); 0 in trees; // возвращает true 3 in trees; // возвращает true 6 in trees; // возвращает false "bay" in trees; // возвращает false (следует указать индекс элемента массива, // а не значение элемента) "length" in trees; // возвращает true (length является свойством объекта Array) // Встроенные объекты "PI" in Math; // возвращает true var myString = new String("coral"); "length" in myString; // возвращает true // Пользовательские объекты var mycar = make: "Honda", model: "Accord", year: 1998 >; "make" in mycar; // возвращает true "model" in mycar; // возвращает true
Оператор instanceof
Оператор instanceof возвращает true, если заданный объект является объектом указанного типа. Его синтаксис:
objectName instanceof objectType
где objectName — имя объекта, тип которого необходимо сравнить с objectType , а objectType — тип объекта, например, Date или Array .
Используйте оператор instanceof , когда вам необходимо подтвердить тип объекта во время выполнения программы. Например, при перехвате исключений вы можете создать различные программные переходы для обработки исключений в зависимости от типа обрабатываемого исключения.
Например, следующий код использует оператор instanceof для проверки того, является ли объект theDay объектом типа Date . Так как theDay действительно является объектом типа Date , то программа выполняет код, содержащийся в утверждении if .
var theDay = new Date(1995, 12, 17); if (theDay instanceof Date) // выполняемый код >
Приоритет операторов
Приоритет операторов определяет порядок их выполнения при вычислении выражения. Вы можете влиять на приоритет операторов с помощью скобок.
Приведённая ниже таблица описывает приоритет операторов от наивысшего до низшего.
| Тип оператора | Операторы |
|---|---|
| свойство объекта | . [] |
| вызов, создание экземпляра объекта | () new |
| отрицание, инкремент | ! ~ — + ++ — typeof void delete |
| умножение, деление | * / % |
| сложение, вычитание | + — |
| побитовый сдвиг | > >>> |
| сравнение, вхождение | < >= in instanceof |
| равенство | == != === !== |
| битовое-и | & |
| битовое-исключающее-или | ^ |
| битовое-или | | |
| логическое-и | && |
| логическое-или | || |
| условный (тернарный) оператор | ?: |
| присваивание | = += -= *= /= %= <>= >>>= &= ^= |= |
| запятая | , |
Более подробная версия данной таблицы, содержащая ссылки и дополнительную информацию по каждому оператору, находится в справочнике JavaScript.
Выражения
Выражением является любой корректный блок кода, который возвращает значение.
Концептуально, существуют два типа выражений: те которые присваивают переменной значение, и те, которые вычисляют значение без его присваивания.
Выражение x = 7 является примером выражения первого типа. Данное выражение использует оператор = для присваивания переменной x значения 7. Само выражение также равняется 7.
Код 3 + 4 является примером выражения второго типа. Данное выражение использует оператор «+» для сложения чисел 3 и 4 без присваивания переменной полученного результата 7.
Все выражения в JavaScript делятся на следующие категории:
- Арифметические: вычисляются в число, например: 3.14159 (Используют арифметические операторы).
- Строковые: вычисляются в текстовую строку, например: «Fred» или «234» (Используют строковые операторы).
- Логические: вычисляются в true или false (Используют логические операторы).
- Основные выражения: Базовые ключевые слова и основные выражения в JavaScript.
- Левосторонние выражения: Значениям слева назначаются значения справа.
Основные выражения
Базовые ключевые слова и основные выражения в JavaScript.
Оператор this
Используйте ключевое слово this для указания на текущий объект. В общем случае this указывает на вызываемый объект, которому принадлежит данный метод. Используйте this следующим образом:
this["propertyName"] this.propertyName
Предположим, функция validate выполняет проверку свойства value некоторого объекта; задан объект, а также верхняя и нижняя граница величины данного свойства:
function validate(obj, lowval, hival) if (obj.value lowval || obj.value > hival) alert("Неверное значение!"); >
Вы можете вызвать функцию validate для обработчика события onChange для каждого элемента формы, используя this для указания на элемент формы, как это показано в следующем примере:
b>Введите число от 18 до 99:b> input type="text" name="age" size="3" onChange="validate(this, 18, 99);" />
Оператор группировки
Оператор группировки «скобки» ( ) контролирует приоритет вычислений в выражениях. Например, вы можете переопределить порядок так, чтобы сложение выполнялось до умножения:
var a = 1; var b = 2; var c = 3; // обычный порядок a + b * c; // 7 // по умолчанию выполняется так a + (b * c); // 7 // теперь поменяем приоритет с помощью скобок, // чтобы сложение выполнялось до умножения (a + b) * c; // 9 // что эквивалентно следующему a * c + b * c; // 9
Упрощённый синтаксис создания массивов и генераторов
Упрощённый синтаксис — экспериментальная возможность JavaScript, которая возможно будет добавлена в будущие версии ECMAScript. Есть 2 версии синтаксиса:
Упрощённый синтаксис для массивов.
Упрощённый синтаксис для генераторов.
Упрощённые синтаксисы существуют во многих языках программирования и позволяют вам быстро собирать новый массив, основанный на существующем. Например:
[for (i of [ 1, 2, 3 ]) i*i ]; // [ 1, 4, 9 ] var abc = [ "A", "B", "C" ]; [for (letters of abc) letters.toLowerCase()]; // [ "a", "b", "c" ]
Левосторонние выражения
Значениям слева назначаются значения справа.
new
Вы можете использовать оператор new для создания экземпляра объекта пользовательского типа или одного из встроенных объектов. Используйте оператор new следующим образом:
var objectName = new objectType([param1, param2, . , paramN]);
super
Ключевое слово используется, чтобы вызывать функции родительского объекта. Это полезно и с классами для вызова конструктора родителя, например.
super([arguments]); // вызывает конструктор родителя. super.functionOnParent([arguments]);
Оператор расширения
Оператор расширения позволяет выражению расширяться в местах с множеством аргументов (для вызовов функций) или множестве элементов (для массивов).
Пример: Сегодня, если у вас есть массив и вы хотите создать новый с существующей частью первого, то литерального синтаксиса массива уже не достаточно, и вы должны писать императивный (без вариантов) код, используя комбинацию push , splice , concat и т.д. Но с этим оператором код становится более коротким:
var parts = ["shoulder", "knees"]; var lyrics = ["head", . parts, "and", "toes"];
Похожим образом оператор работает с вызовами функций:
function f(x, y, z) > var args = [0, 1, 2]; f(. args);
- « Предыдущая статья
- Следующая статья »
Found a content problem with this page?
- Edit the page on GitHub.
- Report the content issue.
- View the source on GitHub.
This page was last modified on 7 авг. 2023 г. by MDN contributors.
Your blueprint for a better internet.
MDN
Support
- Product help
- Report an issue
Our communities
Developers
- Web Technologies
- Learn Web Development
- MDN Plus
- Hacks Blog
- Website Privacy Notice
- Cookies
- Legal
- Community Participation Guidelines
Visit Mozilla Corporation’s not-for-profit parent, the Mozilla Foundation.
Portions of this content are ©1998– 2023 by individual mozilla.org contributors. Content available under a Creative Commons license.
Синтаксис JavaScript
С 1995 года JavaScript прошел длинный путь от скромного компонента браузера Netscape до современных высокопроизводительных JIT-интерпретаторов. Казалось бы, всего лет пять назад разработчики были ошеломлены появлением Ajax, а уже сейчас сложные JavaScript-приложения достигли объемов в сотни и тысячи строк кода.
В прошлом году появилось новое поколение JavaScript-приложений, ничем не отличающихся от приложений рабочего стола, — невероятный прогресс веб-технологий. Ушли в прошлое медленно выполняемые запросы страниц при каждом взаимодействии пользователя с приложением. Движки JavaScript стали настолько мощными, что появилась возможность сохранять состояние на стороне клиента, что существенно ускорило реакцию приложения и улучшило качество его работы.
Если вы знаете другие языки программирования, вам может оказаться полезна информация, что JavaScript является высокоуровневым, динамическим, нетипизированным и интерпретируемым языком программирования, который хорошо подходит для программирования в объектно-ориентированном и функциональном стилях. Свой синтаксис JavaScript унаследовал из языка Java, свои первоклассные функции – из языка Scheme, а механизм наследования на основе прототипов – из языка Self. Но вам не требуется знать все эти языки или быть знакомыми с их терминологией для изучения JavaScript.
В этой статье мы рассмотрим базовые лексические структуры языка.
Символы
При написании программ на JavaScript используется набор символов Юникода. Юникод является надмножеством кодировок ASCII и Latin-1 и поддерживает практически все письменные языки, имеющиеся на планете. Стандарт ECMAScript 3 требует, чтобы реализации JavaScript обеспечивали поддержку стандарта Юникода версии 2.1 или выше, а стандарт ECMAScript 5 требует, чтобы реализации обеспечивали поддержку стандарта Юникода версии 3 или выше.
Чувствительность к регистру
JavaScript – это язык, чувствительный к регистру символов. Это значит, что ключевые слова, имена переменных и функций и любые другие идентификаторы языка должны всегда содержать одинаковые наборы прописных и строчных букв.
Например, ключевое слово while должно набираться как «while», а не «While » или «WHILE». Аналогично myvar, Myvar, MyVar и MYVAR – это имена четырех разных переменных. Заметим, однако, что язык разметки HTML (в отличие от XHTML) не чувствителен к регистру. Так как HTML и клиентский JavaScript тесно связаны, это различие может привести к путанице. Многие JavaScript-объекты и их свойства имеют те же имена, что и теги и атрибуты языка HTML, которые они обозначают. Однако если в HTML эти теги и атрибуты могут набираться в любом регистре, то в JavaScript они обычно должны набираться строчными буквами.
Например, атрибут onclick обработчика события чаще всего задается в HTML как onClick, однако в JavaScript-коде (или в XHTML-документе) он должен быть обозначен как onclick.
Пробелы, переводы строк и символы управления форматом
JavaScript игнорирует пробелы, которые могут присутствовать между лексемами в программе. Кроме того, JavaScript также по большей части игнорирует символы перевода строки. Поэтому пробелы и символы перевода строки могут без ограничений использоваться в исходных текстах программ для форматирования и придания им удобочитаемого внешнего вида.
Помимо обычного символа пробела ( \u0020 ) JavaScript дополнительно распознает как пробельные следующие символы: табуляция ( \u0009 ), вертикальная табуляция ( \u000B ), перевод формата ( \u000C ), неразрывный пробел ( \u00A0 ), маркер порядка следования байтов ( \uFEFF ), а также все символы Юникода, относящиеся к категории Zs.
Следующие символы распознаются интерпретаторами JavaScript как символы конца строки: перевод строки ( \u000A ), возврат каретки ( \u000D ), разделитель строк ( \u2028 ) и разделитель абзацев ( \u2029 ). Последовательность из символов возврата каретки и перевода строки интерпретируется как единственный символ завершения строки.
Символы Юникода, управляющие форматом (категория Cf), такие как RIGHT-TO-LEFT MARK ( \u200F ) и LEFT-TO-RIGHT MARK ( \u200E ), управляют визуальным представлением текста, в котором они присутствуют. Они имеют большое значение для корректного отображения текста на некоторых языках и являются допустимыми в комментариях JavaScript, строковых литералах и в литералах регулярных выражений, но не в идентификаторах (таких как имена переменных), определяемых в программах JavaScript. Исключение составляют ZERO WIDTH JOINER ( \u200D ) и ZERO WIDTH NON-JOINER ( \u200C ), которые можно использовать в идентификаторах при условии, что они не являются первыми символами идентификаторов.
Полную таблицу символов Unicode вы можете посмотреть на сайте Unicode Table.
Необязательные точки с запятой
Как и в других языках программирования, для отделения инструкций друг от друга в языке JavaScript используется точка с запятой (;). Использование точек с запятой имеет важное значение для ясного выражения намерений программиста: без этого разделителя по ошибке можно принять конец одной инструкции за начало следующей и наоборот.
Обычно в JavaScript точку с запятой между инструкциями можно не ставить, если они находятся в разных строках. (Точку с запятой можно также опустить в конце программы или если следующей лексемой в программе является закрывающая фигурная скобка >.) Многие программисты на JavaScript используют точки с запятой для явного обозначения концов инструкций, даже если в этом нет необходимости.
Взгляните на следующий фрагмент. Поскольку две инструкции находятся в разных строках, первую точку с запятой можно опустить:
a = 3 b = 5;Однако если эти инструкции записать, как показано ниже, первая точка с запятой становится обязательной:
a = 3; b = 5;Комментарии
JavaScript поддерживает два способа оформления комментариев. Любой текст между символами // и концом строки рассматривается как комментарий и игнорируется JavaScript. Любой текст между символами /* и */ также рассматривается как комментарий. Эти комментарии могут состоять из нескольких строк, но не могут быть вложенными. Следующие строки представляют собой корректные JavaScript-комментарии:
// Это однострочный комментарий. /* Это тоже комментарий */ // а это другой комментарий. /* Это еще один комментарий. Он располагается в нескольких строках. */
Идентификаторы и зарезервированные слова
Идентификатор — это просто имя. В JavaScript идентификаторы выступают в качестве имен переменных и функций, а также меток некоторых циклов. Идентификаторы в JavaScript должны начинаться с буквы, с символа подчеркивания (_) или знака доллара ($) . Далее могут следовать любые буквы, цифры, символы подчеркивания или знаки доллара. (Цифра не может быть первым символом, так как тогда интерпретатору трудно будет отличать идентификаторы от чисел.) Примеры допустимых идентификаторов:
i my_variable_name v13 _myvar $strДля совместимости и простоты редактирования для составления идентификаторов обычно используются только символы ASCII и цифры. Однако JavaScript допускает возможность использования в идентификаторах букв и цифр из полного набора символов Юникода. Это позволяет программистам давать переменным имена на своих родных языках и использовать в них математические символы:
var имя = 'Александр'; var Π = 3.14;JavaScript резервирует ряд идентификаторов, которые играют роль ключевых слов самого языка. Эти ключевые слова не могут служить идентификаторами в программах. JavaScript также резервирует некоторые ключевые слова, которые в настоящее время не являются частью языка, но которые могут войти в его состав в будущих версиях. В приведенной таблице перечислены все ключевые слова по категориям:
| Категория | Ключевые слова |
|---|---|
| Базовые идентификаторы | break delete function return typeof case do if switch var catch else in this void continue false instanceof throw while debugger finally new true with default for null try |
| Новые ключевые слова в стандарте EcmaScript 5 | class const enum export extends import super |
| Зарезервированные слова в строгом режиме (в обычном они доступны) | implements let private public yield interface package protected static arguments eval |
| Ключевые слова языка Java (зарезервированы в EcmaScript 3) | abstract double goto native static boolean enum implements package super byte export import private synchronized char extends int protected throws class final interface public transient const float long short volatile |
| Предопределенные глобальные переменные и функции | arguments encodeURI Infinity Number RegExp Array encodeURIComponent isFinite Object String Boolean Error isNaN parseFloat SyntaxError Date eval JSON parseInt TypeError decodeURI EvalError Math RangeError undefined decodeURIComponent Function NaN ReferenceError URIError |
Имейте в виду, что конкретные реализации JavaScript могут содержать свои предопределенные глобальные переменные и функции. Кроме того, каждая конкретная платформа JavaScript (клиентская, серверная и прочие) может иметь свой собственный список глобальных свойств.