HR-блог про IT рекрутинг от ИТ Кадрового агентства

20 вопросов и ответов на собеседовании по TypeScript

Вопросы для собеседования

Основные вопросы на собеседовании по TypeScript

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

1. Что такое TypeScript и чем он отличается от JavaScript?

Это фундаментальный вопрос, который интервьюер обычно задает, чтобы оценить знакомство кандидата с языком и то, насколько ему комфортно с его особенностями. Как кандидат, убедитесь, что вы можете описать TypeScript как язык, его основные функции и то, как он связан с JavaScript.
TypeScript — это надмножество JavaScript, которое компилируется в обычный JavaScript. Концептуально отношения между TypeScript и JavaScript сравнимы с отношениями SASS и CSS. Другими словами, TypeScript — это версия JavaScript ES6 с некоторыми дополнительными функциями.
TypeScript — это объектно-ориентированный и статически типизированный язык, похожий на Java и C#, тогда как JavaScript — это язык сценариев, более близкий к Python. Объектно-ориентированный характер TypeScript дополняется такими функциями, как классы и интерфейсы, а его статическая типизация позволяет лучше использовать инструменты с выводом типов в вашем распоряжении.
С точки зрения кода TypeScript записывается в файл с расширением, .ts тогда как JavaScript записывается с .js расширением. В отличие от JavaScript, код TypeScript не понятен браузерам и не может быть выполнен непосредственно в браузере или на любой другой платформе. Файлы .ts необходимо сначала транспилировать с помощью tsc транспилятора TypeScript в обычный JavaScript, который затем запускается целевой платформой.

2. Каковы преимущества использования TypeScript?

У каждого языка программирования есть свои плюсы и минусы, а также причины его применения. Интервьюер может задать этот вопрос, чтобы получить представление о личном опыте кандидата в использовании TypeScript и о том, как это повлияло на опыт разработчика и рабочий процесс проекта.
Вместо того, чтобы просто перечислять преимущества TypeScript, поговорите также о том, как типичный проект может извлечь выгоду из TypeScript. Это может варьироваться от лучшей ремонтопригодности в долгосрочной перспективе или повышения производительности разработчиков благодаря функциям, которые предлагает TypeScript.
Непосредственным преимуществом использования TypeScript является его инструментарий. TypeScript — это строго типизированный язык, использующий вывод типов. Эти характеристики открывают двери для улучшения инструментов и более тесной интеграции с редакторами кода. Строгие проверки TypeScript выявляют ваши ошибки на ранней стадии, что значительно снижает вероятность того, что опечатки и другие человеческие ошибки попадут в рабочую среду. С точки зрения IDE, TypeScript предоставляет вашей IDE возможность лучше понять ваш код, что позволяет отображать более подсказки, предупреждения и ошибки для разработчика. Например, строгая проверка null в TypeScript выдает ошибку во время компиляции (и в вашей IDE), предотвращая распространенную ошибку JavaScript при попытке доступа к свойству неопределенной переменной во время выполнения.
Долгосрочное преимущество использования TypeScript — его масштабируемость и ремонтопригодность. Возможность описывать форму объектов и функций непосредственно в коде делает кодовую базу более понятной и предсказуемой. При правильном использовании TypeScript предоставляет более стандартизированный язык, обеспечивающий лучшую читаемость, что может сэкономить время и усилия в будущем по мере роста кодовой базы.

3. Что такое интерфейсы в TypeScript?

Подобно другим вопросам, связанным с функциями TypeScript, этот вопрос проверяет уровень знаний кандидата и знакомство с функцией языка. Идеальный ответ должен также включать его использование и преимущества использования интерфейсов.
Интерфейсы — это способ TypeScript для определения синтаксиса сущностей. Другими словами, интерфейсы — это способ описания форм данных, таких как объекты или массивы объектов.
Мы объявляем интерфейсы с помощью ключевого interface слова, за которым следует имя интерфейса и его определение. Давайте посмотрим на простой интерфейс для пользовательского объекта
interface User {
  name: string;
  age: number;
}
Затем интерфейс можно использовать для установки типа переменной (аналогично тому, как вы назначаете примитивные типы переменной). Затем переменная с этим User типом будет соответствовать свойствам интерфейса.
let user: User = {
  name: "Bob",
  age: 20, // omitting the `age` property or a assigning a different type instead of a number would throw an error
};
Интерфейсы помогают обеспечить согласованность в вашем проекте TypeScript. Кроме того, интерфейсы также улучшают инструментарий вашего проекта, обеспечивая лучшую функциональность автозаполнения в ваших IDE и гарантируя передачу правильных значений в конструкторы и функции.

