What types exist only at compile time in Typescript - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a type alias in TypeScript.

Typescript

type Name = [1];

Drag options to blanks, or click blank then click option'

Aboolean

B"string"

Cnumber

Dstring

Attempts:

3 left

💡 Hint

Common Mistakes

Putting quotes around type keywords like "string" instead of using string.

Using values instead of type keywords.

In TypeScript, string is a type keyword used only at compile time to describe the type of a variable.

2fill in blank

medium

Complete the code to define an interface in TypeScript.

Typescript

interface Person { name: [1]; age: number; }

Drag options to blanks, or click blank then click option'

A"string"

Bboolean

Cstring

Dnumber

Attempts:

3 left

💡 Hint

Common Mistakes

Using quotes around string type.

Using number or boolean instead of string for name.

The string type describes text data and exists only at compile time in TypeScript.

3fill in blank

hard

Fix the error in this type assertion that uses a compile-time only type.

Typescript

const value = "hello" as [1];

Drag options to blanks, or click blank then click option'

AString

Bstring

C"string"

Dnumber

Attempts:

3 left

💡 Hint

Common Mistakes

Using quoted types like "string" in assertions.

Using the boxed type String instead of string.

Type assertions use compile-time types like string without quotes.

4fill in blank

hard

Fill both blanks to create a mapped type that exists only at compile time.

Typescript

type Readonly[1]<[2]> = { readonly [K in keyof [2]]: [2][K] };

Drag options to blanks, or click blank then click option'

AProps

BT

CU

DV

Attempts:

3 left

💡 Hint

Common Mistakes

Using values instead of type parameter names.

Mixing up the generic parameter name and the new type name.

This mapped type creates a readonly version of a generic type T. Both Props and T are compile-time only types.

5fill in blank

hard

Fill all three blanks to define a conditional type that exists only at compile time.

Typescript

type IsString[1]<[2]> = [2] extends string ? true : [3];

Drag options to blanks, or click blank then click option'

ACheck

BT

Cfalse

Dboolean

Attempts:

3 left

💡 Hint

Common Mistakes

Using values instead of type parameter names.

Using boolean instead of false in the false branch.

This conditional type checks if T is string. It returns true or false, all compile-time types.

Practice

1. Which of the following TypeScript types exist only at compile time and do not produce any JavaScript code?

easy

A. Functions and variables

B. Classes and enums

C. Interfaces and type aliases

D. Objects and arrays

Solution

1. Step 1: Understand TypeScript compile-time types

   Interfaces and type aliases are used only to check types during compilation and do not exist in the final JavaScript.

2. Step 2: Identify runtime constructs

   Classes, enums, functions, variables, objects, and arrays exist in the JavaScript output and run at runtime.

3. Final Answer:

   Interfaces and type aliases -> Option C

4. Quick Check:

   Compile-time only types = Interfaces, type aliases [OK]

Hint: Remember: interfaces and types vanish after compiling [OK]

Common Mistakes:

• Thinking classes are compile-time only
• Confusing enums with type aliases
• Assuming variables are compile-time types

2. Which syntax correctly declares a type alias that exists only at compile time in TypeScript?

easy

A. type User = { name: string; age: number };

B. const User = { name: 'Alice', age: 30 };

C. class User { name: string; age: number; }

D. enum User { Name, Age }

Solution

1. Step 1: Identify type alias syntax

   Using type User = { ... } declares a type alias that exists only during compilation.

2. Step 2: Differentiate from runtime declarations

   Const objects, classes, and enums produce JavaScript code and exist at runtime.

3. Final Answer:

   type User = { name: string; age: number }; -> Option A

4. Quick Check:

   Type alias syntax = type ... = ... [OK]

Hint: Type aliases start with 'type' keyword [OK]

Common Mistakes:

• Using const or class instead of type alias
• Confusing enums with types
• Missing semicolon in type alias

3. What will be the output of the following TypeScript code when compiled and run in JavaScript?

interface Person { name: string; age: number; }
const p: Person = { name: 'Bob', age: 25 };
console.log(typeof Person);

medium

A. "undefined"

B. "object"

C. "function"

D. "string"

Solution

1. Step 1: Understand interface removal at compile time

   Interfaces do not exist in JavaScript output, so Person is not defined at runtime.

2. Step 2: Evaluate typeof on undefined identifier

   Using typeof Person when Person is not defined returns "undefined" as a string.

3. Final Answer:

   "undefined" -> Option A

4. Quick Check:

   Interfaces vanish, typeof interface = "undefined" [OK]

Hint: Interfaces disappear; typeof interface is undefined [OK]

Common Mistakes:

• Expecting 'object' because of interface
• Thinking interface is a function
• Confusing interface with class

4. Identify the error in this TypeScript code snippet:

type Animal = { species: string };
console.log(Animal);

medium

A. Missing semicolon after type declaration

B. Animal should be declared as an interface

C. Type alias syntax is incorrect

D. Animal is not defined at runtime, so console.log causes an error

Solution

1. Step 1: Recognize type alias compile-time only nature

   Type aliases do not exist in JavaScript, so Animal is not a runtime value.

2. Step 2: Understand console.log usage

   Trying to log Animal causes a runtime error because it is undefined in JavaScript.

3. Final Answer:

   Animal is not defined at runtime, so console.log causes an error -> Option D

4. Quick Check:

   Logging type alias = runtime error [OK]

Hint: Type aliases can't be used as runtime values [OK]

Common Mistakes:

• Thinking type aliases exist at runtime
• Ignoring runtime vs compile-time difference
• Assuming missing semicolon causes error

5. You want to create a function that accepts only objects matching a specific shape but does not add any runtime overhead. Which TypeScript feature should you use?

hard

A. Use a type alias and create a runtime object

B. Use an interface to define the object shape

C. Use a class to define the object shape

D. Use an enum to define the object shape

Solution

1. Step 1: Understand compile-time type checking

   Interfaces define object shapes only at compile time and do not generate JavaScript code, so no runtime overhead.

2. Step 2: Compare with other options

   Classes and enums generate runtime code; type aliases do not create runtime objects unless explicitly instantiated.

3. Final Answer:

   Use an interface to define the object shape -> Option B

4. Quick Check:

   Interfaces = compile-time only, no runtime overhead [OK]

Hint: Interfaces check shape without runtime cost [OK]

Common Mistakes:

• Using classes which add runtime code
• Confusing enums with object shapes
• Thinking type aliases create runtime objects