Interview Questions and Answers

                                    npm install package-name
                                

                                npm install -g package-name
                               

                            function fetchData(url, callback) {
                                fetch(url)
                                  .then(response => response.json())
                                  .then(data => {
                                    // Once the data is retrieved, call the callback function
                                    callback(data);
                                  })
                                  .catch(error => {
                                    // Handle errors here
                                    console.error('Error:', error);
                                  });
                              }
                              
                              // Example usage of the fetchData function with a callback
                              fetchData('https://api.example.com/data', function(data) {
                                console.log('Data received:', data);
                              });
                               
                         

function readFileAndProcess(filePath, callback) {
    fs.readFile(filePath, 'utf8', function(err, data) {
      if (err) {
        // Handle the error
        callback(err);
      } else {
        // Process the data
        // ...
        callback(null, processedData);
      }
    });
  }
   

   function createCallback() {
       return function() {
           console.log("This is a callback function");
       };
   }

   const myCallback = createCallback();
   // Now, you can decide when to call the callback
   myCallback(); // Calls the callback function
    

    function performAsyncOperation(callback) {
        // Simulate an async operation
        setTimeout(function() {
            console.log("Async operation completed");
            callback(); // Calling the provided callback
        }, 1000);
    }
 
    performAsyncOperation(function() {
        console.log("This is a callback function");
    });
     

     json
{
  "name": "my-project",
  "version": "1.0.0",
  "description": "A sample project",
  "dependencies": {
    "express": "^4.17.1",
    "lodash": "^4.17.21"
  },
  "devDependencies": {
    "mocha": "^9.1.3"
  },
  "scripts": {
    "start": "node index.js",
    "test": "mocha"
  },
  "main": "index.js",
  "author": "Your Name",
  "license": "MIT"
}
 

                                const util = require('util');
                                const fs = require('fs');
                                const readFileAsync = util.promisify(fs.readFile);
                                
                                readFileAsync('file.txt', 'utf8')
                                    .then(data => {
                                        console.log(data);
                                    })
                                    .catch(err => {
                                        console.error(err);
                                    });
                                 
                                
                                

    console.log(process.cwd());
     

    console.log(__dirname);
     

    process.on('uncaughtException', (error) => {
        console.error('Uncaught Exception:', error);
        // Optionally, you can perform cleanup or other tasks.
        process.exit(1); // Terminate the application (recommended).
    });
     

    process.on('unhandledRejection', (reason, promise) => {
        console.error('Unhandled Promise Rejection:', reason);
        // Optionally, you can perform cleanup or other tasks.
        // Terminate the application or handle the rejection as needed.
    });
     

    const fs = require('fs');
    const zlib = require('zlib');
    
    const source = fs.createReadStream('input.txt'); // Readable stream
    const gzip = zlib.createGzip(); // Transform stream (compress data)
    const destination = fs.createWriteStream('output.txt.gz'); // Writable stream
    
    source.pipe(gzip).pipe(destination); // Pipe data through the transform and write streams
  

    const fs = require('fs');
    const zlib = require('zlib');
    
    const source = fs.createReadStream('input.txt'); // Readable stream
    const gzip = zlib.createGzip(); // Transform stream (compress data)
    const destination = fs.createWriteStream('output.txt.gz'); // Writable stream
    
    source.pipe(gzip).pipe(destination); // Pipe data through the transform and write streams
     

                                const buffer = Buffer.from('Hello, Node.js!', 'utf8');
                                
                                console.log(buffer); // <Buffer 48 65 6c 6c 6f 2c 20 4e 6f 64 65 2e 6a 73 21>
                                 
                             

                                const fs = require('fs');
                                
                                fs.readFile('file.txt', 'utf8', (err, data) => {
                                    if (err) {
                                        console.error(err);
                                    } else {
                                        console.log(data);
                                    }
                                });
                                
                                console.log('This message will be displayed immediately without waiting for the file read.');
                                 
                                
                            

const fs = require('fs');

const readableStream = fs.createReadStream('input.txt');
const writableStream = fs.createWriteStream('output.txt');

readableStream.pipe(writableStream);

    const { Worker, isMainThread, parentPort } = require('worker_threads');
 
    if (isMainThread) {
        // This code runs in the main thread
        const worker = new Worker(__filename);
    } else {
        // This code runs in the child thread
        parentPort.postMessage('Hello from the child thread!');
    }   

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();

myEmitter.on('customEvent', (data) => {
    console.log( Custom event received with data: ${data} );
});

