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?

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

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

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

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

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;

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.

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

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;

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:

• http://nodejs.org/api/net.html
• http://nodejs.org/api/http.html

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.

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

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.

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

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

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:

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