Javascript

Question 1

array.forEach

Answer 1

Executes a provided function once for each array element

Question 2

array.map

Answer 2

Creates a new array with the results of calling a provided function on every element in the calling array.

Question 3

array.filter

Answer 3

Creates a new array with all elements that pass the test implemented by the provided function

Question 4

array.find

Answer 4

Returns the first element in the array that satisfies the provided testing function

Question 5

array.findIndex

Answer 5

Returns the index of the first element in the array that satisfies the provided testing function

Question 6

array.some

Answer 6

Checks if at least one element in the array passes the test implemented by the provided function.

Question 7

array.every

Answer 7

Checks if all elements in the array pass the test implemented by the provided function.

Question 8

array.reduce

Answer 8

Executes a reducer function on each element of the array, resulting in a single output value.

Question 9

array.reduceRight

Answer 9

Same as reduce, but processes the array from right to left.

Question 10

array.sort

Answer 10

Sorts the elements of an array in place and returns the sorted array.

Question 11

array.slice

Answer 11

Returns a shallow copy of a portion of an array into a new array object.

Question 12

array.splice

Answer 12

Changes the contents of an array by removing or replacing existing elements and/or adding new elements in place.

Question 13

array.concat

Answer 13

Returns a new array comprised of this array joined with other array(s) and/or value(s).

Question 14

array.includes

Answer 14

Determines whether an array includes a certain element, returning true or false as appropriate.

Question 15

array.indexOf

Answer 15

Returns the first index at which a given element can be found in the array, or -1 if it is not present.

Question 16

array.lastIndexOf

Answer 16

Returns the last index at which a given element can be found in the array, or -1 if it is not present.

Question 17

array.join

Answer 17

joins all elements of an array into a string.

Question 18

isArray

Answer 18

Determines whether the passed value is an Array

Question 19

array.toString

Answer 19

Returns a string representing the specified array and its elements.

Question 20

array.reverse

Answer 20

Reverses the elements of an array in place.

Question 21

Primitive Data Types

Answer 21

Stored directly in the variable’s location: Primitive data types are stored directly in the variable’s memory location.

Immutable: Once a primitive value is assigned to a variable, its value cannot be changed. Any operation that appears to modify a primitive value actually creates a new value.

Examples: Number, String, Boolean, Undefined, Null, Symbol (ES6).

Question 22

Non-Primitive Data Types (Reference Types):

Answer 22

Stored by reference: Non-primitive data types are stored by reference, meaning that the variable contains a reference (memory address) to the actual value stored elsewhere in memory.

Mutable: Non-primitive values can be modified because they are stored by reference. Changing the value through one reference affects all other references to that value.

Examples: Object, Array, Function, Date, RegExp.

Question 23

Undefined

Answer 23

undefined is a primitive value that represents a variable or object property that has not been assigned a value.

It indicates that a variable has been declared but has not yet been initialized or assigned any value.

It is automatically assigned to variables that have been declared but not explicitly initialized.

Use undefined when a variable or object property has not been assigned any value, either because it has not been initialized or because it has been explicitly set to undefined.

Question 24

null

Answer 24

null is a primitive value that represents the intentional absence of any object value.

It is often used to explicitly indicate that a variable or object does not have a value.

null is explicitly assigned by developers to signify that a variable or object property should not reference any object.

Use null when you want to explicitly denote the intentional absence of a value.

Question 24

Symbol

Answer 24

It represents a unique and immutable value that can be used as an identifier for object properties. Symbols are created using the Symbol() function. Symbols are primarily used as unique property keys for objects. They help avoid property name collisions in objects, especially when working with third-party code or libraries.

Question 25

Object.keys(object)

Answer 25

Returns an array of a given object's own enumerable property names.

Question 26

Object.values(object)

Answer 26

Returns an array of a given object's own enumerable property values.

Question 27

Object.entries(object)

Answer 27