myEmitter.emit('customEvent', 'Some data to send');
 

    const fs = require('fs');
 
    try {
        const data = fs.readFileSync('file.txt', 'utf8');
        console.log(data);
    } catch (error) {
        console.error(error);
    }
     

    const fs = require('fs');
 
    fs.readFile('file.txt', 'utf8', (err, data) => {
        if (err) {
            console.error(err);
        } else {
            console.log(data);
        }
    });
     

    function step1(callback) {
        // Code for step 1
        callback();
    }
 
    function step2(callback) {
        // Code for step 2
        callback();
    }
 
    function step3() {
        // Code for step 3
    }
 
    step1(() => {
        step2(() => {
            step3();
        });
    });
     

    const { promisify } = require('util');
    const fs = require('fs');
    const readFile = promisify(fs.readFile);
 
    readFile('file.txt', 'utf8')
        .then(data => {
            // Handle data
        })
        .catch(err => {
            // Handle error
        });
     

    async function readAndProcessFile() {
        try {
            const data = await readFile('file.txt', 'utf8');
            // Handle data
        } catch (err) {
            // Handle error
        }
    }
 
    readAndProcessFile();   

    const async = require('async');
 
    async.series([
        callback => {
            // Step 1
            callback(null, result1);
        },
        callback => {
            // Step 2
            callback(null, result2);
        },
        callback => {
            // Step 3
            callback(null, result3);
        }
    ], (err, results) => {
        // Handle final results or errors
    });
     

    function performStep1(callback) {
        // Code for step 1
        callback();
    }
 
    function performStep2(callback) {
        // Code for step 2
        callback();
    }
 
    function performStep3() {
        // Code for step 3
    }
 
    performStep1(() => {
        performStep2(() => {
            performStep3();
        });
    });
     

    const { exec } = require('child_process');
 
    exec('ls -l', (error, stdout, stderr) => {
        if (error) {
            console.error( Error: ${error} );
            return;
        }
        console.log( Standard Output: ${stdout} );
        console.error( Standard Error: ${stderr} );
    });
     

    const { spawn } = require('child_process');
 
    const ls = spawn('ls', ['-l']);
 
    ls.stdout.on('data', (data) => {
        console.log( stdout: ${data} );
    });
 
    ls.stderr.on('data', (data) => {
        console.error( stderr: ${data} );
    });
 
    ls.on('close', (code) => {
        console.log( child process exited with code ${code} );
    });
     

    // Node.js Module
    const fs = require('fs');
    module.exports = someFunction;
 
    // ES6 Module
    import fs from 'fs';
    export default someFunction;
     

                                const { VM } = require('vm');
                                
                                const vm = new VM({
                                    timeout: 1000, // Set a time limit for execution
                                    sandbox: {
                                        // Define custom global variables
                                        myVar: 42,
                                        customFunction: (value) => {
                                            return value   2;
                                        },
                                    },
                                });
                                
                                try {
                                    const result = vm.run( 
                                        const result = customFunction(myVar);
                                        result   10;
                                     );
                                
                                    console.log(result); // Output: 840
                                } catch (error) {
                                    console.error(error);
                                }
                                 
                               

    #include <node_api.h>
    
    napi_value MyFunction(napi_env env, napi_callback_info info) {
        napi_value result;
        napi_create_int32(env, 42, &result);
        return result;
    }
    
    napi_value Init(napi_env env, napi_value exports) {
        napi_property_descriptor desc = { "myFunction", 0, MyFunction, 0, 0, 0, napi_default, 0 };
        napi_define_properties(env, exports, 1, &desc);
        return exports;
    }
    
    NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)
     
    

    function someFunction() {
        // ...
        debugger; // Add this line to trigger debugging
        // ...
    }
     

    const fs = require('fs');
      
  

    import fs from 'fs';
     

                                   // myModule.js
                                   const myDefault = 'This is the default export.';
                                   export default myDefault;
                                    
                                
                                

                                   // anotherModule.js
                                   import myDefaultValue from './myModule.js';
                                
                                   console.log(myDefaultValue); // 'This is the default export.'
                                     
                                

                                   // myModule.js
                                   const myDefault = 'This is the default export.';
                                   const namedExport = 'This is a named export.';
                                
                                   export { namedExport };
                                   export default myDefault;
                                    
                                
                                

                                   // anotherModule.js
                                   import myDefaultValue, { namedExport } from './myModule.js';
                                
                                   console.log(myDefaultValue); // 'This is the default export.'
                                   console.log(namedExport);    // 'This is a named export.'
                                    
                                
                                

    emitter.on('event', () => console.log('First listener'));
    emitter.on('event', () => console.log('Second listener'));
     
 

    emitter.on('event', async () => {
        await someAsyncOperation();
        console.log('Async listener');
    });
     

    emitter.on('event', () => {
        process.nextTick(() => console.log('Microtask listener'));
    });
     

                                   const EventEmitter = require('events');
                                   const emitter = new EventEmitter();
                                
                                   emitter.on('event', () => {
                                       console.log('Listener 1');
                                   });
                                
                                   emitter.on('event', () => {
                                       console.log('Listener 2');
                                   });
                                
                                   emitter.emit('event');
                                   console.log('Event emitted');
                                
                                   // Output will be in order:
                                   // Listener 1
                                   // Listener 2
                                   // Event emitted
                                    
                                   

                                   const EventEmitter = require('events');
                                   const emitter = new EventEmitter();
                                
                                   emitter.on('event', async () => {
                                       await new Promise(resolve => setTimeout(resolve, 1000));
                                       console.log('Async Listener');
                                   });
                                
                                   emitter.on('event', () => {
                                       console.log('Sync Listener');
                                   });
                                
                                   emitter.emit('event');
                                   console.log('Event emitted');
                                
                                   // Output will be:
                                   // Sync Listener
                                   // (1 second delay)
                                   // Async Listener
                                   // Event emitted
                                    
                                
                                   

    npm install -g pm2

                                    pm2 start your-app.js
                                

                                Description=Your Node.js Application
                                After=network.target
                              

                                Restart=always
                                User=your-user
                                Group=your-group
                                Environment=NODE_ENV=production

                                [Install]
                                WantedBy=multi-user.target
                               

                                sudo systemctl start your-app
                                sudo systemctl enable your-app
                               

                                    nohup node your-app.js > app.log 2>&1 &
                                

                                screen
                               

                                node your-app.js
                               

                                screen -r
                               

                                pm2 save
                               

                                const cluster = require('cluster');
                                const http = require('http');
                                const numCPUs = require('os').cpus().length;
                                
                                if (cluster.isMaster) {
                                  // Fork workers for each CPU core
                                  for (let i = 0; i < numCPUs; i++) {
                                    cluster.fork();
                                  }
                                
                                  cluster.on('exit', (worker, code, signal) => {
                                    console.log( Worker ${worker.process.pid} died );
                                  });
                                } else {
                                  // Worker process: Create an HTTP server
                                  http.createServer((req, res) => {
                                    res.writeHead(200);
                                    res.end('Hello, world!\n');
                                  }).listen(8000);
                                }
                                 
                                
                                

   const chai = require('chai');
   const expect = chai.expect;
   
   describe('Example Test Suite', () => {
     it('should perform an assertion', () => {
       expect(1 + 1).to.equal(2);
     });
   });
    

   

   const chai = require('chai');
   const chaiHttp = require('chai-http');
   const app = require('./your-express-app'); // Your Express.js application

   chai.use(chaiHttp);

   describe('API Endpoint Test', () => {
     it('should return a 200 response', (done) => {
       chai.request(app)
         .get('/api/resource')
         .end((err, res) => {
           chai.expect(res).to.have.status(200);
           done();
         });
     });
   });
    

   

                                const assert = require('assert');
                                
                                function divide(a, b) {
                                  assert(b !== 0, 'Division by zero is not allowed');
                                  return a / b;
                                }
                                
                                console.log(divide(10, 2)); // Outputs: 5
                                console.log(divide(10, 0)); // Throws an AssertionError
                                 
                                
                                

    global.myGlobalVariable = 42;
     

    console.log(global.myGlobalVariable); // Outputs: 42
     

    global.myGlobalVariable = 'Hello, World!';
    console.log(global.myGlobalVariable); // Outputs: Hello, World!
     

    // module1.js
    global.sharedValue = 'I am a global variable!';
     

    // module2.js
    console.log(global.sharedValue); // Outputs: I am a global variable!
     

    require('./module1');
    require('./module2');
     

    global.config = {
      database: {
        host: 'localhost',
        port: 27017,
        // ...
      },
      // Other configuration options
    };
     

    global.appState = {
      loggedInUsers: 0,
      // Other application state
    };
     

   const MySingleton = require('./mySingleton');
   global.mySingletonInstance = new MySingleton();