So strukturieren Sie Ihren Backend-Code in Node.js (Express.js)

Bei der Entwicklung einer Node.js-Anwendung mit Express.js ist die effektive Strukturierung Ihrer Codebasis für Wartbarkeit, Skalierbarkeit und einfache Zusammenarbeit von entscheidender Bedeutung. Eine gut organisierte Projektstruktur ermöglicht Ihnen die Bewältigung der Komplexität und erleichtert so die Navigation und das Verständnis des Codes. In diesem Blog untersuchen wir eine typische Ordnerstruktur für eine Express.js-Anwendung und erläutern den Zweck jedes Verzeichnisses und jeder Datei.

Übersicht über die Projektstruktur
Hier ist eine allgemeine Ordnerstruktur für eine Express.js-Anwendung:

?
├── ? app.js
├── ? bin
├── ? config
├── ? controllers
│   ├── ? customer.js
│   ├── ? product.js
│   └── ...
├── ? middleware
│   ├── ? auth.js
│   ├── ? logger.js
│   └── ...
├── ? models
│   ├── ? customer.js
│   ├── ? product.js
│   └── ...
├── ? routes
│   ├── ? api.js
│   ├── ? auth.js
│   └── ...
├── ? public
│   ├── ? css
│   ├── ? js
│   ├── ? images
│   └── ...
├── ? views
│   ├── ? index.ejs
│   ├── ? product.ejs
│   └── ...
├── ? tests
│   ├── ? unit
│   ├── ? integration
│   ├── ? e2e
│   └── ...
├── ? utils
│   ├── ? validation.js
│   ├── ? helpers.js
│   └── ...
└── ? node_modules

Erklärung jedes Verzeichnisses und jeder Datei
app.js
Die Datei app.js ist der Einstiegspunkt Ihrer Anwendung. Hier initialisieren Sie die Express-App, richten Middleware ein, definieren Routen und starten den Server. Betrachten Sie es als das Kontrollzentrum Ihrer Webanwendung.

const express = require('express');
const app = express();
const config = require('./config');
const routes = require('./routes');
// Middleware setup
app.use(express.json());
// Routes setup
app.use('/api', routes);
// Start server
const PORT = config.port || 3000;
app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});
module.exports = app;

Mülleimer
Das bin-Verzeichnis enthält normalerweise Skripte zum Starten Ihres Webservers. Diese Skripte können zum Festlegen von Umgebungsvariablen oder zum Verwalten verschiedener Umgebungen (z. B. Entwicklung, Produktion) verwendet werden.

Beispiel: bin/www

#!/usr/bin/env node
const app = require('../app');
const debug = require('debug')('your-app:server');
const http = require('http');
const port = normalizePort(process.env.PORT || '3000');
app.set('port', port);
const server = http.createServer(app);
server.listen(port);
server.on('error', onError);
server.on('listening', onListening);
function normalizePort(val) {
  const port = parseInt(val, 10);
  if (isNaN(port)) return val;
  if (port >= 0) return port;
  return false;
}
function onError(error) {
  if (error.syscall !== 'listen') throw error;
  const bind = typeof port === 'string' ? 'Pipe ' + port : 'Port ' + port;
  switch (error.code) {
    case 'EACCES':
      console.error(bind + ' requires elevated privileges');
      process.exit(1);
      break;
    case 'EADDRINUSE':
      console.error(bind + ' is already in use');
      process.exit(1);
      break;
    default:
      throw error;
  }
}
function onListening() {
  const addr = server.address();
  const bind = typeof addr === 'string' ? 'pipe ' + addr : 'port ' + addr.port;
  debug('Listening on ' + bind);
}

config
Das Konfigurationsverzeichnis enthält Konfigurationsdateien für Ihre Anwendung, z. B. Datenbankverbindungen, Servereinstellungen und Umgebungsvariablen.

Beispiel: config/index.js

module.exports = {
  port: process.env.PORT || 3000,
  db: {
    host: 'localhost',
    port: 27017,
    name: 'mydatabase'
  }
};

Controller
Controller enthalten die Logik zur Bearbeitung eingehender Anfragen und zur Generierung von Antworten. Jede Datei im Controller-Verzeichnis entspricht normalerweise einem anderen Teil Ihrer Anwendung (z. B. Kunden, Produkte).

