Какого типа данных переменная s var s hello
Как и во многих языках программирования, в C# есть своя система типов данных, которая используется для создания переменных. Тип данных определяет внутреннее представление данных, множество значений, которые может принимать объект, а также допустимые действия, которые можно применять над объектом.
В языке C# есть следующие базовые типы данных:
-
bool : хранит значение true или false (логические литералы). Представлен системным типом System.Boolean
bool alive = true; bool isDead = false;
byte bit1 = 1; byte bit2 = 102;
sbyte bit1 = -101; sbyte bit2 = 102;
short n1 = 1; short n2 = 102;
ushort n1 = 1; ushort n2 = 102;
int a = 10; int b = 0b101; // бинарная форма b =5 int c = 0xFF; // шестнадцатеричная форма c = 255
uint a = 10; uint b = 0b101; uint c = 0xFF;
long a = -10; long b = 0b101; long c = 0xFF;
ulong a = 10; ulong b = 0b101; ulong c = 0xFF;
char a = 'A'; char b = '\x5A'; char c = '\u0420';
string hello = "Hello"; string word = "world";
object a = 22; object b = 3.14; object c = "hello code";
Например, определим несколько переменных разных типов и выведем их значения на консоль:
string name = "Tom"; int age = 33; bool isEmployed = false; double weight = 78.65; Console.WriteLine($"Имя: "); Console.WriteLine($"Возраст: "); Console.WriteLine($"Вес: "); Console.WriteLine($"Работает: ");
Для вывода данных на консоль здесь применяется интерполяция: перед строкой ставится знак $ и после этого мы можем вводить в строку в фигурных скобках значения переменных. Консольный вывод программы:
Имя: Tom Возраст: 33 Вес: 78,65 Работает: False
Использование суффиксов
При присвоении значений надо иметь в виду следующую тонкость: все вещественные литералы (дробные числа) рассматриваются как значения типа double . И чтобы указать, что дробное число представляет тип float или тип decimal , необходимо к литералу добавлять суффикс: F/f — для float и M/m — для decimal.
float a = 3.14F; float b = 30.6f; decimal c = 1005.8M; decimal d = 334.8m;
Подобным образом все целочисленные литералы рассматриваются как значения типа int . Чтобы явным образом указать, что целочисленный литерал представляет значение типа uint, надо использовать суффикс U/u , для типа long — суффикс L/l , а для типа ulong — суффикс UL/ul :
uint a = 10U; long b = 20L; ulong c = 30UL;
Использование системных типов
Выше при перечислении всех базовых типов данных для каждого упоминался системный тип. Потому что название встроенного типа по сути представляет собой сокращенное обозначение системного типа. Например, следующие переменные будут эквивалентны по типу:
int a = 4; System.Int32 b = 4;
Неявная типизация
Ранее мы явным образом указывали тип переменных, например, int x; . И компилятор при запуске уже знал, что x хранит целочисленное значение.
Однако мы можем использовать и модель неявной типизации:
var hello = "Hell to World"; var c = 20;
Для неявной типизации вместо названия типа данных используется ключевое слово var . Затем уже при компиляции компилятор сам выводит тип данных исходя из присвоенного значения. Так как по умолчанию все целочисленные значения рассматриваются как значения типа int , то поэтому в итоге переменная c будет иметь тип int . Аналогично переменной hello присваивается строка, поэтому эта переменная будет иметь тип string
Эти переменные подобны обычным, однако они имеют некоторые ограничения.
Во-первых, мы не можем сначала объявить неявно типизируемую переменную, а затем инициализировать:
// этот код работает int a; a = 20; // этот код не работает var c; c= 20;
Во-вторых, мы не можем указать в качестве значения неявно типизируемой переменной null :
// этот код не работает var c=null;
Так как значение null, то компилятор не сможет вывести тип данных.
Типы данных в Go

