Node.js Express多语言URL路由优化方案咨询

Hey there! Great question—scaling multi-language routes in Express can get messy when you add more than a handful of languages, but we can clean this up with a few key optimizations to keep your code maintainable. Here's how to do it:

1. Centralize Supported Languages & Path Mappings #

First, stop hardcoding language codes and language-specific path fragments directly in your route regexes. Instead, create centralized configs that you can update easily when adding new languages:

// 1. List all supported languages (add/remove here as needed)
const supportedLangs = ['en', 'de', 'fr', 'es', 'ja', 'ko'];

// 2. Map language-specific path fragments to universal route identifiers
// This lets us translate language-specific URLs to a common internal structure
const pathMappings = {
  en: {
    'all-services-from': 'service-origin',
    'to': 'service-destination',
    'route-services-services': 'about-services'
  },
  de: {
    'hui-kuan-cong': 'service-origin',
    'zhi': 'service-destination',
    'ain-jian-wen-ti': 'about-services'
  },
  // Example: Add French support in 2 lines
  fr: {
    'tous-les-services-depuis': 'service-origin',
    'vers': 'service-destination',
    'services-itineraire-services': 'about-services'
  }
};

2. Add a Language Validation Middleware #

Create a reusable middleware to validate that the requested language is supported, and attach it to the request for easy access later:

const validateLang = (req, res, next) => {
  const requestedLang = req.params.lang;
  if (!supportedLangs.includes(requestedLang)) {
    // Handle unsupported languages (404 or redirect to default)
    return res.status(404).send('Unsupported language');
  }
  // Attach the valid language to the request object
  req.lang = requestedLang;
  next();
};

3. Build Dynamic, Language-Agnostic Routes #

Instead of writing separate regexes for each language, use the centralized config to create flexible routes that match any supported language, then route to the correct handler based on the path mapping.

Step 3.1: Route for Service Pages #

We'll match any language-specific service URL, parse the origin/destination parameters, and pass them to your serviceRouter:

app.use('/:lang', validateLang, (req, res, next) => {
  const pathSegments = req.path.split('/').filter(seg => seg);
  // Skip if we only have the language segment (handled by langRouter later)
  if (pathSegments.length < 2) return next();

  const langMappings = pathMappings[req.lang];
  const pathFragment = pathSegments[1];

  // Match language-specific service URL pattern (e.g., /en/all-services-from-sin-to-mal)
  const serviceOriginKey = Object.keys(langMappings).find(key => langMappings[key] === 'service-origin');
  const serviceDestKey = Object.keys(langMappings).find(key => langMappings[key] === 'service-destination');
  const servicePattern = new RegExp(`^${serviceOriginKey}-(.+)-${serviceDestKey}-(.+)$`);
  
  const serviceMatch = pathFragment.match(servicePattern);
  if (serviceMatch) {
    // Attach parsed parameters to the request
    req.params.origin = serviceMatch[1];
    req.params.destination = serviceMatch[2];
    // Forward to serviceRouter
    return serviceRouter(req, res, next);
  }

  // If not a service route, move to the next check
  next();
});

Step 3.2: Route for About Pages #

Repeat the pattern for your aboutRouter to match language-specific about URLs:

app.use('/:lang', validateLang, (req, res, next) => {
  const pathSegments = req.path.split('/').filter(seg => seg);
  if (pathSegments.length < 2) return next();

  const langMappings = pathMappings[req.lang];
  const pathFragment = pathSegments[1];

  // Match language-specific about URL pattern (e.g., /de/ain-jian-wen-ti/fund)
  const aboutKey = Object.keys(langMappings).find(key => langMappings[key] === 'about-services');
  const aboutPattern = new RegExp(`^${aboutKey}\/(.+)$`);
  
  const aboutMatch = pathFragment.match(aboutPattern);
  if (aboutMatch) {
    req.params.pr = aboutMatch[1];
    return aboutRouter(req, res, next);
  }

  next();
});

Step 3.3: Route for Language Root Paths #

Finally, handle the root language paths (e.g., /en, /de) with your langRouter:

app.use('/:lang', validateLang, langRouter);

4. Update Your Routers to Use the Unified Parameters #

Now your routers can work with the universal parameters we attached to the request, instead of language-specific path fragments:

// serviceRouter example
serviceRouter.get('*', (req, res) => {
  res.send(`Service from ${req.params.origin} to ${req.params.destination} (${req.lang})`);
});

// aboutRouter example
aboutRouter.get('*', (req, res) => {
  res.send(`About ${req.params.pr} (${req.lang})`);
});

Why This Works #

• Scalability: Adding a new language only requires updating supportedLangs and adding a new entry to pathMappings—no changes to route regexes needed.
• Maintainability: All language-specific logic lives in one config file, making it easy to update path fragments without digging through route code.
• Decoupling: Your route handlers don't need to know about language-specific URLs—they work with universal parameters, keeping them clean.

内容的提问来源于stack exchange，提问作者Senthil