Node.js Fundamentals

# Check Node.js version
node --version   # v20.x.x or higher

# Check npm (Node Package Manager) version
npm --version    # comes with Node.js

# macOS/Linux — nvm (Node Version Manager)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
nvm install --lts
nvm use --lts

# Windows — nvm-windows
# Download from https://github.com/coreybutler/nvm-windows

$ node
> 2 + 2
4
> const name = "Node.js"
undefined
> console.log(`Hello, ${name}!`)
Hello, Node.js!
undefined
> .exit   // Exit the REPL (or Ctrl+C twice)

// app.js — Your first Node.js program
console.log("Hello from Node.js!");
console.log("Platform:", process.platform);  // "darwin", "win32", "linux"
console.log("Node version:", process.version);
console.log("Current dir:", process.cwd());
console.log("Arguments:", process.argv.slice(2));

// Run: node app.js arg1 arg2
// Arguments: [ 'arg1', 'arg2' ]

# Run inline code
$ node -e "console.log(process.version)"
v20.11.0

// math.js — Create a module
const add = (a, b) => a + b;
const subtract = (a, b) => a - b;
const multiply = (a, b) => a * b;

module.exports = { add, subtract, multiply };

// app.js — Import and use
const { add, multiply } = require('./math.js');
console.log(add(5, 3));      // 8
console.log(multiply(3, 7)); // 21

// math.js — ES Module exports
export const add = (a, b) => a + b;
export const subtract = (a, b) => a - b;
export default { add, subtract };

// app.js — ES Module imports
import { add } from './math.js';          // Named import
import * as math from './math.js';        // Namespace import
import mathFunctions from './math.js';    // Default import
console.log(add(5, 3)); // 8

const os = require('os');

console.log('Platform:', os.platform());      // 'darwin', 'win32', 'linux'
console.log('Architecture:', os.arch());      // 'x64', 'arm64'
console.log('CPU Cores:', os.cpus().length);
console.log('Total Memory:', (os.totalmem() / 1024**3).toFixed(1), 'GB');
console.log('Free Memory:', (os.freemem() / 1024**3).toFixed(1), 'GB');
console.log('Home Directory:', os.homedir());
console.log('Uptime:', (os.uptime() / 3600).toFixed(1), 'hours');

const readline = require('readline/promises');

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

async function getUserInfo() {
  const name = await rl.question('What is your name? ');
  const age = await rl.question('How old are you? ');
  console.log(`\nHello, ${name}! You are ${age} years old.`);
  rl.close();
}

getUserInfo();

import path from 'node:path';

path.join('/users', 'mehdi', 'docs', 'file.txt');
// "/users/mehdi/docs/file.txt"

path.resolve('src', 'app.js');
// "/absolute/path/to/src/app.js"

path.basename('/users/mehdi/app.js');   // "app.js"
path.extname('photo.png');              // ".png"
path.dirname('/users/mehdi/app.js');    // "/users/mehdi"

const fs = require('fs/promises');

async function readFile() {
  try {
    const data = await fs.readFile('example.txt', 'utf8');
    console.log('File contents:', data);
  } catch (error) {
    console.error('Error reading file:', error.message);
  }
}
readFile();

const fs = require('fs/promises');

async function writeFile() {
  try {
    await fs.writeFile('output.txt', 'Hello from Node.js!', 'utf8');
    console.log('File written successfully!');

    await fs.appendFile('output.txt', '\nAppended line!', 'utf8');
    console.log('Content appended!');
  } catch (error) {
    console.error('Error:', error.message);
  }
}
writeFile();

const fs = require('fs/promises');

async function workWithDirs() {
  await fs.mkdir('myFolder', { recursive: true });
  const files = await fs.readdir('.');
  console.log('Files:', files);

  try { await fs.access('myFolder'); console.log('Exists!'); }
  catch(e) { console.log('Does not exist'); }
}

const fs = require('fs/promises');
const os = require('os');

async function demo() {
  // Write JSON data
  const user = { name: 'John', age: 30, platform: os.platform() };
  await fs.writeFile('user.json', JSON.stringify(user, null, 2), 'utf8');
  console.log('✓ Created user.json');

  // Read it back
  const content = await fs.readFile('user.json', 'utf8');
  console.log('✓ Read:', JSON.parse(content));

  // Create logs directory & write log
  await fs.mkdir('logs', { recursive: true });
  const log = `[${new Date().toISOString()}] User data accessed\n`;
  await fs.appendFile('logs/app.log', log, 'utf8');
  console.log('✓ Logged activity');

  // List files
  const files = await fs.readdir('.');
  console.log('✓ Files:', files);
}
demo().catch(err => console.error('❌ Error:', err.message));

const http = require('http');

const server = http.createServer((req, res) => {
  console.log('New request received!');
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello from Node.js server!');
});

const PORT = 3000;
server.listen(PORT, () => {
  console.log(`Server running at http://localhost:${PORT}/`);
});