Returns an array of a given object's own enumerable string-keyed property [key, value] pairs.

Question 28

Object.assign(target, source1, source2, ...)

Answer 28

Copies the values of all enumerable own properties from one or more source objects to a target object. It returns the modified target object.

Question 29

Object.freeze(object)

Answer 29

Freezes an object, preventing new properties from being added to it and existing properties from being removed or changed. It also prevents the values of existing properties from being changed.

Question 30

Object.seal(object)

Answer 30

Seals an object, preventing new properties from being added to it. However, existing properties can still be changed.

Question 31

Object.getOwnPropertyNames(object)

Answer 31

Returns an array of all property names (including non-enumerable properties) of a given object.

Question 32

new Date()

Answer 32

Creates a new Date object representing the current date and time.

Question 33

Date.now()

Answer 33

Returns the numeric value corresponding to the current time—the number of milliseconds elapsed since January 1, 1970 00:00:00 UTC (the Unix epoch).

Question 34

getFullYear()

Answer 34

Returns the year (four digits for dates between year 1000 and 9999) of the specified date according to local time.

Question 35

getMonth()

Answer 35

Returns the month (0-11) of the specified date according to local time.

Question 36

getDate()

Answer 36

Returns the day of the month (1-31) for the specified date according to local time

Question 37

getDay()

Answer 37

Returns the day of the week (0-6) for the specified date according to local time. (0 for Sunday, 1 for Monday, and so on.)

Question 38

getHours()

Answer 38

Returns the hour (0-23) in the specified date according to local time.

Question 39

getMinutes()

Answer 39

Returns the minutes (0-59) in the specified date according to local time.

Question 40

getSeconds()

Answer 40

Returns the seconds (0-59) in the specified date according to local time.

Question 41

getMilliseconds()

Answer 41

Returns the milliseconds (0-999) in the specified date according to local time.

Question 42

Object.keys() with filter()

Answer 42

You can use Object.keys() to get an array of keys from the object and then filter this array based on certain conditions

Question 43

Object.entries() with filter()

Answer 43

You can use Object.entries() to get an array of key-value pairs (as arrays) and then filter this array based on certain conditions

Question 44

Reduce() method on Object

Answer 44

You can use the reduce() method to filter the object and accumulate the result.

Question 45

Using for...in loop for Object

Answer 45

You can iterate over the object using a for...in loop and filter based on certain conditions

Question 46

Using Object.entries() with map()

Answer 46

Object.entries() method returns an array of a given object's own enumerable property [key, value] pairs.

Question 47

Using Object.keys() with map()

Answer 47

Object.keys() method returns an array of a given object's own enumerable property names.

Question 48

What is strict mode

Answer 48

Makes debugging easier: Strict mode makes debugging easier by throwing more exceptions for common coding errors, such as using undeclared variables. Prevents accidental global variables: In non-strict mode, assigning a value to an undeclared variable creates a global variable. In strict mode, assigning to an undeclared variable throws a ReferenceError. Makes eval() safer: In strict mode, variables and functions declared inside eval() are not created in the surrounding scope, avoiding potential naming conflicts. Disallows duplicate property names in objects: In strict mode, defining a property multiple times in an object literal or using duplicate parameter names in a function declaration causes a syntax error. Disallows octal literals: In strict mode, octal literals (e.g., 012) are not allowed, preventing potential confusion with decimal numbers. Prevents with statement: The with statement is disallowed in strict mode, as it can lead to ambiguous code and performance issues

Question 49

var

Answer 49

* Function Scope: Variables declared with var are function-scoped. They are accessible anywhere within the function in which they are declared. * Hoisting: Variables declared with var are hoisted to the top of their scope. This means you can access the variable before it's declared without getting an error, but its value will be undefined. * Reassignable: Variables declared with var can be reassigned and re-declared within the same scope.

Question 50

let

Answer 50