4. Как создать новый тип, используя подмножество интерфейса?

Возможность изменять интерфейс полезна для удаления повторяющегося кода, а max_Being - возможность изменять интерфейс полезна для удаления повторяющегося кода и максимального повторного использования существующих интерфейсов (там, где это имеет смысл). Этот вопрос касается одной из многих функций, которые TypeScript предлагает для создания нового интерфейса из существующего интерфейса.
В TypeScript есть служебный тип omit , который позволяет создавать новый тип, передавая текущий тип/интерфейс и выбирая ключи, которые нужно исключить из нового типа. В приведенном ниже примере показано, как создать новый тип UserPreview на основе User интерфейса, но без email свойства.
interface User {
  name: string;
  description: string;
  age: number;
  email: string;
}

// removes the `email` property from the User interface
type UserPreview = Omit<User, "email">;

const userPreview: UserPreview = {
  name: "Bob",
  description: "Awesome guy",
  age: 20,
};

5. Как работают «перечисления» в TypeScript?

Перечисления являются распространенной структурой данных в большинстве типизированных языков. Понимание перечислений и того, как их использовать, играет важную роль в организации вашего кода и делает его более читабельным. Кандидат должен быть в состоянии объяснить перечисления на высоком уровне, а также их основные функции и использование.
Перечисления или перечисляемые типы — это средство определения набора именованных констант. Эти структуры данных имеют постоянную длину и содержат набор постоянных значений. Перечисления в TypeScript обычно используются для представления набора параметров для заданного значения с использованием набора пар ключ/значение.
Давайте рассмотрим пример перечисления для определения набора типов пользователей.
enum UserType {
  Guest = "G",
  Verified = "V",
  Admin = "A",
}

const userType: UserType = UserType.Verified;
Под капотом TypeScript после компиляции переводит перечисления в простые объекты JavaScript. Это делает использование перечислений более выгодным по сравнению с использованием нескольких независимых const переменных. Группировка, которую предлагают перечисления, делает ваш код типобезопасным и более читабельным.
Помните: когда вы практикуетесь с этими техническими вопросами и ответами на собеседовании по TypeScript, не забывайте понимать причины, лежащие в основе каждого вопроса.

6. Что такое стрелочные функции в TypeScript?

Стрелочная функция — это популярная функция ES6 и TypeScript, которая представляет альтернативный более короткий способ определения функций. Хотя стрелочные функции короче, у них есть свои плюсы и минусы, которые важно учитывать при выборе метода для использования.
Стрелочные функции, также известные как лямбда-функции, обеспечивают короткий и удобный синтаксис для объявления функций. Стрелочные функции часто используются для создания функций обратного вызова в TypeScript. Операции с массивами, такие как map, filterи reduce все, принимают стрелочные функции в качестве аргументов.
Однако анонимность стрелочных функций имеет и свои недостатки. Если не соблюдать осторожность, более короткий синтаксис стрелочной функции может быть труднее понять. Кроме того, безымянный характер стрелочных функций также делает невозможным создание самоссылающихся функций (т.е. рекурсий).
Давайте рассмотрим обычную функцию, которая принимает два числа и возвращает их сумму.
function addNumbers(x: number, y: number): number {
  return x + y;
}

addNumbers(1, 2); // returns 3
Теперь давайте преобразуем функцию выше в функцию стрелки.
const addNumbers = (x: number, y: number): number => {
  return x + y;
};

addNumbers(1, 2); // returns 3

7. В чем разница между var, letи const?

