Как вывести две переменные в одну строку python

Обмен значений переменных

Если попытаться сделать такой обмен, сначала присвоив первой переменной значение второй, а второй — значение первой, ничего не получится. Допустим, есть две переменные a и b . При этом a = 5 и b = 6 . Если выполнить выражение a = b , то переменная a будет хранить число 6, также как и b . Число 5 будет утеряно. После этого выражение b = a теряет смысл, так как b будет присвоено его же текущее значение. В данном случае 6.

Поэтому в программировании при обмене значений переменных обычно вводят третью, играющую роль буфера (буферная переменная). В ней сохраняют значение первой переменной, потом первой присваивают значение второй, a новое значение для второй берут из буфера.

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

a = 5 b = 6 buf = a a = b b = buf

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

a = input('a: ') b = input('b: ') buf = a a = b b = buf print('a =', a) print('b =', b)

Пример выполнения программы:

a: 91 b: 162 a = 162 b = 91

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

a = 5 b = 7 a = a + b # 12 b = a - b # 12-7=5 a = a - b # 12-5=7

a = int(input('a: ')) b = int(input('b: ')) a = a + b b = a - b a = a - b print('a =', a) print('b =', b)

Третий вариант — использовать имеющееся в Python множественное присваивание. При этом обмен значений переменных выполняется одной строкой кода:

>>> a = 10 >>> b = 20 >>> a, b = b, a >>> a 20 >>> b 10

Почему такое возможно? В Питоне есть такая структура данных как кортеж.

При выполнении a, b = b, a интерпретатор Python сначала получает значения связанные с переменными b и a (правая часть) и помещает их в кортеж, в данном случае получится (10, 20) . После этого он связывает каждый элемент кортежа в определенной позиции с переменными в той же позиции, но расположенными слева.

Таким образом можно поменять значения не только двух переменных, также трех и более. Кроме того в Python можно обменивать значения переменных разных типов. Это связано с тем, что тип данных в Питоне привязан не к переменной, а к значению:

>>> a = 14 >>> b = 18 >>> c = 16 >>> a,b,c = c,a,b >>> a,b,c (16, 14, 18) >>> d = 4.56 >>> e = "hi" >>> d,e = e,d >>> d 'hi' >>> e 4.56

X Скрыть Наверх

Решение задач на Python

2. Переменные, выражения и предложения¶

Значение — это одна из фундаментальных вещей, которыми манипулирует программа. Значения, которые мы уже видели в главе 1:

2 (результат сложения 1 + 1 ) и
"Hello, World!" .

Эти значения относятся к разным типам: 2 — целое число, а "Hello, World!" — строка, представляющая собой последовательность символов. Строковые значения можно опознать по кавычкам, в которые они заключаются.

Предложение print работает не только со строками, но и с целыми числами.

>>> print 4 4

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

>>> type(«Hello, World!») >>> type(17)

Строки (англ.: string) принадлежат типу str, а целые числа (англ.: integer) — типу int.

Не столь очевидно, что числа, имеющие целую и дробную части, относятся к типу float (англ.: плавать). Название типа данных объясняется тем, что такие числа в компьютере представляются в формате с плавающей точкой.

В России при записи чисел, имеющих целую и дробную части, принято отделять целую часть от дробной при помощи запятой, например: 3,2 . Тогда как во многих других странах, а также в языках программирования (и Python не является исключением), целую часть числа от дробной отделяют при помощи точки. В таких случаях точку называют десятичной точкой.

>>> type(3.2)

Что касается запятой, то она является допустимым символом в Python, но используется для других целей. Хотя 3,2 — неверная запись числа, это допустимая конструкция Python. Если попробовать вывести значение 3,2 , то получим:

>>> print 3,2 3 2

Python интерпретирует 3,2 как список из двух элементов: 3 и 2 . Поэтому не пользуйтесь запятыми для записи чисел с целой и дробной частью!

А что можно сказать о таких значениях, как "17" и "3.2" ? Они выглядят как числа, но они заключены в кавычки, как строки.

>>> type(«17») >>> type(«3.2»)

Строки в Python могут заключаться в одиночные (‘) или в двойные кавычки (”):

>>> type(‘This is a string.’) >>> type(«And so is this.»)

Строки, заключенные в двойные кавычки, могут содержать внутри одинарные кавычки, как в "Say 'Hello'" , а строки, заключенные в одинарные кавычки, могут содержать двойные кавычки, как в 'Say "Hi"' .

