Explore topic-wise InterviewSolutions in .

TYPESCRIPT PROVIDES various utility types that make common TYPE transformations easy. These utility types are available globally. Here are some of the essential utility types included in TypeScript.

FUNCTION is a global type in TypeScript. It has PROPERTIES like bind, CALL, and apply, ALONG with the other properties present on all function values.

You can always call a value of the Function type, and it returns a value of ‘any’ type. 

A conditional type ALLOWS you to DYNAMICALLY select one of two POSSIBLE types based on a CONDITION. The condition is expressed as a type relationship test.

Here, if type C extends B, the value of the above type is TypeX. Otherwise, it is TypeY.

Inheritance ALLOWS a class to extend ANOTHER class and reuse and modify the BEHAVIOR defined in the other class. The class which inherits another class is CALLED the derived class, and the class getting inherited is called the base class.

In TypeScript, a class can only extend one class. TypeScript USES the keyword ‘extends’ to specify the relationship between the base class and the derived classes.

In the above example, because the class Square extends functionality from Rectangle, we can create an instance of square and call both the area() and volume() methods.

Template literal types are similar to the string literal types. You can combine them with concrete, literal types to produce a new string literal type. Template literal types allow us to use the string literal types as BUILDING blocks to create new string literal types.

Template literal types can also expand into multiple STRINGS via unions. It helps us create the SET of every POSSIBLE string literal that each union member can represent.

In TypeScript, you can refer to SPECIFIC strings and numbers as types.

String literal types on their own are not that useful. However, you can combine them into unions. This allows you to specify all the string values that a variable can take, in turn acting like enums. This can be useful for function parameters.

String literal types can help us spell-check the string values. 

An implements clause is used to check that a class satisfies the contract specified by an interface. If a class implements an interface and doesn’t IMPLEMENT that interface, the TypeScript compiler issues an error.

A class can implement more than ONE interface. In this case, the class has to specify all the contracts of those interfaces.

The in operator is used to find if a PROPERTY is in the specified object. It RETURNS true if the property belongs to the object. OTHERWISE, it returns false.

Triple-slash directives are single-line comments that contain a single XML tag. TypeScript uses this XML tag as a compiler directive.

You can only place a triple-slash directive at the top of the containing file. Only single or multi-line comments can come before a triple-slash directive. TypeScript treats them as regular comments if it occurs in the middle of a code block, after a statement.

The primary USE of triple-slash directives is to include other files in the compilation process. For EXAMPLE, the following directive instructs the compiler to include a file specified by the path in the containing TypeScript file.

/// <REFERENCE path="..." />

Triple-slash directives also ORDER the output when using --out or --outFile. The output files are produced to the output file location in the same order as the input files.

A typical TypeScript project references other third-party TypeScript libraries such as JQUERY to perform routine TASKS. Having type information for the library code helps you in coding by providing detailed information about the types, method signatures, etc., and provides IntelliSense.

A type declaration file is a text file ENDING with a .d.ts EXTENSION providing a way to declare the existence of some types or values without actually providing IMPLEMENTATIONS for those values. It contains the type declarations but doesn’t have any source code. It doesn’t produce a .js file after compilation. 

You can mark object properties as immutable by using the readonly keyword before the property NAME. For example:

When you mark a property as readonly, it can only be set when you initialize the object. Once the object is created, you cannot change it. 

Null pointers are ONE of the most common sources of unexpected runtime errors in programming. TYPESCRIPT HELPS you avoid them to a large degree by enforcing strict null checks.

You can enforce strict null checks in two ways:

• providing the --strictNullChecks flag to the TypeScript (tsc) compiler
• setting the strictNullChecks property to true in the tsconfig.json CONFIGURATION file.

When the flag is false, TypeScript IGNORES null and undefined values in the code. When it is true, null and undefined have their distinct types. The compiler throws a type error if you try to use them where a concrete value is expected.

Sometimes, you as a programmer might know more about the type of a variable than TypeScript can infer. Usually, this happens when you know the type of an object is more specific than its current type. In such cases, you can tell the TypeScript compiler not to infer the type of the variable by using type assertions.

TypeScript provides TWO forms to assert the types.

• as SYNTAX:

• <> syntax:

Type assertions are similar to TYPECASTING in other programming languages such as C# or Java. However, unlike those languages, there’s no runtime penalty of boxing and unboxing variables to fit the types. Type assertions simply let the TypeScript compiler know the type of the variable.  

You can destructure tuple elements by USING the assignment operator (=). The DESTRUCTURING variables get the types of the corresponding tuple elements.  

After destructuring, you can’t assign a VALUE of a different type to the destructured VARIABLE. For example,

Tuples are a special TYPE in TypeScript. They are SIMILAR to arrays with a fixed number of elements with a known type. However, the types need not be the same.

Since TypeScript 3.0, a tuple can specify one or more optional types using the ? as shown below.