Beispiel: controllers/customer.js

const Customer = require('../models/customer');
exports.getAllCustomers = async (req, res) => {
  try {
    const customers = await Customer.find();
    res.json(customers);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
};

Middleware
Mittels Middleware-Funktionen werden Anfragen verarbeitet, bevor diese die Controller erreichen. Sie können Aufgaben wie Authentifizierung, Protokollierung und Anforderungsvalidierung übernehmen.

Beispiel: middleware/auth.js

module.exports = (req, res, next) => {
  const token = req.header('Authorization');
  if (!token) return res.status(401).json({ message: 'Access Denied' });
  try {
    const verified = jwt.verify(token, process.env.JWT_SECRET);
    req.user = verified;
    next();
  } catch (err) {
    res.status(400).json({ message: 'Invalid Token' });
  }
};

Modelle
Modelle definieren die Struktur Ihrer Daten und verarbeiten Interaktionen mit der Datenbank. Jede Modelldatei entspricht normalerweise einer anderen Dateneinheit (z. B. Kunde, Produkt).

Beispiel: models/customer.js

const mongoose = require('mongoose');
const customerSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true
  },
  email: {
    type: String,
    required: true,
    unique: true
  },
  createdAt: {
    type: Date,
    default: Date.now
  }
});
module.exports = mongoose.model('Customer', customerSchema);

Routen
Routen definieren die Pfade zu verschiedenen Teilen Ihrer Anwendung und ordnen sie den entsprechenden Controllern zu.

Beispiel: Routen/api.js

const express = require('express');
const router = express.Router();
const customerController = require('../controllers/customer');
router.get('/customers', customerController.getAllCustomers);
module.exports = router;

öffentlich
Das öffentliche Verzeichnis enthält statische Dateien wie CSS, JavaScript und Bilder, die direkt an den Client bereitgestellt werden.

Beispiel: Verzeichnisstruktur

public/
├── css/
├── js/
├── images/

Ansichten
Ansichten sind Vorlagen, die den HTML-Code für den Client rendern. Mit einer Template-Engine wie EJS, Pug oder Handlers können Sie dynamisches HTML generieren.

Beispiel: view/index.ejs

<!DOCTYPE html>
<html>
<head>
  <title>My App</title>
  <link rel="stylesheet" href="/css/styles.css">
</head>
<body>
  <h1>Welcome to My App</h1>
  <div id="content">
    <%- content %>
  </div>
</body>
</html>

Tests
Das Testverzeichnis enthält Testdateien, um sicherzustellen, dass Ihre Anwendung ordnungsgemäß funktioniert. Tests werden häufig in Unit-Tests, Integrationstests und End-to-End-Tests (E2E) unterteilt.

Beispiel: Verzeichnisstruktur

tests/
├── unit/
├── integration/
├── e2e/

Dienstprogramme
Dienstprogrammfunktionen und Hilfsmodule werden im Utils-Verzeichnis gespeichert. Diese Funktionen führen allgemeine Aufgaben wie Validierung und Formatierung aus, die in der gesamten Anwendung verwendet werden.

Beispiel: utils/validation.js

exports.isEmailValid = (email) => {
  const re = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return re.test(String(email).toLowerCase());
};

node_modules
Das Verzeichnis node_modules enthält alle Abhängigkeiten, die Ihr Projekt benötigt. Dieses Verzeichnis wird von npm (oder Yarn) verwaltet und enthält Pakete, die aus der npm-Registrierung installiert wurden.

Fazit
Eine gut strukturierte Node.js-Anwendung mit Express.js verbessert die Wartbarkeit, Skalierbarkeit und Zusammenarbeit. Jedes Verzeichnis und jede Datei in der Struktur dient einem bestimmten Zweck, von der Handhabung der Konfiguration und der Definition von Routen bis hin zur Verwaltung der Middleware und dem Rendern von Ansichten. Durch die effektive Organisation Ihrer Codebasis können Sie problemlos robuste und skalierbare Anwendungen erstellen.

Das obige ist der detaillierte Inhalt vonSo strukturieren Sie Ihren Backend-Code in Node.js (Express.js). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!