J'ai un programme node.js simple en cours d'exécution sur ma machine et je veux obtenir l'adresse IP locale du PC sur lequel mon programme s'exécute. Comment l'obtenir avec node.js?

'use strict';

var os = require('os');
var ifaces = os.networkInterfaces();

Object.keys(ifaces).forEach(function (ifname) {
  var alias = 0;

  ifaces[ifname].forEach(function (iface) {
    if ('IPv4' !== iface.family || iface.internal !== false) {
      // skip over internal (i.e. 127.0.0.1) and non-ipv4 addresses
      return;
    }

    if (alias >= 1) {
      // this single interface has multiple ipv4 addresses
      console.log(ifname + ':' + alias, iface.address);
    } else {
      // this interface has only one ipv4 adress
      console.log(ifname, iface.address);
    }
    ++alias;
  });
});

// en0 192.168.1.101
// eth0 10.0.0.101

os.networkInterfaces en ce moment ne fonctionne pas sur Windows. L'exécution de programmes pour analyser les résultats semble un peu aléatoire. Voici ce que j'utilise.

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

Cela devrait renvoyer votre première IP locale d'interface réseau.

https://github.com/indutny/node-ip

var ip = require("ip");
console.dir ( ip.address() );

Toute IP de votre machine que vous pouvez trouver en utilisant le module os - et qui est native de NodeJS

var os = require( 'os' );

var networkInterfaces = os.networkInterfaces( );

console.log( networkInterfaces );

Tout ce que vous devez faire est d'appeler os.networkInterfaces () et vous obtiendrez une liste facile à gérer - plus facile que d'exécuter ifconfig par ligues

http://nodejs.org/api/os.html#os_os_networkinterfaces

Meilleur

Edoardo

Voici un extrait de code node.js qui analysera la sortie de ifconfiget (de manière asynchrone) renverra la première adresse IP trouvée:

(testé sur MacOS Snow Leopard uniquement; j'espère que cela fonctionne aussi sur 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 OSs without 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 IPs
            var matches = stdout.match(filterRE);
            // JS has no lookbehind REs, 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 mise à jour

Renvoie un tableau de toutes les adresses de réseau local.

Testé sur Ubuntu 11.04 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 pour la version mise à jour

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

Voici ma méthode utilitaire pour obtenir l'adresse IP locale, en supposant que vous recherchez une adresse IPv4 et que la machine n'a qu'une seule interface réseau réelle. Il pourrait facilement être refactorisé pour renvoyer un tableau d'adresses IP pour les machines multi-interfaces.

function getIPAddress() {
  var interfaces = require('os').networkInterfaces();
  for (var devName in interfaces) {
    var iface = interfaces[devName];

    for (var i = 0; i < iface.length; i++) {
      var alias = iface[i];
      if (alias.family === 'IPv4' && alias.address !== '127.0.0.1' && !alias.internal)
        return alias.address;
    }
  }

  return '0.0.0.0';
}

Installez un module appelé ip comme

npm install ip

puis utilisez ce code.

var ip = require("ip");
console.log( ip.address() );

Appeler ifconfig est très dépendant de la plate-forme, et la couche réseau sait quelles adresses IP un socket est activé, il est donc préférable de le demander. Node n'expose pas une méthode directe pour ce faire, mais vous pouvez ouvrir n'importe quel socket et demander quelle adresse IP locale est utilisée. Par exemple, ouvrir un socket sur 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);
    }
});

Votre IP locale est toujours 127.0.0.1.

Ensuite, il y a l'IP du réseau, que vous pouvez obtenir auprès de ifconfig(* nix) ou ipconfig(win). Ceci n'est utile que dans le réseau local.

Ensuite, il y a votre adresse IP externe / publique, que vous ne pouvez obtenir que si vous pouvez le demander au routeur, ou vous pouvez configurer un service externe qui renvoie l'adresse IP du client chaque fois qu'il reçoit une demande. Il existe également d'autres services de ce type, comme whatismyip.com.

