Javascript сложение строк как числом. Простое сложение в javascript: учимся складывать числа, строки и массивы

В этой статье речь пойдет о том, что такое строки в JavaScript и методах работы с ними.

Строки — это просто группы символов, такие как « JavaScript », « Hello world! », « http://www.quirksmode.org » или даже « 14 ». Для программирования на JavaScript Вам необходимо знать, что такое строки и как с ними работать, т. к. использовать их придется очень часто. Многие вещи, такие как URL -страницы, значения CSS -параметров и элементов ввода форм — все является строками.

Сначала постараюсь объяснить работы со строками , затем — разницу между в JavaScript. Даже если у Вас есть опыт программирования на другом языке, внимательно прочтите эту часть. В конце я расскажу о самых важных строк в JavaScript .

Основы работы со строками

Давайте рассмотрим основы работы со строками в JavaScript.

Использование кавычек

Когда Вы объявляете строки в JavaScript или работаете с ними, всегда заключайте их в одинарные или двойные кавычки. Этим Вы объясняете браузеру, что он имеет дело со строкой. Не смешивайте использование кавычек в коде, если Вы начали строку с одинарной кавычки, а закончили двойной, JavaScript не поймет, что Вы имели в виду. Как правило, я использую одинарные кавычки для работы со строками, так как двойные кавычки я решил использовать для HTML , а одинарные — для JavaScript. Конечно, Вы можете делать все по-другому, но я советую вам придумать подобное правило для себя.

Давайте представим две строки, которые мы будем использовать на протяжении всей статьи:

Var a = "Hello world!"; var b = "I am a student.";

Сейчас мы объявили две переменные, « a » и « b », и присвоили им строковые значения. После этого мы можем с ними работать, но сначала решим одну проблему: допустим, я написал:

Var b = "I"m a student.";

Строка содержит в себе лишнюю одинарную кавычку, и JavaScript думает, что строка закончена и выводит сообщение об ошибке, не понимая, что следует дальше. Поэтому Вам нужно экранировать кавычку , сообщая браузеру, что её нужно рассматривать как символ, а не как окончание строки. Это осуществляется с помощью «обратного слеша» перед кавычкой:

Var b = "I\"m a student.";

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

Var b = "I\"m a "student".";

воспринимается без проблем. Двойные кавычки автоматически рассматриваются, как части строки, а не команды.

Встроенные функции

После определения строк можно начать их использование. Например, Вы можете соединить одну строку с другой , или взять из строки « b » подстроку, состоящую из второго—четвертого символов и вставить их в середину строки « a », или определить какой символ стоит двенадцатым в « a », сколько символов в « b », есть ли в них буква «q» и т. д.

Для этого Вы можете использовать встроенные функции, которые JavaScript предопределяет для каждой строки. Одна из них — «length» — возвращает длину строки. То есть если Вы хотите вычислить длину «Hello world!», напишите:

Var c = "Hello world!".length;

Ранее мы присвоили эту строку переменной « а ». Таким образом, Вы сделали переменную « a » строкой, поэтому к ней тоже применима функция «length», и следующая операция даст такой же результат:

Var c = a.length;

Запомните, что Вы можете использовать «length» для любой строки — это встроенная функция. Вы можете вычислить длину любой строки , например: « location.href » или « document.title » или объявленной Вами.

Ниже я представлю список распространенных встроенных методов и свойств.

Строки и числа

В некоторых языках программирования от Вас требуется указывать, является ли переменная числом или строкой, перед тем, как делать с ней что-либо ещё. JavaScript проще относится к разнице между строками и числами. Фактически Вы даже можете складывать числа со строками:

Var c = a + 12;

В некоторых языках программирования обработка такой строки приведет к ошибке. Всё же « a » — это строка, а «12» — число. Однако JavaScript пытается решить проблему, предполагая, что «12» — тоже строка. Таким образом « с » принимает значение « Hello world!12 ». Значит, если Вы используете «+» со строкой и числом, JavaScript пытается сделать из числа строку. Если же Вы применяете математические операции к строке, JavaScript пробует превратить её в число. При отсутствии возможности перевода строки в число (например, из-за наличия в ней букв), JavaScript возвращает NaN — «Not a Number — не является числом».

