Using event loops

Using synchronous execution

Using promises only

Using immediate callbacks

Both represent no value

`null` is assigned, `undefined` means no assignment

`undefined` is an object, `null` is a number

A function inside another function that remembers the environment

An immediate function call

A function that modifies its own scope

A class-based function

Refers to the global object

Refers to the object in the current execution context

Always refers to the DOM element

Refers to the window object in strict mode

It binds a function to a context object

It creates a copy of a function

It modifies the value of `this`

It permanently changes the prototype of an object

To assign values to variables

To merge objects into one

To create a copy of an array

To delete properties from an object

Directly attaching events to child elements

Attaching events to a parent element to capture events on child elements

Blocking event propagation

Handling form submission with callbacks

`async` turns a function into a promise, `await` pauses execution until the promise resolves

`async` forces synchronous behavior, `await` is for handling errors

`await` works only with synchronous functions

`async` returns only errors

`forEach` returns a new array, `map` modifies the original

`forEach` modifies the original, `map` returns a new array

`forEach` works on arrays only, `map` works on objects

`forEach` can stop early, `map` cannot

Objects inherit directly from other objects via prototypes

Classes extend other classes through prototypes

Functions can only inherit through prototypes

Prototypes exist only on arrays and strings

Function and variable declarations are moved to the top of their scope

Only variables are moved to the top of their scope

Functions are executed at the end

Objects are declared before variables

Arrow functions are more performant

Arrow functions do not have their own `this` context

Arrow functions have global scope

Arrow functions prevent memory leaks

To spread out the elements of an array

To combine objects into one

To perform destructuring

To change the scope of a function

A way to handle synchronous code

A way to execute a function immediately

A proxy for a value that will be available in the future

A method to bind events

`setTimeout` runs code after a delay, `setInterval` runs code repeatedly

`setTimeout` stops after one call, `setInterval` runs until stopped

`setTimeout` modifies scope, `setInterval` forces global execution

`setTimeout` returns a callback, `setInterval` doesn't

To invoke a function with a specific `this` context

To define a new function

To modify object properties

To access an object's prototype chain

With try-catch blocks

With promise chaining

With `catch()` for rejected promises

By returning undefined for failed promises

It prevents variable hoisting

It enforces stricter parsing and error handling

It disallows function calls within loops

It modifies event propagation

Breaking down complex objects into simpler ones

Copying objects without references

Assigning object properties to variables directly

Removing properties from objects

String literals that support multi-line strings and expressions

Special functions to handle arrays

Functions that deal with string interpolation

Methods for creating promises

To sum array values

To return a new array

To accumulate a single value based on array elements

To break an array into chunks

It processes events asynchronously using a queue

It blocks execution until events complete

It handles synchronous execution only

It executes events in parallel

To define the structure of an object

To define a function's signature

To handle class inheritance

To enforce private variables

`interface` is more flexible than `type`

`type` can represent unions and intersections

`type` is used for methods only

`interface` handles object literals only

A type that can hold any value

A type that enforces type checking

A type that disables the compiler

A type for arrays and objects

It allows variables to be assigned only once

It prevents variables from being mutated

It forces shallow comparison of objects

It handles class inheritance

To define a set of named constants

To create variables with restricted values

To ensure type safety in functions

To manage state in classes

By using `?` after the property name

By using `null` values

By enforcing default values

By using the `readonly` keyword

`unknown` enforces type checking, `any` does not

`unknown` is for functions, `any` is for objects

`unknown` is for errors, `any` is for types

`unknown` disables type safety

They allow functions and classes to operate on multiple types without specifying them

They enforce strict typing

They create multiple instances of a class

They define constant values for objects

By specifying types in the function signature

By using `any` for all arguments

By using optional parameters

By adding type assertions

For functions that never return

For variables that can hold any value

For default type parameters

For methods that have optional arguments

`null` must be explicitly assigned, `undefined` means a variable has not been initialized

`null` and `undefined` are equivalent in TypeScript

`undefined` is an object, `null` is a string

Blocks of code to split functionalities into files

Templates for functions

Reserved words for type definitions

Methods to handle async code

By overriding the inferred type of a variable

By creating a union of types

By adding an interface to the type

By forcing a specific return type

To group logically related code and avoid global scope pollution

To define private methods

To handle errors in classes

To manage memory efficiently

`var` is function-scoped, `let` is block-scoped

`let` allows hoisting, `var` does not

`var` is block-scoped, `let` is function-scoped

`var` creates constants, `let` does not

They allow functions and variables to be shared across files

They handle object destructuring

They manage promises in async functions

They manage object lifecycles

They add behavior to classes or methods

They define type assertions

They enforce immutability

They handle object inheritance

To check if a value conforms to a specific type

To handle errors in functions

To prevent variable reassignment

To enforce immutability

Strongly-typed variables

Dynamic typing

Automatic memory management

Built-in debugging tools

To define the types of data a variable can hold

To declare a new variable

To perform type casting

To add comments to the code

interpreted language

compiled language

Static typing

Dynamic typing

Runtime checks

Enhanced performance

let

const

var

type

variable

typeOf

isType

:

#

TypeScript Compiler (tsc)

JavaScript Transformer (jst)

TypeScript Formatter (tsf)

JavaScript Linter (eslint)

True

False

Used to store data

Used to transfer Data

File format

Used to maintain the version of packages

Used for Configuration setting

store your all packages

all the dependencies are inside the node module

it manage the version of our project

it lock all the packages

None of above

Quiz 1

Quiz cancel

Quiz postponed

Error

Type Number is not assignable to Type string

23

Typescript Cheety

Error

Type Inferance

Explicit Typing

Dynamic Typing

None of Above

True

False

True

False

True

False

True

False

Number is not assignable to type string

Error: Strings cannot be added together

Pakistani Developers are number 1

None of above

Welcome to programming

101

Welcome to programming 101

Type number is not assignable to type string

True

False

True

False

Welcome to typescript class

23

false

Error

Unknown

void

any

undefined

null

101

null

undefined

Error

Strongly Typed

Weakly Typed

Dynamically Typed

Statistically Typed

.js

.tx

.ts

.tys

C++

Java

Python

JavaScript

build

tsc

node tsc

build tsc

Number

String

Boolean

Object

let a = true

let a: boolean = true

let a = true:bolean

let boolan: a = true

Run time

Compile time

Code time

Dev Time

names = [ ]

names: any = [ ]

names: string = [ ]

names: string[] = [ ]

Optional parameters

Default parameters

Return type

None of the options

Optional parameters

Default parameters

Return type

None of the options

Type alias

Switch parameters

Optional parameters

Generics

&

|

~

^

Represents a variable that can have any type

Represents a function that never returns

Represents an object with an unknown structure

There is no unkonwn

Using the "generic" keyword

Using the "type" keyword

Using the "<>" syntax

Using the "any" keyword

True

False

How na??

None of the options

createPerson('sam')

createPerson(true)

createPerson({

name: 'sam'

})

All of the options

0

1

2

3

Any Type

Union Type

Tuples

Array Type

Public

Private

Protected

Readonly

Static

To check the type of a variable

To define a new variable

To create an instance of an object

To import external modules