TypeScript предоставляет три способа объявления переменной, каждый из которых имеет свои рекомендуемые варианты использования. Способность различать три ключевых слова и понимание того, какое из них использовать, играет важную роль в написании качественного кода. Как кандидат, убедитесь, что вы объяснили вариант использования каждого из ключевых слов вместе с их поведением.
  • var : объявляет переменную области действия или глобальную переменную с поведением и правилами области действия, аналогичными переменным JavaScript var . var переменные не требуют установки значения во время объявления.
  • let : объявляет локальную переменную блочной области. let переменные не требуют установки значения переменной во время ее объявления. Локальная переменная с областью действия блока означает, что доступ к переменной возможен только внутри содержащего ее блока, такого как функция, блок if/else или цикл. Кроме того, в отличие от var, let переменные не могут быть прочитаны или записаны до их объявления.
// reading/writing before a `let` variable is declared
console.log("age", age); // Compiler Error: error TS2448: Block-scoped variable 'age' used before its declaration
age = 20; // Compiler Error: error TS2448: Block-scoped variable 'age' used before its declaration

let age: number;

// accessing `let` variable outside it's scope
function user(): void {
  let name: string;
  if (true) {
    let email: string;
    console.log(name); // OK
    console.log(email); // OK
  }
  console.log(name); // OK
  console.log(email); // Compiler Error: Cannot find name 'email'
}
  • const : объявляет постоянное значение в области блока, которое нельзя изменить после его инициализации. const переменные требуют инициализации как часть своего объявления. Это идеально подходит для переменных, которые не меняются на протяжении всего их жизненного цикла.
// reassigning a `const` variable
const age: number = 20;
age = 30; // Compiler Error: Cannot assign to 'age' because it is a constant or read-only property

// declaring a `const` variable without initialization
const name: string; // Compiler Error: const declaration must be initialized
Примечание: линтеры отлично справляются с обнаружением таких ошибок в ваших IDE, и компиляторы выдают ошибку, если правило нарушается в результате неправильного использования этих ключевых слов.

8. Когда вы используете возвращаемый тип neverи чем он отличается от void?

Это вопрос, который демонстрирует понимание кандидатом типов TypeScript и вариантов их использования в контексте определения возвращаемых типов. Кандидат должен уметь различать два типа и определять возвращаемый тип функции, глядя на ее содержимое.
Прежде чем углубляться в различия между never и void, давайте поговорим о поведении функции JavaScript, когда ничего не возвращается явно.
Давайте возьмем функцию в примере ниже. Он явно ничего не возвращает вызывающей стороне. Однако, если вы присвоите его переменной и зарегистрируете значение переменной, вы увидите, что значение функции равно undefined.
printName(name: string): void {
  console.log(name);
}

const printer = printName('Will');
console.log(printer); // logs "undefined"
Приведенный выше фрагмент является примером void функций. TypeScript предполагает, что функции без явного возврата имеют возвращаемый тип void.
Напротив, never это тип, представляющий значение, которое никогда не встречается. Например, функция с бесконечным циклом или функция, выдающая ошибку, — это функции, которые имеют возвращаемый never тип.
const error = (): never => {
  throw new Error("");
};
Таким образом, void используется всякий раз, когда функция ничего не возвращает явно, тогда как never используется всякий раз, когда функция никогда не возвращает значение.

9. Какие модификаторы доступа поддерживает TypeScript?

Модификаторы доступа и инкапсуляция идут рука об руку. Подобный вопрос — это возможность понять знания кандидата о концепции инкапсуляции и подходе TypeScript к ограничениям доступа к данным. Интервьюер также может искать реальное применение модификаторов доступа, причины их использования и их преимущества.
Понятие « инкапсуляция » используется в объектно-ориентированном программировании для управления видимостью его свойств и методов. TypeScript использует модификаторы доступа для установки видимости содержимого класса. Поскольку TypeScript компилируется в JavaScript, логика, связанная с модификаторами доступа, применяется во время компиляции, а не во время выполнения.
В TypeScript есть три типа модификаторов доступа: public, private, и protected.
  • public : все свойства и методы по умолчанию общедоступны. Публичные члены класса видны и доступны из любого места.
  • protected : защищенные свойства доступны из того же класса и его подкласса. Например, переменная или метод с protected ключевым словом будут доступны из любого места в своем классе и в другом классе, который расширяет класс, содержащий переменную или метод.
  • private : частные свойства доступны только из класса, в котором определено свойство или метод.
