Obtenez l'adresse IP locale dans node.js


Réponses:


419
'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

17
var _ = require ('underscore'); var ip = _.chain (require ('os'). networkInterfaces ()). flatten (). filter (function (val) {return (val.family == 'IPv4' && val.internal == false)})) .pluck ('adresse'). first (). value (); console.log (ip)
Carter Cole

La sixième ligne devrait être if( details.family=='IPv4' && details.internal === false ) {si vous voulez juste des IP externes.
Arlen Beiler

3
@CarterCole vous avez besoin d'un appel supplémentaire à .values ​​() avant d'aplatir.
Guido

1
Que faire si je souhaite récupérer uniquement l'adresse IP de l'interface active?
Tejas

1
one-liner sans lodash pour node> = 7.0.0 :Object.values(require('os').networkInterfaces()).reduce((r, list) => r.concat(list.reduce((rr, i) => rr.concat(i.family==='IPv4' && !i.internal && i.address || []), [])), [])
som

224

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.


4
@HermannIngjaldsson: Ce n'est pas une critique très approfondie. Pourriez-vous être plus précis? Peut-être prendre l'exemple de code et le mettre dans une nouvelle question en fournissant plus de détails et en demandant pourquoi cela ne fonctionne pas?
Xedecimal

8
Ce n'est pas toujours une bonne idée d'utiliser la recherche DNS, car elle peut renvoyer des informations erronées (c'est-à-dire des données mises en cache). L'utilisation de 'os.networkInterfaces' est une meilleure idée à mon avis.
Guido

1
L'utilisation de DNS fonctionne si votre serveur a une entrée DNS quelque part. Cependant, dans de nombreuses applications, il n'y a pas d'entrée DNS (par exemple, mon ordinateur portable). os.networkInterfaces () est probablement la voie à suivre.
Jeff Whiting

1
Notez que cela utilise la recherche de système d'exploitation, qui ne fait pas nécessairement de recherches DNS et devrait connaître sa propre adresse IP principale ...
w00t

que faire si j'obtiens l'adresse DNS de chaque interface
taha027

203

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

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

@Uri c'est ce que la question demande
Seb

1
la documentation de ce package n'est pas claire ... puis-je également obtenir l'adresse de diffusion ou dois-je la fournir moi-même?
Michael

12
@majidarif je ne reconnais pas cela comme une excuse valable pour une mauvaise documentation
Michael

7
Cela fonctionne incroyablement bien. L'obtention de l'adresse IP est littéralement une ligne. Excellent.
EvSunWoodard

5
Il ne vous donne pas l'adresse IP de tous les adaptateurs. Si Docker est installé, il donne l'adresse de docker vEthernet au lieu de votre adresse Ethernet réelle
TetraDev

62

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


9
Réponse impressionnante. var ip = networkInterfaces ['eth0'] [0] ['address']
Natus Drew

bien que cela semble génial parce que c'est simple, son efficacité réelle dépend probablement de la configuration de votre réseau. Par exemple, il n'y a pas eth0 sur la configuration par défaut d'OS X, c'est en0.
ccnokes

3
Travaille pour moi. var address = networkInterfaces['venet0:0'][0].address
Anthony

bizarre. sur SunOS 5.11, cet appel renvoie un objet vide
Michael

34

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);

Testé tout à l'heure sur OSX Lion, parfait. Merci beaucoup!
T3db0t

J'ai dû supprimer le trait d'union après le mot "IP" dans votre expression régulière Windows, car ma sortie n'avait pas le trait d'union (j'utilise Windows XP 32 bits). Je ne sais pas si cela était une faute de frappe ou si votre version de Windows émet vraiment un trait d' union après « IP », mais juste pour être du bon côté, je suppose qu'il peut être en option: filterRE = /\bIP-?[^:\r\n]+:\s*([^\s]+)/g;. Mis à part cela, un excellent script, une véritable bouée de sauvetage. Merci beaucoup!
Utilisateur non trouvé

@jSepia: C'est probablement une chose de localisation. Windows allemand imprime "IP-Adresse";)
user123444555621

Assez bien, mais maintenant vous l'avez encore cassé: p Ma sortie ipconfig n'inclut pas "v4" ni "v6", qui semble être une chose Vista / 7 (voir technet.microsoft.com/en-us/library/bb726952 .aspx )
Utilisateur non trouvé

Il n'y a aucune raison pour un tel hack. Nous avons maintenant os.networkInterfaces ().
Brad

32

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';
}

Version café:getLocalIP = (interfaceName = "en0",version = "IPv4")-> iface = require('os').networkInterfaces()[interfaceName] for alias in iface if (alias.family == version && !alias.internal) return alias.address return "0.0.0.0"
Jay

30

Installez un module appelé ip comme

npm install ip

puis utilisez ce code.

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

5
Cela renvoie le 127.0.0.1
WeSam Abdallah

il renvoie une adresse IP privée et non publique.
Mehmet Kurtipek

23

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);
    }
});

