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

В JavaScript есть несколько различных примитивных типов (MDN):

	Пример	Тип Flow
Логические значения	true or false	boolean
Строки	'foo'	string
Числа	123	number
Null	null	null
Undefined	undefined	void
Символы (добавлены в ES2015)	Symbol('foo')	symbol
BigInt (добавлены в ES2020)	123n	bigint

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

true;
"hello";
3.14;
null;
undefined;
3n;

Значения BigInt и Symbol можно создать с помощью вызовов BigInt и Symbol соответственно:

BigInt("2364023476023");
Symbol("hello");

Типы Flow для литеральных значений записываются в нижнем регистре (как и результат выражения JavaScript typeof):

function func(a: number, b: string, c: boolean, d: bigint) { /* ... */ }


func(3.14, "hello", true, 3n);

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

function acceptTwo(x: 2) { /* ... */ }


acceptTwo(2); // Works!
acceptTwo(1); // Error!

Некоторые примитивы также можно обернуть в объекты:

ПРИМЕЧАНИЕ: Скорее всего, вам никогда не понадобятся варианты объектов-обёрток.

new Boolean(false);
new String("world");
new Number(42);

Типы объектов-обёрток записываются с заглавной буквы (как и их конструкторы):

function func(x: Number, y: String, z: Boolean) {
  // ...
}


func(new Number(42), new String("world"), new Boolean(false));

Эти объекты-обёртки используются редко.

Логические значения​

Логические значения в JavaScript — это значения true и false. Тип boolean в Flow принимает эти значения.

function acceptsBoolean(value: boolean) { /* ... */ }


acceptsBoolean(true);  // Works!
acceptsBoolean(false); // Works!


acceptsBoolean("foo"); // Error!

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

if (42) {} // 42 => true
if ("") {} // "" => false

Flow понимает эти приведения и допускает их в качестве проверки в операторе if или в других условных контекстах.

Чтобы явно преобразовать значение, не являющееся логическим, в boolean, можно использовать Boolean(x) или !!x.

function acceptsBoolean(value: boolean) { /* ... */ }


acceptsBoolean(0);          // Error!


acceptsBoolean(Boolean(0)); // Works!
acceptsBoolean(!!0);        // Works!

Можно уточнить значение до boolean с помощью проверки typeof:

function acceptsBoolean(value: boolean) { /* ... */ }


function func(value: unknown) {
  if (typeof value === 'boolean') {
    acceptsBoolean(value); // Works: `value` is `boolean`
  }
}

Помните, что boolean и Boolean — это разные типы.

• boolean — это литеральное значение, например true или false, либо результат выражения, например a === b.
• Boolean — это объект-обёртка, созданный глобальным конструктором new Boolean(x). Скорее всего, вам не понадобится его использовать!

Числа​

Числовые литералы в JavaScript — это числа с плавающей точкой, например 42 или 3.14. JavaScript также считает числами Infinity и NaN. Они представлены типом number. В JavaScript также есть отдельный тип BigInt.

function acceptsNumber(value: number) { /* ... */ }


acceptsNumber(42);       // Works!
acceptsNumber(3.14);     // Works!
acceptsNumber(NaN);      // Works!
acceptsNumber(Infinity); // Works!


acceptsNumber("foo");    // Error!
acceptsNumber(123n);     // Error!

Можно уточнить значение до number с помощью проверки typeof:

function acceptsNumber(value: number) { /* ... */ }


function func(value: unknown) {
  if (typeof value === 'number') {
    acceptsNumber(value); // Works: `value` is `number`
  }
}

Помните, что number и Number — это разные типы.

• number — это литеральное значение, например 42 или 3.14, либо результат выражения, например parseFloat(x).
• Number — это объект-обёртка, созданный глобальным конструктором new Number(x). Скорее всего, вам не понадобится его использовать!

Строки​

Строки в JavaScript — это значения "foo". Тип string в Flow принимает эти значения.

function acceptsString(value: string) { /* ... */ }


acceptsString("foo"); // Works!
acceptsString(`template literal`); // Works!


acceptsString(false); // Error!

JavaScript неявно преобразует значения других типов в строки, объединяя их.

"foo" + 42; // "foo42"
"foo" + {}; // "foo[object Object]"

При объединении со строками Flow допускает только строки и числа.

"foo" + "foo"; // Works!
"foo" + 42;    // Works!
`foo ${42}`;   // Works!


"foo" + {};    // Error!
"foo" + [];    // Error!
`foo ${[]}`;   // Error!

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

"foo" + String({});     // Works!
"foo" + [].toString();  // Works!
"" + JSON.stringify({}) // Works!

Можно уточнить значение до string с помощью проверки typeof:

