Obtenir l'adresse IP locale dans node.js
J'ai un programme node.js simple en cours d'exécution sur ma machine et je souhaite obtenir l'adresse IP locale du PC sur lequel mon programme est exécuté. 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 à partir de maintenant ne fonctionne pas sur Windows. Exécuter des programmes pour analyser les résultats semble un peu hasardeux. 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 adresse IP locale d'interface réseau.
https://github.com/indutny/node-ip
var ip = require("ip");
console.dir ( ip.address() );
Toute adresse IP de votre machine que vous pouvez trouver en utilisant le module os - et qui est en natif pour NodeJS
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 simple que d'exécuter ifconfig par lieues
http://nodejs.org/api/os.html#os_os_networkinterfaces
Meilleur
Edoardo
Voici un extrait de code node.js qui analysera la sortie de ifconfig et renverra (de manière asynchrone) la première adresse IP trouvée:
(testé sur MacOS Snow Leopard uniquement; espérons que cela fonctionne également 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 en cache est utilisée.
Version mise à jour
Renvoie un tableau de toutes les adresses réseau locales.
Testé sous 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);
Installez un module appelé ip comme
npm install ip
puis utilisez ce code.
var ip = require("ip");
console.log( ip.address() );
Voici ma méthode d'utilité pour obtenir l'adresse IP locale, en supposant que vous recherchiez une adresse IPv4 et que la machine ne dispose que d'une seule interface réseau réelle. Il pourrait facilement être modifié pour renvoyer un tableau d'adresses IP pour des machines à interfaces multiples.
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';
}
L'appel d'ifconfig est très dépendant de la plate-forme, et la couche réseau sait quelles adresses IP se trouvent sur un socket, il est donc préférable de le lui demander. Node n'expose pas de 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, ouvrez 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 adresse IP locale est toujours 127.0.0.1.
Ensuite, il y a l'adresse IP du réseau, que vous pouvez obtenir de ifconfig (* nix) ou ipconfig (win). Ceci n'est utile que dans le réseau local.
Ensuite, il y a votre IP externe/publique, que vous pouvez obtenir uniquement 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, tels que whatismyip.com.
Dans certains cas (par exemple, si vous avez une connexion WAN), l'IP du réseau et l'IP publique sont identiques et peuvent être utilisés en externe pour atteindre votre ordinateur.
Si votre réseau et vos adresses IP publiques sont différents, votre routeur de réseau devra peut-être transférer toutes les connexions entrantes vers votre adresse IP de réseau.
Mise à jour 2013:
Il existe maintenant une nouvelle façon de procéder: vous pouvez rechercher dans l’objet Socket de votre connexion une propriété appelée localAddress, par exemple. net.socket.localAddress. Il retourne l'adresse sur votre bout 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.
Le liner correct pour les deux nderscore et lodash est:
var ip = require('underscore')
.chain(require('os').networkInterfaces())
.values()
.flatten()
.find({family: 'IPv4', internal: false})
.value()
.address;
utiliser le module ip npm
var ip = require('ip');
console.log(ip.address());
> '192.168.0.117'
Tout ce que je sais, c'est que je voulais une adresse IP commençant par 192.168.. Ce code vous donnera que:
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 cherchez un autre.
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.
Ceci est plus fiable que de choisir une interface à partir de os.networkInterfaces() ou des recherches DNS du nom d'hôte. Il est capable d'ignorer les interfaces virtuelles VMware, les interfaces de bouclage et VPN, et fonctionne sous Windows, Linux, Mac OS et FreeBSD. Sous le capot, il exécute route.exe ou netstat et 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 javascript de Vanilla pour obtenir une seule adresse 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 les utilisations Linux et MacOS, essayez ceci si vous voulez obtenir vos adresses IP de manière synchrone.
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' ]
Pour les personnes intéressées par la brièveté, voici quelques "lignes simples" qui ne nécessitent pas de plugins/dépendances qui ne font pas partie d'une installation standard Node:
Public IPv4 et IPv6 de eth0 sous forme de tableau:
var ips = require('os').networkInterfaces().eth0.map(function(interface) {
return interface.address;
});
Première adresse IP publique de eth0 (généralement IPv4) sous forme de chaîne:
var ip = require('os').networkInterfaces().eth0[0].address;
Google m’a dirigé vers cette question en cherchant "node.js get server ip" , donnons donc une réponse alternative à ceux qui tentent de réaliser cela dans leur node.js serveur programme (peut être le cas de l’affiche originale).
Dans le cas le plus trivial où le serveur est lié à 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 transmis à la fonction listen() ).
Dans le cas moins trivial où le serveur est lié à plusieurs adresses IP, il peut être nécessaire de déterminer l'adresse IP de l'interface à laquelle un client est connecté. Et comme l’a brièvement suggéré Tor Toramo, nous pouvons facilement obtenir ces informations à partir de la prise connectée et de sa propriété localAddress.
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 générique TCP:
var net = require("net")
net.createServer(function (socket) {
console.log(socket.localAddress)
socket.end(socket.localAddress)
}).listen(8000)
Lorsque vous exécutez un programme serveur, cette solution offre une portabilité, une précision et une efficacité très élevées.
Pour plus de détails, voir:
Voici une variante des exemples ci-dessus. Il prend soin de filtrer les interfaces vMware, etc. Si vous ne transmettez pas un index, il renvoie toutes les adresses, sinon vous voudrez peut-être le définir par défaut sur 0, il vous suffit de passer à null pour obtenir tout, mais vous allez régler ce problème. Vous pouvez également passer un autre argument pour le filtre regex si vous êtes enclin à 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;
}
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;
}
Basé sur 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 de values(). Il semble que os.networkInterfaces() renvoie maintenant un objet au lieu d'un tableau.
Semblable à d'autres réponses mais plus succinct:
'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);
J'ai pu faire cela en utilisant simplement le noeud js
Comme 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 (le noeud js doit être installé)
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 aimez la brièveté, utilisez ici 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);Une doublure pour MAC ou la première adresse localhost uniquement.
Lorsque vous développez des applications sur un ordinateur Mac et que vous souhaitez le tester sur votre téléphone, votre application doit sélectionner automatiquement l'adresse IP de l'hôte localhost.
require('os').networkInterfaces().en0.find(Elm=>Elm.family=='IPv4').address
Ceci est juste pour mentionner comment vous pouvez trouver l'adresse IP automatiquement. Pour tester cela, vous pouvez aller au hit terminal
node
os.networkInterfaces().en0.find(Elm=>Elm.family=='IPv4').address
la sortie sera votre adresse IP localhost.
Plusieurs fois, je trouve qu'il existe plusieurs interfaces internes et externes disponibles (exemple: 10.0.75.1, 172.100.0.1, 192.168.2.3), et c'est l'interface externe que je suis vraiment après (172.100.0.1).
Au cas où quelqu'un d'autre aurait des préoccupations similaires, voici une autre solution 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);
Il s’agit d’une modification de la réponse acceptée, qui ne tient pas compte des adresses IP vEthernet telles que Docker, etc.
/**
* Get local IP, while ignoring vEthernet IPs (like from Docker, etc)
*/
let localIP;
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(ifname === 'Ethernet') {
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;
localIP = iface.address;
}
});
});
console.log(localIP);
Cela retournera une adresse IP comme 192.168.2.169 au lieu de 10.55.1.1
j'espère que cela t'aides
var os = require( 'os' );
var networkInterfaces = os.networkInterfaces( );
var arr = networkInterfaces['Local Area Connection 3']
var ip = arr[1].address;
Je réalise que c’est un vieux fil, mais j’aimerais proposer une amélioration par rapport à la réponse principale pour les raisons suivantes:
- Le code doit être aussi explicite que possible.
- L'énumération sur un tableau en utilisant for ... in ... devrait être évitée.
for ... in ... l'énumération doit être validée pour garantir que l'objet énuméré contient la propriété que vous recherchez. Comme javsacript est assez typé et que pour ... dans ... peut recevoir 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);
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;
}
Voici un joli one-liner 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];
La réponse acceptée est asynchrone, je voulais une version synchrone, espérons que cela aide quelqu'un.
var os = require('os');
var ifaces = os.networkInterfaces();
console.log(JSON.stringify(ifaces, null, 4));
for (var iface in ifaces) {
var iface = ifaces[iface];
for (var alias in iface) {
var alias = iface[alias];
console.log(JSON.stringify(alias, null, 4));
if ('IPv4' !== alias.family || alias.internal !== false) {
debug("skip over internal (i.e. 127.0.0.1) and non-ipv4 addresses");
continue;
}
console.log("Found ipaddress: " + alias.address);
return alias.address;
}
}
return false;
Pour obtenir une adresse IP dans le nœud js, nous devons inclure trois modules - connect, net et request-ip. Si ces modules ne sont pas installés, installons-les d'abord à l'aide de npm.
Ce lien contient la solution que vous voulez, veuillez le parcourir -
Voici une variante qui vous permet d'obtenir l'adresse IP locale (testée sur Mac et Win):
var
// Local ip address that we're trying to calculate
address
// Provides a few basic operating-system related utility functions (built-in)
,os = require('os')
// Network interfaces
,ifaces = os.networkInterfaces();
// Iterate over interfaces ...
for (var dev in ifaces) {
// ... and find the one that matches the criteria
var iface = ifaces[dev].filter(function(details) {
return details.family === 'IPv4' && details.internal === false;
});
if(iface.length > 0) address = iface[0].address;
}
// Print the result
console.log(address); // 10.25.10.147
La plus grande question est "Pourquoi?"
Si vous avez besoin de connaître le serveur sur lequel votre NODE écoute, vous pouvez utiliser req.hostname.