Наконец, в JavaScript нет разницы между целыми величинами и числами с плавающей точкой.

Число → строка

Для преобразования числа в строку введите:

Var c = (16 * 24) / 49 + 12; d = c.toString();

После этого Вы можете применять к « d » все строковые методы, а « c » все ещё содержит число.

Строка → число

Если Вы хотите преобразовать строку в число, сначала убедитесь, что она состоит только из символов 0—9 . Для этого я просто умножаю строку на 1 .

Var c = "1234"; d = c * 1;

Так как умножение производится только с числами, JavaScript превращает строку в число, если это возможно. В противном случае, результат — NaN .

Заметим, если написать:

Var c = "1234"; d = c + 0;

Результатом будет « 12340 », потому что JavaScript использует «+» для соединения строк, а не их сложения.

Строковые свойства и методы

Так что же мы можем делать со строками? Объединение — это особый случай, но все остальные команды (методы) могут использоваться с любой строкой с помощью конструкции:

Имя_строки.метод();

Список встроенных методов JavaScript для работы со строками

Конкатенация — объединение строк

Во-первых, Вы можете объединить строки, сложив их вместе, вот так:

Document.write(a + b);

в результате получится: « Hello world!I am a student. ». Но, конечно же, Вы хотите, чтобы между предложениями был пробел. Для этого запишем код следующим образом:

Document.write(a + " " + b);

Так мы соединим три строки: « а », « " " » (один пробел) и « b », в итоге получив: « Hello world! I am a student. »

Вы можете использовать даже числа или вычисления, например:

Document.write (a + 3 * 3 + b);

Сейчас мы соединяем строку « а », затем результат выражения « 3 * 3 », рассматриваемый как строка, и « b », получая: « Hello world!9 I am a student. »

При использовании сложения нужно быть внимательным. Команда

Document.write (a + 3 + 3 + b);

соединяет 4 строки: « а », « 3 », « 3 » и « b », потому что «+» в данном случае означает «соединить строки», а не «сложить» и в результате: « Hello world!33 I am a student. ». Если Вы хотите сложить 3 и 3 перед созданием строки, используйте скобки.

Document.write (a + (3 + 3) + b);

Данное выражение соединяет строку « а », результат выражения « 3 + 3 » и « b », в итоге: « Hello world!6 I am a student. ».

indexOf

Один из самых широко используемых встроенных методов это «indexOf». Каждый символ имеет свой индекс, содержащий номер его позиции в строке. Заметим, что индекс первого символа — 0 , второго — 1 и т. д. Таким образом, индекс символа «w» в сроке « а » — 6 .

Используя «indexOf» мы можем вывести индекс символа. Напишите « .indexOf(" ") » после названия строки и вставьте искомый символ между кавычками. Например:

Var a = "Hello world!"; document.write(a.indexOf("w"));

возвратит 6 . Если символ встречается несколько раз, этот метод возвращает первое вхождение. То есть

Document.write(a.indexOf("o"));

возвратит 4 , потому что это индекс первой «o» в строке.

Вы также можете искать комбинацию символов. (Конечно, это тоже строка, но, чтобы избежать путаницы, я не буду называть её так). «indexOf» возвращает позицию первого символа комбинации. Например:

Document.write(a.indexOf("o w"));

тоже возвратит 4 , потому что это индекс «o».

Более того, возможен поиск символа после определенного индекса. Если Вы введете

Document.write(a.indexOf("o", 5));

то получите индекс первой «o», следующей за символом с индексом 5 (это пробел), то есть результат будет — 7 .

Если символ или комбинация не встречается в строке, «indexOf» возвратит « -1 ». Это, по сути, самое популярное применение «indexOf»: проверка существования определенной комбинации символов. Оно является ядром скрипта, определяющего браузер. Для определения IE Вы берете строку:

Navigator.userAgent;

и проверяете, содержит ли она « MSIE »:

