Типы данных в TypeScript

Articles

Эта статья объясняет типы данных в TypeScript.

YouTube Video

Типы данных в TypeScript

TypeScript предлагает множество типов данных. Это позволяет задавать строгие типы для переменных, аргументов функций и возвращаемых значений. Ниже перечислены основные типы данных и их использование.

Примитивные типы

Тип number

1let age: number = 25;
2console.log(age);          // Outputs: 25
3console.log(typeof age);    // Outputs: number

Тип number используется для обработки числовых значений, включая целые числа и числа с плавающей запятой (десятичные числа). Обработка значений, превышающих определённые пределы, приводит к результатам Infinity или NaN (Не-число).

1// Decimal calculations
2console.log(0.1 + 0.2 === 0.3); // false
3console.log(0.1 + 0.2); // 0.30000000000000004
4
5// Calculations with large numbers
6console.log(9007199254740991 + 1); // correct value
7console.log(9007199254740991 + 2); // incorrect value

В TypeScript числа представлены как числа с плавающей запятой. Это может привести к небольшим неточностям в результатах вычислений.
Когда требуются точные вычисления, такие как финансовые суммы, необходимо избегать ошибок округления, подобных этой. Например, вы можете использовать BigInt или toFixed(), или регулировать количество десятичных знаков, используя такие библиотеки, как decimal.js.

Тип string

Тип string обрабатывает текстовые данные.

1let greeting: string = "Hello, TypeScript!";
2console.log(greeting);     // Outputs: Hello, TypeScript!
3console.log(typeof greeting);  // Outputs: string

Тип boolean (Логический тип)

Тип boolean имеет два значения: true или false.

1let isOpen: boolean = true;
2console.log(isOpen);       // Outputs: true
3console.log(typeof isOpen);    // Outputs: boolean

null и undefined

null представляет собой 'несуществующее значение', а undefined представляет 'неопределенное значение'.

1let emptyValue: null = null;
2let notDefined: undefined = undefined;
3
4console.log(emptyValue);       // Outputs: null
5console.log(typeof emptyValue);    // Outputs: object (JavaScript specification)
6
7console.log(notDefined);       // Outputs: undefined
8console.log(typeof notDefined);    // Outputs: undefined

Array

В TypeScript вы можете указать тип элементов массива. number[] - массив чисел, а string[] - массив строк.

1let numbers: number[] = [1, 2, 3, 4];
2console.log(numbers);        // Outputs: [1, 2, 3, 4]
3console.log(typeof numbers); // Outputs: object
4
5let words: string[] = ["TypeScript", "JavaScript"];
6console.log(words);          // Outputs: ["TypeScript", "JavaScript"]
7console.log(typeof words);   // Outputs: object

Кортеж (Tuple)

Кортеж - это массив с элементами разных типов.

1let person: [string, number] = ["Alice", 30];
2console.log(person);         // Outputs: ["Alice", 30]
3console.log(typeof person);  // Outputs: object

Перечисление (Enum)

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

1enum Color {
2    Red,
3    Green,
4    Blue
5}
6
7let favoriteColor: Color = Color.Green;
8console.log(favoriteColor);  // Outputs: 1 (Defaults start from 0)
9console.log(typeof favoriteColor); // Outputs: number

any

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

1let anything: any = "Hello";
2console.log(anything);       // Outputs: Hello
3console.log(typeof anything);    // Outputs: string
4
5anything = 42;
6console.log(anything);       // Outputs: 42
7console.log(typeof anything);    // Outputs: number

Объединенный тип (Union Type)

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

1let identifier: number | string = "ID_12345";
2console.log(identifier);     // Outputs: ID_12345
3console.log(typeof identifier);  // Outputs: string
4
5identifier = 12345;
6console.log(identifier);     // Outputs: 12345
7console.log(typeof identifier);  // Outputs: number

Резюме

number, string, boolean: Примитивные типы.
null, undefined: Специальные значения.
Array: Массив с аннотациями типов.
Tuple: Массив с элементами разных типов.
enum: Перечисляемый тип.
any: Любой тип.
Union: Переменная, которая может принимать одно из нескольких типов.

Используя эти типы данных, TypeScript улучшает безопасность типов, что упрощает предотвращение ошибок во время разработки.

Объекты-оболочки

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

В JavaScript (и TypeScript) существуют объекты-обертки, соответствующие примитивным типам, таким как string, number и boolean. Они создаются с использованием функций-конструкторов, называемых соответственно String, Number и Boolean.

