Ich habe ein einfaches node.js-Programm auf meinem Computer und möchte die lokale IP-Adresse des PCs abrufen, auf dem mein Programm ausgeführt wird. Wie bekomme ich es mit 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 funktioniert derzeit nicht unter Windows. Das Ausführen von Programmen zum Parsen der Ergebnisse scheint etwas zweifelhaft. Folgendes benutze ich.

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

Dies sollte Ihre erste lokale IP-Adresse der Netzwerkschnittstelle zurückgeben.

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

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

Jede IP Ihrer Maschine können Sie mit dem finden os - Modul - und das ist heimisch zu NodeJS

var os = require( 'os' );

var networkInterfaces = os.networkInterfaces( );

console.log( networkInterfaces );

Alles, was Sie tun müssen, ist os.networkInterfaces () aufzurufen, und Sie erhalten eine einfach zu verwaltende Liste - einfacher als ifconfig nach Ligen auszuführen

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

Beste

Edoardo

Hier ist ein Ausschnitt aus dem Code von node.js, der die Ausgabe von analysiert ifconfigund (asynchron) die erste gefundene IP-Adresse zurückgibt:

(nur unter MacOS Snow Leopard getestet; hoffe, es funktioniert auch unter 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);
        });
    };
})();

Anwendungsbeispiel:

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

Wenn der zweite Parameter lautet true, führt die Funktion jedes Mal einen Systemaufruf aus. Andernfalls wird der zwischengespeicherte Wert verwendet.

Aktualisierte Version

Gibt ein Array aller lokalen Netzwerkadressen zurück.

Getestet unter Ubuntu 11.04 und 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);
        });
    };
})();

Anwendungsbeispiel für aktualisierte Version

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

Hier ist meine Dienstprogrammmethode zum Abrufen der lokalen IP-Adresse, vorausgesetzt, Sie suchen nach einer IPv4-Adresse und der Computer verfügt nur über eine echte Netzwerkschnittstelle. Es könnte leicht überarbeitet werden, ein Array von IPs für Maschinen mit mehreren Schnittstellen zurückzugeben.

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

Installieren Sie ein Modul namens ip like

npm install ip

Verwenden Sie dann diesen Code.

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

Das Aufrufen von ifconfig ist sehr plattformabhängig, und die Netzwerkschicht weiß, auf welchen IP-Adressen sich ein Socket befindet. Fragen Sie am besten danach. Der Knoten stellt keine direkte Methode dafür bereit, aber Sie können jeden Socket öffnen und fragen, welche lokale IP-Adresse verwendet wird. Öffnen eines Sockets für 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');
  });
}

Anwendungsfall:

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

Ihre lokale IP ist immer 127.0.0.1.

Dann gibt es die Netzwerk-IP, die Sie von ifconfig(* nix) oder ipconfig(win) erhalten können. Dies ist nur innerhalb des lokalen Netzwerks nützlich.

Dann gibt es Ihre externe / öffentliche IP, die Sie nur erhalten können, wenn Sie den Router irgendwie danach fragen können, oder Sie können einen externen Dienst einrichten, der die Client-IP-Adresse zurückgibt, wenn er eine Anfrage erhält. Es gibt auch andere solche Dienste wie whatismyip.com.

In einigen Fällen (z. B. wenn Sie eine WAN-Verbindung haben) sind die Netzwerk-IP und die öffentliche IP identisch und können beide extern verwendet werden, um Ihren Computer zu erreichen.

Wenn sich Ihr Netzwerk und Ihre öffentlichen IP-Adressen unterscheiden, muss Ihr Netzwerkrouter möglicherweise alle eingehenden Verbindungen an Ihre Netzwerk-IP weiterleiten.

Update 2013:

Es gibt jetzt eine neue Möglichkeit, dies zu tun. Sie können das Socket-Objekt Ihrer Verbindung auf eine Eigenschaft namens localAddressz net.socket.localAddress. Es gibt die Adresse an Ihrem Ende des Sockets zurück.

Am einfachsten ist es, einen zufälligen Port zu öffnen und ihn abzuhören, dann Ihre Adresse abzurufen und den Socket zu schließen.

Update 2015:

Das vorherige funktioniert nicht mehr.

Verwenden Sie das IP-Modul npm

var ip = require('ip');

console.log(ip.address());

> '192.168.0.117'

Der richtige Liner für Unterstrich und Lodash ist:

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

Hier ist die sauberste und einfachste Antwort ohne Abhängigkeiten, die auf allen Plattformen funktioniert.

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

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

Ich weiß nur, dass ich die IP-Adresse von Anfang an haben wollte 192.168.. Dieser Code gibt Ihnen Folgendes:

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

Natürlich können Sie die Nummern auch einfach ändern, wenn Sie nach einer anderen suchen.

Wenn Sie unter Linux und MacOS Ihre IP-Adressen synchron abrufen möchten, versuchen Sie dies.

var ips = require('child_process').execSync("ifconfig | grep inet | grep -v inet6 | awk '{gsub(/addr:/,\"\");print $2}'").toString().trim().split("\n");
console.log(ips);

Das Ergebnis wird ungefähr so ​​sein.

[ '192.168.3.2', '192.168.2.1' ]

Ich habe ein Node.js-Modul geschrieben , das Ihre lokale IP-Adresse anhand der Netzwerkschnittstelle ermittelt, die Ihr Standard-Gateway enthält.

Dies ist zuverlässiger als das Auswählen einer Schnittstelle os.networkInterfaces()oder DNS-Suche des Hostnamens. Es kann virtuelle VMware-Schnittstellen, Loopback- und VPN-Schnittstellen ignorieren und funktioniert unter Windows, Linux, Mac OS und FreeBSD. Unter der Haube wird die Ausgabe ausgeführt route.exeoder netstatanalysiert.

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

