Основы TypeScript

Переменные и константы

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

Для определения переменных, как в JavaScript, можно использовать ключевое слово var:

var z;	// переменная z

Другой способ определения переменной применяет ключевое слово let, которое было добавлено в JavaScript в стандарте ES 2015:

let z;

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

var x = "hello";
console.log(x);
var x = "work";
console.log(x);

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

let x = "hello";
console.log(x);
let x = "work";	// здесь будет ошибка, так как переменная x уже объявлена
console.log(x);

То же самое относится, если переменная с одним и тем же именем определяется два раза, но с помощью обоих ключевых слов - let и var:

let x = "hello";
console.log(x);
var x = "work";	// здесь будет ошибка, так как переменная x уже объявлена
console.log(x);

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

let z = 6;
z = 8;

Кроме переменных в TypeScript имеются константы - для них можно установить значение только один раз. И далее процессе работы программы мы уже не сможем изменить это значение. Для определение констант используется ключевое слово const:

const z = 6;
z = 8;	// здесь ошибка - нельзя изменить значение константы z

Область видимости переменной и констант

Выше было сказано, что нельзя определить с помощью let определить более одного раза переменную (а с помощью const - константу) с одним и тем же именем. Данное утверждение относится к ситуации, когда переменные let и константы определяются в одной области видимости. Есть локальная область видимости, которая опреляется блоком кода, ограниченным фигурными скобками { //....код }. И есть глобальная область видимости - вне какого-либо блока кода.

Переменные и константы во вложенной области видимости могут скрывать переменные и константы с тем же именем, определенные во внешней области видимости. Например:

let x = 10;
{
	let x = 25;
	console.log(x);	// 25
}
console.log(x);	// 10

Здесь определены две переменных с одним и тем же именем. Но ошибки нет, поскольку они определены в разных областях видимости. Переменная let x = 10 определена в глобальной области видимости. А переменная let x = 25; определена во вложенном блоке кода - в локальной области видимости. И она скрывает внешнюю глобальную переменную. Поэтому консоль браузера выведет нам следующее:

25
10

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

let x = 10;
{
	let x = 25;
	{
		let x = 163;
		console.log(x);	// 163
	}
	console.log(x);	// 25
}
console.log(x);	// 10

Различия между var и let/const

Можно следующим образом суммировать различия между var и let/const:

{
	var x = 94;
}
console.log(x);	// норм

{
	let x = 94;
}
console.log(x); // ! Ошибка

console.log(x); // undefined, но норм
var x = 76;

console.log(x); // ! Ошибка
let x = 76;

var x = 72;
console.log(x);	// 72
var x = 24;		// норм
console.log(x);	// 24

let x = 72;
console.log(x);	// 72
let x = 24;		// ! Ошибка
console.log(x);