risposta-alla-domanda-sullo-sviluppo-web-bd.com

Ottieni l'indirizzo IP locale in node.js

Ho un semplice programma node.js in esecuzione sulla mia macchina e voglio ottenere l'indirizzo IP locale del PC su cui è in esecuzione il mio programma. Come ottengo con node.js?

266
yojimbo87
'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
361
nodyou

os.networkInterfaces come al momento non funziona su Windows. Eseguire programmi per analizzare i risultati sembra un po 'incerto. Ecco cosa uso.

require('dns').lookup(require('os').hostname(), function (err, add, fam) {
  console.log('addr: '+add);
})

Questo dovrebbe restituire il primo IP locale dell'interfaccia di rete.

211
Xedecimal

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

var ip = require("ip");
console.dir ( ip.address() );
169
Jan Jůna

Qualsiasi IP del tuo computer che puoi trovare usando il ( modulo os - e questo è nativo a NodeJS

var os = require( 'os' );

var networkInterfaces = os.networkInterfaces( );

console.log( networkInterfaces );

Tutto quello che devi fare è chiamare os.networkInterfaces () e otterrai un elenco facile da gestire - più facile che in esecuzione ifconfig dai campionati

http://nodejs.org/api/os.html#os_os_networkinterfaces

Migliore

Edoardo

49
Edoardo

Ecco un frammento 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; altrimenti viene utilizzato il valore memorizzato nella cache.


Versione aggiornata

Restituisce una matrice 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);
32
user123444555621

Installa un modulo chiamato ip like

npm install ip

quindi utilizzare questo codice.

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

Ecco il mio metodo di utilità per ottenere l'indirizzo IP locale, assumendo che si stia cercando un indirizzo IPv4 e che la macchina abbia solo un'interfaccia di rete reale. Potrebbe essere facilmente refactored per restituire una serie 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';
}
25
jhurliman

La chiamata a ifconfig dipende molto dalla piattaforma e il livello di rete non sa su quale indirizzo IP si trova 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 d'uso:

getNetworkIP(function (error, ip) {
    console.log(ip);
    if (error) {
        console.log('error:', error);
    }
});
22
Jimbly

Il tuo indirizzo IP locale è sempre 127.0.0.1.

Poi c'è l'IP di rete, che puoi ottenere da ifconfig (* nix) o ipconfig (win). Questo è utile solo all'interno della rete locale.

Poi c'è il tuo IP esterno/pubblico, che puoi ottenere solo se puoi chiedere in qualche modo al router, oppure puoi configurare 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 uguali e possono 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 ingresso sul 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 sulla tua 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ù.

19
Tor Valamo

Il liner corretto per entrambi underscore e lodash è:

var ip = require('underscore')
    .chain(require('os').networkInterfaces())
    .values()
    .flatten()
    .find({family: 'IPv4', internal: false})
    .value()
    .address;
11
vault

usa il modulo ip npm

var ip = require('ip');

console.log(ip.address());

> '192.168.0.117'
10
KARTHIKEYAN.A

Tutto quello che so è che volevo che l'indirizzo IP iniziasse con 192.168.. Questo codice ti darà questo:

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 stai cercando uno diverso.

7
mpen

Ho scritto un modulo Node.js che determina il tuo indirizzo IP locale controllando quale interfaccia di rete contiene il tuo gateway predefinito.

Questo è più affidabile rispetto alla selezione di un'interfaccia da os.networkInterfaces() o ricerche DNS del nome host. È in grado di ignorare interfacce virtuali VMware, loopback e interfacce VPN e funziona su Windows, Linux, Mac OS e FreeBSD. Sotto il cofano, esegue route.exe o netstat e 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 
});
6
Ben Hutchison

Ecco una versione semplificata in Vanilla javascript 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';
}
5
SimoAmi

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

Per chiunque sia interessato alla brevità, ecco alcuni "one-liner" che non richiedono plugin/dipendenze che non fanno parte di un'installazione di nodo standard:

IPv4 pubblico e IPv6 di eth0 come matrice:

var ips = require('os').networkInterfaces().eth0.map(function(interface) { 
    return interface.address;
});

Primo IP pubblico di eth0 (solitamente IPv4) come String:

var ip = require('os').networkInterfaces().eth0[0].address;
4
KyleFarris

Google mi ha indirizzato a questa domanda durante la ricerca di "node.js get server ip" , quindi diamo una risposta alternativa per coloro che stanno cercando di ottenere questo risultato nel loro node.js programma server (potrebbe essere il caso del poster originale).

Nel caso più banale in cui il server è associato a un solo indirizzo IP, non ci dovrebbe essere bisogno di determinare l'indirizzo IP poiché sappiamo già a quale indirizzo l'abbiamo associato (ad esempio il secondo parametro passato alla funzione listen()).

Nel caso meno banale in cui il server è associato a più indirizzi IP, potrebbe essere necessario determinare l'indirizzo IP dell'interfaccia a cui è collegato un client. E come suggerito brevemente da Tor Valamo, al giorno d'oggi, possiamo facilmente ottenere queste informazioni dal socket connesso e dalla sua proprietà localAddress.

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 è un generico TCP server:

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 elevata portabilità, precisione ed efficienza.

Per maggiori dettagli, vedi:

3
Krizalys

Ecco una variazione degli esempi sopra. Si cura di filtrare le interfacce vMware ecc. Se non si passa un indice, si ritornano tutti gli indirizzi altrimenti si potrebbe voler impostare il valore predefinito su 0 quindi basta passare null per ottenere tutto, ma lo si risolve. Potresti anche passare un altro argomento per il filtro regex se così 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
origin1tech

