{
 "name": "my-app",
 "version": "1.0.0",
 "main": "index.js",
 "dependencies": { "express": "^4.18.0" }
}

npm install lodash # local
npm install -g nodemon # global

const fs = require('fs');
const myModule = require('./myModule');

// CommonJS
module.exports = { add, subtract };
// ES Modules
export { add, subtract };

const path = require('path');
const http = require('http');

console.log(__dirname);
console.log(__filename);

require('dotenv').config();
const apiKey = process.env.API_KEY;

fs.readFile('file.txt', (err, data) => {
 if (err) throw err;
 console.log(data.toString());
});

setTimeout(() => console.log('once'), 1000);
const id = setInterval(() => console.log('repeating'), 1000);
clearInterval(id);

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

const path = require('path');
console.log(path.join('/users', 'tom', 'file.txt'));

const http = require('http');
const server = http.createServer((req, res) => {
 res.writeHead(200, { 'Content-Type': 'text/plain' });
 res.end('Hello World');
});
server.listen(3000);

const express = require('express');
const app = express();
app.get('/', (req, res) => res.send('Hello World'));
app.listen(3000);

app.get('/users/:id', (req, res) => {
 res.send(`User ID: ${req.params.id}`);
});

app.use(express.json());
app.post('/users', (req, res) => {
 console.log(req.body);
});

app.use(express.static('public'));

try {
 JSON.parse(invalidJson);
} catch (err) {
 console.error('Parse error:', err.message);
}

doAsyncTask()
 .then(result => process(result))
 .catch(err => console.error('Failed:', err));

{
 "scripts": {
 "start": "node index.js",
 "test": "jest"
 }
}
// run with: npm start / npm test

npm install -g nodemon
nodemon app.js

var a = 1;
let b = 2;
const c = 3;

const name = 'World';
console.log(`Hello, ${name}!`);

console.log(0 == '0'); // true
console.log(0 === '0'); // false

const os = require('os');
console.log(os.cpus().length);

// .env file: API_KEY=abc123
require('dotenv').config();
console.log(process.env.API_KEY);

// node script.js arg1 arg2
console.log(process.argv.slice(2)); // ['arg1', 'arg2']

res.set('X-Custom-Header', 'value');
res.json({ ok: true });

npx create-react-app my-app

// CommonJS
module.exports = myFunction;
// ES Modules
export default myFunction;

console.log(process.env.NODE_ENV);
console.log(process.argv);

fetch(url)
 .then(response => response.json())
 .then(data => console.log(data))
 .catch(err => console.error(err));

async function getData() {
 try {
 const response = await fetch(url);
 const data = await response.json();
 return data;
 } catch (err) {
 console.error(err);
 }
}

const results = await Promise.allSettled([p1, p2, p3]);

const util = require('util');
const readFileAsync = util.promisify(fs.readFile);
const data = await readFileAsync('file.txt');

const EventEmitter = require('events');
const emitter = new EventEmitter();
emitter.on('greet', (name) => console.log(`Hello, ${name}`));
emitter.emit('greet', 'World');

emitter.off('greet', myListener);

const fs = require('fs/promises');
const data = await fs.readFile('data.txt', 'utf8');

const fs = require('fs');
fs.createReadStream('input.txt').pipe(fs.createWriteStream('output.txt'));

const buf = Buffer.from('Hello', 'utf8');
console.log(buf); // <Buffer 48 65 6c 6c 6f>

fs.watch('config.json', (eventType, filename) => {
 console.log(`${filename} changed: ${eventType}`);
});

app.use((req, res, next) => {
 console.log(`${req.method} ${req.url}`);
 next();
});

app.use((err, req, res, next) => {
 console.error(err.stack);
 res.status(500).send('Something broke!');
});

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

const router = express.Router();
router.get('/', (req, res) => res.send('User list'));
app.use('/users', router);

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

async function run() {
 try {
 const data = await fetchData();
 } catch (err) {
 console.error(err);
 }
}

class NotFoundError extends Error {
 constructor(message) {
 super(message);
 this.name = 'NotFoundError';
 this.statusCode = 404;
 }
}

test('adds 1 + 2 to equal 3', () => {
 expect(add(1, 2)).toBe(3);
});

jest.mock('./db');
db.getUser.mockResolvedValue({ id: 1, name: 'Tom' });

node --inspect-brk app.js

const { exec } = require('child_process');
exec('ls -la', (err, stdout) => console.log(stdout));

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

const result = await pool.query('SELECT * FROM users WHERE email = $1', [email]);

const bcrypt = require('bcrypt');
const hash = await bcrypt.hash(password, 10);
const match = await bcrypt.compare(inputPassword, hash);