Dans certains cas (par exemple si vous avez une connexion WAN), l'IP du réseau et l'IP publique sont les mêmes et peuvent toutes deux être utilisées en externe pour atteindre votre ordinateur.

Si votre réseau et vos adresses IP publiques sont différents, vous devrez peut-être demander à votre routeur réseau de transmettre toutes les connexions entrantes à votre adresse IP réseau.

Mise à jour 2013:

Il y a une nouvelle façon de faire maintenant, vous pouvez vérifier l'objet socket de votre connexion pour une propriété appelée localAddress, par exemple net.socket.localAddress. Il renvoie l'adresse à votre extrémité du socket.

Le moyen le plus simple consiste à simplement ouvrir un port aléatoire et à l'écouter, puis à obtenir votre adresse et à fermer le socket.

Mise à jour 2015:

Le précédent ne fonctionne plus.

utiliser le module ip npm

var ip = require('ip');

console.log(ip.address());

> '192.168.0.117'

La bonne doublure pour le soulignement et le lodash est:

var ip = require('underscore')
    .chain(require('os').networkInterfaces())
    .values()
    .flatten()
    .find({family: 'IPv4', internal: false})
    .value()
    .address;

Voici ce qui pourrait être la réponse la plus propre et la plus simple sans dépendances et qui fonctionne sur toutes les plateformes.

const { lookup } = require('dns').promises;
const { hostname } = require('os');

async function getMyIPAddress(options) {
  return (await lookup(hostname(), options))
    .address;
}

Tout ce que je sais, c'est que je voulais commencer par l'adresse IP 192.168.. Ce code vous donnera:

function getLocalIp() {
    const os = require('os');

    for(let addresses of Object.values(os.networkInterfaces())) {
        for(let add of addresses) {
            if(add.address.startsWith('192.168.')) {
                return add.address;
            }
        }
    }
}

Bien sûr, vous pouvez simplement changer les chiffres si vous en cherchez un autre.

pour les utilisations Linux et MacOS, si vous souhaitez obtenir vos adresses IP de manière synchrone, essayez ceci.

var ips = require('child_process').execSync("ifconfig | grep inet | grep -v inet6 | awk '{gsub(/addr:/,\"\");print $2}'").toString().trim().split("\n");
console.log(ips);

le résultat sera quelque chose comme ça.

[ '192.168.3.2', '192.168.2.1' ]

J'ai écrit un module Node.js qui détermine votre adresse IP locale en regardant quelle interface réseau contient votre passerelle par défaut.

C'est plus fiable que de choisir une interface os.networkInterfaces()ou des recherches DNS du nom d'hôte. Il est capable d'ignorer les interfaces virtuelles VMware, les boucles et les interfaces VPN, et il fonctionne sur Windows, Linux, Mac OS et FreeBSD. Sous le capot, il exécute route.exeou netstatet analyse la sortie.

var localIpV4Address = require("local-ipv4-address");

localIpV4Address().then(function(ipAddress){
    console.log("My IP address is " + ipAddress);
    // My IP address is 10.4.4.137 
});

Voici une version simplifiée en vanilla javascript pour obtenir une seule IP:

function getServerIp() {

  var os = require('os');
  var ifaces = os.networkInterfaces();
  var values = Object.keys(ifaces).map(function(name) {
    return ifaces[name];
  });
  values = [].concat.apply([], values).filter(function(val){ 
    return val.family == 'IPv4' && val.internal == false; 
  });

  return values.length ? values[0].address : '0.0.0.0';
}

Pour toute personne intéressée par la brièveté, voici quelques "one-liners" qui ne nécessitent pas de plugins / dépendances qui ne font pas partie d'une installation Node standard:

IPv4 et IPv6 publics de eth0 en tant que tableau:

var ips = require('os').networkInterfaces().eth0.map(function(interface) { 
    return interface.address;
});

Première IP publique d'Eth0 (généralement IPv4) en tant que chaîne:

var ip = require('os').networkInterfaces().eth0[0].address;