2.2. Переменные¶

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

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

>>> message = "Say 'Hello'" >>> n = 17 >>> pi = 3.14159

В этом примере три предложения присваивания. Первое присваивает строку "Say 'Hello'" новой переменной с именем message . Второе присваивает целое значение 17 переменной n , а третье присваивает число с плавающей точкой 3.14159 переменной pi .

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

>>> 17 = n

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

Имена и значения переменных

Предложение print также работает с переменными.

>>> print message Say 'Hello' >>> print n 17 >>> print pi 3.14159

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

>>> type(message) >>> type(n) >>> type(pi)

Тип переменной в Python есть тип присвоенного ей значения.

Замечание: Для работы со строковыми значениями на русском языке, или любом другом языке, в котором используются символы, отличные от латинских, нужно познакомиться с тем, что такое кодировка и кое-чему дополнительно научиться. Подробности можно найти в Приложении A. Как научить Python русскому языку.

2.3. Имена переменных и ключевые слова¶

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

Имена переменных могут быть произвольной длины. Они могут содержать буквы и цифры, но обязаны начинаться с буквы. Хотя допустимо использовать буквы верхнего регистра, по существующему соглашению они не используются. Если вы захотите их использовать, помните, что регистр имеет значение. Bruce и bruce — это две разные переменные.

В имени можно использовать символ подчеркивания ( _ ). Он часто используется в именах, состоящих из нескольких слов, таких, как my_name или price_of_tea_in_china .

Если дать переменной недопустимое имя, это приведет к синтаксической ошибке:

>>> 76trombones = "big parade" SyntaxError: invalid syntax >>> more$ = 1000000 SyntaxError: invalid syntax >>> SyntaxError: invalid syntax

Имя 76trombones недопустимо потому, что начинается не с буквы. Имя more$ неправильно потому, что содержит недопустимый символ доллара. А что не так с class ?

Слово class является одним из ключевых слов Python. Ключевые слова определяют правила и структуру языка, и не могут использоваться как имена переменных.

В языке Python 31 ключевое слово:

and	as	assert	break	class	continue
def	del	elif	else	except	exec
finally	for	from	global	if	import
in	is	lambda	not	or	pass
print	raise	return	try	while	with
yield

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

2.4. Предложения¶

Предложение — это инструкция, которую интерпретатор Python может выполнить. До сих пор мы видели два вида предложений: print и присваивание.

Если ввести предложение в строке с приглашением, Python выполнит его и отобразит результат, если таковой имеется. Результатом выполнения предложения print является выведенное значение. Предложение присваивания не производит результата.

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

print 1 x = 2 print x

Обратите внимание, что предложение присваивания ничего не выводит.

2.5. Вычисление выражений¶

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

>>> 1 + 1 2

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

>>> 17 17 >>> x 2

Обратите внимание, что вычисление выражения и отображение результата — не то же самое, что печать значения выражения.

>>> message = "Say 'Hello'" >>> message "Say 'Hello'" >>> print message Say 'Hello'

Когда Python в интерактивном режиме отображает значение выражения, он использует тот же формат, который используется для ввода значения. В случае строк это означает, что кавычки также выводятся. А предложение print печатает значение выражения, которым в данном случае является содержание строки (без кавычек).

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

17 3.2 "Hello, World!" 1 + 1

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

2.6. Операторы и операнды¶

Операторы — это специальные символы, обозначающие операции, например, такие, как сложение и умножение. Значения, с которыми работает оператор, называются операндами.

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

20 + 32 hour - 1 hour * 60 + minute minute / 60 5 ** 2 (5 + 9) * (15 - 7)

Символы + , - и / , а также использование скобок для группировки операций, означают в Python то же, что и в математике. Звездочка * обозначает умножение, а две звездочки подряд ** обозначают возведение в степень. Пробелы вокруг операторов не обязательны, однако они облегчают чтение выражений.

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

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

>>> minute = 59 >>> minute / 60 0

Значением minute является 59, а 59, деленное на 60, дает 0.98333, а не 0. Полученный результат объясняется тем, что Python выполняет целочисленное деление.

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

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

>>> minute * 100 / 60 98

Вновь результат округлен в меньшую сторону, но, по крайней мере, теперь он приблизительно правильный.

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

2.7. Порядок выполнения операций¶

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