const http = require('http');

const server = http.createServer((req, res) => {
  if (req.method === 'POST') {
    let body = '';

    req.on('data', (chunk) => {
      body += chunk.toString();
    });

    req.on('end', () => {
      try {
        const data = JSON.parse(body);
        console.log('Parsed:', data);
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ message: 'Data received!', received: data }));
      } catch (error) {
        res.writeHead(400);
        res.end('Invalid JSON');
      }
    });
  } else {
    res.end('Send a POST request with JSON data');
  }
});

server.listen(3000);

const http = require('http');

const server = http.createServer((req, res) => {
  const { method, url } = req;

  if (url === '/' && method === 'GET') {
    res.writeHead(200, { 'Content-Type': 'text/html' });
    res.end('<h1>Welcome!</h1><p><a href="/about">About</a></p>');
  }
  else if (url === '/about' && method === 'GET') {
    res.writeHead(200, { 'Content-Type': 'text/html' });
    res.end('<h1>About</h1><p>Node.js server</p>');
  }
  else if (url === '/api/users' && method === 'GET') {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify([{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]));
  }
  else {
    res.writeHead(404, { 'Content-Type': 'text/html' });
    res.end('<h1>404 - Not Found</h1>');
  }
});

server.listen(3000, () => console.log('Server at http://localhost:3000'));

const http = require('http');

const todos = [
  { id: 1, task: 'Learn Node.js', completed: false },
  { id: 2, task: 'Build a server', completed: true }
];

const server = http.createServer((req, res) => {
  const { method, url } = req;
  res.setHeader('Access-Control-Allow-Origin', '*');
  res.setHeader('Content-Type', 'application/json');

  if (url === '/api/todos' && method === 'GET') {
    res.writeHead(200);
    res.end(JSON.stringify({ todos }));
  }
  else if (url === '/api/todos' && method === 'POST') {
    let body = '';
    req.on('data', chunk => body += chunk);
    req.on('end', () => {
      try {
        const data = JSON.parse(body);
        const newTodo = { id: todos.length + 1, task: data.task, completed: false };
        todos.push(newTodo);
        res.writeHead(201);
        res.end(JSON.stringify({ message: 'Created!', todo: newTodo }));
      } catch(e) {
        res.writeHead(400);
        res.end(JSON.stringify({ error: 'Invalid JSON' }));
      }
    });
  }
  else if (url.startsWith('/api/todos/') && method === 'DELETE') {
    const id = parseInt(url.split('/')[3]);
    const index = todos.findIndex(t => t.id === id);
    if (index !== -1) {
      todos.splice(index, 1);
      res.writeHead(200);
      res.end(JSON.stringify({ message: 'Deleted!' }));
    } else {
      res.writeHead(404);
      res.end(JSON.stringify({ error: 'Not found' }));
    }
  }
  else {
    res.writeHead(404);
    res.end(JSON.stringify({ error: 'Endpoint not found' }));
  }
});

server.listen(3000, () => console.log('🚀 Todo API at http://localhost:3000'));

# Create package.json (interactive)
npm init

# Quick init with defaults
npm init -y

{
  "name": "my-node-project",
  "version": "1.0.0",
  "description": "My awesome Node.js project",
  "main": "index.js",
  "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js",
    "test": "echo \"Error: no test\" && exit 1"
  },
  "dependencies": {
    "express": "^4.18.2"
  },
  "devDependencies": {
    "nodemon": "^3.0.1"
  }
}

# Install a package → dependencies
npm install express
npm i express          # shorthand

# Install multiple
npm install express mongoose dotenv

# Install as dev dependency
npm install --save-dev nodemon
npm i -D nodemon       # shorthand

# Install all from package.json
npm install

# Install specific version
npm install express@4.17.1

# Install globally
npm install -g nodemon

# Special scripts — can omit "run"
npm start        # runs "start" script
npm test         # runs "test" script

# Custom scripts — need "run"
npm run dev      # runs "dev" script
npm run build    # runs "build" script

# Install as dev dependency
npm install --save-dev nodemon

// package.json
{
  "scripts": {
    "start": "node server.js",     // Production
    "dev": "nodemon server.js"     // Development (auto-restart)
  }
}

// Access environment variables
const PORT = process.env.PORT || 3000;
const NODE_ENV = process.env.NODE_ENV || 'development';
const DATABASE_URL = process.env.DATABASE_URL;
const API_KEY = process.env.API_KEY;

app.listen(PORT, () => {
  console.log(`Server on port ${PORT} in ${NODE_ENV} mode`);
});

# 1. Install
npm install dotenv

# 2. Create .env file (see above)

# 3. Load in your app (first line!)

// server.js
require('dotenv').config(); // Load .env at the very top!

const PORT = process.env.PORT || 3000;
const DB = process.env.DATABASE_URL;
const API_KEY = process.env.API_KEY;

console.log('Port:', PORT);
console.log('Database:', DB);
// Never log API keys in production!