Google m'a dirigé vers cette question lors de la recherche de "node.js get server ip" , alors donnons une réponse alternative à ceux qui essaient de le faire dans leur programme de serveur node.js (peut être le cas de l'affiche originale).

Dans le cas le plus trivial où le serveur n'est lié qu'à une seule adresse IP, il ne devrait pas être nécessaire de déterminer l'adresse IP car nous savons déjà à quelle adresse nous l'avons lié (par exemple, le deuxième paramètre passé à la listen()fonction).

Dans le cas moins banal où le serveur est lié à plusieurs adresses IP, il se peut que nous devions déterminer l'adresse IP de l'interface à laquelle un client s'est connecté. Et comme brièvement suggéré par Tor Valamo, de nos jours, nous pouvons facilement obtenir ces informations à partir de la prise connectée et de sa localAddresspropriété.

Par exemple, si le programme est un serveur Web:

var http = require("http")

http.createServer(function (req, res) {
    console.log(req.socket.localAddress)
    res.end(req.socket.localAddress)
}).listen(8000)

Et s'il s'agit d'un serveur TCP générique:

var net = require("net")

net.createServer(function (socket) {
    console.log(socket.localAddress)
    socket.end(socket.localAddress)
}).listen(8000)

Lors de l'exécution d'un programme serveur, cette solution offre une portabilité, une précision et une efficacité très élevées.

Pour plus de détails, voir:

• http://nodejs.org/api/net.html
• http://nodejs.org/api/http.html

Sur la base d'un commentaire ci-dessus, voici ce qui fonctionne pour la version actuelle de Node:

var os = require('os');
var _ = require('lodash');

var ip = _.chain(os.networkInterfaces())
  .values()
  .flatten()
  .filter(function(val) {
    return (val.family == 'IPv4' && val.internal == false)
  })
  .pluck('address')
  .first()
  .value();

Le commentaire sur l'une des réponses ci-dessus manquait l'appel à values(). Il semble que os.networkInterfaces()maintenant retourne un objet au lieu d'un tableau.

Voici une variante des exemples ci-dessus. Il prend soin de filtrer les interfaces vMware, etc. Si vous ne transmettez pas d'index, il renvoie toutes les adresses, sinon vous pouvez le définir par défaut sur 0, puis passez simplement null pour obtenir tout, mais vous trierez cela. Vous pouvez également passer un autre argument pour le filtre d'expression régulière si vous êtes disposé à ajouter

    function getAddress(idx) {

    var addresses = [],
        interfaces = os.networkInterfaces(),
        name, ifaces, iface;

    for (name in interfaces) {
        if(interfaces.hasOwnProperty(name)){
            ifaces = interfaces[name];
            if(!/(loopback|vmware|internal)/gi.test(name)){
                for (var i = 0; i < ifaces.length; i++) {
                    iface = ifaces[i];
                    if (iface.family === 'IPv4' &&  !iface.internal && iface.address !== '127.0.0.1') {
                        addresses.push(iface.address);
                    }
                }
            }
        }
    }

    // if an index is passed only return it.
    if(idx >= 0)
        return addresses[idx];
    return addresses;
}

J'ai pu le faire en utilisant seulement le nœud js

En tant que Node JS

var os = require( 'os' );
var networkInterfaces = Object.values(os.networkInterfaces())
    .reduce((r,a)=>{
        r = r.concat(a)
        return r;
    }, [])
    .filter(({family, address}) => {
        return family.toLowerCase().indexOf('v4') >= 0 &&
            address !== '127.0.0.1'
    })
    .map(({address}) => address);
var ipAddresses = networkInterfaces.join(', ')
console.log(ipAddresses);

