Static vs Dynamic Type Checking - Quiz

Generics in programming languages, including TypeScript, allow accepting arguments of different types.

Generics provide a way to create functions, classes, or interfaces that can work with a variety of data types while maintaining type safety. When you use generics, you can specify the type of data that a function, class, or interface will work with, and that type can vary across different invocations. This flexibility enables you to write more reusable and type-safe code.

It seems like you are referring to TypeScript type annotations. In TypeScript, type annotations are implemented using the syntax : type. So, among the options you provided:

• length: number is a valid type annotation in TypeScript, indicating that the variable length is expected to be of type number.
• static length=12 is not a valid type annotation. This syntax is used in TypeScript for static class properties but doesn't provide type information.
• var lengthC='1' is a variable declaration in JavaScript/TypeScript, but it doesn't include a type annotation. TypeScript will infer the type as string for this variable.
• length=12 is a variable assignment in JavaScript/TypeScript, not a type annotation. TypeScript will infer the type based on the assigned value, so in this case, it would be inferred as number.

If you want to explicitly annotate the type of the variable length, you would use the syntax : type. For example:

let length: number = 12;

This declares a variable named length with an explicit type annotation indicating that it should be a number.

Static type checking is done at compilation time.

In languages with static typing, like TypeScript, the type checking is performed by the compiler before the code is executed. The compiler analyzes the code, checks for type errors, and ensures that the types are used correctly based on the declared types and annotations. This process occurs during compilation, allowing developers to catch potential type-related issues early in the development process, before the code is executed.

In TypeScript, when a variable is assigned the value null, it is often given the type null. This is a specific type in TypeScript that represents the absence of an object value.

So, the correct answer would be:

None of the options.

The variable is given the type null when it is explicitly assigned the value null. If you don't want to specify a particular type, you would typically use the any type, but if you assign a value of null, TypeScript will consider the variable to have the type null.

During runtime, Dynamic Type checking is done.

Dynamic typing is a feature of some programming languages where the type of a variable is checked at runtime, as opposed to static typing where type checking is done at compile time. In dynamically typed languages, the type of a variable can change during the execution of the program, and type errors are caught at runtime. This is in contrast to static typing, where type information is checked at compile time. JavaScript, for example, is a dynamically typed language.

Type Annotations allow us to record the intended contract of the function or variable.

Type annotations in programming languages, including TypeScript, are used to specify the intended data type of a variable, the return type of a function, or the types of function parameters. They provide a way for developers to explicitly state the expected types, making the code more self-documenting and allowing tools like compilers or IDEs to perform static type checking.

While type annotations help ensure that the code adheres to the specified types, they don't directly perform casting or reassign the type of data. They serve as a form of documentation and a tool for static type checking during development.

A type system is a set of rules.

A type system in programming is a collection of rules and constraints that govern the ways in which types of values can be used in a program. It defines the set of types available, the operations permitted on those types, and how types interact with each other. The purpose of a type system is to prevent the occurrence of certain errors, such as attempting to use a value of one type as if it were another type.

So, in the context of your question, a type system is a set of rules that define how different types of data and variables can be used in a program.

All the options you provided are valid ways of defining an enum in TypeScript, but they serve different purposes:

1. enum Enum {}: This is a standard way of defining an enum in TypeScript. It creates an enum named Enum with no values. You can add enum members inside the curly braces.

   
   enum Enum {
     Value1,
     Value2,
     Value3,
   }
   
   

2. const enum DNA {}: This defines a const enum, where the enum is inlined at compile time. This means that the enum values are directly substituted in the generated JavaScript code, and no runtime object is created for the enum.

   
   const enum DNA {
     Adenine,
     Thymine,
     Cytosine,
     Guanine,
   }
   
   

   Note: Const enums cannot have computed or non-constant enum members.

3. declare enum Enum {}: This is used to declare an enum that may be defined elsewhere (e.g., in an external JavaScript library). It tells TypeScript to expect that the enum is defined at runtime, even though the actual definition may not be available in the TypeScript code.

   
   declare enum Enum {
     Value1,
     Value2,
     Value3,
   }
   
   

Choose the option that best suits your needs based on whether you want a standard enum, a const enum, or if you're declaring an enum that's defined elsewhere.

False.

any is not a generic type; rather, it is a type in TypeScript that represents a lack of a specific type. Variables of type any can hold values of any type, and TypeScript's type checker does not perform type checking on them. The use of any should be minimized in TypeScript code, as it essentially opts out of the static type checking that TypeScript provides.

Generics, on the other hand, allow you to write functions and classes that work with a variety of types while maintaining type safety. Generics are a way of parameterizing types to make them more flexible and reusable across different data types.

Generics is a/an template.

Generics in programming languages are a way to create templates or placeholders for types. They allow you to write functions, classes, and data structures that can work with a variety of types without sacrificing type safety.

So, while "template" is not the only way to describe generics, it captures the idea that you can create reusable and flexible code that can be customized for different data types.