Ottieni l'indirizzo IP locale in node.js


Risposte:


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 _ = request ('trattino basso'); var ip = _.chain (request ('os'). networkInterfaces ()). flatten (). filter (function (val) {return (val.family == 'IPv4' && val.internal == false)}) . .pluck () valore ( 'indirizzo') prima ().; console.log (ip)
Carter Cole,

La sesta riga dovrebbe essere if( details.family=='IPv4' && details.internal === false ) {se vuoi solo IP esterni.
Arlen Beiler,

3
@CarterCole è necessaria una chiamata extra a .values ​​() prima di appiattire.
Guido

1
E se volessi recuperare solo l'indirizzo IP dell'interfaccia attiva?
Tejas,

1
one-liner senza lodash per nodo> = 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 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.


4
@HermannIngjaldsson: questa non è una critica molto approfondita. Potresti essere più specifico? Forse prendi il codice di esempio e inseriscilo in una nuova domanda fornendo maggiori dettagli e chiedendoti perché non funziona?
Xedecimal

8
Non è sempre una buona idea utilizzare la ricerca DNS, poiché può restituire informazioni errate (ad es. Dati memorizzati nella cache). L'uso di "os.networkInterfaces" è un'idea migliore secondo me.
Guido,

1
L'uso del DNS funziona se il tuo server ha una voce DNS da qualche parte. Tuttavia, in molte applicazioni non esiste una voce dns (ad esempio il mio laptop). os.networkInterfaces () è probabilmente la strada da percorrere.
Jeff Whiting,

1
Si noti che questo utilizza la ricerca del sistema operativo, che non necessariamente esegue ricerche DNS e dovrebbe conoscere il proprio indirizzo IP primario ...
w00t,

cosa succede se ottengo l'indirizzo DNS di ciascuna interfaccia
taha027

203

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

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

@Uri questo è ciò che la domanda chiede
Seb,

1
la documentazione per questo pacchetto non è chiara ... posso anche ottenere l'indirizzo di trasmissione o devo fornirlo da solo?
Michael,

12
@majidarif non lo riconosco come una scusa valida per scarsa documentazione
Michael

7
Funziona incredibilmente bene. Ottenere l'indirizzo IP è letteralmente una linea. Eccellente.
EvSunWoodard,

5
Non ti dà l'indirizzo IP di tutti gli adattatori. Se hai Docker installato, fornisce l'indirizzo docker vEthernet invece del tuo vero indirizzo Ethernet
TetraDev

62

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


9
Risposta fantastica. var ip = networkInterfaces ['eth0'] [0] ['address']
Natus Drew l'

mentre questo sembra fantastico perché è semplice, la sua effettiva efficacia dipende probabilmente dalla configurazione della rete. Ad esempio, non esiste eth0 nella configurazione predefinita di OS X, è en0.
ccnokes

3
Per me va bene. var address = networkInterfaces['venet0:0'][0].address
Anthony,

strano. su SunOS 5.11 questa chiamata restituisce un oggetto vuoto
Michael

34

Ecco uno snippet di codice node.js che analizzerà l'output di ifconfige (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.


Versione aggiornata

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

Esempio di utilizzo per la versione aggiornata

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

Testato proprio ora su OSX Lion, perfetto. Grazie mille!
T3db0t,

Ho dovuto rimuovere il trattino dopo la parola "IP" nel tuo regexp di Windows, perché il mio output non aveva il trattino (sto usando Windows XP a 32 bit). Non so se questo era un errore di battitura o se la versione di Windows in uscita davvero un trattino dopo "IP", ma solo per essere sul sicuro, suppongo che può essere reso opzionale: filterRE = /\bIP-?[^:\r\n]+:\s*([^\s]+)/g;. A parte questo, ottima sceneggiatura, un vero salvavita. Grazie molto!
Utente non trovato il

@jSepia: questa è probabilmente una cosa di localizzazione. Windows tedesco stampa "Indirizzo IP";)
user123444555621

Abbastanza giusto, ma ora l'hai rotto di nuovo: p Il mio output ipconfig non include "v4" né "v6", che sembra essere una cosa Vista / 7 (vedi technet.microsoft.com/en-us/library/bb726952 .aspx )
Utente non trovato il

