TypeScript

Question 1

ECMA Script 2015 introduced which two new keywords for declaring variables, and constants ?

Answer 1

let , const

Question 2

What is the main difference between declaring a variable using keyword “var” or using keywords “let” or “const” ?

Answer 2

The main difference is in the scoping rules applied to the identifiers declared with them. Variables using “var” are globally available within the function they were declared in, while variables declared with “let” and “const” are local to the block they were declared in.

Question 3

How can one identify a “block” ?

Answer 3

Usually a block is defined by a set of curly braces.

Question 4

What is another difference between variables declared with “var” and variables declared with “let” and “const” ?

Answer 4

Variables declared with “var” are hoisted to the top of the function they were declared in, meaning, the run time behavior will be as if it was declared on the top even if it was declared on the bottom of a function. Variables declared with “let” and “const” are only available where they were declared.

Question 5

What is the main difference between declaring a variable using keyword “var” or using keywords “let” or “const” ?

Answer 5

When using “var” , it is possible to declare the same variable name twice in the same function. This is usually not good practice, and with “let” and “const” you can only declare one name per block, avoiding this problem all-together.

Question 6

What are the different “types” used in TypeScript ?

Answer 6

Boolean, Number, String, Array, Tuple, Enum, Any, Void, Null, Undefined, and Never.

Question 7

What is a boolean’s value ?

Answer 7

True or false .

let isDone: boolean = false;

Question 8

What is a number’s value ?

Answer 8

Any integer. It is not treated like a string !

let decimal: number = 6;
let hex: number = 0xf00d;
let binary: number = 0b1010;
let octal: number = 0o744;

Question 9

What is a string’s value ?

Answer 9

Anything between “ “ .

let color: string = “blue”;
color = ‘red’;

Question 10

What is an array’s value ?

Answer 10

A collection of more then 1 of a certain type .

let list: number[ ] = [1, 2, 3];

–this is a more generic way–
let list: Array = [1, 2, 3];

Question 11

What is a Tuple’s value ?

Answer 11

Tuple types allow you to express an array where the type of a fixed number of elements is known, but need not be the same. For example, you may want to represent a value as a pair of a string and a number:

// Declare a tuple type
let x: [string, number];
// Initialize it
x = ["hello", 10]; // OK
// Initialize it incorrectly
x = [10, "hello"]; // Error

Question 12

What is a Enum’s value ?

Answer 12

An enum is a way of giving more friendly names to sets of numeric values.

enum Color {Red, Green, Blue};
let c: Color = Color.Green;

Question 13

Enums begin numbering their members starting at what ?

Answer 13

Enums start numbering at 0, but you can change that by manually setting the value of one of its members, or all of its members.

enum Color {Red = 1, Green = 2, Blue = 4};
let c: Color = Color.Green;

Question 14

What is a handy feature of Enums ?

Answer 14

You can also go from a numeric value to the name of that value in the enum. For example, if we had the value 2 but weren’t sure what that mapped to in the Color enum we could look up the corresponding name:

enum Color {Red = 1, Green, Blue};
let colorName: string = Color[2];

alert(colorName);

Question 15

What is Any’s value ?

Answer 15

It’s any value ! Allowing you to gradually opt-in and opt-out of type-checking during compilation.

Question 16

What is Void’s value ?

Answer 16

the opposite of any: the absence of having any type at all. You may commonly see this as the return type of functions that do not return a value:

function warnUser(): void {
    alert("This is my warning message");
}

Question 17

What is Null and Undefined ?

Answer 17

By default null and undefined are subtypes of all other types. That means you can assign null and undefined to something like number.

Question 18

What is Never’s value ?

Answer 18

The never type represents the type of values that never occur. For instance, never is the return type for a function expression or an arrow function expression that always throws an exception or one that never returns.

Question 19

How do you assign a type to a variable ?

Answer 19

: type // after the variable

Question 20

What happens if you don’t assign a type ?

Answer 20

TypeScript will infer one based on how you used the variable.

Question 21

How do you assign a type to the return value of a function ?

Answer 21

: type // after the ) of the function parameters.

Question 22

Find the problem :

function sumMatrix(matrix: number[ ][ ]) {
    var sum = 0;
    for (var i = 0; i < matrix.length; i++) {
        var currentRow = matrix[i];
        for (var i = 0; i < currentRow.length; i++) {
            sum += currentRow[i];
        }
    }

return sum; }

Answer 22

The inner for-loop will accidentally overwrite the variable i because i refers to the same function-scoped variable.

Question 23

What is the output of the following ? Why ?

for (var i = 0; i < 10; i++) {
    setTimeout(function() { console.log(i); }, 100 * i);
}

Answer 23

The output will be 10, 10, 10 etc. The reason : setTimeout will run a function after some number of milliseconds(though waiting for anything else to stop running), but only after the for loop has stopped executing; By the time the for loop has stopped executing, the value of i is 10. So each time the given function gets called, it will print out 10!

Question 24

How do you avoid a 10, 10, 10 with setTimeout ?

Answer 24

Immediately Invoked Function Expression:

for (var i = 0; i < 10; i++) {
    // capture the current state of 'i'
    // by invoking a function with its current value
    (function(i) {
        setTimeout(function() { console.log(i); }, 100 * i);
    })(i);
}

Question 25

How are “let” statements written ?

Answer 25

let hello = “Hello!”;

Question 26

What is lexical-scoping or better know as block-scoping ?

Answer 26

Unlike variables declared with var whose scopes leak out to their containing function, block-scoped variables are not visible outside of their nearest containing block or for-loop.