Чтобы использовать любой из этих модификаторов доступа, добавьте public, protectedили public (если он опущен, TypeScript по умолчанию будет общедоступным) перед свойством или методом.
class User {
  private username; // only accessible inside the `User` class
// only accessible inside the `User` class and its subclassprotected updateUser(): void {}
// accessible from any locationpublic getUser() {}
}
Нарушение правил модификатора доступа, например попытка доступа к частному свойству класса из другого класса, приведет к следующей ошибке в процессе компиляции.
Property '<property-name>' is private and only accessible within class '<class-name>'.
В заключение, модификаторы доступа играют важную роль в организации вашего кода. Они позволяют открыть набор общедоступных API и скрыть детали реализации. Вы можете думать о модификаторах доступа как о форме входных ворот в ваш класс. Эффективное использование модификаторов доступа значительно снижает вероятность ошибок из-за неправильного использования содержимого другого класса.

10. Что такое дженерики и как их использовать в TypeScript?

В дополнение к «что», интервьюер, задающий этот вопрос, может также искать ответы о том, как дженерики связаны с гибкостью кода, и о причинах использования дженериков по сравнению с другими типами. Обсудите, что такое дженерики, как они работают и в чем их преимущества.
Хорошая практика разработки программного обеспечения часто способствует повторному использованию и гибкости. Использование дженериков обеспечивает возможность повторного использования и гибкость, позволяя компоненту работать с различными типами, а не с одним, сохраняя при этом свою точность (в отличие от использования any).
Ниже приведен пример универсальной функции, которая позволяет вызывающей стороне определить тип, который будет использоваться внутри функции.
function updateUser<Type>(arg: Type): Type {
  return arg;
}
Чтобы вызвать универсальную функцию, вы можете либо явно передать тип в угловых скобках, либо через вывод аргумента типа , позволяя TypeScript вывести тип на основе типа переданного аргумента.
// explicitly specifying the type
let user = updateUser<string>("Bob");

// type argument inference
let user = updateUser("Bob");
Обобщения позволяют нам отслеживать информацию о типе по всей функции. Это делает код гибким и пригодным для повторного использования без ущерба для точности типов.

Промежуточные вопросы для собеседования по TypeScript

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

1. Когда следует использовать unknownтип?

Знание различий между unknown и any и когда использовать, что важно при работе с TypeScript. unknown обычно является предпочтительным вариантом из-за более безопасного ввода. Как кандидат убедитесь, что вы можете объяснить, unknown для чего используется тип и как его использовать.
unknown — это особый тип, похожий на any. Например any, распространенный вариант использования этого unknown типа — это когда вы заранее не знаете точный тип. unknown переменные принимают любое значение. Однако при попытке оперировать переменной unknown TypeScript требует проверки типа или утверждения типа. Это различие unknown составляет
Давайте рассмотрим два примера, чтобы подчеркнуть различия между типами any и unknown .
Фрагмент ниже показывает допустимый код TypeScript, в котором вы можете передать любое значение в качестве callback параметра, и invokeCallback метод попытается его вызвать. Эта функция не выдает никаких ошибок времени компиляции, однако может привести к ошибке времени выполнения, когда вы передаете переменную, которую нельзя вызывать в качестве параметра callback .
invokeCallback(callback: any): void {
  callback();
}
Эквивалент unknown приведенного выше примера требует, чтобы вы добавили проверку типа перед вызовом callback функции. Дополнительная проверка типа предотвращает появление описанной выше ошибки времени выполнения.
invokeCallback(callback: unknown): void {
  if (typeof callback === 'function') {
    callback();
  }
}
Подводя итог, можно присвоить что угодно как типу, any так и unknown типу. Однако unknown типы требуют проверки типа или утверждения типа для выполнения любой операции над переменной.

2. Что такое noImplicitAnyи какова его цель?