Sulla base di un commento sopra, ecco cosa funziona per la versione corrente 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();

Il commento su una delle risposte precedenti mancava la chiamata a values(). Sembra che os.networkInterfaces() ora restituisca un oggetto invece di un array.

3
nwinkler

Simile ad altre risposte ma più succinto:

'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);
2
Facundo Olano

Ecco la mia variante che consente di ottenere indirizzi IPv4 e 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 con la 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
Uli Köhler

Se ti occupi dell'intera 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
user1760680

Un solo rivestimento per MAC os solo il primo indirizzo localhost.

Quando sviluppi app su mac os e vuoi testarle sul telefono, e hai bisogno della tua app per selezionare automaticamente l'ip localhost.

require('os').networkInterfaces().en0.find(Elm=>Elm.family=='IPv4').address

Questo è solo per menzionare come è possibile trovare automaticamente l'indirizzo IP. Per testare questo puoi andare al successo del terminale

node
os.networkInterfaces().en0.find(Elm=>Elm.family=='IPv4').address

l'output sarà il tuo indirizzo IP localhost.

2
Tarandeep Singh

Molte volte trovo che sono disponibili più interfacce interne ed esterne (esempio: 10.0.75.1, 172.100.0.1, 192.168.2.3), ed è quella esterna che sto seguendo (172.100.0.1).

Nel caso in cui qualcun altro abbia una preoccupazione simile, ecco un altro punto su questo che si spera possa essere di qualche 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;
2
Dave Templin

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);
1
Yc Zhang

Questa è una modifica della risposta accettata, che non tiene conto degli IP di vEthernet come Docker, ecc.

/**
 * Get local IP, while ignoring vEthernet IPs (like from Docker, etc)
 */
let localIP;
var os = require('os');
var ifaces = os.networkInterfaces();
Object.keys(ifaces).forEach(function (ifname) {
   var alias = 0;

   ifaces[ifname].forEach(function (iface) {
      if ('IPv4' !== iface.family || iface.internal !== false) {
         // skip over internal (i.e. 127.0.0.1) and non-ipv4 addresses
         return;
      }

      if(ifname === 'Ethernet') {
         if (alias >= 1) {
            // this single interface has multiple ipv4 addresses
            // console.log(ifname + ':' + alias, iface.address);
         } else {
            // this interface has only one ipv4 adress
            // console.log(ifname, iface.address);
         }
         ++alias;
         localIP = iface.address;
      }
   });
});
console.log(localIP);

Ciò restituirà un IP come 192.168.2.169 anziché 10.55.1.1

1
TetraDev

spero che questo ti aiuti

var os = require( 'os' );
var networkInterfaces = os.networkInterfaces( );
var arr = networkInterfaces['Local Area Connection 3']
var ip = arr[1].address;
1
flaalf

Sono stato in grado di farlo usando solo il nodo js

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

Come script bash (richiede il nodo js installato)

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

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

  • Il codice dovrebbe essere il più esplicativo possibile.
  • Enumerare su un array usando per ... in ... dovrebbe essere evitato.
  • per ... in ... l'enumerazione deve essere convalidata per garantire che l'oggetto che viene enumerato contiene la proprietà che stai cercando. Poiché javsacript è tipicamente digitato e il per ... in ... può essere passato a qualsiasi oggetto arbore 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);
    
1
Chris GW Green

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
sethpollack

Ecco quale potrebbe essere la risposta più semplice e pulita senza dipendenze e che funzioni su tutte le piattaforme.

const { lookup } = require('dns').promises;
const { hostname } = require('os');

async function getMyIPAddress(options) {
  return (await lookup(hostname(), options))
    .address;
}
1
user87064

Ecco un piccolo liner per te che funziona in modo funzionale:

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];
1
A T

La risposta accettata è asincrona, volevo una versione sincrona, spero che questo aiuti qualcuno.

var os = require('os');
var ifaces = os.networkInterfaces();

console.log(JSON.stringify(ifaces, null, 4));

for (var iface in ifaces) {
  var iface = ifaces[iface];
  for (var alias in iface) {
    var alias = iface[alias];

    console.log(JSON.stringify(alias, null, 4));

    if ('IPv4' !== alias.family || alias.internal !== false) {
      debug("skip over internal (i.e. 127.0.0.1) and non-ipv4 addresses");
      continue;
    }
    console.log("Found ipaddress: " + alias.address);
    return alias.address;
  }
}
return false;
0
Simon Hutchison

Per ottenere l'indirizzo IP nel nodo js, ​​è necessario includere tre moduli: connect, net e request-ip. Se non hai questi moduli installati, prima installiamo questi moduli usando il npm.

Questo dato link contiene la soluzione che desideri, perfavore percorrila

Ottenere l'indirizzo IP e digitare il nodo js

0
Anjali

Ecco una variante che ti consente di ottenere l'indirizzo IP locale (testato su Mac e Win):


var
    // Local ip address that we're trying to calculate
    address
    // Provides a few basic operating-system related utility functions (built-in)
    ,os = require('os')
    // Network interfaces
    ,ifaces = os.networkInterfaces();


// Iterate over interfaces ...
for (var dev in ifaces) {

    // ... and find the one that matches the criteria
    var iface = ifaces[dev].filter(function(details) {
        return details.family === 'IPv4' && details.internal === false;
    });

    if(iface.length > 0) address = iface[0].address;
}

// Print the result
console.log(address); // 10.25.10.147
0

La domanda più grande è "Perché?"

Se è necessario conoscere il server su cui il NODE è in ascolto, è possibile utilizzare req.hostname.

0
ATOzTOA