Question 27

What is the “temporal dead zone” ?

Answer 27

This is just a sophisticated way of saying you can’t access the variable before the let statement, and luckily TypeScript will let you know that.

Question 28

What is “shadowing” ?

Answer 28

The act of introducing a new name in a more nested scope.

Question 29

What is the output of the following? Why ?

for (let i = 0; i < 10 ; i++) {
    setTimeout(function() { console.log(i); }, 100 * i);
}

Answer 29

0, 1, 2, 3.. etc The reason : “let” declarations have drastically different behavior when declared as part of a loop. Rather than just introducing a new environment to the loop itself, these declarations sort of create a new scope per iteration.

Question 30

What is a “const” ?

Answer 30

Its a way to declare an variable, they are like “let” declarations but, as their name implies, their value cannot be changed once they are bound. In other words, they have the same scoping rules as “let”, but you can’t re-assign to them.

Question 31

Are const’s immutable ?

Answer 31

NO ! Unless you take specific measures to avoid it, the internal state of a const variable is still modifiable. Fortunately, TypeScript allows you to specify that members of an object are readonly.

Question 32

When should you use “const” ?

Answer 32

All declarations other than those you plan to modify should use “const”.

Question 33

When should you use “let” ?

Answer 33

All declarations you plan to modify should use “let”.

Question 34

What does … do ?

Answer 34

You can create a variable for the remaining items in a list using the syntax …
let [first, …rest] = [1, 2, 3, 4];
console.log(first); // outputs 1
console.log(rest); // outputs [ 2, 3, 4 ]

Question 35

What is Default value ?

Answer 35

Default values let you specify a default value in case a property is undefined:

function keepWholeObject(wholeObject: { a: string, b?: number }) {
    let { a, b = 1001 } = wholeObject;
}

Question 36

How do you make a parameter optional ?

Answer 36

you add a ? after the parameter .

Question 37

What is destructuring ?

Answer 37

Think of destructuring as an inverse of structuring. You can take a variable with properties, and create variables out of them. Array destructuring can allow you to use arrays as though they were tuples.

Question 38

What types of destructuring can you do in typescript ?

Answer 38

Array and object .

Question 39

What is an example of object deconstruction ?

Answer 39

var rect = { x: 0, y: 10, width: 15, height: 20 };

// Destructuring assignment
var {x, y, width, height} = rect;
console.log(x, y, width, height); // 0,10,15,20

Question 40

What is another example of object deconstruction ?

Answer 40

var foo = { bar: { bas: 123 } };
var {bar: {bas}} = foo; // Effectively `var bas = foo.bar.bas;`

Question 41

What is an example of array deconstruction ?

Answer 41

var x = 1, y = 2;
[x, y] = [y, x];
console.log(x, y); // 2,1

Question 42

What is an example of Array Destructuring with rest ?

Answer 42

var [x, y, …remaining] = [1, 2, 3, 4];

console.log(x, y, remaining); // 1, 2, [3,4]

Question 43

What is an example of Array Destructuring with ignores ?

Answer 43

You can ignore any index by simply leaving its location empty i.e. , , in the left hand side.
var [x, , …remaining] = [1, 2, 3, 4];
console.log(x, remaining); // 1, [3,4]

Question 44

What is an example of property renaming ?

Answer 44

let { a: newName1, b: newName2 } = o;
------the same as writing : -------
let newName1 = o.a;
let newName2 = o.b;

Question 45

How do you specify a type while destructuring ?

Answer 45

let { a, b }: { a: string, b: number } = o;

Question 46

What is the “spread” operator ?

Answer 46

The spread operator is the opposite of destructuring. It allows you to spread an array into another array, or an object into another object.

Question 47

What is an example of using a “spread” operator with arrays ?

Answer 47

let first = [1, 2];
let second = [3, 4];
let bothPlus = [0, …first, …second, 5];
This gives bothPlus the value [0, 1, 2, 3, 4, 5]. Spreading creates a shallow copy of first and second. They are not changed by the spread.

Question 48

What is an example of using a “spread” operator with objects ?

Answer 48

let defaults = { food: "spicy", price: "\$\$", ambiance: "noisy" };
let search = { ...defaults, food: "rich" };

Question 49

How is “spread” different in objects then arrays ?

Answer 49

Like array spreading, it proceeds from left-to-right, but the result is still an object. This means that properties that come later in the spread object overwrite properties that come earlier.

Question 50

What some limits of “object spread” ?

Answer 50

First, it only includes own, enumerable properties. Basically, that means you lose methods when you spread instances of an object. Second, the Typescript compiler doesn’t allow spreads of type parameters from generic functions. That feature is expected in future versions of the language.

Question 51

What is “duck typing” ? If it looks like a duck, walks like a duck, and quacks like a duck…its a DUCK !

Answer 51

One of TypeScript’s core principles is that type-checking focuses on the shape that values have. This is sometimes called “duck typing” or “structural subtyping”. In TypeScript, interfaces fill the role of naming these types, and are a powerful way of defining contracts within your code as well as contracts with code outside of your project.

Question 52

What is an example of a simple interface?

Answer 52

function printLabel(labelledObj: { label: string }) {
    console.log(labelledObj.label);
}

let myObj = {size: 10, label: "Size 10 Object"};
printLabel(myObj);

Question 53

What is a "readonly property" ?
interface Point {
    readonly x: number;
    readonly y: number;
}

Answer 53

Some properties should only be modifiable when an object is first created. You can specify this by putting readonly before the name of the property.