Nodejs implémente des liens courts

Avec le développement d'Internet, les liens courts sont devenus une forme de liens très populaire. Les liens courts peuvent non seulement raccourcir la longueur du lien, mais également embellir le lien et augmenter le taux de clics des utilisateurs. Cet article explique comment implémenter des liens courts avec Node.js.

1. Qu'est-ce qu'un lien court ?

Un lien court est en fait une chaîne de caractères, correspondant à un lien long. L’avantage des liens courts est qu’ils peuvent réduire la longueur des liens, embellir les liens et augmenter les taux de clics des utilisateurs.

Habituellement, les services de liens courts sont fournis par un tiers, qui génère un lien court basé sur le lien long de l'utilisateur, puis redirige vers l'adresse du lien long d'origine. Il existe de nombreux services de ce type, tels que Bitly, TinyURL, etc.

2. Pourquoi utiliser Node.js pour implémenter des liens courts

Node.js est un environnement d'exécution JavaScript open source et multiplateforme, qui permet à JavaScript de s'exécuter côté serveur. Par rapport à d'autres langages côté serveur, le plus grand avantage de Node.js est sa haute concurrence et sa légèreté, qui peuvent répondre rapidement aux demandes des utilisateurs et gérer de très grandes demandes simultanées.

Un autre avantage majeur de Node.js est le gestionnaire de packages NPM, qui dispose d'un grand nombre de modules légers disponibles, ce qui réduit considérablement la complexité du développement et améliore l'efficacité du développement.

Par conséquent, utiliser Node.js pour implémenter des liens courts peut non seulement répondre rapidement aux demandes, mais également utiliser facilement le gestionnaire de packages NPM pour gérer les dépendances.

3. Étapes de mise en œuvre

Cet article implémentera les liens courts selon les étapes suivantes :

1. Générer des codes courts
2. Stocker la relation de mappage entre les codes courts et les liens longs
3. Analyser les liens courts et rediriger

3.1 Générer liens courts Code

Le cœur de la génération de codes courts est d'utiliser une valeur entière longue unique comme entrée et de la convertir en chaîne. Évidemment, l’entier long saisi doit être suffisamment grand, sinon le nombre de codes courts sera très limité.

Dans l'implémentation spécifique, vous pouvez utiliser l'alphabet et les chiffres pour encoder et convertir la valeur entière longue en une chaîne arbitraire, telle que 32 bases ou 62 bases.

Ce qui suit est un exemple de code pour générer un code court :

const alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
const base = alphabet.length;
function encode(num) {
  let encoded = '';
  while (num) {
    const remainder = num % base;
    num = Math.floor(num / base);
    encoded = alphabet[remainder].toString() + encoded;
  }
  return encoded;
}

Le code ci-dessus génère une fonction qui peut représenter une chaîne de 62 chiffres. Pour une valeur entière d'entrée, cette fonction la convertit en une chaîne de 62 chiffres via la méthode du reste continu et renvoie finalement la chaîne générée.

3.2 Stockage de la relation de mappage entre le code court et le lien long

Dans ce qui précède, nous avons réalisé la génération du code court. L'étape suivante consiste à stocker la relation de mappage entre le code court et le lien long. Ici, nous choisissons d'utiliser Redis. comme base de données de stockage.

Redis est une base de données de stockage clé-valeur efficace écrite en langage C. Elle peut lire et écrire rapidement des données. Elle prend également en charge la construction de clusters et est très appropriée pour une utilisation comme stockage de données pour les applications à haute concurrence.

Ce qui suit est un exemple de code permettant d'utiliser Redis pour stocker les relations de mappage dans Node.js :

const redis = require('redis');
const client = redis.createClient({ host: 'localhost', port: 6379 });

function saveUrl(url, callback) {
  client.incr('short:id', function(err, id) {
    if (err || !id) {
      return callback(err);
    }
    const shortUrl = encode(id);
    client.set(`short:${shortUrl}`, url, (err) => {
      if (err) {
        return callback(err);
      }
      callback(null, shortUrl);
    });
  });
}

Dans le code ci-dessus, nous utilisons d'abord la commande incr pour obtenir un identifiant unique auto-incrémenté de Redis. Ensuite, encodez cet identifiant dans un shortcode et utilisez la commande set pour stocker le shortcode et le mappage des liens longs vers Redis. incr 命令从 Redis 中获取一个唯一自增的id。然后，将该id编码为短码，并使用 set 命令将短码和长链接映射存储到 Redis。

3.3 解析短链接并进行重定向

最后，我们实现一个处理请求的路由来解析短链接，并将用户重定向到长链接地址。

以下是在Node.js中实现重定向功能的示例代码：

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

http.createServer(function (req, res) {
  const shortUrl = url.parse(req.url).pathname.slice(1);
  client.get(`short:${shortUrl}`, function (err, url) {
    if (err) {
      return console.error(err);
    }
    if (!url) {
      res.writeHead(404);
      return res.end('404 Not Found');
    }
    res.writeHead(301, { Location: url });
    res.end();
  });
}).listen(8080, () => console.log('Listening on port 8080...'));

通过以上代码，我们使用 http.createServer 创建一个 HttpServer 实例，并在回调函数中使用 url 模块解析请求的连接。

然后，我们从Redis中获取该短链接所对应的原链接，并使用 res.writeHead

3.3 Analyser les liens courts et rediriger

Enfin, nous implémentons une route qui gère les requêtes pour analyser les liens courts et rediriger les utilisateurs vers l'adresse du lien long.

4. Ce qui suit est un exemple de code pour implémenter la fonction de redirection dans Node.js :
rrreee

Avec le code ci-dessus, nous utilisons http.createServer pour créer une instance HttpServer et utilisons dans le rappel function Le module url résout la connexion demandée.

Ensuite, nous obtenons le lien d'origine correspondant au lien court de Redis et utilisons res.writeHead pour rediriger vers l'adresse du lien d'origine.

Bien sûr, nous devons également prendre en compte l'exception de validité du lien court. Par exemple, si le lien court n'est pas trouvé dans la base de données, une erreur 404 doit être renvoyée. 🎜🎜🎜Résumé🎜🎜🎜Cet article explique comment utiliser Node.js pour implémenter des liens courts, notamment générer des liens courts, stocker la relation de mappage entre les codes courts et les liens longs et analyser les liens courts pour la redirection. 🎜🎜Redis est utilisé ici pour implémenter le stockage de données, la redirection est implémentée via un simple routage et une interaction http, et nodejs et Redis sont utilisés ensemble pour créer une expérience de développement efficace et agréable, nous permettant d'implémenter des services de liaison courte à une vitesse rapide. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!