Это вопрос о конфигурации TypeScript, который даст интервьюеру представление об уровне знакомства кандидата с настройкой проекта TypeScript. Хотя это только одно свойство из списка настраиваемых свойств TypeScript, оно noImplicitAny играет важную роль в крупных проектах.
noImplicitAny — это свойство в файле конфигурации проекта TypeScript ( tsconfig.json), которое изменяет способ обработки компилятором TypeScript неявных типов вашего проекта any . Флаг noImplicitAny может быть установлен как true, так и false, и его всегда можно изменить позже. Нет правильного ответа на вопрос, каким должно быть это значение, поскольку каждый проект индивидуален. Чтобы иметь возможность решить, на что должен быть установлен флаг, важно понимать разницу между тем, когда он включен, и когда он выключен.
Когда noImplicitAny флаг равен false (по умолчанию), компилятор не делает вывод о типе переменной на основе того, как она используется. Вместо этого компилятор по умолчанию устанавливает тип any.
С другой стороны, когда noImplicitAny флаг имеет значение true, компилятор попытается определить тип, выдав ошибку времени компиляции, если компилятор не сможет определить тип.
Установка noImplicitAny флага в значение true или false не мешает вам установить тип переменной в any.

3. Что такое условные типы в TypeScript?

Иногда тип переменной зависит от ее ввода. Условные типы помогают связать тип ввода и вывода — преобразование типа переменной на основе заданного условия. Условный тип — это важная функция TypeScript, которая помогает писать безопасный для типов код, подобный фреймворку, такой как границы API. Хотя кандидат может не использовать эту функцию напрямую каждый день, он может использовать ее косвенно при использовании кода из других фреймворков или библиотек.
Условные типы в TypeScript похожи на тернарные операторы. Как следует из названия, он присваивает тип переменной на основе условия.
Общее выражение для определения условного типа в TypeScript выглядит следующим образом:
A extends B ? X : Y
Тип X в приведенном выше фрагменте применяется, если переменная удовлетворяет условию, тогда как тип Y применяется, если переменная не соответствует. В приведенном выше примере тип X присваивается, если A расширяет B, а тип Y присваивается, если A не расширяется B.

4. В чем разница между типами объединения и пересечения?

Типы объединения и пересечения считаются расширенными типами в TypeScript. Понимание этого важно при создании типов в ваших проектах TypeScript, чтобы уменьшить дублирование типов. В идеале кандидат должен быть в состоянии объяснить, что такое типы объединения и пересечения, их различия и варианты использования.
Объединения и типы пересечения позволяют составлять и комбинировать существующие типы, а не создавать их с нуля. И объединение, и пересечение имеют свои уникальные характеристики, которые делают их идеальными для различных вариантов использования.
Тип объединения описывается как тип, который может быть одним из нескольких типов. Тип объединения использует | символ (вертикальная черта) для разделения списка типов, которые будут использоваться в новом типе. Давайте рассмотрим пример:
interface B {
  name: string,
  email: string
}

interface C {
  name: string,
  age: number
}

type A = B | C;
A в приведенном выше фрагменте может быть либо типа, B либо C. Основанный на интерфейсах B and s, может содержать and ( ) или and ( ), но не and .CAnameemailBnameageCemailage
При доступе к типу ATypeScript позволяет вам получить доступ только к свойствам, которые существуют в обоих B и C ( name), поскольку это единственные свойства, в существовании которых TypeScript может быть уверен.
С другой стороны, пересечение описывается как тип, который объединяет несколько типов в один, объединяя все свойства каждого типа для создания нового типа. Пересечение использует & символ для разделения списка типов, которые будут объединены. Давайте посмотрим на пример:
interface B {
  name: string,
  email: string
}

interface C {
  name: string,
  age: number
}

type A = B & C;
A в приведенном выше фрагменте будут содержать все свойства обоих B и C ( name, email, и age).

5. В чем разница между extendsи implementsв TypeScript?

Наследование является важным понятием в объектно-ориентированном программировании, особенно для полиморфизма и повторного использования кода. Есть два основных ключевых слова, которые TypeScript использует для наследования — extends и implements. Этот вопрос — шанс проверить наши знания о концепции наследования и о том, как это сделать в TypeScript.
Реализует и расширяет имеет различное использование. Давайте рассмотрим каждого человека и посмотрим на пример, чтобы сравнить их.
Когда класс расширяет другой класс, дочерний класс наследует все свойства и методы класса, который он расширяет. Вы можете переопределить любое из существующих свойств и методов его родителя и добавить новые.
Когда класс реализует другой класс или интерфейс, класс должен реализовать все методы и свойства реализованного класса или интерфейса. Ключевое implements слово действует как контракт, которому должен следовать класс, и TypeScript позаботится о том, чтобы класс имел ту же форму, что и класс или интерфейс, который он реализует.
Давайте рассмотрим пример класса и то, как другой класс может расширить и реализовать его.
class User {
  name: string;
  age: number;
}