Скобки имеют наивысший приоритет. Поскольку выражение в скобках вычисляется первым, то 2 * (3 - 1) дает 4, а (1 + 1) ** (5 - 2) дает 8. Можно использовать скобки и для того, чтобы сделать выражения легче для чтения, например, (minute * 100) / 60 , хотя на результат это никак не влияет.
Возведение в степень имеет следующий приоритет после скобок, так что 2 ** 1 + 1 дает 3, а не 4, и 3 * 1 ** 3 дает 3, а не 27.
Умножение и деление имеют одинаковый приоритет, более высокий, чем сложение и вычитание, приоритет которых также одинаковый. Так, 2 * 3 - 1 дает 5, а не 4, и 2 / 3 - 1 даст -1, а не 1 (помните о целочисленном делении, 2 / 3 = 0).
Операторы с одинаковым приоритетом вычисляются слева направо. Так, в выражении minute * 100 / 60 сначала выполняется умножение, что дает 5900 / 60, которое, в свою очередь, дает 98. Если бы операции выполнялись справа налево, результат бы был 59 * 1 , что дает 59, и в целом неверно.

2.8. Операции над строками¶

Нельзя выполнять математические операции над строками, даже если строки выглядят как числа. Следующие выражения недопустимы (предполагаем, что message имеет тип str ):

message - 1 "Hello" / 123 message * "Hello" "15" + 2

Интересно, что оператор + все же работает со строками, хотя и делает не то, чего можно было бы ожидать. Для строк оператор + выполняет конкатенацию, то есть соединение двух операндов вместе. Например:

>>> fruit = "banana" >>> baked_good = " nut bread" >>> print fruit + baked_good banana nut bread

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

Оператор * также работает со строками. Он выполняет повторение строки. Например, 'Fun' * 3 дает 'FunFunFun' . Один из операндов обязан быть строкой, другой — целым числом.

С одной стороны, такая интерпретация символов + и * имеет смысл по аналогии со сложением и умножением. Так же, как 4 * 3 эквивалентно 4 + 4 + 4 , мы ожидаем, что "Fun" * 3 будет эквивалентно "Fun" + "Fun" + "Fun" , и так оно и есть. С другой стороны, есть существенный момент, который отличает конкатенацию и повторение строк от сложения и умножения чисел. Можете сами отыскать свойство, которым обладают сложение и умножение чисел, но не обладают конкатенация и повторение строк?

2.9. Ввод¶

В Python есть две встроенные функции для получения ввода с клавиатуры:

n = raw_input("Please enter your name: ") print n n = input("Enter a numerical expression: ") print n

Пример выполнения этого скрипта может выглядеть так:

$ python tryinput.py Please enter your name: Arthur, King of the Britons Arthur, King of the Britons Enter a numerical expression: 7 * 3 21

Каждая из этих функций позволяет внутри скобок указать приглашение для пользователя.

2.10. Композиция¶

До сих пор мы рассматривали элементы программ — переменные, выражения и предложения — по отдельности, не затрагивая вопроса о том, как их комбинировать.

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

>>> print 17 + 3 20

В действительности, сложение должно быть выполнено до вывода, так что действия, на самом деле, выполняются не одновременно. Важно то, что любое выражение, включающее числа, строки и переменные, может использоваться в предложении print:

print "Number of minutes since midnight: ", hour * 60 + minute

Можно также поместить произвольные выражения в правую часть предложения присваивания:

percentage = (minute * 100) / 60

Как видите, композиция позволяет записывать сложные вычисления кратко и выразительно.

Предупреждение: Существуют ограничения на то, где можно использовать определенные выражения. Например, левая часть предложения присваивания должна быть именем переменной, а не выражением. Поэтому следующее предложение неверно: minute + 1 = hour .

2.11. Комментарии¶

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

Поэтому хорошей идеей является добавление к вашим программам заметок, которые бы на естественном языке объясняли, что делает программа. Такие заметки называются комментариями, и помечаются символом # :

# calculate elapsed hour percent percentage = (minute * 100) / 60

В этом случае комментарий занимает целую строку. Можно также поместить комментарий в конец строки, содержащей предложение Python:

percentage = (minute * 100) / 60 # integer division!

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

Замечание: Для того, чтобы писать комментарии в скриптах на русском языке, необходимо специально позаботиться о кодировке, используемой для хранения текста вашей программы на Python. Подробности можно найти в Приложении A. Как научить Python русскому языку.