Non c'è motivo per un tale hack. Ora abbiamo os.networkInterfaces ().
Brad,

32

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

Versione caffè: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

Installa un modulo chiamato ip like

npm install ip

quindi usa questo codice.

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

5
Ciò restituisce il 127.0.0.1
WeSam Abdallah

restituisce un indirizzo IP privato non quello pubblico.
Mehmet Kurtipek,

23

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

Nel caso ti stia chiedendo, questo non ottiene necessariamente l'indirizzo IP pubblico che il mondo vede.
artur,

Sarebbe una buona soluzione se non dipendesse dalla connessione a Internet e dalla sua velocità ..
Jacob Rask,

Nel mio caso questa soluzione è perfetta, in quanto ho bisogno di conoscere l'IP dell'interfaccia su cui viene trasmessa una particolare richiesta.
Radicand,

20

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ù.


Ciò significa che per ottenere l'indirizzo di rete in nodejs è necessario effettuare una chiamata di sistema ifconfigo ipconfiganalizzare la stringa di risposta?
user123444555621

@ Pumbaa80 - Praticamente, a meno che la tua scheda di rete non abbia alcuni driver che puoi chiamare. Inoltre, se hai diverse schede di rete (o adattatori, come hamachi), non puoi assolutamente chiamare una funzione e ottenere un IP che è L' IP. Quindi analizzarlo e interpretare l'output di of ifconfigè praticamente l'unico modo.
Tor Valamo,

Sembra un net.socketritorno undefineddal 2015, quindi il "nuovo modo di farlo" non funziona più. C'è un net.Socket, ma non ha una localAddressproprietà.
trysis

14

utilizzare il modulo ip npm

var ip = require('ip');

console.log(ip.address());

> '192.168.0.117'

1
Non so come dire agli utenti che arrivano su questa pagina ora che questa è l'unica opzione adatta nel contesto attuale.
Gagan,

Grazie @Gagan Il tuo apprezzamento.
KARTHIKEYAN. Un

13

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;

3
Puoi usare: .find({family: 'IPv4', internal: false})anche per un codice più breve ed elegante
dcohenb

9

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

8

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.


Cosa succede se l'indirizzo non inizia con 192.168?
anu,

@anu O cambia il prefisso con quello che stai cercando, oppure usa una delle tante altre soluzioni che le persone hanno pubblicato qui :-) Il mio IP locale inizia sempre con il 192.168.motivo per cui l'ho scelto.
Aprire il

6

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

6

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.exeo netstatanalizza 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 
});

peccato che non funzioni su Windows quando la lingua non è impostata in inglese :(
Javier G.

1
Grazie per aver segnalato questo errore, @JavierG! Ho pubblicato la versione 0.0.2 che dovrebbe risolverlo.
Ben Hutchison,

5

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

4

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;

Tieni presente che questi one-liner sono specifici della piattaforma. Su OS X, ho en0e en1per Ethernet e WiFi. Su Windows, ho Local Area Connectione Wireless Network Connection.
xverges

Se vuoi conoscere il tuo IP pubblico remoto (su OS X), usa: var ip = require ('os'). NetworkInterfaces (). En0 [1] .address;
Marcelo dos Santos,

3

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 localAddressproprietà.

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:


3

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.


1
I <3 lodash. Soprattutto lodash golf! Il _.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.
Ryan Graham,

3

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

3

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

2

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

2

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


2

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

1
voglio solo menzionare che è possibile sostituire Object.keys(interfaces).reduce(...)con Object.values(interfaces).flat()e sarebbe la stessa cosa.
Kimbaudi,

2

Un liner solo per MAC os primo indirizzo localhost.

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.


2

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

per rendere il tuo codice più conciso, puoi eliminare la chiamata reducee sostituirla mapcon una chiamata a flatMap.
Kimbaudi,

2

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;

1

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

Funziona con 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.
Blueren,

1

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

1

Mi rendo conto che questo è un vecchio thread, ma mi piacerebbe offrire un miglioramento sulla risposta migliore per i seguenti motivi:

  • Il codice dovrebbe essere il più possibile esplicativo.
  • Si dovrebbe evitare di enumerare un array usando for ... in ...
  • 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);
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.