Au cas où vous vous poseriez la question, cela n'obtient pas nécessairement l'adresse IP publique que le monde voit.
artur

Ce serait une bonne solution si cela ne dépendait pas de la connexion Internet et de sa vitesse ..
Jacob Rask

Dans mon cas, cette solution est parfaite, car j'ai besoin de connaître l'IP de l'interface sur laquelle une demande particulière est envoyée.
radicand

20

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.


Cela signifie-t-il que pour obtenir l'adresse réseau dans nodejs, vous devez effectuer un appel système vers ifconfigou ipconfiget analyser la chaîne de réponse?
user123444555621

@ Pumbaa80 - À peu près, à moins que votre carte réseau ne dispose de pilotes que vous pouvez appeler. De plus, si vous avez plusieurs cartes réseau (ou adaptateurs, comme hamachi), il n'y a aucun moyen d'appeler simplement une fonction quelconque et d'obtenir une IP qui est L' IP. Donc, l'analyser et interpréter la sortie de ifconfigest à peu près la seule façon.
Tor Valamo

Cela ressemble à des net.socketretours à undefinedpartir de 2015, donc la "nouvelle façon de faire" ne fonctionne plus. Il y en a un net.Socket, mais il n'a pas de localAddresspropriété.
trysis

14

utiliser le module ip npm

var ip = require('ip');

console.log(ip.address());

> '192.168.0.117'

1
Je ne sais pas, comment dire aux utilisateurs qui arrivent sur cette page maintenant que c'est la seule option appropriée dans le contexte actuel.
Gagan

Merci @Gagan Votre appréciation.
KARTHIKEYAN.A

13

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;

3
Vous pouvez également utiliser: .find({family: 'IPv4', internal: false})pour un code plus court et plus élégant
dcohenb

9

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;
}

8

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.


Et si l'adresse ne commence pas par 192.168?
Anu

@anu Modifiez le préfixe en celui que vous recherchez, ou utilisez l'une des nombreuses autres solutions que les gens ont publiées ici :-) Mon IP locale commence toujours par, 192.168.c'est pourquoi j'ai choisi cela.
mpen

6

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' ]

6

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 
});

Dommage que cela ne fonctionne pas sur Windows lorsque la langue n'est pas définie sur l'anglais :(
Javier G.

1
Merci d'avoir signalé ce bogue, @JavierG! J'ai publié la version 0.0.2 qui devrait le corriger.
Ben Hutchison

5

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';
}

4

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;

Gardez à l'esprit que ces monolignes sont spécifiques à la plateforme. Sur OS X, j'ai en0et en1pour ethernet et wifi. Sous Windows, j'ai Local Area Connectionet Wireless Network Connection.
xverges

Si vous souhaitez connaître votre IP publique distante (sous OS X), utilisez: var ip = require ('os'). NetworkInterfaces (). En0 [1] .address;
Marcelo dos Santos

3

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:


3

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.


1
Je <3 lodash. Surtout le golf lodash! Le _.chain(..)peut être réécrit en tant que _(...), le .filter(..)peut être réécrit en tant que .where({family: 'IPv4', internal: false}), et vous pouvez supprimer le final value()car .first()il le fait pour vous lors du chaînage.
Ryan Graham

3

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;
}

3

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);
    """
}

2

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' } }

2

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);


2

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);

1
je veux juste mentionner que vous pouvez remplacer Object.keys(interfaces).reduce(...)par Object.values(interfaces).flat()et ce serait la même chose.
kimbaudi

2

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.


2

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];

pour rendre votre code plus concis, vous pouvez éliminer l'appel à reduceet remplacer l'appel à mappar un appel à flatMap.
kimbaudi

2

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;

1

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);

Cela fonctionne avec hostname -I(majuscule i). Il renvoie une liste de toutes les adresses IP attribuées de la machine. La première adresse IP est ce dont vous avez besoin. Cette IP est celle attachée à l'interface actuelle qui est en place.
blueren

1

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;
}

1

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);
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.