2.12. Глоссарий¶

int Тип данных Python, представляющий положительные и отрицательные целые числа. float Тип данных Python, представляющий числа с плавающей точкой. Числа с плавающей точкой имеют внутреннее представление, состоящее из двух частей: мантиссы и степени. При выводе в стандартном формате, они выглядят как десятичные числа с целой и дробной частями. Используя тип float , имейте в виду, что возможны ошибки округления, и всегда помните, что имеете дело с приблизительными значениями. str Тип данных Python, представляющий последовательности символов. выражение Комбинация переменных, операторов и значений, результатом вычисления которой является единственное значение. значение Число или строка (или что-то другое, о чем мы поговорим позднее), которые могут быть сохранены в переменной или использованы в выражении. имя переменной Имя, данное переменной. Имена переменных в Python есть последовательность букв ( a..z, A..Z ), цифр ( 0..9 ) и символа _ , начинающаяся с буквы или символа подчеркивания. Хорошей практикой программирования является выбор таких имен для переменных, которые описывают использование этих переменных в программе. ключевое слово Слово, зарезервированное для специального использования в языке программирования. На ключевые слова опирается компилятор при синтаксическом разборе программы; нельзя использовать ключевые слова, например, if , def и while , в качестве имен переменных. комментарий Информация в программе, предназначенная для программистов (или любого читателя исходного кода) и не оказывающая влияния на выполнение программы. композиция Комбинирование простых выражений и предложений в составные для того, чтобы представить сложные вычисления в удобной и краткой форме. конкатенация Соединение двух строк. операнд То, над чем выполняется операция. оператор Специальный символ, который обозначает операцию, например, сложение, умножение или конкатенацию строк. оператор присваивания Символ = есть оператор присваивания в Python. Его не следует путать со знаком равенства в математике, так как они семантически различны. переменная Имя, связанное со значением. предложение Инструкция, которую интерпретатор Python может выполнить. Примерами предложений языка программирования являются предложение присваивания и предложение print. предложение присваивания

Предложение, которое присваивает значение имени (переменной). Слева от оператора присваивания = находится имя, справа — выражение, которое вычисляется интерпретатором Python и затем присваивается имени. Разница между левой и правой частями предложения присваивания часто сбивает с толку начинающих программистов. В следующем предложении присваивания:

n = n + 1

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

приоритет операций Набор правил, управляющий порядком вычисления выражений, включающих более одного оператора. тип данных Множество значений. Тип значения определяет, как это значение можно использовать в выражениях. Типы, которые мы встречали до сих пор: целые числа (тип int ), числа с плавающей точкой (тип float ) и строки (тип str ). целочисленное деление Операция деления целого на целое, результатом которой является целое. Целочисленное деление дает полное число раз, которое делитель умещается в делимое, и отбрасывает остаток.

2.13. Упражнения¶

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

>>> print n = 7

Работа с текстом — строки в JavaScript

Теперь мы обратим внимание на строки — в программировании так называют части текста. В этой статье мы рассмотрим все распространённые вещи, которые вы должны действительно знать о строках при изучении JavaScript, например, создание строк, экранирование кавычек в строках и объединение строк вместе.

Необходимые навыки:	Базовая компьютерная грамотность, базовое понимание HTML и CSS, понимание что такое JavaScript.
Цель:	Знакомство с основами строк в JavaScript.

Сила слов

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

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

Строки — основы

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

Создание строки

Для начала введите следующие строки:

const string = "Революция не будет транслироваться по телевидению."; string;

const badString = Тест; const badString = 'Тест; const badString = Тест';

const badString = string; badString;

Одиночные кавычки vs. Двойные кавычки

В JavaScript вы можете выбрать одинарные кавычки или двойные кавычки, чтобы обернуть ваши строки. Оба варианта будут работать нормально:

const sgl = "Одиночные кавычки."; const dbl = "Двойные кавычки."; sgl; dbl;

const badQuotes = 'Что происходит?";

const sglDbl = 'Я не сказала "да", милорд…'; const dblSgl = "Вы не сказали 'нет'… (королева, Бэкингем)"; sglDbl; dblSgl;

const bigmouth = 'Жанна Д'Арк — народная героиня Франции.';

Экранирование кавычек в строках

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

const bigmouth = "Жанна Д'Арк — народная героиня Франции."; bigmouth;