// John will contain name and age from the User class
class John extends User {}

// this will result in an error as Bob doesn't have all the properties that
// the User class has
class Bob implements User {}

// This is valid as Mike satisfies the "contract" specified by the 
// User class
class Mike implements User {
  name = 'Mike';
  age = 25
}

Продвинутые вопросы на собеседовании по TypeScript

Следующий набор расширенных вопросов для интервью с Typescript должен проверить ваше глубокое знание TS и некоторых его концепций и функций более экспертного уровня.

1. Объясните, как необязательная цепочка работает в TypeScript.

Необязательная цепочка — это функция TypeScript, которая обеспечивает более безопасный и простой доступ к значениям внутри глубоких объектов. Понимание того, как и когда использовать эту функцию, поможет написать более лаконичный код (там, где это имеет смысл). Кандидат должен уметь объяснить, что такое необязательная цепочка, а также подробно рассказать о вариантах ее использования, плюсах и минусах.
Необязательная цепочка позволяет вам получить доступ к свойствам и методам, расположенным глубоко внутри объекта, без необходимости проверять действительность каждой ссылки в цепочке.
?.Необязательная цепочка использует в качестве оператора вопросительный знак, за которым следует точка ( ). TypeScript оценивает каждую ссылку в цепочке и выполняет нулевую или неопределенную проверку перед доступом к своим дочерним элементам. TypeScript немедленно останавливает выполнение, когда он не проходит проверку null или undefined, и возвращает значение undefined для всей цепочки.
Фрагмент кода ниже является примером доступа к свойству с использованием необязательной цепочки и без нее.
const user = {
  personalInfo: {
    name: 'John'
  }
}

// without optional chaining
const name = user && user.personalInfo && user.personalInfo.name || undefined;

// with optional chaining
const name = user?.personalInfo?.name;

2. Что такое абстрактные классы?

Абстрактный класс — еще одна особенность TypeScript, связанная с концепцией наследования в объектно-ориентированном программировании (ООП). Интервьюер может задать этот вопрос, чтобы получить представление о понимании кандидатом ООП и его более продвинутых функций в TypeScript.
Абстрактные классы определяют контракт для объектов без возможности их непосредственного создания. Однако абстрактный класс может также предоставлять сведения о реализации для своих членов.
Абстрактный класс содержит один или несколько абстрактных членов. Любые классы, которые расширяют абстрактный класс, затем должны будут предоставить реализацию для абстрактных членов суперкласса.
Давайте рассмотрим пример того, как абстрактный класс написан на TypeScript и как его можно расширить другим классом. В приведенном ниже примере оба Car и Bike расширяют Vehicle класс, однако каждый из них имеет различную реализацию метода drive() .
abstract class Vehicle {
abstract drive(): void;
  startEngine(): void {
    console.log('Engine starting...');
  }
}

class Car extends Vehicle {
  drive(): void {
    console.log('Driving in a car');
  }
}

class Bike extends Vehicle {
  drive(): void {
    console.log('Driving on a bike');
  }
}

3. Что такое утверждения типа в TypeScript?

Утверждения Tpye — это способ сообщить TypeScript тип переменной. Поскольку типы широко используются в приложениях TypeScript, вы часто сталкиваетесь со сценариями, когда вам нужно указать более конкретный тип для переменной. Кандидат должен уметь объяснить не только что такое утверждения типов, но и их синтаксис и причины, по которым вы можете их использовать.
Утверждение типа позволяет вам явно установить тип значения и сообщить компилятору, чтобы он не выводил его. Это полезно, когда вы знаете тип объекта более конкретно, чем его текущий тип или текущий предполагаемый тип. В таких случаях вы можете использовать утверждения типа, чтобы указать TypeScript текущий тип переменной.
TypeScript предоставляет два синтаксиса для утверждений типа — as и <>.
// using the `as` keyword
const name: string = person.name as string;

