Obtenir l'adresse IP locale dans Node.js

Question

J'ai un programme Node.js simple qui tourne sur ma machine et je veux obtenir l'adresse IP locale d'un PC sur lequel mon programme tourne. Comment puis-je l'obtenir avec Node.js ?

Answer 1

Cette information peut être trouvée dans os.networkInterfaces() Un objet qui associe les noms des interfaces réseau à leurs propriétés (de sorte qu'une interface peut, par exemple, avoir plusieurs adresses) :

'use strict';

const { networkInterfaces } = require('os');

const nets = networkInterfaces();
const results = Object.create(null); // Or just '{}', an empty object

for (const name of Object.keys(nets)) {
    for (const net of nets[name]) {
        // Skip over non-IPv4 and internal (i.e. 127.0.0.1) addresses
        if (net.family === 'IPv4' && !net.internal) {
            if (!results[name]) {
                results[name] = [];
            }
            results[name].push(net.address);
        }
    }
}

// 'results'
{
  "en0": [
    "192.168.1.101"
  ],
  "eth0": [
    "10.0.0.101"
  ],
  "<network name>": [
    "<ip>",
    "<ip alias>",
    "<ip alias>",
    ...
  ]
}

// results["en0"][0]
"192.168.1.101"

Answer 2

L'exécution de programmes pour analyser les résultats semble un peu incertaine. Voici ce que j'utilise.

require('dns').lookup(require('os').hostname(), function (err, add, fam) {
  console.log('addr: ' + add);
})

Vous devriez obtenir l'adresse IP locale de votre première interface réseau.

Answer 3

Toute adresse IP de votre machine que vous pouvez trouver en utilisant l'option os module - et c'est indigène à Node.js :

var os = require('os');

var networkInterfaces = os.networkInterfaces();

console.log(networkInterfaces);

Il vous suffit d'appeler _os.networkInterfaces()_ et vous obtiendrez une liste facile à gérer - plus facile que de courir ifconfig par les ligues.

Answer 4

Voici un extrait de code Node.js qui analysera la sortie de l'application ifconfig et renvoie (de manière asynchrone) la première adresse IP trouvée :

(Il a été testé sur Mac OS X v10.6 (Snow Leopard) uniquement ; j'espère que cela fonctionne aussi sous Linux).

var getNetworkIP = (function () {
    var ignoreRE = /^(127\.0\.0\.1|::1|fe80(:1)?::1(%.*)?)$/i;

    var exec = require('child_process').exec;
    var cached;
    var command;
    var filterRE;

    switch (process.platform) {
        // TODO: implement for OSes without the ifconfig command
        case 'darwin':
             command = 'ifconfig';
             filterRE = /\binet\s+([^\s]+)/g;
             // filterRE = /\binet6\s+([^\s]+)/g; // IPv6
             break;
        default:
             command = 'ifconfig';
             filterRE = /\binet\b[^:]+:\s*([^\s]+)/g;
             // filterRE = /\binet6[^:]+:\s*([^\s]+)/g; // IPv6
             break;
    }

    return function (callback, bypassCache) {
        // Get cached value
        if (cached && !bypassCache) {
            callback(null, cached);
            return;
        }

        // System call
        exec(command, function (error, stdout, sterr) {
            var ips = [];
            // Extract IP addresses
            var matches = stdout.match(filterRE);

            // JavaScript doesn't have any lookbehind regular expressions, so we need a trick
            for (var i = 0; i < matches.length; i++) {
                ips.push(matches[i].replace(filterRE, '$1'));
            }

            // Filter BS
            for (var i = 0, l = ips.length; i < l; i++) {
                if (!ignoreRE.test(ips[i])) {
                    //if (!error) {
                        cached = ips[i];
                    //}
                    callback(error, ips[i]);
                    return;
                }
            }
            // Nothing found
            callback(error, null);
        });
    };
})();

Exemple d'utilisation :

getNetworkIP(function (error, ip) {
    console.log(ip);
    if (error) {
        console.log('error:', error);
    }
}, false);

Si le deuxième paramètre est true la fonction exécutera un appel système à chaque fois ; sinon, la valeur mise en cache est utilisée.

---

Version actualisée

Renvoie un tableau de toutes les adresses de réseaux locaux.

Testé sur Ubuntu 11.04 (Natty Narwhal) et Windows XP 32

var getNetworkIPs = (function () {
    var ignoreRE = /^(127\.0\.0\.1|::1|fe80(:1)?::1(%.*)?)$/i;

    var exec = require('child_process').exec;
    var cached;
    var command;
    var filterRE;

    switch (process.platform) {
        case 'win32':
        //case 'win64': // TODO: test
            command = 'ipconfig';
            filterRE = /\bIPv[46][^:\r\n]+:\s*([^\s]+)/g;
            break;
        case 'darwin':
            command = 'ifconfig';
            filterRE = /\binet\s+([^\s]+)/g;
            // filterRE = /\binet6\s+([^\s]+)/g; // IPv6
            break;
        default:
            command = 'ifconfig';
            filterRE = /\binet\b[^:]+:\s*([^\s]+)/g;
            // filterRE = /\binet6[^:]+:\s*([^\s]+)/g; // IPv6
            break;
    }

    return function (callback, bypassCache) {
        if (cached && !bypassCache) {
            callback(null, cached);
            return;
        }

        // System call
        exec(command, function (error, stdout, sterr) {
            cached = [];
            var ip;
            var matches = stdout.match(filterRE) || [];
            //if (!error) {
            for (var i = 0; i < matches.length; i++) {
                ip = matches[i].replace(filterRE, '$1')
                if (!ignoreRE.test(ip)) {
                    cached.push(ip);
                }
            }
            //}
            callback(error, cached);
        });
    };
})();

Exemple d'utilisation de la version mise à jour

getNetworkIPs(function (error, ip) {
console.log(ip);
if (error) {
    console.log('error:', error);
}
}, false);

Answer 5

L'appel à ifconfig est très dépendant de la plate-forme, et la couche réseau sait sur quelles adresses IP se trouve une socket, donc le mieux est de lui demander.

Node.js n'expose pas une méthode directe pour faire cela, mais vous pouvez ouvrir n'importe quel socket, et demander quelle adresse IP locale est utilisée. Par exemple, en ouvrant un socket vers www.google.com :

var net = require('net');
function getNetworkIP(callback) {
  var socket = net.createConnection(80, 'www.google.com');
  socket.on('connect', function() {
    callback(undefined, socket.address().address);
    socket.end();
  });
  socket.on('error', function(e) {
    callback(e, 'error');
  });
}

Cas d'utilisation :

getNetworkIP(function (error, ip) {
    console.log(ip);
    if (error) {
        console.log('error:', error);
    }
});