Так лучше. Таким же образом можно экранировать и другие символы, например «\ . Кроме того существуют специальные коды. Для дополнительной информации см. Escape notation.

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

Конкатенация — это новомодное программистское слово, которое означает «объединить». Объединение строк в JavaScript использует оператор плюс (+), тот же, который мы используем для сложения чисел, но в этом контексте он делает кое-что другое. Попробуем пример в нашей консоли.

const one = "Привет, "; const two = "как дела?"; const joined = one + two; joined;

const multiple = one + one + one + one + two; multiple;

const response = one + "Я в порядке — " + two; response;

Примечание: Когда вы вводите фактическую строку в свой код, заключённую в одинарные или двойные кавычки, она называется строковым литералом.

Конкатенация строк в контексте

Давайте посмотрим на конкатенацию строк в действии — вот пример из предыдущего курса:

button>Press mebutton>

const button = document.querySelector("button"); button.onclick = function ()  const name = prompt("Как тебя зовут?"); alert("Привет, " + name + ", рад тебя видеть!"); >;

Здесь мы используем функцию Window.prompt () в строке 4, которая просит пользователя ответить на вопрос через всплывающее диалоговое окно, а затем сохраняет введённый текст внутри заданной переменной — в этом случае name . Затем мы используем функцию Window.alert () в строке 5 для отображения другого всплывающего окна, содержащего строку, которую мы собрали из двух строковых литералов и переменной name .

Числа vs. строки

Итак, что происходит, когда мы пытаемся добавить (или конкатенировать) строку и число? Попробуем это в нашей консоли:

"Front " + 242;

const myDate = "19" + "67"; typeof myDate;

Объект Number преобразует всё переданное в него в число, если это возможно. Попробуйте следующее:

const myString = "123"; const myNum = Number(myString); typeof myNum;

const myNum = 123; const myString = myNum.toString(); console.log(typeof myString);

Эти конструкции могут быть действительно полезны в некоторых ситуациях. Например, если пользователь вводит число в текстовое поле формы, данные будут распознаны как строка. Однако, если вы хотите добавить это число к чему-то, вам понадобится его значение, поэтому вы можете передать его через Number() , чтобы справиться с этим. Именно это мы сделали в нашей Number Guessing Game, в строке 59.

Совмещение строк с различными выражениями

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

const song = "Fight the Youth"; const score = 9; const highestScore = 10; const output = `Мне нравится песня $song>. Я оценил её на $ (score / highestScore) * 100 >%.`; console.log(output); // "Мне нравится песня Fight the Youth. Я оценил её на 90%."

Многострочный текст

Литералы шаблона учитывают разрывы строк в исходном коде, поэтому вы можете писать текст в несколько строчек, например:

const output = `Мне нравится эта песня. Я оценил её на 90%.`; console.log(output); /* Мне нравится эта песня. Я оценил её на 90%. */

Чтобы получить эквивалентный вывод с использованием обычной строки, вам придется включить в строку символы переноса строки ( \n ):

const output = "Мне нравится эта песня.\nЯ оценил её на 90%."; console.log(output); /* Мне нравится эта песня. Я оценил её на 90%. */

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

Заключение

Итак, это основы строк, используемых в JavaScript. В следующей статье мы рассмотрим некоторые из встроенных методов, доступных для строк в JavaScript и то, как мы можем использовать их для управления нашими строками только в той форме, в которой мы хотим.

В этом модуле

Что такое JavaScript?
Первое погружение в JavaScript
Что пошло не так? Устранение ошибок JavaScript
Переменные — место хранения необходимой информации
Базовая математика в JavaScript — числа и операторы
Работа с текстом — строки в JavaScript
Полезные методы для строк
Массивы
Генератор глупых историй

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 8 окт. 2023 г. by MDN contributors.

Your blueprint for a better internet.

Переменные

JavaScript-приложению обычно нужно работать с информацией. Например:

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

Переменные используются для хранения этой информации.

Переменная

Переменная – это «именованное хранилище» для данных. Мы можем использовать переменные для хранения товаров, посетителей и других данных.

Для создания переменной в JavaScript используйте ключевое слово let .

Приведённая ниже инструкция создаёт (другими словами, объявляет) переменную с именем «message»:

let message;

Теперь можно поместить в неё данные (другими словами, определить переменную), используя оператор присваивания = :

let message; message = 'Hello'; // сохранить строку 'Hello' в переменной с именем message

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