Типы данных определяют виды значений, которые сохраняются определенными переменными при написании программы. Типы данных также помогают определить операции, которые можно выполнять с использованием данных.
В этой статье мы рассмотрим наиболее важные типы данных в Go. Это не исчерпывающее исследование типов данных, но оно поможет вам поближе познакомиться с доступными в Go возможностями. Понимание основных типов данных поможет писать более эффективный и понятный код.
Базовая информация
Чтобы лучше понять типы данных следует посмотреть на различные типы данных, которые мы используем в реальном мире. Например, в реальном мире мы используем числа. Это могут быть положительные числа (0, 1, 2, …), целые числа (…, -1, 0, 1, …) и, например, иррациональные числа (π).
Обычно в математике мы можем сочетать числа разных типов и получать определенный ответ. Например, мы можем выполнить операцию сложения 5 и π:
5 + π
Мы можем сохранить уравнения как ответ, чтобы учитывать иррациональное число, или округлить π до числа с уменьшенным количеством знаков после запятой, а затем сложить числа:
5 + π = 5 + 3.14 = 8.14
Однако если мы попробуем оценить числа с помощью другого типа данных, такого как слова, выражения будут иметь меньше смысла. Как мы решим следующее уравнение?
shark + 8
Для компьютеров все типы данных отличаются, как слова и числа. В результате нам нужно осторожно подходить к использованию различных типов данных для назначения значений и манипуляции этими значениями посредством операций.
Целые числа
Как и в математике, в программировании к целым числам относятся положительные числа, отрицательные числа и 0 (…, -1, 0, 1, …). В Go целое число определяется как int . Как и в других языках программирования, в числах не следует использовать запятые для отделения нулей, так что вместо 1,000 нужно писать 1000 .
Целое число можно вывести в простой форме:
fmt.Println(-459)
Output-459
Также мы можем декларировать переменную, которая будет выступать как символ используемого или изменяемого числа, например:
var absoluteZero int = -459 fmt.Println(absoluteZero)
Output-459
В Go можно выполнять математические операции с целыми числами. В следующем блоке кода мы используем оператор назначения := для декларирования и инициализации переменной sum :
sum := 116 - 68 fmt.Println(sum)
Output48
Как видно на экране результатов, математический оператор — был использован для вычитания целого числа 68 из 116 , в результате чего получилось 48 . Дополнительную информацию о декларировании переменных можно найти в разделе Объявление типов данных для переменных.
Целые числа можно использовать в программах Go разными способами. По мере дальнейшего изучения Go у вас появится много возможностей работать с целыми числами и развивать знания об этом типе данных.
Числа с плавающей запятой
*Число с плавающей точкой или float *— это действительное число, которое нельзя выразить в форме целого числа. В состав действительных чисел входят все рациональные и иррациональные числа, и поэтому числа с плавающей точкой могут содержать дробную часть, например 9,0 или -116,42. Чтобы представить тип float в программе Go, подумайте о числе с десятичной запятой.
Мы можем вывести число с плавающей запятой так же легко, как и целое число:
fmt.Println(-459.67)
Output-459.67
Также мы можем объявить переменную, которая будет представлять число типа float:
absoluteZero := -459.67 fmt.Println(absoluteZero)
Output-459.67
В Go можно выполнять математические операции с числами с плавающей точкой, как и с целыми числами:
var sum = 564.0 + 365.24 fmt.Println(sum)
Output929.24
При работе с целыми числами и числами с плавающей точкой важно помнить, что 3 ≠ 3.0, поскольку 3 означает целое число, а 3.0 — число с плавающей точкой.
Размеры числовых типов
Помимо различия между целыми числами и числами с плавающей точкой, в Go имеется два типа числовых данных, которые различаются по статическому или динамическому характеру их размера. Первый тип — это архитектурно-независимый тип, и это означает, что размер данных в битах не изменяется вне зависимости от того, на какой машине выполняется код.
Сегодня большинство системных архитектур представляют собой 32-битные или 64-битные архитектуры. Например, вы можете разрабатывать приложения для современных ноутбуков с 64-битной операционной системой Windows. Однако, если вы разрабатывает приложения для таких устройств, как фитнес-браслеты, вам может потребоваться 32-битная архитектура. Если вы используете архитектурно-независимый тип, например int32 , вне зависимости от компилируемой архитектуры, у этого типа будет постоянный размер.
Второй тип относится к конкретному варианту реализации. В этом типе разрядность может отличаться в зависимости от архитектуры, на базе которой построена программа. Например, если мы используем тип int при компиляции в Go для 32-битной архитектуры, размер типа данных будет составлять 32 бита. Если программа компилируется для 64-битной архитектуры, размер переменной будет составлять 64 бита.
Помимо разных размеров, такие типы данных, как целые числа, могут иметь два базовых типа: со знаком и без знака. int8 — это целое число со знаком, которое может иметь значение от -128 до 127. uint8 — целое число без знака, которое может иметь только положительное значение от 0 до 255.
Диапазоны зависят от размера в битах. Для двоичных данных 8 бит могут представлять 256 разных значений. Поскольку тип int должен поддерживать как положительные, так и отрицательные значения, 8-битное целое число ( int8 ) будет иметь диапазон от -128 до 127, что соответствует 256 возможных уникальных значений.
В Go имеются следующие архитектурно-независимые типы целых чисел:
uint8 unsigned 8-bit integers (0 to 255) uint16 unsigned 16-bit integers (0 to 65535) uint32 unsigned 32-bit integers (0 to 4294967295) uint64 unsigned 64-bit integers (0 to 18446744073709551615) int8 signed 8-bit integers (-128 to 127) int16 signed 16-bit integers (-32768 to 32767) int32 signed 32-bit integers (-2147483648 to 2147483647) int64 signed 64-bit integers (-9223372036854775808 to 9223372036854775807)
Числа с плавающей точкой и комплексные числа также могут иметь разные размеры:
float32 IEEE-754 32-bit floating-point numbers float64 IEEE-754 64-bit floating-point numbers complex64 complex numbers with float32 real and imaginary parts complex128 complex numbers with float64 real and imaginary parts
Также существует несколько типов псевдонимов чисел, которые присваивают полезные имена определенным типам данных:
byte alias for uint8 rune alias for int32
Псевдоним byte дает понять, что ваша программа использует в качестве единицы измерения элементов символьной строки байты, а не малые целые числа, не связанные с измерением данных в байтах. Хотя после компиляции программы byte и uint8 будут идентичны, byte часто используется для представления символьных данных в числовой форме, а uint8 предполагается как число в программе.
Псевдоним rune немного отличается от вышеописанного. Если byte и uint8 содержат одни и те же данные, rune может представлять собой один байт или четыре байта, определенный в int32 диапазон . rune используется для представления символа Unicode, в то время как символы ASCII может представлять только тип данных int32 .
Кроме того, в Go имеются следующие типы для конркретных реализаций:
uint unsigned, either 32 or 64 bits int signed, either 32 or 64 bits uintptr unsigned integer large enough to store the uninterpreted bits of a pointer value
Размер типов для конкретных реализаций определяется архитектурой, для которой скомпилирована программа.
Выбор числовых типов данных
Выбор правильного размера больше зависит от производительности целевой архитектуры, чем от размера данных, с которыми вы работаете. Однако если вы не знаете особые требования вашей программы к производительности, в начале работы вы можете следовать некоторым из этих базовых рекомендаций.
Как обсуждалось ранее в этой статье, существуют типы, не зависящие от архитектуры, и типы, зависящие от реализации. Для целочисленных данных в Go обычно используются такие типы реализации, как int или uint вместо int64 или uint64 . Обычно это обеспечивает более высокую скорость обработки в целевой архитектуре. Например, если вы используете int64 и выполняете компиляцию до 32-битной архитектуры, обработка этих значений займет в два раза меньше времени, поскольку для перемещения данных по архитектуре требуются дополнительные процессорные циклы. Если вы использовали int , программа определяет 32-битный размер для 32-битной архитектуры, в результате чего обработка будет значительно быстрее.
Если вы не хотите выходить за пределы определенного диапазона размеров, выбор архитектурно-независимого типа может увеличить скорость и снизить нагрузку на память. Например, если вы знаете, что ваши данные не превысят значение 100 и будут только положительными числами, выбор uint8 сделает вашу программу более эффективной, поскольку для нее будет требоваться меньше памяти.
Мы рассмотрели некоторые возможные диапазоны типов числовых данных. Теперь посмотрим, что произойдет в случае превышения этих диапазонов в нашей программе.
Переполнение и циклический переход
При попытке сохранения значения, превышающего возможности типа данных, в Go возможны переполнение или циклический переход, в зависимости от того, рассчитывается ли значение при компиляции или во время исполнения Ошибка при компиляции возникает, если программа обнаруживает ошибку при попытке сборки программы. Ошибка времени исполнения возникает во время фактического выполнения уже скомпилированной программы.
В следующем прмере мы зададим для maxUint32 максимальное значение:
package main import "fmt" func main() var maxUint32 uint32 = 4294967295 // Max uint32 size fmt.Println(maxUint32) >
После компиляции и запуска получим следующий результат:
Output4294967295
Если мы прибавим 1 к значению времени исполнения, произойдет циклический переход на 0 :
Output0
Теперь изменим программу, чтобы прибавить 1 к переменной при ее назначении, то есть до компиляции:
package main import "fmt" func main() var maxUint32 uint32 = 4294967295 + 1 fmt.Println(maxUint32) >
Во время компиляции, если компилятор определяет, что значение слишком большое для заданного типа данных, он выводит сообщение об ошибке переполнения . Это означает, что рассчитанное значение слишком большое для заданного типа данных.
Поскольку компилятор может определить переполнение, он выведет сообщение об ошибке:
Outputprog.go:6:36: constant 4294967296 overflows uint32
Понимание ограничений данных поможет избежать потенциальных ошибок программы в будущем.
Мы поговорили о числовых типах, и теперь пришло время перейти к хранению логических значений.
Логические операторы
Тип данных boolean может иметь значение истина или ложь и определяется как bool при декларировании. Логические операторы используются для представления значений истины, связанных с логическим ответвлением математики, которое информирует алгоритмы в информатике.
Значения true и false всегда обозначаются символами t и f в нижнем регистре, поскольку эти идентификаторы заранее декларированы в Go.
Многие математические операции дают ответы, соответствующие значениям «истина» или «ложь»:
Как и для чисел, значения логических операторов могут храниться в переменных:
myBool := 5 > 8
Мы можем распечатать значение логического оператора посредством вызова функции fmt.Println() :
fmt.Println(myBool)
Поскольку 5 не больше 8 , мы получим следующий результат:
Outputfalse
Чем больше программ вы напишете на Go, тем лучше вы поймете принципы работы логических операторов и влияние оценки истинности и ложности разных функций или операций на выполнение программы.
Строки
Строка — это последовательность из одного или нескольких символов (буквы, числа, символы), которая может представлять собой константу или переменную. Строки существуют внутри одинарных кавычек ` или двойных кавычек » в Go и имеют разные характеристики в зависимости от типа кавычек.
Если вы используете одинарные кавычки, вы создаете необработанный строковый литерал. Если вы используете двойные кавычки, вы создаете интерпретируемый строковый литерал.
Необработанные литералы строк
Необработанные строковые литералы — это последовательности символов между одинарными кавычками. Каждый символ внутри кавычек будет выглядеть точно так же, как он отображается, за исключением самих символов одинарных кавычек.
a := `Say "hello" to Go!` fmt.Println(a)
OutputSay "hello" to Go!
Специальные символы в строках обычно обозначаются обратной косой чертой. Например, в интерпретируемой строке \n представляет новую строчку в строке. Однако внутри необработанных литералов строк обратная косая черта не имеет особого значения:
a := `Say "hello" to Go!\n` fmt.Println(a)
Поскольку в литерале строки обратная косая черта не имеет особого значения, программа будет выводить значение \n вместо создания новой строки:
OutputSay "hello" to Go!\n
Необработанные литералы строк также могут использоваться для создания строк, включающих несколько строчек:
a := `This string is on multiple lines within a single back quote on either side.` fmt.Println(a)
OutputThis string is on multiple lines within a single back quote on either side.
В предыдущих блоках кода новые строчки буквально переносились из входных данных в результаты.
Интерпретируемые литералы строк
Интерпретируемые строковые литералы — это последовательность символов внутри двойных кавычек, например, «bar» . Внутри кавычек может находиться любой символ, кроме символа новой строчки и незакрытых двойных кавычек. Для отображения двойных кавычек в интерпретируемой строке вы можете использовать обратную косую черту в качестве символа перехода:
a := "Say \"hello\" to Go!" fmt.Println(a)
OutputSay "hello" to Go!
Практически всегда вы будете использовать интерпретируемые строковые литералы, поскольку они позволяют выполнять экранирование символов внутри строк. Дополнительную информацию о строках можно найти в статье, посвященной основам работы со строками в Go.
Строки с символами UTF-8
UTF-8 — это схема кодировки, используемая для кодировки символов переменной ширины в 1-4 байтах. Go поддерживает символы UTF-8 без специальных настроек, библиотек или пакетов. Латинские символы, такие как буква A , могут быть представлены значением ASCII, например, числом 65. Однако при использовании специальных символов, таких как международный символ 世 , требуется UTF-8. Go использует тип псевдонима rune для данных UTF-8.
a := "Hello, 世界"
Вы можете использовать ключевое слово range в цикле for для индексации любых строк в Go, в том числе строк UTF-8. Мы более подробно расскажем о циклах for и о ключевом слове range позднее, а сейчас важно помнить, что мы можем использовать их для подсчета количества байт в строке:
package main import "fmt" func main() a := "Hello, 世界" for i, c := range a fmt.Printf("%d: %s\n", i, string(c)) > fmt.Println("length of 'Hello, 世界': ", len(a)) >
В блоке кода выше мы декларировали переменную a и назначили для нее значение Hello, 世界 . Назначенный текст содержит символы UTF-8.
Затем мы использовали стандартный цикл for и ключевое слово range . В Go ключевое слово range индексирует строку, возвращая по одному символу, а также выполняет байтовую индексацию символа в строке.
С помощью функции fmt.Printf мы выводим строку формата %d: %s\n . %d — это печатное обозначение цифры (в данном случае целого числа), а %s — обозначение строки. Затем мы задали значения i или текущего индекса цикла for ,а также c , который представляет текущий символ цикла for .
В заключение мы распечатали полную переменную a с помощью встроенной функции len .
Мы уже упоминали, что rune является псевдонимом int32 и может состоять из 1-4 байт. Для определения символа 世 требуется три байта, и индекс перемещается соответствующим образом при изменении диапазона в строке UTF-8. По этой причине печать i не выполняется последовательно.
Output0: H 1: e 2: l 3: l 4: o 5: , 6: 7: 世 10: 界 length of 'Hello, 世界': 13
Как видите, длина превышает количество проходов диапазона строки.
Вы не всегда будете использовать строки UTF-8, но теперь вы понимаете, почему они относятся к типу rune, а не int32 .
Декларирование типов данных для переменных
Вы узнали о разных типах данных примитивов, и теперь мы перейдем к назначению этих типов для переменных в Go.
В Go мы можем определять переменные с помощью ключевого слова var , за которым идут имя переменной и желаемый тип данных.
В следующем примере мы декларируем переменную с именем pi типа float64 .
В первую очередь декларируется ключевое слово var :
var pi float64
Далее идет имя переменной pi :
var pi float64
Последним идет тип данных float64 :
var pi float64
При желании мы можем задать начальное значение, например, 3.14 :
var pi float64 = 3.14
Go — это язык статических типов. Использование статических типов означает, что каждое выражение в программе проверяется во время компиляции. Также это означает, что тип данных привязан к переменной, как в динамически связанных языках тип данных привязан к значению.
Например, в Go тип декларируется при декларировании переменной:
var pi float64 = 3.14 var week int = 7
Каждая из этих переменных может соответствовать отдельному типу данных, если вы декларировали их по разному.
Этим Go отличается от таких языков как PHP, где тип данных привязывается к значению:
$s = "sammy"; // $s is automatically a string $s = 123; // $s is automatically an integer
В предыдущем блоке кода первая переменная $s является строкой, поскольку ей присвоено значение «sammy» , а вторая являетя целым числом, поскольку ей присвоено значение 123 .
Теперь рассмотрим более сложные типы данных — массивы.
Массивы
Массив представляет собой упорядоченную последовательность элементов. Вместимость массива определяется во время создания. После определения размера массива его нельзя изменить. Поскольку массив имеет статичный размер, память для него выделяется только один раз. Это делает массивы менее гибкими, но повышает производительность вашей программы. Поэтому массивы обычно используются при оптимизации программ. Срезы, о которых мы поговорим позднее, являются более гибкими и соответствуют общепринятой концепции массивов, применяемой в других языках.
Массивы определяются посредством декларирования размера массива и типа данных с определением значений внутри фигурных скобок < >.
Массив строк должен выглядеть следующим образом:
[3]string"blue coral", "staghorn coral", "pillar coral">
Мы можем сохранить массив в переменной и распечатать его:
coral := [3]string"blue coral", "staghorn coral", "pillar coral"> fmt.Println(coral)
Output[blue coral staghorn coral pillar coral]
Как мы уже говорили, срезы похожи на массивы, но при этом более гибкие. Рассмотрим следующий мутируемый тип данных.
Срезы
Срезы — это упорядоченная последовательность элементов, длина которых может изменяться. Размер срезов может увеличиваться динамически. Если при добавлении в срез новых элементов в срезе оказывается недостаточно памяти, он запрашивает в системе дополнительную память по мере необходимости. Поскольку срез можно расширить для добавления дополнительных элементов, они используются чаще, чем массивы.
Срезы определяются посредством декларирования типа данных, которому предшествуют открывающая и закрывающая квадратные скобки [] , а значения указываются в фигурных скобках < >.
Срез целых чисел выглядит следующим образом:
[]int-3, -2, -1, 0, 1, 2, 3>
Срез чисел с плавающей точкой выглядит следующим образом:
[]float643.14, 9.23, 111.11, 312.12, 1.05>
Срез строк выглядит следующим образом:
[]string"shark", "cuttlefish", "squid", "mantis shrimp">
Определим срез строк как seaCreatures :
seaCreatures := []string"shark", "cuttlefish", "squid", "mantis shrimp">
Мы можем распечатать его посредством вызова переменной:
fmt.Println(seaCreatures)
Выводимые результаты будут выглядеть точно так, как созданный нами список:
Output[shark cuttlefish squid mantis shrimp]
Мы можем использовать ключевое слово append для добавления элементов в срез. Следующая команда добавляет значение строки seahorse в срез:
seaCreatures = append(seaCreatures, "seahorse")
Вы можете проверить его добавление посредством вывода значений:
fmt.Println(seaCreatures)
Output[shark cuttlefish squid mantis shrimp seahorse]
Как видите, если вам требуется управление неизвестным количеством элементов, срез будет более гибким, чем массив.
Карты
Карта — это встроенный в Go тип хэша или словаря. Карты используют пары ключей и значений для хранения данных. Это полезно в программировании для быстрого просмотра значений по индексу или (в данном случае) по ключу. Например, вам может потребоваться карта пользователей с индексацией по идентификатору пользователя. Ключ может быть идентификатором пользователя, а объект пользователя будет значением. Карта создается с помощью ключевого слова map с типом данных ключа в квадратных скобках [ ] , за которым идут пары значение и ключ в фигурных скобках.
map[key]value<>
Карты обычно используются для хранения связанных данных, в том числе информации из идентификаторов, и выглядят следующим образом:
map[string]string"name": "Sammy", "animal": "shark", "color": "blue", "location": "ocean">
Обратите внимание, что помимо фигурных скобок карта содержит двоеточия. Слова слева от двоеточий являются ключами. Ключи могут относится к любому *comparable *типу в Go. Сравнимые типы — это типы примитивов, в том числе строки , целы е числа и т. д. Тип примитива определяется языком, а не составляется посредством сочетания других типов. Хотя допускается использование определяемых пользователем типов, во избежание ошибок программирования их лучше оставлять простыми. В словаре выше содержатся ключи: name , animal , color и location .
Слова справа от двоеточий являются значениями. Значения могут состоять из любого типа данных. Значения в словаре выше: Sammy , shark , blue и ocean .
Давайте сохраним карту внутри переменной и выведем ее:
sammy := map[string]string"name": "Sammy", "animal": "shark", "color": "blue", "location": "ocean"> fmt.Println(sammy)
Outputmap[animal:shark color:blue location:ocean name:Sammy]
Если мы хотим изолировать цвет Sammy, мы можем использовать вызов sammy[«color»] . Распечатаем результат:
fmt.Println(sammy["color"])
Outputblue
Поскольку карты предоставляют пары ключ-значение для хранения данных, они могут стать важным элементом вашей программы Go.
Заключение
Теперь вы должны лучше понимать основные типы данных, доступные для использования в Go. Каждый из этих типов данных важен при разработке проектов на языке Go.
Когда вы разберетесь с доступными типами данных в Go, вы также можете изучить конвертацию типов данных, чтобы иметь возможность изменять типы данных в зависимости от ситуации.
Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.
Типы данных в TypeScript
TypeScript добавляет дополнительные типы данных в JavaScript. Типы данных используются для добавления статических ограничений на программные элементы, такие как функции, переменные и свойства. Это позволяет компилятору и средствам разработки осуществлять более тщательную проверку и поддержку в процессе разработки. Система типов времени компиляции TypeScript моделирует динамическую систему типов времени выполнения JavaScript, позволяя программистам точно выражать взаимодействия типов. Анализ типов в TypeScript осуществляется только во время компиляции и не добавляет никаких задержек во время выполнения готовой программы.
Все типы в TypeScript являются подтипами главного типа, которым является тип Any. Данный тип обозначается ключевым словом any. Тип Any — единственный, который может представлять любое значение JavaScript без всяких ограничений. Все остальные типы накладывают определенные ограничения на свои значения.
Примитивными типами являются Number, String, Symbol, Void, Null, Undefined и также типы-перечисления (enums), определяемые пользователем.
Тип Any
Тип Any используется когда мы не знаем какой тип должна иметь та или иная переменная. Эта переменная может быть получена из некоего динамического содержимого, как например, если бы использовалась некая сторонняя библиотека. В таких случаях нужно отказаться от проверки типов и позволить таким переменным проходить проверку во время компиляции. Для того, чтобы это сделать, нужно указать переменной тип Any с помощью ключевого слова any.
let someVar: any = 4;
someVar= "потом может стать строкой";
someVar= false; // или boolean
Стоит отметить, что если объявить переменную и не указывать ее тип, то будет считаться, что она имеет тип Any.
let withoutTypeVar; // на самом деле переменная имеет тип Any
Рекомендуется всегда явно указывать тип там, где это возможно во избежание ошибок. Но не стоит везде использовать тип Any, т.к. в этом случае нивелируются преимущества, которые дает TypeScript при использовании конкретных типов. Также повсеместное использование данного типа может говорить о плохо продуманном коде и привести к нежелательным ошибкам в будущем.
Тип Any является средством, которое позволяет работать с существующими JavaScript библиотеками и не приводить к ошибкам компиляции.
let notSure: any = 4;
notSure.ifItExists(); // OK, может существовать во время выполнения
notSure.toFixed(); // OK, ошибки компиляции не будет
Может показаться, что тип Object (предоставляет интерфейс для доступа к общим для всех объектов JavaScript методам) может выполнять такую же роль. Однако в данном случае получится только присвоить значение переменной этого типа. Вызвать метод, который может и существует на самом деле не получится
let someObj: Object = 4;
someObj.toFixed(); // Ошибка
Тип Any может прийти на помощь также, если вам известна только часть типа. Например, вам известно, что переменная является массивом, но тип элемента массива неизвестен или элементы могут иметь разный тип. В этом случае можно поступить следующим образом:
let arr: any[] = [1, true, "some string", . ];arr[1] = "another string"; // OK
Примитивные типы
Тип Number
Как и в JavaScript, все числа в TypeScript являются числами с плавающей точкой. Для указания данного типа переменной используется ключевое слово number. Все переменные этого типа также реализуют глобальный интерфейс Number.
let x: number; // Явное указание типа
let y = 0; // Тоже, что и y: number = 0
let z = 123.456; // Тоже, что и z: number = 123.456
let s = z.toFixed(2); // Свойство интерфейса Number
В дополнение к десятичной и шестнадцатеричной форме записи чисел ,TypeScript поддерживает также записи чисел в двоичной и восьмеричной системе, которые появились в стандарте ECMAScript 2015:
let decimal: number = 6;
let hex: number = 0xf00d;
let binary: number = 0b1010;
let octal: number = 0o744;
Тип Boolean
Тип Boolean совпадает с одноименным типом JavaScript и представляет собой логическое значение: истина (true) или ложь (false).
Объявляется данный тип с помощью ключевого слова boolean.
var logical: boolean = false;
var checked = true; // Тоже, что и var checked: boolean = true;
В TypeScript все переменные этого типа реализуют также глобальный интерфейс ‘Boolean’.
Тип String
Тип String соответствует аналогичному в JavaScript и представляет собой последовательность символов в кодировке Unicode UTF-16. Как и в JavaScript, значение строки должно быть окружено либо одинарными, либо двойными кавычками.
var s: string = "some string";
var empty = "";
var another = 'another string';
var c = another.charAt(2); // Свойство интерфейса 'String'
Все переменные данного типа реализуют глобальный интерфейс ‘String’.
Для создания строк также можно пользоваться шаблонами строк.Для этого содержимое строки заключаться в обратные кавычки (`), а выражения должны выглядеть как $ .
let name: string = `Сергей`;
let age: number = 33;
let sentence: string = `Hello, my name is $. I’ll be $ < age + 1 >years old next month.`;
Это будет эквивалентно:
let sentence: string = "Hello, my name is "+ name+ ".\n\n" + "I’ll be "+ (age + 1) + "years old next month.";
Тип Void
Можно сказать, что тип Void является противоположностью типу Any. Этот тип означает отсутствие какого-либо типа. Обычно используется для указания того, что функция не возвращает никакого значения.
function someFunction(): void alert("message");
>
Тип Void является подтипом типа Any, и супертипом для типов Null и Undefined. В тоже время тип Void не зависит от всех остальных типов.
Объявлять переменную с данным типом можно, но это не имеет никакого смысла, т.к. в данном случае такой переменной можно присвоить только значение null или undefined.
let v1: void = null;
let v2: void = undefined;
Типы Null и Undefined
Типы Null и Undefined соответствуют одноименным типам в JavaScript. Данные типы являются подтипами для всех остальных типов по умолчанию.
let n: number = null; // Примитивные типы могут быть null
let m: number = undefined; // Примитивные типы могут быть undefined
let x = null; // тоже самое, что и x: any = null
let y = undefined; // тоже самое, что и y: any = undefined
let e: Null; // Ошибка
let r: Undefined; //Ошибка
Если объявить переменной тип null или undefined, то такой переменной можно будет присвоить только значение null или undefined соответственно, что не имеет никакого практического применения.
let n: null = null; // Только это значение можно присвоить
n = 1; // Ошибка!
let m: undefined = undefined;
m = "some string"; //Ошибка!
Стоит отметить, что если использовать директиву компилятора —strictNullChecks , null и undefined могут быть присвоены только переменной типа void и переменным с типами null или undefined соответственно. Это помогает избежать множества ошибок. В таком случае, если переменной нужно присвоить значение с типом string или null или undefined , можно использовать тип объединение string | null | undefined .
Тип Array
В TypeScript, также как и в JavaScript, можно работать с массивами значений. Для создания массива необходимо к указанному типу переменной добавить [].
var arr: number[] = [1, 2, 3];
var otherArr: any[] = [1, true, "string"];
Созданная переменная также реализует обобщенный интерфейс Array , где Т — тип элементов массива. Свойство length данного интерфейса возвращает количество элементов массива.
interface Array <
length: number; // длина массива
[x: number]: T; // сигнатура для доступа к элементу массива по его индексу
// . остальные методы
>
Соответственно, создавать массивы также можно следующим образом:
var list: Array = [1, 2, 3];
list[1] = 4; // [1, 4, 3]
var length = list.length; // 3
Тип Tuple
Тип Tuple или кортеж представляет собой массив JavaScript, каждому из элементов которого можно указать свой тип. Кортеж
[T1, T2, . Tn]
можно представить как объект с численно именованными свойствами
0: T1,
1: T2,
.
n: Tn
>
let tuple: [string, number];tuple = ["some", 10]; // Правильно
tuple = [10, "some"]; // Неверно! Типы не совпадаютconsole.log(tuple[0]); // "some"
console.log(tuple[1]); // 10
Как и обычному массиву, кортежу можно присвоить значение, которое выходит за пределы определенных типов, например:
tuple[200] = "some string"; // OK
tuple[300] = 1; // OK
tuple[400] = true; // Ошибка!
В этом случае тип элемента должен быть string | number.
Можно создавать именованные кортежи путем объявления интерфейса, унаследованного от Array и введя численно именованные свойства.
interface KeyValuePair extends Array let x: KeyValuePair = [10, “ten”];
Тип Enum
Полезным добавлением к набору типов данных JavaScript является тип Enum (перечисление). Как и языке C#, enum — это способ указать более привычные имена набору числовых значений.
enum Color ;
let c: Color = Color.Green;
По умолчанию у перечислений нумерация начинается с нуля. Но можно поменять это вручную установкой значения например для одного из значений перечисления.
enum Color ; // нумерация начинается с 1
let c: Color = Color.Green;
Или можно для каждого значения назначить свое значение
enum Color ;
let c: Color = Color.Green;
Для получения имени по числовому значению, необходимо
console.log(Color[4]); // выведет в консоли Blue
Тип Never
Тип never представляет тип, значение которого никогда не наступает. Например, never является типом, который возвращает функция, которая всегда бросает исключения или выход из которой никогда не происходит (например бесконечный цикл). Переменные также могут иметь данный тип например для того, чтобы никогда не принимать значение true.
Тип never является подтипом любого типа. Переменная типа never может быть присвоена переменной любого другого типа. С другой стороны, нет такого типа, который будет являться подтипом данного типа, также как и переменной данного типа ничего нельзя присвоить кроме переменной такого же типа (never).
function error(message: string): never throw new Error(message);
>// Выведенным типом fail() будет never
function fail() return error("Something failed");
>// нет выхода из этой функции
function infiniteLoop(): never while (true) >
>
Тип Symbol
Тип Symbol является примитивным и соответствует одноименному типу в языке JavaScript. Данный тип предоставляет уникальные идентификаторы, которые могут быть использованы как ключи для свойств объекта.
Значения, имеющие тип Symbol реализуют глобальный объект ‘Symbol’, который имеет набор методов и свойств, которые могут быть вызваны как функции.
var secretKey = Symbol();
var obj = <>; obj[secretKey] = “secret message”; // Символ как свойство
obj[Symbol.toStringTag] = “test”;
Приведение типов
Иногда может оказаться так, что вы знаете немного больше о значении некоторой переменной, чем определено в TypeScript. Обычно это случается когда вы знаете, что тип некоторой переменной может быть более конкретным или определенным, чем текущий.
Приведение типов — это способ сказать компилятору “Доверься мне, я знаю, что я делаю”. Приведение типов в TypeScript похоже на приведение типов в других языках программирования, но не требует никаких специальных проверок или реструктуризации данных. Также этот процесс не оказывает никакого воздействия на скомпилированную программу и используется только компилятором.
Существует две формы приведения типов. Первый — синтаксис с использованием угловых скобок (<>):
let someValue: any = “this is a string”; let strLength: number = (string>someValue).length;
Второй — as-синтаксис:
let someValue: any = “this is a string”; let strLength: number = (someValue as string).length;
Два приведенных примера полностью аналогичны. Использовать один или другой — по большому счету это выбор предпочтений; однако, когда TypeScript используется совместно с JSX, допускаются только приведение типов через as-синтаксис.
Немного о let
Ключевое слово let является новым в JavaScript. Переменная, объявленная с помощью let будет видна только в текущей (локальной) области видимости. Это позволяет избегать множество проблем в JavaScript. Поэтому рекомендуется пользоваться let вместо var везде, где это возможно.
Переменные
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 ); // "Джон"