const jwt = require('jsonwebtoken');
const token = jwt.sign({ userId: 1 }, secretKey, { expiresIn: '1h' });
const decoded = jwt.verify(token, secretKey);

const rateLimit = require('express-rate-limit');
app.use(rateLimit({ windowMs: 15*60*1000, max: 100 }));

const mongoose = require('mongoose');
await mongoose.connect('mongodb://localhost:27017/mydb');

const userSchema = new mongoose.Schema({ name: String, age: Number });
const User = mongoose.model('User', userSchema);

const { Pool } = require('pg');
const pool = new Pool({ connectionString: process.env.DATABASE_URL });
const result = await pool.query('SELECT * FROM users');

await sequelize.transaction(async (t) => {
 await Account.update({ balance: newBalance }, { transaction: t });
});

function counter() {
 let count = 0;
 return () => ++count;
}
const increment = counter();
console.log(increment()); // 1
console.log(increment()); // 2

const obj = {
 name: 'Tom',
 regular: function() { console.log(this.name); }, // 'Tom'
 arrow: () => { console.log(this.name); } // undefined, inherits outer scope
};

class Animal {
 constructor(name) { this.name = name; }
 speak() { console.log(`${this.name} makes a sound`); }
}

const { name, age } = person;
const [first, second] = [1, 2];

const arr2 = [...arr1, 4, 5];
const merged = { ...obj1, ...obj2 };

(function() {
 console.log('Runs immediately');
})();

pm2 start app.js -i max
pm2 list
pm2 logs

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

const cached = await redisClient.get(key);
if (cached) return JSON.parse(cached);

const io = require('socket.io')(server);
io.on('connection', (socket) => {
 socket.on('message', (msg) => io.emit('message', msg));
});

app.use('/api/v1', v1Router);
app.use('/api/v2', v2Router);

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

const token = crypto.randomBytes(32).toString('hex');

const zlib = require('zlib');
fs.createReadStream('file.txt').pipe(zlib.createGzip()).pipe(fs.createWriteStream('file.txt.gz'));

const { URL } = require('url');
const myUrl = new URL('https://example.com/page?name=Tom');
console.log(myUrl.searchParams.get('name'));

const assert = require('assert');
assert.strictEqual(1 + 1, 2);

process.on('SIGTERM', async () => {
 await closeConnections();
 process.exit(0);
});

npm install -D typescript @types/node
npx tsc --init

server.close(() => {
 console.log('Server closed gracefully');
 process.exit(0);
});

const multer = require('multer');
const upload = multer({ dest: 'uploads/' });
app.post('/upload', upload.single('photo'), (req, res) => {
 res.send(req.file);
});

app.get('/health', (req, res) => res.status(200).json({ status: 'ok' }));

const { body, validationResult } = require('express-validator');
app.post('/users', body('email').isEmail(), (req, res) => {
 const errors = validationResult(req);
 if (!errors.isEmpty()) return res.status(400).json({ errors: errors.array() });
});

npm login
npm version patch
npm publish

FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --production
COPY . .
CMD ["node", "index.js"]

const request = require('supertest');
const response = await request(app).get('/users').expect(200);

const buf1 = Buffer.from('hello');
const buf2 = Buffer.alloc(10);

const https = require('https');
const options = { key: fs.readFileSync('key.pem'), cert: fs.readFileSync('cert.pem') };
https.createServer(options, handler).listen(443);

"engines": { "node": ">=18.0.0" }

const obj = Object.freeze({ a: 1 });
obj.a = 2; // silently fails (or throws in strict mode)
console.log(obj.a); // 1

process.nextTick(() => console.log('nextTick'));
setImmediate(() => console.log('immediate'));
console.log('sync');

const { Worker } = require('worker_threads');
const worker = new Worker('./heavy-task.js');

(function(exports, require, module, __filename, __dirname) {
 // module code
});

process.on('uncaughtException', (err) => {
 console.error('Uncaught exception:', err);
 process.exit(1);
});

process.on('unhandledRejection', (reason, promise) => {
 console.error('Unhandled Rejection:', reason);
});

const cluster = require('cluster');
const os = require('os');
if (cluster.isPrimary) {
 for (let i = 0; i < os.cpus().length; i++) cluster.fork();
} else {
 require('./server');
}

// parent.js
const child = require('child_process').fork('child.js');
child.send({ hello: 'world' });
child.on('message', msg => console.log(msg));

const { Readable } = require('stream');
class MyStream extends Readable {
 _read() {
 this.push('data chunk');
 this.push(null); // end stream
 }
}

const asyncHandler = fn => (req, res, next) => Promise.resolve(fn(req, res, next)).catch(next);
app.get('/users', asyncHandler(async (req, res) => {
 const users = await getUsers();
 res.json(users);
}));

delete require.cache[require.resolve('./myModule')];