function acceptsString(value: string) { /* ... */ }


function func(value: unknown) {
  if (typeof value === 'string') {
    acceptsString(value); // Works: `value` is `string`
  }
}

Помните, что string и String — это разные типы.

• string — это литеральное значение, например "foo", либо результат выражения, например "" + 42.
• String — это объект-обёртка, созданный глобальным конструктором new String(x). Скорее всего, вам не понадобится его использовать!

null и undefined​

В JavaScript есть и null, и undefined. Flow рассматривает их как отдельные типы: null и void (для undefined).

function acceptsNull(value: null) { /* ... */ }


acceptsNull(null);      // Works!
acceptsNull(undefined); // Error!


function acceptsUndefined(value: void) { /* ... */ }


acceptsUndefined(undefined); // Works!
acceptsUndefined(null);      // Error!

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

function acceptsNull(value: null) { /* ... */ }


function func(value: unknown) {
  if (value === null) {
    acceptsNull(value); // Works: `value` is `null`
  }
}

function acceptsUndefined(value: void) { /* ... */ }


function func(value: unknown) {
  if (value === undefined) {
    acceptsUndefined(value); // Works: `value` is `void`
  }
}

null и void также встречаются в других типах:

Типы Maybe​

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

?T эквивалентно T | null | void.

function acceptsMaybeString(value: ?string) { /* ... */ }


acceptsMaybeString("bar");     // Works!
acceptsMaybeString(undefined); // Works!
acceptsMaybeString(null);      // Works!
acceptsMaybeString();          // Works!

Для уточнения проверки value == null проверяют именно оба значения: null и undefined.

Подробнее см. в документации по типам Maybe.

Необязательные свойства объектов​

В типах объектов могут быть необязательные свойства: после имени свойства ставится знак вопроса ?.

{propertyName?: string}

Помимо заданного типа значения, такие необязательные свойства могут иметь значение void или отсутствовать. Однако они не могут иметь значение null.

function acceptsObject(value: {foo?: string}) { /* ... */ }


acceptsObject({foo: "bar"});     // Works!
acceptsObject({foo: undefined}); // Works!
acceptsObject({});               // Works!


acceptsObject({foo: null});      // Error!

Необязательные параметры функций​

У функций могут быть необязательные параметры: после имени параметра ставится знак вопроса ?.

function func(param?: string) { /* ... */ }

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

function acceptsOptionalString(value?: string) { /* ... */ }


acceptsOptionalString("bar");     // Works!
acceptsOptionalString(undefined); // Works!
acceptsOptionalString();          // Works!


acceptsOptionalString(null);      // Error!

Параметры функций со значениями по умолчанию​

Для параметров функций также можно задавать значения по умолчанию. Эта возможность появилась в ES2015.

function func(value: string = "default") { /* ... */ }

Помимо заданного типа, параметры со значениями по умолчанию также могут иметь значение void или отсутствовать. Однако они не могут иметь значение null.

function acceptsOptionalString(value: string = "foo") { /* ... */ }


acceptsOptionalString("bar");     // Works!
acceptsOptionalString(undefined); // Works!
acceptsOptionalString();          // Works!


acceptsOptionalString(null);      // Error!

Символы​

В JavaScript символы создаются с помощью Symbol(). Flow поддерживает символы на базовом уровне с помощью типа symbol.

function acceptsSymbol(value: symbol) { /* ... */ }


acceptsSymbol(Symbol()); // Works!
acceptsSymbol(Symbol.isConcatSpreadable); // Works!


acceptsSymbol(false); // Error!

Можно уточнить значение до symbol с помощью проверки typeof:

function acceptsSymbol(value: symbol) { /* ... */ }


function func(value: unknown) {
  if (typeof value === 'symbol') {
    acceptsSymbol(value); // Works: `value` is `symbol`
  }
}

BigInt​

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

Литерал bigint — это литерал number с суффиксом n.

Обратите внимание, что bigint и number — несовместимые типы. То есть bigint нельзя использовать там, где ожидается number, и наоборот.

function acceptsBigInt(value: bigint) { /* ... */ }


acceptsBigInt(42n); // Works!
acceptsBigInt(42); // Error!

Можно уточнить значение до bigint с помощью проверки typeof:

function acceptsBigInt(value: bigint) { /* ... */ }


function func(value: unknown) {
  if (typeof value === 'bigint') {
    acceptsBigInt(value); // Works: `value` is `bigint`
  }
}

См. также​

• Литеральные типы — использование конкретных примитивных значений (например, 2 или "foo") в качестве типов
• Типы Maybe — возможность принимать значение null для любого типа с помощью сокращённой записи ?T
• Уточнения — сужение широких типов до конкретных примитивных с помощью typeof