面试题与答案

Node.js is an open-source, cross-platform JavaScript runtime environment that executes JavaScript code server-side.

Example:

console.log('Hello, Node.js!');

npm (Node Package Manager) is the default package manager for Node.js, used to manage and distribute Node.js packages/modules.

Example:

npm install package_name

package.json is a manifest file that contains metadata about a Node.js project, including dependencies, scripts, and other project-specific configurations.

Example:

npm init

The 'global' object represents the global scope in Node.js. Variables declared in the global scope are available globally to all modules in the application.

Example:

global.myVariable = 'Hello';

The 'require' function is used to include modules in Node.js. It is the way to import functionality from other modules.

Example:

const fs = require('fs');

The 'os' module provides a way to interact with the operating system. It includes methods to get information about the operating system like CPU architecture, memory, and network interfaces.

Example:

const os = require('os');
console.log(os.totalmem());

The 'fs' module in Node.js provides file system-related functionality. It allows reading from and writing to files, manipulating file paths, and performing other file-related operations.

Example:

const fs = require('fs');
fs.readFile('file.txt', 'utf8', (err, data) => { /* handle file content */ });

The 'url' module provides utilities for URL resolution and parsing. It allows working with URLs, including parsing query parameters and formatting URL components.

Example:

const url = require('url');
const parsedUrl = url.parse('https://example.com/path?query=value', true);

The 'dotenv' module is used to load environment variables from a '.env' file into 'process.env'. It is commonly used in Node.js applications to manage configuration variables.

Example:

require('dotenv').config();

Node.js follows an event-driven, non-blocking I/O model. It means that the server can handle multiple connections simultaneously, and when an event occurs, the corresponding callback function is executed.

Example:

const server = require('http').createServer((req, res) => { /* handle request */ });

Middleware functions are functions that have access to the request, response, and next middleware function in the application’s request-response cycle. They can modify the request and response objects or end the request-response cycle.

Example:

app.use((req, res, next) => { /* middleware logic */ next(); });

Node.js uses callbacks, Promises, and async/await to handle asynchronous operations. Callbacks are a common pattern, but Promises and async/await provide more readable and maintainable code.

Example:

fs.readFile('file.txt', 'utf8', (err, data) => { /* handle file content */ });

The 'process' object is a global object that provides information about the current Node.js process. It can be used to get information about the environment, control the process, and handle signals.

Example:

console.log(process.env.NODE_ENV);

'process.nextTick()' and 'setImmediate()' are used to execute a callback function in the next iteration of the event loop. 'process.nextTick()' has a higher priority and runs before 'setImmediate()'.

Example:

process.nextTick(() => { console.log('Next Tick'); });

The 'Buffer' class in Node.js is used to handle binary data. It provides a way to work with raw data directly without requiring encoding/decoding.

Example:

const buffer = Buffer.from('Hello, Node.js');

The event loop is a core concept in Node.js that allows the execution of non-blocking asynchronous operations. It continuously checks the message queue and executes callbacks when events occur.

Example:

console.log('Start');
setTimeout(() => console.log('Timeout'), 1000);
console.log('End');

'require.resolve()' is used to find the path of a module file. It returns the absolute path of the resolved module.

Example:

const path = require.resolve('path');

Middleware functions in Express.js are functions that have access to the request, response, and next middleware function. They can modify the request and response objects, terminate the request-response cycle, or call the next middleware in the stack.

Example:

app.use((req, res, next) => { /* middleware logic */ next(); });

'exports' is a shorthand reference to 'module.exports', but reassigning 'exports' directly does not work. To export an object or function, 'module.exports' should be used.

Example:

module.exports = { key: 'value' };

The 'child_process' module in Node.js is used to create child processes. It provides the 'spawn', 'exec', 'execFile', and 'fork' methods to create and interact with child processes.

Example:

const { spawn } = require('child_process');
const child = spawn('ls', ['-l']);

The 'net' module in Node.js provides a way to create TCP servers and clients. It allows you to build networking applications, such as chat servers or custom protocols.

Example:

const net = require('net');
const server = net.createServer((socket) => { /* handle connection */ });

The 'cluster' module in Node.js allows you to create child processes that share server ports. It enables the creation of multi-core server applications, improving performance.

Example:

const cluster = require('cluster');
if (cluster.isMaster) { /* create workers */ } else { /* start server logic */ }

The 'crypto' module provides cryptographic functionality in Node.js. It allows for the generation of hashes, HMAC (Hash-based Message Authentication Code), and various encryption/decryption algorithms.

Example:

const crypto = require('crypto');
const hash = crypto.createHash('sha256').update('Hello').digest('hex');

npm scripts are user-defined scripts that can be run using the 'npm run' command. They are defined in the 'scripts' section of the 'package.json' file and can be used for various tasks such as testing, building, or starting the application.

Example:

"scripts": { "start": "node index.js", "test": "mocha test/*.js" }

Errors in Node.js can be handled using try-catch blocks, using the 'error' event in asynchronous operations, or by using middleware functions in frameworks like Express.js to catch errors globally.

Example:

try { /* code that may throw an error */ } catch (error) { /* handle error */ }

Event emitters in Node.js allow objects to emit named events that cause functions (listeners) to be called. They are at the core of Node.js's event-driven architecture and are used throughout the standard library.

Example:

const EventEmitter = require('events');
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();
myEmitter.on('event', () => console.log('Event emitted'));

WebSocket is a communication protocol that provides full-duplex communication channels over a single, long-lived connection. In Node.js, the 'ws' library is commonly used to implement WebSocket servers and clients.

Example:

const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });

Middleware chaining in Express.js is the process of sequentially applying multiple middleware functions to a request. Each middleware function can modify the request and response objects or terminate the request-response cycle.

Example:

app.use(middleware1);
app.use(middleware2);
app.use(middleware3);

'pm2' is a process manager for Node.js applications. It allows you to run, monitor, and manage Node.js processes, enabling features like automatic restarts, clustering, and log management.

Example:

pm2 start app.js

CORS (Cross-Origin Resource Sharing) middleware in Express.js is used to enable or restrict cross-origin HTTP requests. It adds the necessary headers to allow or deny requests from different origins.

Example:

const cors = require('cors');
app.use(cors());