Ниже приведены примеры объектов-оберток.

Объект String

Объект String предоставляет свойства и методы для работы со строками.

1let strPrimitive: string = "Hello, World!";
2let strObject: String = new String("Hello, World!");
3
4console.log(strPrimitive);         // Outputs: Hello, World!
5console.log(typeof strPrimitive);  // Outputs: string
6
7console.log(strObject);            // Outputs: [String: 'Hello, World!']
8console.log(typeof strObject);     // Outputs: object

Особенности:

В отличие от примитивного string, объект String воспринимается как object с помощью typeof.
Объекты-обертки полезны при работе со строками или вызове методов для работы с ними.

Объект Number

Объект Number предоставляет свойства и методы для работы с числами.

1let numPrimitive: number = 42;
2let numObject: Number = new Number(42);
3
4console.log(numPrimitive);         // Outputs: 42
5console.log(typeof numPrimitive);  // Outputs: number
6
7console.log(numObject);            // Outputs: [Number: 42]
8console.log(typeof numObject);     // Outputs: object

Особенности:

Объект Number, как обертка для чисел, включает методы для выполнения числовых операций (например, toFixed).

Объект Boolean

Объект Boolean предоставляет свойства и методы для работы с булевыми значениями.

1let boolPrimitive: boolean = true;
2let boolObject: Boolean = new Boolean(true);
3
4console.log(boolPrimitive);        // Outputs: true
5console.log(typeof boolPrimitive); // Outputs: boolean
6
7console.log(boolObject);           // Outputs: [Boolean: true]
8console.log(typeof boolObject);    // Outputs: object

Особенности:

Объект Boolean является оберткой для примитивного типа boolean и воспринимается как object.

Различия между объектами-обертками и примитивными типами

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

1let numPrimitive: number = 123;
2let numObject: Number = new Number(123);
3
4console.log('==  : ', numPrimitive == numObject);  // Outputs: true (Value comparison)
5console.log('=== : ', numPrimitive === numObject); // Outputs: false (Due to differing types)

Особенности:

== сравнивает значения, тогда как === строго сравнивает с учетом типов. === возвращает false при сравнении объектов-оберток с примитивными типами.

Преобразование типов

В TypeScript важно правильно управлять неявными и явными преобразованиями типов.

Неявное преобразование типов

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

1const result: string = 5 + "5"; // "55" (the number is converted to a string)
2
3console.log(result);

В этом примере число 5 неявно преобразуется в строку, в результате чего получается строка "55".

Явное преобразование типов

В TypeScript используйте аннотации типов или функции преобразования типов для безопасного выполнения преобразований.

1const num: string = "123";
2const convertedNum: number = Number(num); // Converts "123" to the number 123
3
4console.log(typeof num);
5console.log(typeof convertedNum);

В этом примере функция Number() используется для явного преобразования строки "123" в число 123.

Проверка типов

В TypeScript вы можете использовать оператор typeof для проверки типа данных переменной.

 1// Output: The type of 42 is: number
 2console.log('The type of 42             is:', typeof 42);
 3
 4// Output: The type of 42 is: bigint
 5console.log('The type of 42n            is:', typeof 42n);
 6
 7// Output: The type of "hello" is: string
 8console.log('The type of "hello"        is:', typeof "hello");
 9
10// Output: The type of true is: boolean
11console.log('The type of true           is:', typeof true);
12
13// Output: The type of undefined is: undefined
14console.log('The type of undefined      is:', typeof undefined);
15
16// Output: The type of null is: object
17console.log('The type of null           is:', typeof null);
18
19// Output: The type of Symbol() is: symbol
20console.log('The type of Symbol()       is:', typeof Symbol());
21
22// Output: The type of {} is: object
23console.log('The type of {}             is:', typeof {});
24
25// Output: The type of function () {} is: function
26console.log('The type of function () {} is:', typeof function () {});

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

Резюме

Объекты-обертки рассматриваются как объекты, так как они предоставляют дополнительные методы и свойства для примитивных типов.
String, Number и Boolean являются представительными примерами объектов-оберток.
В отличие от примитивных типов, объекты-обертки идентифицируются как object с помощью typeof.

Вы можете следовать этой статье, используя Visual Studio Code на нашем YouTube-канале. Пожалуйста, также посмотрите наш YouTube-канал.

YouTube Video

Основы TypeScript Операторы в TypeScript