Ho un semplice programma node.js in esecuzione sul mio computer e desidero ottenere l'indirizzo IP locale del PC su cui è in esecuzione il mio programma. Come lo ottengo con node.js?
Ho un semplice programma node.js in esecuzione sul mio computer e desidero ottenere l'indirizzo IP locale del PC su cui è in esecuzione il mio programma. Come lo ottengo con node.js?
Risposte:
'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 ) {
se vuoi solo IP esterni.
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 al momento non funziona su Windows. L'esecuzione di programmi per analizzare i risultati sembra un po 'incerta. Ecco cosa uso.
require('dns').lookup(require('os').hostname(), function (err, add, fam) {
console.log('addr: '+add);
})
Questo dovrebbe restituire il tuo primo IP locale dell'interfaccia di rete.
https://github.com/indutny/node-ip
var ip = require("ip");
console.dir ( ip.address() );
Qualsiasi IP della tua macchina puoi trovare usando il modulo os - ed è nativo di NodeJS
var os = require( 'os' );
var networkInterfaces = os.networkInterfaces( );
console.log( networkInterfaces );
Tutto quello che devi fare è chiamare os.networkInterfaces () e otterrai un facile elenco gestibile - più semplice dell'esecuzione di ifconfig da parte dei campionati
http://nodejs.org/api/os.html#os_os_networkinterfaces
Migliore
Edoardo
var address = networkInterfaces['venet0:0'][0].address
Ecco uno snippet di codice node.js che analizzerà l'output di ifconfig
e (in modo asincrono) restituirà il primo indirizzo IP trovato:
(testato solo su MacOS Snow Leopard; spero che funzioni anche su 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);
});
};
})();
Esempio di utilizzo:
getNetworkIP(function (error, ip) {
console.log(ip);
if (error) {
console.log('error:', error);
}
}, false);
Se il secondo parametro è true
, la funzione eseguirà una chiamata di sistema ogni volta; in caso contrario viene utilizzato il valore memorizzato nella cache.
Restituisce un array di tutti gli indirizzi di rete locali.
Testato su Ubuntu 11.04 e 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;
. A parte questo, ottima sceneggiatura, un vero salvavita. Grazie molto!
Ecco il mio metodo di utilità per ottenere l'indirizzo IP locale, supponendo che tu stia cercando un indirizzo IPv4 e che la macchina abbia solo una vera interfaccia di rete. Potrebbe essere facilmente riformulato per restituire una matrice di IP per macchine multi-interfaccia.
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"
Installa un modulo chiamato ip like
npm install ip
quindi usa questo codice.
var ip = require("ip");
console.log( ip.address() );
La chiamata a ifconfig dipende molto dalla piattaforma e il livello di rete sa quali indirizzi IP è attivo un socket, quindi è meglio chiederlo. Il nodo non espone un metodo diretto per farlo, ma è possibile aprire qualsiasi socket e chiedere quale indirizzo IP locale è in uso. Ad esempio, aprendo un socket su 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');
});
}
Caso di utilizzo:
getNetworkIP(function (error, ip) {
console.log(ip);
if (error) {
console.log('error:', error);
}
});
Il tuo IP locale è sempre 127.0.0.1.
Quindi c'è l'IP di rete, che puoi ottenere da ifconfig
(* nix) o ipconfig
(win). Questo è utile solo all'interno della rete locale.
Quindi c'è il tuo IP esterno / pubblico, che puoi ottenere solo se puoi in qualche modo chiederlo al router, oppure puoi impostare un servizio esterno che restituisce l'indirizzo IP del client ogni volta che riceve una richiesta. Esistono anche altri servizi simili, come whatismyip.com.
In alcuni casi (ad esempio se si dispone di una connessione WAN), l'IP di rete e l'IP pubblico sono gli stessi e possono entrambi essere utilizzati esternamente per raggiungere il computer.
Se la rete e gli IP pubblici sono diversi, potrebbe essere necessario che il router di rete inoltri tutte le connessioni in entrata al proprio IP di rete.
Aggiornamento 2013:
C'è un nuovo modo per farlo ora, puoi controllare l'oggetto socket della tua connessione per una proprietà chiamata localAddress
, ad es net.socket.localAddress
. Restituisce l'indirizzo sull'estremità del socket.
Il modo più semplice è aprire una porta casuale e ascoltarla, quindi ottenere il tuo indirizzo e chiudere il socket.
Aggiornamento 2015:
Il precedente non funziona più.
ifconfig
o ipconfig
analizzare la stringa di risposta?
ifconfig
è praticamente l'unico modo.
net.socket
ritorno undefined
dal 2015, quindi il "nuovo modo di farlo" non funziona più. C'è un net.Socket
, ma non ha una localAddress
proprietà.
utilizzare il modulo ip npm
var ip = require('ip');
console.log(ip.address());
> '192.168.0.117'
Il liner corretto sia per il trattino basso che per il lodash è:
var ip = require('underscore')
.chain(require('os').networkInterfaces())
.values()
.flatten()
.find({family: 'IPv4', internal: false})
.value()
.address;
.find({family: 'IPv4', internal: false})
anche per un codice più breve ed elegante
Ecco quale potrebbe essere la risposta più pulita e semplice senza dipendenze e che funziona su tutte le piattaforme.
const { lookup } = require('dns').promises;
const { hostname } = require('os');
async function getMyIPAddress(options) {
return (await lookup(hostname(), options))
.address;
}
Tutto quello che so è che volevo l'indirizzo IP a partire da 192.168.
. Questo codice ti darà che:
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;
}
}
}
}
Ovviamente puoi semplicemente cambiare i numeri se ne cerchi uno diverso.
192.168
?
192.168.
motivo per cui l'ho scelto.
per Linux e MacOS usa, se vuoi ottenere i tuoi IP in modo sincrono, prova questo.
var ips = require('child_process').execSync("ifconfig | grep inet | grep -v inet6 | awk '{gsub(/addr:/,\"\");print $2}'").toString().trim().split("\n");
console.log(ips);
il risultato sarà qualcosa di simile.
[ '192.168.3.2', '192.168.2.1' ]
Ho scritto un modulo Node.js che determina il tuo indirizzo IP locale osservando quale interfaccia di rete contiene il gateway predefinito.
Questo è più affidabile della scelta di un'interfaccia os.networkInterfaces()
o delle ricerche DNS del nome host. È in grado di ignorare le interfacce virtuali VMware, loopback e interfacce VPN e funziona su Windows, Linux, Mac OS e FreeBSD. Sotto il cofano, esegue route.exe
o netstat
analizza l'output.
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
});
Ecco una versione semplificata in javascript alla vaniglia per ottenere un singolo 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';
}
Per chiunque sia interessato alla brevità, ecco alcuni "one-liners" che non richiedono plug-in / dipendenze che non fanno parte di un'installazione Node standard:
IPv4 pubblico e IPv6 di eth0 come array:
var ips = require('os').networkInterfaces().eth0.map(function(interface) {
return interface.address;
});
Primo IP pubblico di eth0 (solitamente IPv4) come stringa:
var ip = require('os').networkInterfaces().eth0[0].address;
en0
e en1
per Ethernet e WiFi. Su Windows, ho Local Area Connection
e Wireless Network Connection
.
Google mi ha indirizzato a questa domanda durante la ricerca di "node.js get server ip" , quindi diamo una risposta alternativa a coloro che stanno cercando di raggiungere questo obiettivo nel loro programma server node.js (potrebbe essere il caso del poster originale).
Nel caso più banale in cui il server è associato a un solo indirizzo IP, non dovrebbe essere necessario determinare l'indirizzo IP poiché sappiamo già a quale indirizzo lo abbiamo associato (es. Secondo parametro passato alla listen()
funzione).
Nel caso meno banale in cui il server è associato a più indirizzi IP, potrebbe essere necessario determinare l'indirizzo IP dell'interfaccia a cui si è connesso un client. E come suggerito brevemente da Tor Valamo, al giorno d'oggi, possiamo facilmente ottenere queste informazioni dalla presa connessa e dalle sue localAddress
proprietà.
Ad esempio, se il programma è un server Web:
var http = require("http")
http.createServer(function (req, res) {
console.log(req.socket.localAddress)
res.end(req.socket.localAddress)
}).listen(8000)
E se si tratta di un server TCP generico:
var net = require("net")
net.createServer(function (socket) {
console.log(socket.localAddress)
socket.end(socket.localAddress)
}).listen(8000)
Quando si esegue un programma server, questa soluzione offre portabilità, precisione ed efficienza molto elevate.
Per maggiori dettagli, vedi:
Sulla base di un commento sopra, ecco cosa funziona per l'attuale versione di 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();
Nel commento su una delle risposte precedenti mancava la chiamata a values()
. Sembra che os.networkInterfaces()
ora restituisca un oggetto anziché un array.
_.chain(..)
può essere riscritto come _(...)
, il .filter(..)
può essere riscritto come .where({family: 'IPv4', internal: false})
e puoi eliminare il finale value()
perché lo .first()
fa per te durante il concatenamento.
Ecco una variante degli esempi sopra. Si prende cura di filtrare le interfacce vMware ecc. Se non si passa un indice restituisce tutti gli indirizzi, altrimenti si consiglia di impostarlo come predefinito su 0, quindi passare null per ottenere tutto, ma lo si risolverà. Potresti anche passare un altro argomento per il filtro regex se sei propenso ad aggiungere
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;
}
Sono stato in grado di farlo usando solo il nodo js
Come nodo 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);
Come script bash (richiede l'installazione del nodo 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); """ }
Ecco la mia variante che consente di ottenere sia gli indirizzi IPv4 che IPv6 in modo portatile:
/**
* 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;
};
Ecco una versione di CoffeeScript della stessa funzione:
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
Esempio di output per 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' } }
Se ti piace tutta la brevità, qui sta usando 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);
Simile ad altre risposte ma più conciso:
'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(...)
con Object.values(interfaces).flat()
e sarebbe la stessa cosa.
Quando si sviluppano app su Mac OS e si desidera testarlo sul telefono, è necessario che l'app scelga automaticamente l'IP localhost.
require('os').networkInterfaces().en0.find(elm=>elm.family=='IPv4').address
Questo è solo per menzionare come è possibile scoprire automaticamente l'indirizzo IP. Per testarlo puoi andare al colpo terminale
node
os.networkInterfaces().en0.find(elm=>elm.family=='IPv4').address
l'output sarà il tuo indirizzo IP localhost.
Ecco un piccolo one-liner pulito per te che lo fa funzionalmente:
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
e sostituirla map
con una chiamata a flatMap
.
Molte volte trovo ci sono più interfacce paramento interno ed esterno a disposizione (ad esempio: 10.0.75.1
, 172.100.0.1
, 192.168.2.3
), ed è quello esterno che sono davvero dopo ( 172.100.0.1
).
Nel caso in cui qualcun altro abbia una preoccupazione simile, ecco un'altra interpretazione che spero possa esserti di aiuto ...
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;
Sto usando node.js 0.6.5
$ node -v
v0.6.5
Ecco cosa faccio
var util = require('util');
var exec = require('child_process').exec;
function puts(error, stdout, stderr) {
util.puts(stdout);
}
exec("hostname -i", puts);
hostname -I
(maiuscola i). Restituisce un elenco di tutti gli indirizzi IP assegnati alla macchina. Il primo indirizzo IP è quello che ti serve. Quell'IP è quello collegato all'interfaccia corrente che è attiva.
Ecco una versione multi-ip della risposta di jhurliman sopra:
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;
}
Mi rendo conto che questo è un vecchio thread, ma mi piacerebbe offrire un miglioramento sulla risposta migliore per i seguenti motivi:
l' enumerazione per ... in ... deve essere convalidata per assicurarsi che l'oggetto su cui si sta enumerando contenga la proprietà che si sta cercando. Dato che javsacript è scritto in modo approssimativo e for for ... in ... può essere passato a qualsiasi oggetto arbitory da gestire; è più sicuro convalidare la proprietà che stiamo cercando è disponibile.
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);