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?
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?
Réponses:
'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
if( details.family=='IPv4' && details.internal === false ) {
si vous voulez juste des IP externes.
Object.values(require('os').networkInterfaces()).reduce((r, list) => r.concat(list.reduce((rr, i) => rr.concat(i.family==='IPv4' && !i.internal && i.address || []), [])), [])
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
var address = networkInterfaces['venet0:0'][0].address
Voici un extrait de code node.js qui analysera la sortie de ifconfig
et (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.
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);
});
};
})();
getNetworkIPs(function (error, ip) {
console.log(ip);
if (error) {
console.log('error:', error);
}
}, false);
filterRE = /\bIP-?[^:\r\n]+:\s*([^\s]+)/g;
. Mis à part cela, un excellent script, une véritable bouée de sauvetage. Merci beaucoup!
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';
}
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"
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.
ifconfig
ou ipconfig
et analyser la chaîne de réponse?
ifconfig
est à peu près la seule façon.
net.socket
retours à undefined
partir 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 localAddress
propriété.
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;
.find({family: 'IPv4', internal: false})
pour un code plus court et plus élégant
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.
192.168
?
192.168.
c'est pourquoi j'ai choisi cela.
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.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 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;
en0
et en1
pour ethernet et wifi. Sous Windows, j'ai Local Area Connection
et Wireless Network Connection
.
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 localAddress
proprié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:
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.
_.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.
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);
Object.keys(interfaces).reduce(...)
par Object.values(interfaces).flat()
et ce serait la même chose.
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];
reduce
et remplacer l'appel à map
par un appel à flatMap
.
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);
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.
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:
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);