// using `<>`
const name: string = <string>person.name;
Поскольку утверждения типа — это всего лишь способ сообщить компилятору TypeScript о типе переменной, за это в ваших проектах TypeScript не будет штрафа во время выполнения.

4. В чем разница между выводом типа и контекстной типизацией?

Вывод типов — это ключевая функция TypeScript, помогающая писать безопасный для типов код, менее подверженный ошибкам и более удобный для чтения. Интервьюер может задать этот вопрос, чтобы оценить понимание кандидатом как вывода типов TypeScript, так и его общего знакомства с системой типов TypeScript.
TypeScript может определить тип переменной, как правило, на основе инициализации или объявления переменной. Этот процесс известен как вывод типа .
Фрагмент ниже является примером вывода типа, когда TypeScript выводит тип name как «строку» на основе присвоенного ему значения.
let name = 'john'
Контекстная типизация — это подмножество вывода типа, где TypeScript использует местоположение или контекст переменной для вывода ее типа. Вы можете думать об этом как о выводе типов в противоположном направлении.
В приведенном ниже фрагменте TpyeScript использует информацию из onmousedown функции для определения типа mouseEvent параметра.
window.onmousedown = function(mouseEvent) {
   console.log(mouseEvent.button);   // OK
   console.log(mouseEvent.person);   // Error
};

5. Как перегрузки функций работают в TypeScript?

howПерегрузка функций помогает сделать функции более гибкими и пригодными для повторного использования, позволяя одной и той же функции вести себя по-разному в зависимости от переданного набора входных данных. аспект повторного использования кода и любые другие преимущества, которые он предоставляет.
Перегрузка функции — это когда одно и то же имя функции используется несколько раз с другим набором аргументов — количеством аргументов, типов или возвращаемых типов.
Давайте рассмотрим пример того, как print функция может принимать несколько типов в качестве своего параметра, используя перегрузку функций.
print(message: string): void;
print(message: string[]): void;

print(message: unknown): void {if (typeof message === 'string') {
    console.log(message);
  } else if (Array.isArray(message)) {
    message.forEach((individualMessage) => {
      console.log(individualMessage);
    });
  } else {
    throw new Error('unable to print');
  }
}
Основываясь на приведенном выше фрагменте кода, теперь мы можем вызвать print передачу либо одной строки сообщения, либо массива строк сообщения.
print('Single message');
// Console Output:
// Single message

print(['First message', 'Second message']);
// Console Output
// First message
// Second message
Помимо возможности повторного использования функции, перегрузка функций также поддерживает автозаполнение. При вызове функции (в зависимости от вашей IDE) вам будет предоставлен список всех возможных перегрузок, которые вы можете выбрать для своего конкретного варианта использования, что улучшит процесс разработки.

Заключение

Независимо от того, являетесь ли вы разработчиком, готовящимся к собеседованию, или менеджером по найму, который ищет идеального кандидата, мы надеемся, что эти вопросы для интервью TypeScript помогут вам в этом процессе.
Имейте в виду, что технические навыки и знания — это только часть процесса найма. Прошлый опыт и социальные навыки одинаково важны для того, чтобы вы получили работу (или нашли подходящего кандидата).
Имейте в виду, что многие вопросы интервью TypeScript являются открытыми и не имеют одного правильного ответа. Интервьюеры хотят знать, что стоит за вашими ответами. Объясните свой мыслительный процесс и всегда будьте готовы к дополнительным вопросам о том, как вы пришли к своему ответу.
Удачи на предстоящем собеседовании по TypeScript!

Наше ИТ кадровое агентство предлагает вам найти разработчиков менее чем за 2 недели. Свяжитесь с нами сегодня, чтобы узнать больше о том, как мы можем помочь масштабировать ваш следующий проект до новых высот. Мы гарантируем поиск самого сильного, а не самого дорого кандидата. За 10 лет в подборе it специалистов, мы закрыли 5500+ вакансий и собрали 25+ команд с нуля. Убедитесь сами и ознакомьтесь с отзывами клиентов о нашем рекрутинговом агентстве! Нужно больше референсов? Напишите нам в телеграмм.