If(navigator.userAgent.indexOf("MSIE") != -1) { //Какие-либо дествия с Internet Explorer }

Если индекс « MSIE » — не « -1 » (если « MSIE » встречается где-либо в строке), то текущий браузер — IE .

lastIndexOf

Также существует метод «lastIndexOf», который возвращает последнее вхождение символа или комбинации. Он действует противоположно «indexOf». Команда

Var b = "I am a student."; document.write(b.lastIndexOf("t"));

возвратит 13 , потому что это индекс последней «t» в строке.

charAt

Метод «charAt» возвращает символ, стоящий на указанной позиции. Например, когда Вы вводите

Var b = "I am a student."; document.write(b.charAt(5));

в результате получается « a », так как это символ на шестой позиции (помните, что индекс первого символа начинается с 0).

length

Метод «length» возвращает длину строки.

Var b = "I am a student."; document.write(b.length);

возвратит «15». Длина строки на 1 больше, чем индекс последнего символа.

split

« split » — это специальный метод, позволяющий разделить строку по определенным символам. Используется, когда результат необходимо заносить в массив, а не в простую переменную. Давайте разделим « b » по пробелам:

Var b = "I am a student." var temp = new Array(); temp = b.split(" ");

Теперь строка разбита на 4 подстроки, которые помещаются в массив « temp ». Сами пробелы исчезли.

Temp = "I"; temp = "am"; temp = "a"; temp = "student";

Метод «substring» используется для выделения части строки. Синтаксис метода: « .substring(первый_индекс, последний_индекс) ». Например:

Var a = "Hello world!"; document.write(a.substring(4, 8));

возвратит « o wo », от первой «o» (индекс 4) до второй (индекс 7). Заметьте, что «r» (индекс 8) не является частью подстроки.

Также можно написать:

Var a = "Hello world!"; document.write(a.substring(4));

Это даст целую подстроку « o world! », начиная от символа с индексом 4 и до конца строки.

substr

Также есть метод «substr», работающий немного по-другому. В качестве второго аргумента он использует не номер индекса, а количество символов. То есть

Document.write(a.substr(4, 8));

возвращает 8 символов, начиная от символа с индексом 4 («o»), то есть в результате получаем: « o world! »

toLowerCase и toUpperCase

Наконец, 2 метода, которые иногда могут Вам пригодиться: «toLowerCase» переводит всю строку в нижний регистр, а «toUpperCase» — в верхний.

Var b = "I am a student."; document.write(b.toUpperCase());

В результате получим « I AM A STUDENT. ».

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

Как Вы уже знаете из предыдущей статьи (Основы JavaScript), переменные объявляются с помощью ключевого слова var .

Здесь важно отметить, что регистр важен при объявлении и использовании переменной. То есть переменная var A и переменная var a , это две разные переменные. И то имя, которое задали переменной изначально, то и нужно использовать во всем скрипте.

Так как JavaScript является клиентским языком, то значения переменных хранятся в оперативную память пользователя. В языке PHP значения хранятся в оперативную память сервера.

Как правильно задать имя переменной в JavaScript

В имена переменных нельзя использовать специальные символы, такие как #, $, дефис, пробел, точка и другие. Можно использовать только буквы (рекомендуется строчные), цифры и знак подчеркивания(_).

Нельзя чтобы первым символом в имени было число. Например, так назвать можно bmw_93 а так нельзя 123_opel.

Также нельзя назвать переменную зарезервированными словами языка, как например var, for, if.

Список зарегистрированных слов в JavaScript

abstract boolean break
byte case catch
char class const
continue default do
double else extends
false final finally
float for function
goto if implements
import in instanceof
int interface long
native new null
package private protected
public return short
static super switch
synchronized this throw
throws transient true
try var void
while with

Рекомендуется наименовать переменные осмысленно, чтобы интуитивно было понятно, что за значение хранится в этой переменной, например для хранения количеств автомобилей можно использовать такое название count_cars а не abcsd.

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

Типы переменных

Любая объявляемая переменная относится к определенному типу. В программировании существует несколько типов данных, из которых более важными являются следующие:

  • Integer – В этот тип входят целые числовые числа, как положительные так и отрицательные (например: 1,2,4, -8, -100).
  • Double – В этот тип входят числа с плавающей точкой, они еще называются дробные числа (например 1.6, -9.8, 2.5). Они тоже могут быть и отрицательными.
  • String – Это строковые значения. К этому типу относится любой символ, любая буква или же строка. Все строковые значения должны быть объявлены в одинарные либо двойные кавычки.
  • Boolean – Данный тип является логическим. Он может иметь только одну из двух значений, это либо true (истина) либо false (ложь).
  • Массив – это сбор данных, которые могут быть разных типов. Существует два типа массивов, это числовой, у которого индексы(ключи) числовые и ассоциативный, со строчными индексами.
  • Объект – Может быть одним из двух типов данных, либо ассоциативный массив, либо экземпляр какого не будь класса.

Переменные можно использовать напрямую в строку. Для примера создадим несколько переменных разных типов и выведем их всех сразу, одной строкой.

Хочу отметить, что переменные всегда выводятся без кавычек.

Var age = 47; var money = 50.5; var name = " Ральф "; document.write("

Меня зовут " + name + ".
Мне " + age + " лет и у меня есть " + money + " рублей

");


Булевские переменные (тип Boolean) редко когда используются напрямую в строке. Они больше предназначены для сохранения результата разных логических операций. Потом этот результат чаще всего используется для условного оператора if, которого изучим в другой статье.

Для примера все-таки, попробуем их вывести в браузер.

Объявим две булевские переменные, одна со значением true а другая со значением false. И используем их в качестве ответов на двух вопросов.

Var bool_1 = true; var bool_2 = false; document.write("

Вопрос: Вы хотите стать программистом?
Ответ: " + bool_1 + " (Истина)

"); document.write("

Вопрос: Мальчик сделал уроки?
Ответ: " + bool_2 + " (Ложь)

");

Сохраняем документ и открываем его в браузере.

Как видите в JavaScript, значения булевских переменных отображаются, как заданы. В PHP они отображаются иначе.

Можно объявить переменную изначально без присваивания значения, потом по необходимости сделать это.

Var mouse; //Некий код mouse = "мышь";

Еще можно объявить сразу несколько переменных через запятую, используя ключевое слово var только один раз.

Var comp, television, auto; var count = 5, current_year = 2016, phone;

Массивы и объекты являются сложными типами данных, поэтому мы рассмотрим их в других статьях.

Арифметические операции

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

С начало объявим две переменные с произвольными числовыми значениями. Которые будем использовать в операциях.

Сложение переменных

И начнем мы с самой распространённой операции, со сложения.

Var x = - 8; var y = 14.7; //В переменную result вставляем результат сложения. var result = x + y; document.write(x + " + " + y + " = " + result);

В результате мы получим такое число 6.699999999999999.

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

Убираем переменную result и попробуем сложить переменные сразу при выводе.

Var x = - 8; var y = 14.7; //В переменную result вставляем результат сложения. document.write("

"); document.write("

");

Сохраняем документ и смотрим на результат:


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

Document.write("

" + x +" - "+ y +" = "+ (x-y) + "

"); document.write("

" + x +" * "+ y +" = "+ (x*y) + "

"); document.write("

" + x +" / "+ y +" = "+ (x/y) + "

");

И вот результат:


В программировании существует еще один важный оператор, с которым Вы точно, встречались и на уроке математике. Речь едет об операторе "остаток деления", он обозначается знаком процента (%) .

Чтобы лучше понять, как работает данный оператор, приведу небольшой пример.

Var x = 20; var y = 6; document.write("

" + x +" % "+ y +" = "+ (x%y) + "

"); //Результат: 2

Почему 20 % 6 равно 2 ? Потому что 6 * 3 равно 18 и до 20 остается 2. То есть 2 это остаток деления 20 / 6.

Данный оператор (%) чаще всего используется в циклах.

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

Инкремент - это увеличение значения переменной на единичку.

Например, есть какая-нибудь переменная x со значением 1. И мы хотим значение этой переменной увеличить на единичку. И вместо того чтобы написать так x = x + 1, лучше воспользоваться инкрементом и написать так x++, результатом будет 2.

Var x = 1; x++; //Вместо x = x + 1. document.write(" x = " + x); //Результат: x = 2.

Можно написать и так ++x, результатом тоже будет 2.

Var x = 1; ++x; //Вместо x = x + 1. document.write(" x = " + x); //Результат: x = 2

Если мы сделаем инкремент сразу при выводе, то в случае ++x, значение измениться, а в случае x++, нет, то есть значение останется той же.

Результат остается тот же.

Var x = 1; document.write(" x = " + (x++)); //Результат: x = 1

Значение увеличится на 1.

Var x = 1; document.write(" x = " + (++x)); //Результат: x = 2

Декремент – Это обратное операция инкремента. То есть уменьшение значение переменной на единичку.

Var x = 10; x--; //Вместо x = x - 1. document.write(" x = " + x); //Результат: x = 9

Все операции с инкрементом аналогичны и с декрементом.

Разница между x++ и ++x

var x = 5; var y; y = ++x; // y = 6, x = 6: сначала увеличивается x на 1, потом y = x. y = --x; // y = 5, x = 5: сначала уменьшается x на 1, потом y = x. y = x++; // y = 5, x = 6: сначала присваивается значение y = x, потом x увеличивается на 1. document.write(y); // y = 6

Инкремент всегда используется в циклах. Декремент тоже используется, но намного реже.

Сокращенные записи арифметических операций

Для всех арифметических операции существует и сокращенная запись. Оно действительно только когда хотим производить какую-то операцию только с одной переменной. Например:

  • вместо x = x + 10; можно написать так x += 10;
  • вместо x = x - 3; можно написать так x -= 3;
  • вместо x = x * 5; можно написать так x *= 5;
  • вместо x = x / 2; можно написать так x /= 2;
  • вместо x = x % 3; можно написать так x %= 3;

Строковые операции

Допустим, есть две переменные со строковыми значениями. Например, одна будет содержать слово ‘ша’ а другая ‘рик’. Мы хотим объединить эти слова, чтобы получилось слово ‘шарик’. Для этого воспользуемся операцией сложения.

Var slog_1 = "ша"; var slog_2 = "рик"; var word = slog_1 + slog_2; document.write(word); //Результат: шарик

Теперь обратим внимание на такой случай. Мы знаем, что в переменной можно записать и числа и строки, но также можно записать и строковые числа (например var = "64"). Допустим, у нас есть две таких переменных со строковыми числами и нам нужно сложить эти числа.

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

Var x = "78"; var y = "90"; document.write("result = "+ (x + y));//Результат: result = 7890

Поэтому перед тем как сделать какую-то операцию со строковыми числами необходимо сначала их преобразовать из строки в число. Делается это с помощью функции Number() .

Var x = "78"; var y = "90"; x = Number(x); y = Number(y); document.write("result = "+ (x + y));//Результат: result = 168

Теперь приступим к логическим операциям. Здесь используются только булевские данные, true(истина) и false(ложь).

Например, после сравнения двух чисел получаем какой-то булевский результат, либо true, либо false.

Var count_ball = 16, сount_players = 32, compare; compare = count_ball > count_players; document.write(count_ball + " > " + count_players + " = " + compare + "
"); //false compare = count_ball < count_players; document.write(count_ball + " < " + count_players + " = " + compare + "
"); //true

Данные операции чаще всего используются в условных операторах if, else.

Для лучшего понимания, покажу Вам таблицу истинности. Ее Вы должны знать наизусть. Для этого достаточно ее понять.


Вместо true может быть 1, а вместо false 0.

&& - Это оператор AND, то есть И. Его можно понять как оператор умножения.

  • 0(false) && 0(false) = 0(false)
  • 0(false) && 1(true) = 0(false)
  • 1(true) && 0(false) = 0(false)
  • 1(true) && 1(true) = 1(true)

|| - Это оператор OR, то есть ИЛИ. Его можно понять как оператор сложение.

  • 0(false) || 0(false) = 0(false)
  • 0(false) || 1(true) = 1(true)
  • 1(true) || 0(false) = 1(true)
  • 1(true) || 1(true) = 1(true)

Символ "|" на клавиатуре печатается с помощью комбинации клавиш Shift + Back slesh(Обратный слеш \).

^ - Это оператор XOR, то есть Исключающее ИЛИ. Он используется редко. Но его нужно знать по любому, вдруг понадобится.

  • 0(false) ^ 0(false) = 0(false)
  • 0(false) ^ 1(true) = 1(true)
  • 1(true) ^ 0(false) = 1(true)
  • 1(true) ^ 1(true) = 0(false)

Вот и все о чем хотел Вам рассказать в этой статье. Теперь Вы знаете, какие типы переменных существуют в программировании и как использовать их в различных арифметических и логических операциях.

Операторы: - (вычитание ), + (сложение ), * (умножение ) и / (деление ) работают точно так же, как и арифметические действия в математике. Оператор % (деление с остатком ) возвращает остаток от деления первого операнда на второй. Результат деления с остатком будет иметь тот же знак, что и первый операнд:

Alert(10 + 2); // 12 alert(10 - 2); // 8 alert(10 * 2); // 20 alert(10 / 2); // 5 alert(5 % 2); // 1 alert(-5 % 2); // -1

Оператор ** (возведение в степень ) имеет два операнда. Первый операнд является основанием степени, второй операнд - показателем степени, в результате оператор возвращает основание, возведённое в указанную степень:

2 ** 4; // 16

Все математические операторы преобразуют операнды по тем же правилам, что и функция Number() .

Унарные + (плюс) и - (минус)

Оператор + (унарный плюс ) преобразует значение своего операнда в число и возвращает преобразованное значение. При использовании с числовым операндом он не выполняет никаких действий:

Var x = +"5";

Оператор - (унарный минус ) преобразует значение своего операнда в число, если это необходимо, и затем делает число отрицательным:

Var x = -5 + 3;

Унарные плюс и минус преобразуют операнды по тем же правилам, что и функция Number() .

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

Оператор ++ (инкремент ) увеличивает значение своего операнда на единицу. Если значение операнда не является числом, оператор автоматически преобразует его в число, увеличивает на единицу и возвращает результат, который присваивается обратно операнду.

Инкремент имеет две формы - постфиксную (оператор ставится после операнда) и префиксную (оператор ставится перед операндом). Если он используется в постфиксной форме, то сначала возвращается исходное значение операнда, и только затем значение операнда увеличивается на единицу.

JavaScript - Урок 1. Основные понятия

Язык программирования JavaScript был разработан фирмой Netscape в сотрудничестве с Sun Microsystems и анансирован в 1995 году. JavaScript предназначен для создания интерактивных html-документов. Основные области использования JavaScript:
  • Создание динамических страниц, т.е. страниц, содержимое которых может меняться после загрузки.

  • Проверка правильности заполнения пользовательских форм.

  • Решение "локальных" задач с помощью сценариев.

  • JavaScript-код - основа большинства Ajax-приложений.

JavaScript позволяет создавать приложения, выполняемые на стороне клиента, т.е. эти приложения выполняются браузером на компьютере пользователя.

Программы (сценарии) на этом языке обрабатываются встроенным в браузер интерпретатором. К сожалению, не все сценарии выполняются корректно во всех браузерах, поэтому тестируйте свои javascript-программы в различных браузерах.

Язык JavaScript регистрозависимый, т.е. заглавные и прописные буквы алфавита считаются разными символами.

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

Литералы

Литералы - это простейшие данные с которыми может работать программа.

  • Литералы целого типа - целые числа в представлении:
    • десятичном, например: 15, +5, -174.

    • шестнадцатеричном, например: 0х25, 0хff. Шестнадцатеричные числа включают цифры 0 - 9 и буквы a, b, c, d, e, f. Записываются они с символами 0х перед числом.

    • восьмеричном, например: 011, 0543. Восьмеричные числа включают только цифры 0 - 7.


  • Вещественные литералы - дробные цисла. Целая часть отделяется от дробной точкой, например: 99.15, -32.45. Возможна экспоненциальная форма записи, например: 2.73e -7 . В привычном виде это 2.73Х10 -7 , но в javascript знак умножения и 10 заменяются символом -e-.

  • Логические значения - из два: истина (true) и ложь (false).

  • Строковые литералы - последовательность символов, заключенная в одинарные или двойные кавычки. Например: "ваше имя", "ваше имя".
Переменные

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

Например:
var test
var _test
var _my_test1

Каждой переменной можно присвоить значение либо при ее инициализации (объявлении), либо в коде самой программы. Оператор присваивания обозначается знаком равно (= ), но знак равенства здесь не имеет своего прямого значения. В данном случае он лишь указывает на то, что данной переменной присвоили значение.

Например:
var a=15
var b=23.15
var c="выполнено"
var s=true

Каждая переменная имеет тип, определяемый значением переменной. Так в нашем примере: переменные a и b имеют тип number , переменная c имеет тип string , а переменная s - логический тип.

Выражения

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

В выражении a*b, a и b называются операндами , а * - знак операции. В javascript определены следующие операции:

Операторы в выражении вычисляются слева направо в соответствии с приоритетами арифметических операций. Изменить порядок вычисления можно с помощью скобок.

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

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

Для того, чтобы можно было сравнивать два значения в javascript определены операции сравнения, результатом которых может быть только логическое значение: true или false:

В javascript определены логические операции:

&& - логическое И (AND),

|| - логическое ИЛИ (OR),

! - логическое НЕ (NOT).

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

A B A&&B A||B !A
true true true true false
true false false true false
false true false true true
false false false false true

Проще говоря, значение выражения A&&B истинно, если истинны оба оператора, и ложно в противном случае. Значение выражения A||B истинно, если значение хотя бы одного операнда истинно, и ложно в противном случае. Если значение операнда А истинно, то!A - ложно и наоборот.

Для строковых литералов определена операция конкатенация строк , т.е. их объединение. Обозначается эта операция знаком плюс (+). Результатом выполнения операции является также строка. Пример:

Var st1="Привет";
var st2="Вася";
var st3=st1+st2;

В результате в переменной st3 будет значение "Привет Вася".

В конце приведем таблицу приоритетов операций в порядке их убывания. Приоритет операций определяет порядок, в котором выполняются операции в выражении.

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

Тип данных строка (string) используется для представления текста. Соответственно, значениями типа string является текст. Любой текст в JavaScript является строкой.

Кавычки

Строки в JavaScript должны быть заключены в кавычки. В JavaScript существует три вида кавычек: двойные (" "), одинарные (" ") и обратные (` `):

"Строка в двойных кавычках" "Строка в одинарных кавычках" `Строка в обратных кавычках`

Вид кавычек в начале и конце строки должен совпадать.

Строки могут состоять из нуля и более символов:

"" // Пустая строка "Строка" // Не пустая строка

Строки с двойными и одинарными кавычками ничем не отличаются между собой по функционалу - они могут содержать лишь текст и управляющие последовательности. А вот строки с обратными кавычками имеют более широкий функционал. Такие строки могут содержать так называемые подстановки , обозначаемые знаком доллара и фигурными скобками ${выражение} . Подстановки могут содержать любые произвольные выражения:

Let стр = "Мир!"; let стр2 = `Привет, ${стр}`; // Использование переменной в строке alert(стр2); // Привет, Мир! alert(`2 + 3 = ${2 + 3}.`); // 2 + 3 = 5.

Выражение, расположенное в подстановке (${...}) вычисляется, и его результат становится частью строки.

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

Let числа = `Числа: 1 2`; alert(числа); // Числа: // 1 // 2

Строки с обратными кавычками называются строками-шаблонами или шаблонными литералами .

Строки, заключённые в одни кавычки, могут содержать другие кавычки:

"одинарные "кавычки" и `обратные` внутри двойных" "а здесь "так" и `так`!" `а здесь "так" и "так"!`

Для удобства, большие строковые литералы можно разбивать на несколько строк, заканчивая каждую строку, кроме последней, символом \ :

Alert("это всё одна \ длинная \ строка"); // это всё одна длинная строка alert("это всё одна \ длинная \ строка"); // это всё одна длинная строка alert(`это всё одна \ длинная \ строка`); // это всё одна длинная строка

Кодировка символов строки

Вне зависимости от того, какая кодировка установлена для страницы, в JavaScript для строк всегда используется кодировка UTF-16.

В JavaScript строка - это неизменяемая, упорядоченная последовательность 16-битных значений, каждое из которых представляет символ Unicode. Для представления символов Unicode в JavaScript используется кодировка UTF-16. Символы включают в себя буквы, цифры, знаки пунктуации, специальные символы и пробельные символы.

Длина строки

Длина строки - это количество 16-битных значений (а не самих символов), содержащихся в ней. Длину строки содержит свойство length:

Alert("Привет".length); // 6

Символы, кодовые пункты которых не умещаются в 16 бит, обрабатываются в соответствии с правилами кодировки UTF-16 как последовательности из двух 16-битных значений. Это означает, что строка, имеющая длину, равную 2 (два 16-битных значения), на деле может представлять единственный символ:

Alert("a".length); // 1 alert("𝑒".length); // 2

Нумерация и доступ к символам строки

Как уже было сказано, строка представляет собой упорядоченную последовательность 16-битных значений, каждому из которых соответствует определённый символ. Нумерация 16-битных значений в строке начинается с нуля, т. е. первое 16-битное значение находится под индексом 0, второе - под индексом 1 и т. д. Индекс - это порядковый номер.

Получить символ строки (состоящий из одного 16-битного значения) можно с помощью индекса, заключённого в квадратные скобки [индекс] :

Let стр = "Привет"; alert(стр); // П alert(стр); // В

Чтобы с помощью индексов обратиться к символу, состоящему из двух 16-битных значений, нужно, используя конкатенацию, написать эти индексы так, чтобы в результате получилась последовательность из двух 16-битных значений:

Let стр = "𝑒"; alert(стр + стр); // "𝑒"

Строки неизменяемые

В JavaScript строки неизменяемые. Это значит, что в уже существующей строке нельзя менять никакие символы или добавлять в неё что-то новое.

Так как строки неизменяемые, то методы, используемые для работы со строками, возвращают новые строки, а не изменяют ту строку, относительно которой они были вызваны:

Let стр = "Привет!"; alert(стр.toUpperCase()); // "HELLO" - новое возвращаемое методом значение alert(стр); // "hello" - первоначальная строка не изменена

Чтобы изменить строку, можно создать новую строку и записать её в ту же самую переменную вместо старой строки:

Let стр = "Строка"; стр = стр.toUpperCase(); alert(стр); // "СТРОКА"

Управляющие последовательности

В строковых литералах можно использовать управляющие последовательности. Управляющая последовательность - это последовательность, состоящая из обычных символов, которая обозначает символ, не представимый внутри строки другими способами. Управляющие последовательности предназначены для форматирования вывода текстового содержимого.

В таблице ниже представлены управляющие последовательности:

Последовательность Значение
\0 Символ NUL - пустой символ ("\u0000").
\t Горизонтальная табуляция ("\u0009").
\n Перевод на новую строку ("\u000A").
\b Возврат на одну позицию - то, что происходит при нажатии на клавишу backspace ("\u0008").
\r Возврат каретки ("\u000D").
\f Перевод страницы - очистка страницы ("\u000C").
\v Вертикальная табуляция ("\u000B").
\" Двойная кавычка ("\u0022").
\" Одинарная кавычка ("\u0027").
\\ Обратный слэш ("\u005C").
\xNN Номер символа из набора символов ISO Latin-1, заданный двумя шестнадцатеричными цифрами (N - шестнадцатеричная цифра 0-F). Например, "\x41" (это код буквы "A").
\uNNNN Номер символа из набора символов Unicode, заданный четырьмя шестнадцатеричными цифрами (N - шестнадцатеричная цифра 0-F). Например, "\u0041" (это код буквы "A"s).

Управляющие последовательности могут находиться в любом месте строки:

Alert("Греческая буква сигма: \u03a3."); // Греческая буква сигма: Σ. alert("Многострочная\nстрока") // Многострочная // строка alert("внутри используются \"двойные\" кавычки"); // внутри используются "двойные" кавычки

Если символ \ предшествует любому символу, отличному от приведённых в таблице, то он просто игнорируется интерпретатором:

Alert("\k"); // "k"

Символы Unicode, указываемые с помощью управляющей последовательности, можно использовать не только внутри строковых литералов, но и в идентификаторах:

Let a\u03a3 = 5; alert(a\u03a3); // 5

Конкатенация

Конкатенация - это объединение двух или более строк в одну большую. Объединение происходит с помощью оператора + (плюс). При конкатенации каждая последующая строка добавляется в конец предыдущей:

Var str1 = "Hello "; var str2 = "World!"; document.write(str1 + str2 + "
"); // "Hello World!" document.write(str1 + "World!"); Попробовать »

Значение любого типа, которое объединяется со строкой, будет неявно (автоматически) преобразовано в строку и далее будет произведена конкатенация.

Var str1 = "Hello "; alert(str1 + 1); // "Hello 1" alert(true + str1); // "trueHello" alert(str1 + NaN); // "Hello NaN"