Type aliases give a new, meaningful NAME for a type. They don’t create new TYPES but create new names that refer to that type.

For example, you can alias a union type to avoid TYPING all the types everywhere that value is being used.

Intersection types let you combine the members of TWO or more types by using the ‘&’ operator. This allows you to combine existing types to get a SINGLE type with all the features you need.

The following example creates a NEW type Supervisor that has the members of types Employee and Manager.

A union type is a special construct in TypeScript that INDICATES that a value can be one of several types. A vertical bar (|) separates these types.

Consider the FOLLOWING example where the variable value belongs to a union type consisting of strings and numbers. The value is initialized to string “Foo”. Because it can only be a string or a number, we can change it to a number later, and the TypeScript compiler doesn’t complain. 

However, if we try to set the value to a type not included in the union types, we get the following error. 

Union types allow you to create new types out of existing types. This removes a lot of BOILERPLATE CODE as you don’t have to create new classes and type hierarchies.  

An anonymous function is a function without a name. Anonymous FUNCTIONS are typically used as callback functions, i.e., they are passed around to other functions, only to be invoked by the other function at a later point in time. For example,

Abstract classes are similar to interfaces in that they specify a contract for the objects, and you cannot instantiate them directly. HOWEVER, unlike interfaces, an abstract class may provide implementation details for one or more of its members.

An abstract class marks one or more of its members as abstract. Any classes that EXTEND an abstract class have to provide an implementation for the abstract members of the superclass.

Here is an example of an abstract class WRITER with two member functions. The write() method is marked as abstract, whereas the greet() method has an implementation. Both the FictionWriter and RomanceWriter classes that extend from Writer have to provide their specific implementation for the write method.

TypeScript doesn’t SUPPORT static classes, unlike the popular object-oriented programming LANGUAGES like C# and Java.

These languages need static classes because all code, i.e., data and functions, need to be inside a class and cannot exist independently. Static classes provide a way to allow these functions without ASSOCIATING them with any OBJECTS.

In TypeScript, you can create any data and functions as SIMPLE objects without creating a containing class. Hence TypeScript doesn’t need static classes. A singleton class is just a simple object in TypeScript. 

TypeScript provides three KEYWORDS to control the visibility of CLASS members, such as PROPERTIES or methods.

• public: You can access a public member ANYWHERE outside the class. All class members are public by default. 
• protected: A protected member is visible only to the subclasses of the class containing that member. Outside code that doesn’t EXTEND the container class can’t access a protected member. 
• private: A private member is only visible inside the class. No outside code can access the private members of a class.

Usually, when we don’t provide any type on a variable, TypeScript assumes ‘any’ type. For EXAMPLE, TypeScript compiles the following CODE, assuming the parameter ‘s’ is of any type. It WORKS as long as the caller passes a string.

However, the code breaks down as SOON as we pass a number or other type than a string that doesn’t have a split() method on it. For example,

noImplicitAny is a compiler option that you set in the tsconfig.json file. It forces the TypeScript compiler to raise an error whenever it infers a variable is of any type. This prevents us from accidentally causing similar errors.

When the TypeScript compiler USES the location (or context) of a variable to infer its type, it’s called CONTEXTUAL typing.

In the following example, TypeScript uses the Window.onmousedown function type information to infer the type of the function expression on the right-hand side of the assignment. This allows it to infer the type of the e parameter, which does have a button property but not a property NAMED foo.

TypeScript can infer the type of a variable when you don’t provide an EXPLICIT type. This is KNOWN as type inference. This is usually done when the variables or parameters are INITIALIZED during the declaration.

For example, TypeScript knows that the variable FOO is a string, even THOUGH we don’t mention string as a type.

Function overloading allows us to define MULTIPLE functions with the same name, as long as their number of parameters or the types of parameters are different.

The following example defines TWO OVERLOADS for the function buildDate. The first overload takes a number as a parameter, whereas the SECOND takes three numbers as parameters. These are called overload signatures.

The body of the function also called an implementation signature, follows the overload signatures. You can’t call this signature directly, as it’s not visible from the outside. It should be compatible with the overload signatures.

Optional chaining allows you to ACCESS PROPERTIES and call methods on them in a chain-like fashion. You can do this using the ‘?.’ operator.

TypeScript immediately STOPS running some expression if it runs into a ‘null’ or ‘undefined’ value and RETURNS ‘undefined’ for the entire expression chain.

Using optional chaining, the following expression

can be expressed as:

Symbols were introduced in ES6 and are supported by TypeScript. Similar to NUMBERS and strings, symbols are PRIMITIVE TYPES. You can use Symbols to create unique properties for objects.

You can create symbol values by calling the Symbol() constructor, optionally providing a string key.

A key characteristic of symbols is that they are unique and immutable.

TypeScript provides the FOLLOWING THREE WAYS to LOOP over collections.

• ‘for’ loop

• ‘forEach’ function

• ‘for..of’ statement