* Block Scope: Variables declared with let are block-scoped. They are accessible only within the block in which they are declared (block is defined by {}). * No Hoisting: Variables declared with let are not hoisted to the top of their scope. Trying to access the variable before it's declared will result in a ReferenceError. * Reassignable: Variables declared with let can be reassigned, but not re-declared within the same scope.

Question 51

const

Answer 51

* Block Scope: Like let, variables declared with const are block-scoped. * No Hoisting: Variables declared with const are not hoisted to the top of their scope. * Immutable: Variables declared with const cannot be reassigned. However, if the variable is an object or array, its properties or elements can be modified.

Question 52

Using ==

Answer 52

Using loose equality (==)

Question 53

===

Answer 53

strict equality (===)

Question 54

Not using hasOwnProperty()

Answer 54

When iterating over object properties, not using hasOwnProperty() can cause unexpected behavior if the object's prototype chain has been modified.

Question 55

str.charAt(index)

Answer 55

Returns the character at the specified index in a string.

Question 56

str.charCodeAt(index)

Answer 56

Returns the Unicode value of the character at the specified index in a string.

Question 57

str.concat(str1, str2, ..., strN)

Answer 57

Combines two or more strings together. javascript

Question 58

str.includes(searchString, position)

Answer 58

Checks if a string contains another specified string

Question 59

str.indexOf(searchValue, fromIndex)

Answer 59

Returns the index of the first occurrence of a specified value in a string.

Question 60

str.lastIndexOf(searchValue, fromIndex)

Answer 60

Returns the index of the last occurrence of a specified value in a string.

Question 61

str.slice(startIndex, endIndex)

Answer 61

Extracts a section of a string and returns it as a new string.

Question 62

str.split(separator, limit)

Answer 62

Splits a string into an array of substrings based on a specified separator.

Question 63

str.substring(startIndex, endIndex)

Answer 63

Returns the part of the string between the start and end indexes.

Question 64

str.toLowerCase()

Answer 64

Converts a string to lowercase.

Question 65

str.toUpperCase()

Answer 65

Converts a string to uppercase.

Question 66

str.trim()

Answer 66

Removes whitespace from both ends of a string.

Question 67

Callbacks

Answer 67

Traditionally, JavaScript used callbacks to handle asynchronous operations. Callbacks are functions passed as arguments to other functions, which are then executed when the asynchronous task completes. However, this approach can lead to callback hell, making code difficult to read and maintain, especially when dealing with nested callbacks.

Question 68

Promises

Answer 68

Promises provide a cleaner way to work with asynchronous code by representing a value (or the eventual completion or failure of an asynchronous operation) that may be available now, in the future, or never. A Promise can be in one of three states: pending, fulfilled (resolved), or rejected. Promises have then() and catch() methods to handle successful and failed outcomes, respectively.

Question 69

Async/Await

Answer 69

Async functions and the await keyword provide a more concise and readable way to write asynchronous code. Async functions are declared with the async keyword, and they always return a Promise. Within an async function, the await keyword can be used to pause the execution of the function until a Promise is settled (resolved or rejected). This makes asynchronous code look more synchronous and easier to understand.

Question 70

Error Handling

Answer 70

Both Promises and async/await support error handling using catch() blocks or try-catch blocks, respectively. This allows you to gracefully handle errors that occur during asynchronous operations.

Question 71

Chaining

Answer 71

Promises and async/await can be chained together to handle multiple asynchronous operations sequentially or in parallel, depending on the requirements of your code.

Question 72

Single Thread

Answer 72

JavaScript is single-threaded, meaning it can only execute one piece of code at a time. This is different from multi-threaded environments where multiple threads of execution can happen concurrently.

Question 73

Non-blocking I/O

Answer 73

JavaScript uses non-blocking I/O operations, which means that it doesn't wait for I/O operations like network requests or file system operations to complete before moving on to the next task. Instead, it delegates these tasks to the browser or runtime environment and continues executing other code.