let message; message = 'Hello!'; alert(message); // показывает содержимое переменной

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

let message = 'Hello!'; // определяем переменную и присваиваем ей значение alert(message); // Hello!

Мы также можем объявить несколько переменных в одной строке:

let user = 'John', age = 25, message = 'Hello';

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

Многострочный вариант немного длиннее, но легче для чтения:

let user = 'John'; let age = 25; let message = 'Hello';

Некоторые люди также определяют несколько переменных в таком вот многострочном стиле:

let user = 'John', age = 25, message = 'Hello';

…Или даже с запятой в начале строки:

let user = 'John' , age = 25 , message = 'Hello';

В принципе, все эти варианты работают одинаково. Так что это вопрос личного вкуса и эстетики.

var вместо let

В старых скриптах вы также можете найти другое ключевое слово: var вместо let :

var message = 'Hello';

Ключевое слово var – почти то же самое, что и let . Оно объявляет переменную, но немного по-другому, «устаревшим» способом.

Есть тонкие различия между let и var , но они пока не имеют для нас значения. Мы подробно рассмотрим их в главе Устаревшее ключевое слово «var».

Аналогия из жизни

Мы легко поймём концепцию «переменной», если представим её в виде «коробки» для данных с уникальным названием на ней.

Например, переменную message можно представить как коробку с названием «message» и значением «Hello!» внутри:

Мы можем положить любое значение в коробку.

Мы также можем изменить его столько раз, сколько захотим:

let message; message = 'Hello!'; message = 'World!'; // значение изменено alert(message);

При изменении значения старые данные удаляются из переменной:

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

let hello = 'Hello world!'; let message; // копируем значение 'Hello world' из переменной hello в переменную message message = hello; // теперь две переменные содержат одинаковые данные alert(hello); // Hello world! alert(message); // Hello world!

Повторное объявление вызывает ошибку

Переменная может быть объявлена только один раз.

Повторное объявление той же переменной является ошибкой:

let message = "Это"; // повторение ключевого слова 'let' приводит к ошибке let message = "Другое"; // SyntaxError: 'message' has already been declared

Поэтому следует объявлять переменную только один раз и затем использовать её уже без let .

Функциональные языки программирования

Примечательно, что существуют функциональные языки программирования, такие как Scala или Erlang, которые запрещают изменять значение переменной.

В таких языках однажды сохранённое «в коробку» значение остаётся там навсегда. Если нам нужно сохранить что-то другое, язык заставляет нас создать новую коробку (объявить новую переменную). Мы не можем использовать старую переменную.

Хотя на первый взгляд это может показаться немного странным, эти языки вполне подходят для серьёзной разработки. Более того, есть такая область, как параллельные вычисления, где это ограничение даёт определённые преимущества. Изучение такого языка (даже если вы не планируете использовать его в ближайшее время) рекомендуется для расширения кругозора.

Имена переменных

В JavaScript есть два ограничения, касающиеся имён переменных:

Имя переменной должно содержать только буквы, цифры или символы $ и _ .
Первый символ не должен быть цифрой.

Примеры допустимых имён:

let userName; let test123;

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

Самое интересное – знак доллара ‘$’ и подчёркивание ‘_’ также можно использовать в названиях. Это обычные символы, как и буквы, без какого-либо особого значения.

Эти имена являются допустимыми:

let $ = 1; // объявили переменную с именем "$" let _ = 2; // а теперь переменную с именем "_" alert($ + _); // 3

Примеры неправильных имён переменных:

let 1a; // не может начинаться с цифры let my-name; // дефис '-' не разрешён в имени

Регистр имеет значение

Переменные с именами apple и APPLE – это две разные переменные.

Нелатинские буквы разрешены, но не рекомендуются

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

let имя = '. '; let 我 = '. ';

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

Зарезервированные имена

Существует список зарезервированных слов, которые нельзя использовать в качестве имён переменных, потому что они используются самим языком.

Например: let , class , return и function зарезервированы.

Приведённый ниже код даёт синтаксическую ошибку:

let let = 5; // нельзя назвать переменную "let", ошибка! let return = 5; // также нельзя назвать переменную "return", ошибка!

Создание переменной без использования use strict

Обычно нам нужно определить переменную перед её использованием. Но в старые времена было технически возможно создать переменную простым присвоением значения без использования let . Это все ещё работает, если мы не включаем use strict в наших файлах, чтобы обеспечить совместимость со старыми скриптами.