En tant que script bash (nécessite l'installation du nœud js)

function ifconfig2 ()
{
    node -e """
        var os = require( 'os' );
        var networkInterfaces = Object.values(os.networkInterfaces())
            .reduce((r,a)=>{
                r = r.concat(a)
                return r;
            }, [])
            .filter(({family, address}) => {
                return family.toLowerCase().indexOf('v4') >= 0 &&
                    address !== '127.0.0.1'
            })
            .map(({address}) => address);
        var ipAddresses = networkInterfaces.join(', ')
        console.log(ipAddresses);
    """
}

Voici ma variante qui permet d'obtenir les adresses IPv4 et IPv6 de manière portable:

/**
 * Collects information about the local IPv4/IPv6 addresses of
 * every network interface on the local computer.
 * Returns an object with the network interface name as the first-level key and
 * "IPv4" or "IPv6" as the second-level key.
 * For example you can use getLocalIPs().eth0.IPv6 to get the IPv6 address
 * (as string) of eth0
 */
getLocalIPs = function () {
    var addrInfo, ifaceDetails, _len;
    var localIPInfo = {};
    //Get the network interfaces
    var networkInterfaces = require('os').networkInterfaces();
    //Iterate over the network interfaces
    for (var ifaceName in networkInterfaces) {
        ifaceDetails = networkInterfaces[ifaceName];
        //Iterate over all interface details
        for (var _i = 0, _len = ifaceDetails.length; _i < _len; _i++) {
            addrInfo = ifaceDetails[_i];
            if (addrInfo.family === 'IPv4') {
                //Extract the IPv4 address
                if (!localIPInfo[ifaceName]) {
                    localIPInfo[ifaceName] = {};
                }
                localIPInfo[ifaceName].IPv4 = addrInfo.address;
            } else if (addrInfo.family === 'IPv6') {
                //Extract the IPv6 address
                if (!localIPInfo[ifaceName]) {
                    localIPInfo[ifaceName] = {};
                }
                localIPInfo[ifaceName].IPv6 = addrInfo.address;
            }
        }
    }
    return localIPInfo;
};

Voici une version CoffeeScript de la même fonction:

getLocalIPs = () =>
    ###
    Collects information about the local IPv4/IPv6 addresses of
      every network interface on the local computer.
    Returns an object with the network interface name as the first-level key and
      "IPv4" or "IPv6" as the second-level key.
    For example you can use getLocalIPs().eth0.IPv6 to get the IPv6 address
      (as string) of eth0
    ###
    networkInterfaces = require('os').networkInterfaces();
    localIPInfo = {}
    for ifaceName, ifaceDetails of networkInterfaces
        for addrInfo in ifaceDetails
            if addrInfo.family=='IPv4'
                if !localIPInfo[ifaceName]
                    localIPInfo[ifaceName] = {}
                localIPInfo[ifaceName].IPv4 = addrInfo.address
            else if addrInfo.family=='IPv6'
                if !localIPInfo[ifaceName]
                    localIPInfo[ifaceName] = {}
                localIPInfo[ifaceName].IPv6 = addrInfo.address
    return localIPInfo

Exemple de sortie pour console.log(getLocalIPs())

{ lo: { IPv4: '127.0.0.1', IPv6: '::1' },
  wlan0: { IPv4: '192.168.178.21', IPv6: 'fe80::aa1a:2eee:feba:1c39' },
  tap0: { IPv4: '10.1.1.7', IPv6: 'fe80::ddf1:a9a1:1242:bc9b' } }

Si vous êtes dans la brièveté, ici, il utilise lodash :

var os = require('os');
var _ = require('lodash');
var firstLocalIp = _(os.networkInterfaces()).values().flatten().where({ family: 'IPv4', internal: false }).pluck('address').first();

console.log('First local IPv4 address is ' + firstLocalIp);

Semblable à d'autres réponses mais plus succincte:

'use strict';

const interfaces = require('os').networkInterfaces();

const addresses = Object.keys(interfaces)
  .reduce((results, name) => results.concat(interfaces[name]), [])
  .filter((iface) => iface.family === 'IPv4' && !iface.internal)
  .map((iface) => iface.address);

Un liner pour MAC os première adresse localhost uniquement.

Lorsque vous développez des applications sur Mac OS, que vous souhaitez le tester sur le téléphone et que votre application choisit automatiquement l'IP localhost.

require('os').networkInterfaces().en0.find(elm=>elm.family=='IPv4').address

C'est juste pour mentionner comment vous pouvez trouver automatiquement l'adresse IP. Pour tester cela, vous pouvez aller au terminal hit

node
os.networkInterfaces().en0.find(elm=>elm.family=='IPv4').address

la sortie sera votre adresse IP localhost.

Voici un petit one-liner soigné pour vous qui le fait fonctionnellement:

const ni = require('os').networkInterfaces();
Object
  .keys(ni)
  .map(interf =>
    ni[interf].map(o => !o.internal && o.family === 'IPv4' && o.address))
  .reduce((a, b) => a.concat(b))
  .filter(o => o)
  [0];

Plusieurs fois , je trouve qu'il ya plusieurs interfaces de parement internes et externes disponibles (exemple: 10.0.75.1, 172.100.0.1, 192.168.2.3), et il est celui que je suis externe vraiment après ( 172.100.0.1).

Au cas où quelqu'un d'autre aurait une préoccupation similaire, voici une autre prise de position qui, espérons-le, pourrait être utile ...

const address = Object.keys(os.networkInterfaces())
    // flatten interfaces to an array
    .reduce((a, key) => [
        ...a,
        ...os.networkInterfaces()[key]
    ], [])
    // non-internal ipv4 addresses only
    .filter(iface => iface.family === 'IPv4' && !iface.internal)
    // project ipv4 address as a 32-bit number (n)
    .map(iface => ({...iface, n: (d => ((((((+d[0])*256)+(+d[1]))*256)+(+d[2]))*256)+(+d[3]))(iface.address.split('.'))}))
    // set a hi-bit on (n) for reserved addresses so they will sort to the bottom
    .map(iface => iface.address.startsWith('10.') || iface.address.startsWith('192.') ? {...iface, n: Math.pow(2,32) + iface.n} : iface)
    // sort ascending on (n)
    .sort((a, b) => a.n - b.n)
    [0]||{}.address;

J'utilise node.js 0.6.5

$ node -v
v0.6.5

Voici ce que je fais

var util = require('util');
var exec = require('child_process').exec;
function puts(error, stdout, stderr) {
        util.puts(stdout);
}
exec("hostname -i", puts);

Voici une version multi-ip de la réponse de jhurliman ci-dessus:

function getIPAddresses() {

    var ipAddresses = [];

    var interfaces = require('os').networkInterfaces();
    for (var devName in interfaces) {
        var iface = interfaces[devName];
        for (var i = 0; i < iface.length; i++) {
            var alias = iface[i];
            if (alias.family === 'IPv4' && alias.address !== '127.0.0.1' && !alias.internal) {
                ipAddresses.push(alias.address);
            }
        }
    }

    return ipAddresses;
}

Je me rends compte que c'est un vieux fil, mais je voudrais offrir une amélioration sur la réponse du haut pour les raisons suivantes:

• Le code doit être aussi explicite que possible.
• L'énumération sur un tableau à l'aide de for ... in ... doit être évitée.

• L' énumération for ... in ... doit être validée pour garantir que l'objet énuméré contient la propriété que vous recherchez. Comme javsacript est mal tapé et le for ... in ... peut être remis à n'importe quel objet arbitraire à manipuler; il est plus sûr de valider la propriété que nous recherchons est disponible.

  var os = require('os'),
      interfaces = os.networkInterfaces(),
      address,
      addresses = [],
      i,
      l,
      interfaceId,
      interfaceArray;
  
  for (interfaceId in interfaces) {
      if (interfaces.hasOwnProperty(interfaceId)) {
          interfaceArray = interfaces[interfaceId];
          l = interfaceArray.length;
  
          for (i = 0; i < l; i += 1) {
  
              address = interfaceArray[i];
  
              if (address.family === 'IPv4' && !address.internal) {
                  addresses.push(address.address);
              }
          }
      }
  }
  
  console.log(addresses);