Question 74

Event Queue

Answer 74

When an asynchronous operation completes or an event occurs (like a user clicking a button), the callback associated with that operation or event is placed into a queue called the event queue.

Question 75

Event Loop

Answer 75

The event loop continuously checks the call stack (the place where function calls are managed) and the event queue. If the call stack is empty, it takes the first callback from the event queue and pushes it onto the call stack, allowing it to execute. This process continues indefinitely, ensuring that asynchronous operations are handled in the order they were received and that the JavaScript engine remains responsive.

Question 76

Closures

Answer 76

They occur when a function retains access to its lexical scope even after the outer function has finished executing. This means that inner functions have access to the variables and parameters of their outer functions, even after the outer function has returned.

Question 77

Prototype

Answer 77

Every JavaScript object has a prototype. When you create an object using object literals {}, arrays [], or functions, they inherit properties and methods from a prototype. You can access an object's prototype using Object.getPrototypeOf() or the __proto__ property.

Question 78

Prototype Chain

Answer 78

JavaScript objects form a chain of prototypes, known as the prototype chain. When you access a property or method on an object, JavaScript looks for it in the object itself. If it's not found, it looks up the prototype chain until it finds the property or until it reaches the end of the chain (the Object.prototype).

Question 79

Prototypal Inheritance:

Answer 79

Objects inherit properties and methods from their prototype. If a property or method is not found on the object itself, JavaScript automatically looks for it in the object's prototype and continues up the prototype chain until it finds it. This is known as prototypal inheritance.

Question 80

Constructor Functions

Answer 80

Constructor functions can be used to create objects with shared properties and methods. When you use the new keyword with a constructor function, it creates a new object that inherits from the constructor's prototype.

Question 81

Object.prototype

Answer 81

At the top of the prototype chain is Object.prototype, which contains common methods and properties shared by all objects in JavaScript, such as toString(), hasOwnProperty(), etc.

Question 82

Event Emitters

Answer 82

Event emitters are objects in Node.js that allow you to register listeners for named events and emit events when certain actions occur. They are commonly used for handling asynchronous operations, such as I/O operations, network requests, or user interactions.

Question 83

Observables

Answer 83

Observables are a pattern used in reactive programming to handle data streams and asynchronous events. They represent a sequence of values over time and provide operators to manipulate and process those values. Observables are commonly used in libraries like RxJS.

Question 84

When to use Array of objects?

Answer 84

Use an array of objects when you need to maintain an ordered collection of elements, and each element is a distinct entity with multiple properties. Arrays allow duplicate elements, so if your data can contain duplicates, an array might be more appropriate. Arrays provide convenient methods for accessing, adding, removing, and manipulating elements, such as push, pop, splice, etc. If you need to perform operations that rely on the index or specific order of elements, an array is usually the better choice.

Question 85

When to use a set?

Answer 85

Use a Set when you need a collection of unique elements and duplicates are not allowed or not desirable. Sets automatically handle duplicate values by only storing unique elements. If you want to ensure that each element appears only once in your collection, a Set is a good choice. Sets provide methods for adding, removing, and checking for the presence of elements, such as add, delete, has, etc. Sets are especially useful when you need to perform set operations like union, intersection, or difference between collections.

Question 86

create set

Answer 86

const mySet = new Set();

Question 87

add to set

Answer 87

mySet.add(1); availableBooks.set('one', { title: 'One', author: 'Author One', available: true });

Question 88

access entries in set

Answer 88

availableBooks.get('one') // Output: { title: 'One', author: 'Author One', available: true }

Question 89

Checking for existence in set

Answer 89

availableBooks.has('two') // Output: true

Question 90

Removing an entry set

Answer 90

availableBooks.delete('three');

Question 91

Iterating over entries in set

Answer 91

availableBooks.forEach((value, key) => { console.log(`${key}: ${value.title} by ${value.author}`); });