This question does not have a definitive answer. It is intended to assess the extent of one's knowledge of the framework they are using. Please explain the advantages and disadvantages of selecting that framework.

Callback hell occurs when there is an excessive number of nested callback functions.

This is callback hell:

getData(function(a){

getMoreData(a, function(b){

getMoreData(b, function(c){

getMoreData(c, function(d){

getMoreData(d, function(e){

...

});

});

});

});

});

To avoid: modularization: break callbacks into independent functions

use a control flow library, like async

use generators with Promises

use async/await

const objectArray = [

{ id: 8, body: 'cat', value: 12},

undefined,

undefined,

{ id: 4, body: 'dog', value: 24 }

]

const result = objectArray

.filter( obj => !!obj )

.reduce( ( accumulator, obj ) => accumulator + obj.value, [])

console.log(result - 10)

The outcome variable will eliminate the elements in the objectArray that are not specified, then generate a new array using reduce that will join the numbers rather than adding them.

The console.log will print the value "1214"

Although NodeJS's primary thread is single-threaded, there are several operations running in the background which allow NodeJS to be executed simultaneously.

The child_process and cluster modules can be utilized to bypass single-threading, however the performance cost may be high.

The worker_threads module, available since NodeJS v12.4.0, allows JavaScript to be executed in parallel and offers the advantage of memory sharing, unlike the other two modules.

Pros:

- Making the most of the processing power available: By utilizing clusters on each core of the processor, node applications can be run more efficiently, taking full advantage of the CPU and avoiding any wasted energy.

- Cluster libraries are used for load balancing, allowing for every second call to be sent to the next instance of the app on a different processor core.

- Replacing "simple implementation" with "easy implementation": Cluster libraries are easy to use and setup, requiring very little to no extra coding, and deployment/node scripts may be sufficient.

- The single-threaded nature of NodeJs prevents you from taking full advantage of your multicore CPU as the app or process is only running on one core. Cluster allows for the utilization of all the cores.

Cons:

- NodeJs clusters are not well-suited for session based apps since each instance would require its own session to be established.

- Running multiple processes in parallel that attempt to access the same records simultaneously can cause difficulties with Cron jobs.

- NodeJS has added a datatype called Buffer to the five primitive data types (boolean, string, number, undefined, and null) and all-encompassing objects (which include arrays and functions) available in front-end JavaScript.

- The Buffer is a block of memory consisting of a fixed number of bytes that have been allocated outside of the V8 JavaScript engine and appears to be an array of integers, each representing a byte of data. It is not possible to resize the Buffer once it has been created.

- A buffer can be constructed out of an array, another buffer, ArrayBuffer, or a string. It also includes encoding options such as UTF-8, ASCII, HEX, and other formats.

- Buffers can be thought of as highly efficient data storage containers. Node.js is programmed to utilize buffers whenever possible, including when accessing data from a file system or when packets are received over a network.

- Data packets are widely utilized for streaming in the present day.

__dirname: returns the directory of the executed/called file

process.cwd(): returns the root directory of the project

i.e

Project

- main.js

Module

- moduleFile.js

main.js

console.log(process.cwd()) -> ./project

console.log(__dirname) -> ./project

moduleFile.js

console.log(process.cwd()) -> ./project

console.log(__dirname) -> ./project/Module

NodeJs features an in-built operation known as readFile, which is located in the fs module.

Repl enables one to enter Javascript statements directly into a shell prompt and evaluate the results for the purpose of testing, debugging, and experimentation, making it an essential tool.

Node.js is a single thread process that does not provide the developer with access to child threads or thread management techniques. While certain tasks such as asynchronous I/O may spawn child threads in the background, they will not execute any code from the application and will not disrupt the main event loop.

save-dev

function myMiddleware(x, y, z)

The next function will be the third argument in the application's request-response cycle. This argument is more commonly referred to as 'next'.