// заметка: "use strict" в этом примере не используется num = 5; // если переменная "num" раньше не существовала, она создаётся alert(num); // 5

Это плохая практика, которая приводит к ошибке в строгом режиме:

"use strict"; num = 5; // ошибка: num is not defined

Константы

Чтобы объявить константную, то есть, неизменяемую переменную, используйте const вместо let :

const myBirthday = '18.04.1982';

Переменные, объявленные с помощью const , называются «константами». Их нельзя изменить. Попытка сделать это приведёт к ошибке:

const myBirthday = '18.04.1982'; myBirthday = '01.01.2001'; // ошибка, константу нельзя перезаписать!

Если программист уверен, что переменная никогда не будет меняться, он может гарантировать это и наглядно донести до каждого, объявив её через const .

Константы в верхнем регистре

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

Названия таких констант пишутся с использованием заглавных букв и подчёркивания.

Например, сделаем константы для различных цветов в «шестнадцатеричном формате»:

const COLOR_RED = "#F00"; const COLOR_GREEN = "#0F0"; const COLOR_BLUE = "#00F"; const COLOR_ORANGE = "#FF7F00"; // . когда нам нужно выбрать цвет let color = COLOR_ORANGE; alert(color); // #FF7F00

COLOR_ORANGE гораздо легче запомнить, чем «#FF7F00» .
Гораздо легче допустить ошибку при вводе «#FF7F00» , чем при вводе COLOR_ORANGE .
При чтении кода COLOR_ORANGE намного понятнее, чем #FF7F00 .

Когда мы должны использовать для констант заглавные буквы, а когда называть их нормально? Давайте разберёмся и с этим.

Название «константа» просто означает, что значение переменной никогда не меняется. Но есть константы, которые известны до выполнения (например, шестнадцатеричное значение для красного цвета), а есть константы, которые вычисляются во время выполнения сценария, но не изменяются после их первоначального назначения.

const pageLoadTime = /* время, потраченное на загрузку веб-страницы */;

Значение pageLoadTime неизвестно до загрузки страницы, поэтому её имя записано обычными, а не прописными буквами. Но это всё ещё константа, потому что она не изменяется после назначения.

Другими словами, константы с именами, записанными заглавными буквами, используются только как псевдонимы для «жёстко закодированных» значений.

Придумывайте правильные имена

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

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

Именование переменных – это один из самых важных и сложных навыков в программировании. Быстрый взгляд на имена переменных может показать, какой код был написан новичком, а какой – опытным разработчиком.

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

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

Несколько хороших правил:

Используйте легко читаемые имена, такие как userName или shoppingCart .
Избегайте использования аббревиатур или коротких имён, таких как a , b , c , за исключением тех случаев, когда вы точно знаете, что так нужно.
Делайте имена максимально описательными и лаконичными. Примеры плохих имён: data и value . Такие имена ничего не говорят. Их можно использовать только в том случае, если из контекста кода очевидно, какие данные хранит переменная.
Договоритесь с вашей командой об используемых терминах. Если посетитель сайта называется «user», тогда мы должны называть связанные с ним переменные currentUser или newUser , а не, к примеру, currentVisitor или newManInTown .

Звучит просто? Действительно, это так, но на практике для создания описательных и кратких имён переменных зачастую требуется подумать. Действуйте.

Повторно использовать или создавать новую переменную?

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

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

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

Дополнительная переменная – это добро, а не зло.

Современные JavaScript-минификаторы и браузеры оптимизируют код достаточно хорошо, поэтому он не создаёт проблем с производительностью. Использование разных переменных для разных значений может даже помочь движку оптимизировать ваш код.

Итого

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

let – это современный способ объявления.
var – это устаревший способ объявления. Обычно мы вообще не используем его, но мы рассмотрим тонкие отличия от let в главе Устаревшее ключевое слово «var» на случай, если это всё-таки вам понадобится.
const – похоже на let , но значение переменной не может изменяться.

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

Задачи

Работа с переменными

важность: 2

Объявите две переменные: admin и name .
Запишите строку «Джон» в переменную name .
Скопируйте значение из переменной name в admin .
Выведите на экран значение admin , используя функцию alert (должна показать «Джон»).

В коде ниже каждая строка решения соответствует одному элементу в списке задач.

let admin, name; // можно объявить две переменные через запятую name = "Джон"; admin = name; alert( admin ); // "Джон"