Hier ist eine vereinfachte Version in Vanille-Javascript, um eine einzelne IP zu erhalten:

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

Für alle, die an Kürze interessiert sind, sind hier einige "Einzeiler", für die keine Plugins / Abhängigkeiten erforderlich sind, die nicht Teil einer Standardknoteninstallation sind:

Öffentliches IPv4 und IPv6 von eth0 als Array:

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

Erste öffentliche IP von eth0 (normalerweise IPv4) als String:

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

Google hat mich auf diese Frage verwiesen, als ich nach "node.js get server ip" gesucht habe. Geben wir also eine alternative Antwort für diejenigen, die dies in ihrem node.js- Serverprogramm versuchen (möglicherweise im Fall des Originalplakats).

In dem trivialsten Fall, in dem der Server nur an eine IP-Adresse gebunden ist, sollte es nicht erforderlich sein, die IP-Adresse zu bestimmen, da wir bereits wissen, an welche Adresse wir sie gebunden haben (z. B. zweiter Parameter, der an die listen()Funktion übergeben wurde).

In dem weniger trivialen Fall, in dem der Server an mehrere IP-Adressen gebunden ist, müssen wir möglicherweise die IP-Adresse der Schnittstelle ermitteln, mit der ein Client verbunden ist. Und wie von Tor Valamo kurz vorgeschlagen, können wir diese Informationen heutzutage leicht von der angeschlossenen Steckdose und ihrer localAddressEigenschaft erhalten.

Wenn das Programm beispielsweise ein Webserver ist:

var http = require("http")

http.createServer(function (req, res) {
    console.log(req.socket.localAddress)
    res.end(req.socket.localAddress)
}).listen(8000)

Und wenn es sich um einen generischen TCP-Server handelt:

var net = require("net")

net.createServer(function (socket) {
    console.log(socket.localAddress)
    socket.end(socket.localAddress)
}).listen(8000)

Wenn Sie ein Serverprogramm ausführen, bietet diese Lösung eine sehr hohe Portabilität, Genauigkeit und Effizienz.

Weitere Einzelheiten finden Sie unter:

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

Basierend auf einem Kommentar oben funktioniert Folgendes für die aktuelle Version von 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();

Dem Kommentar zu einer der obigen Antworten fehlte der Anruf an values(). Es sieht so aus, als würde os.networkInterfaces()jetzt ein Objekt anstelle eines Arrays zurückgegeben.

Hier ist eine Variation der obigen Beispiele. Es wird darauf geachtet, vMware-Schnittstellen usw. herauszufiltern. Wenn Sie keinen Index übergeben, werden alle Adressen zurückgegeben, andernfalls möchten Sie ihn möglicherweise auf 0 setzen. Übergeben Sie einfach null, um alle zu erhalten, aber Sie werden das klären. Sie können auch ein anderes Argument für den Regex-Filter übergeben, wenn Sie dazu neigen, etwas hinzuzufügen

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

Ich konnte dies nur mit dem Knoten js tun

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

Als Bash-Skript (muss Knoten js installiert sein)

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

Hier ist meine Variante, mit der sowohl IPv4- als auch IPv6-Adressen auf tragbare Weise abgerufen werden können:

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

Hier ist eine CoffeeScript-Version derselben Funktion:

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

Beispielausgabe für 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' } }

Wenn Sie sich für die ganze Kürze interessieren , verwenden Sie hier 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);

Ähnlich wie bei anderen Antworten, aber prägnanter:

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

Ein Liner für MACs erste lokale Hostadresse.

Wenn Sie Apps auf Mac OS entwickeln und diese auf dem Telefon testen möchten und Ihre App die IP-Adresse des lokalen Hosts automatisch auswählen muss.

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

Dies ist nur zu erwähnen, wie Sie die IP-Adresse automatisch herausfinden können. Um dies zu testen, können Sie zum Terminal-Treffer gehen

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

Die Ausgabe erfolgt über die IP-Adresse Ihres lokalen Hosts.

Hier ist ein hübscher kleiner Einzeiler für Sie, der dies funktional erledigt:

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

Viele Male habe ich finde es mehrere interne und externe Verkleidungs Schnittstellen zur Verfügung (Beispiel: 10.0.75.1, 172.100.0.1, 192.168.2.3), und es ist die externe ein , dass ich wirklich nach ( 172.100.0.1).

Für den Fall, dass jemand anderes ein ähnliches Problem hat, hier noch eine Einstellung dazu, die hoffentlich hilfreich sein kann ...

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;

Ich benutze node.js 0.6.5

$ node -v
v0.6.5

Hier ist was ich tue

var util = require('util');
var exec = require('child_process').exec;
function puts(error, stdout, stderr) {
        util.puts(stdout);
}
exec("hostname -i", puts);

Hier ist eine Multi-IP-Version von Jhurlimans Antwort oben:

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

Mir ist klar, dass dies ein alter Thread ist, aber ich möchte aus folgenden Gründen eine Verbesserung der Top-Antwort anbieten:

• Der Code sollte so selbsterklärend wie möglich sein.
• Das Aufzählen über ein Array mit for ... in ... sollte vermieden werden.

• Die Aufzählung für ... in ... sollte überprüft werden, um sicherzustellen, dass das Objekt, über das aufgezählt wird, die gesuchte Eigenschaft enthält. Da javsacript lose geschrieben ist und das for ... in ... jedes zu handhabende willkürliche Objekt übergeben werden kann; Es ist sicherer zu überprüfen, ob die gesuchte Immobilie verfügbar ist.

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