Uzyskaj lokalny adres IP w node.js

Odpowiedzi:

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
nodyou
źródło
17
var _ = wymagany („podkreślenie”); var ip = _.chain (wymagany ('os'). networkInterfaces ()). flatten (). filter (function (val) {return (val.family == 'IPv4' && val.internal == false)}) .pluck („adres”). first (). value (); console.log (ip)
Carter Cole
Szósta linia powinna być, if( details.family=='IPv4' && details.internal === false ) {jeśli chcesz tylko zewnętrznych adresów IP.
Arlen Beiler
3
@CarterCole potrzebujesz dodatkowego połączenia z .values ​​() przed spłaszczeniem.
Guido
1
Co jeśli chcę pobrać tylko adres IP aktywnego interfejsu?
Tejas,
1
one-liner bez lodash dla węzła> = 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 na razie nie działa w systemie Windows. Uruchamianie programów do analizowania wyników wydaje się nieco niepewne. Oto czego używam.

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

Powinno to zwrócić pierwszy lokalny interfejs sieciowy IP.

Xedecimal
źródło
4
@HermannIngjaldsson: To nie jest bardzo wyczerpująca krytyka. Możesz być bardziej dokładny? Może weź przykładowy kod i zadaj mu nowe pytanie, podając więcej szczegółów i pytając, dlaczego nie działa?
Xedecimal
8
Nie zawsze dobrym pomysłem jest korzystanie z wyszukiwania DNS, ponieważ może zwrócić nieprawidłowe informacje (np. Dane z pamięci podręcznej). Moim zdaniem użycie „os.networkInterfaces” jest lepszym pomysłem.
Guido
1
Korzystanie z DNS działa, jeśli twój serwer ma gdzieś wpis dns. Jednak w wielu aplikacjach nie ma wpisu dns (np. Mój laptop). os.networkInterfaces () jest prawdopodobnie właściwą drogą.
Jeff Whiting,
1
Zauważ, że używa to wyszukiwania systemu operacyjnego, które niekoniecznie wyszukuje DNS i powinien znać swój własny podstawowy adres IP ...
w00t
co jeśli otrzymam adres DNS każdego interfejsu
taha027
203

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

var ip = require("ip");
console.dir ( ip.address() );
Jan Jůna
źródło
@Uri to właśnie pytanie prosi
Seb
1
dokumentacja tego pakietu jest niejasna ... czy mogę również uzyskać adres rozgłoszeniowy, czy też muszę go podać osobiście?
Michael
12
@majidarif Nie uważam tego za usprawiedliwienie złej dokumentacji
Michael
7
Działa to niesamowicie dobrze. Uzyskanie adresu IP jest dosłownie jednorazowe. Świetny.
EvSunWoodard
5
Nie podaje adresu IP wszystkich adapterów. Jeśli masz zainstalowany Docker, podaje on adres dokera vEthernet zamiast faktycznego adresu Ethernet
TetraDev,
62

Dowolny adres IP twojego komputera, który możesz znaleźć za pomocą modułu os - i to jest natywne dla NodeJS

var os = require( 'os' );

var networkInterfaces = os.networkInterfaces( );

console.log( networkInterfaces );

Wystarczy zadzwonić do os.networkInterfaces (), a otrzymasz łatwą do zarządzania listę - łatwiejszą niż uruchamianie ifconfig przez ligi

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

Najlepsza

Edoardo

Edoardo
źródło
9
Świetna odpowiedź. var ip = networkInterfaces ['eth0'] [0] ['address']
Natus Drew
choć wydaje się to świetne, ponieważ jest proste, jego rzeczywista skuteczność prawdopodobnie zależy od konfiguracji sieci. Na przykład domyślna konfiguracja systemu OS X nie zawiera eth0, jest to en0.
ccnokes
3
Pracuje dla mnie. var address = networkInterfaces['venet0:0'][0].address
Anthony
dziwne. w SunOS 5.11 to wywołanie zwraca pusty obiekt
Michael
34

Oto fragment kodu node.js, który przeanalizuje dane wyjściowe ifconfigi (asynchronicznie) zwróci pierwszy znaleziony adres IP:

(testowane tylko w systemie MacOS Snow Leopard; mam nadzieję, że działa również na systemie 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);
        });
    };
})();

Przykład użycia:

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

Jeśli drugim parametrem jest true, funkcja będzie wykonywać wywołanie systemowe za każdym razem; w przeciwnym razie używana jest wartość buforowana.


Zaktualizowana wersja

Zwraca tablicę wszystkich adresów sieci lokalnej.

Testowane na Ubuntu 11.04 i 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);
        });
    };
})();

Przykład użycia zaktualizowanej wersji

getNetworkIPs(function (error, ip) {
console.log(ip);
if (error) {
    console.log('error:', error);
}
}, false);
użytkowników123444555621
źródło
Testowane teraz na OSX Lion, idealne. Dzięki wielkie!
T3db0t
Musiałem usunąć myślnik po słowie „IP” w wyrażeniu regularnym Windows, ponieważ moje dane wyjściowe nie miały myślnika (używam 32-bitowego systemu Windows XP). Nie wiem, czy to była literówka czy dana wersja systemu Windows naprawdę wyprowadza myślnik po „IP”, ale po prostu się na bezpiecznej stronie, przypuszczam może być opcjonalnie: filterRE = /\bIP-?[^:\r\n]+:\s*([^\s]+)/g;. Poza tym świetny skrypt, prawdziwy ratownik. Wielkie dzięki!
Użytkownik nie znalazł
@ jSepia: Prawdopodobnie jest to kwestia lokalizacji. Niemiecki system Windows drukuje „
Adres
W porządku, ale teraz znowu go zepsułeś: p Moje wyjście ipconfig nie zawiera „v4” ani „v6”, co wydaje się być Vista / 7 (patrz technet.microsoft.com/en-us/library/bb726952 .aspx )
Nie znaleziono użytkownika
Nie ma powodu do takiego włamania. Mamy teraz os.networkInterfaces ().
Brad
32

Oto moja użyteczna metoda uzyskiwania lokalnego adresu IP, zakładając, że szukasz adresu IPv4, a urządzenie ma tylko jeden prawdziwy interfejs sieciowy. Można go łatwo refaktoryzować, aby zwrócić tablicę adresów IP dla maszyn z wieloma interfejsami.

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';
}
jhurliman
źródło
Wersja do kawy: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

Zainstaluj moduł o nazwie ip like

npm install ip

następnie użyj tego kodu.

var ip = require("ip");
console.log( ip.address() );
Gokul
źródło
5
Zwraca 127.0.0.1
WeSam Abdallah
zwraca prywatny adres IP, a nie publiczny.
Mehmet Kurtipek
23

Wywołanie ifconfig jest bardzo zależne od platformy, a warstwa sieciowa wie, na jakich adresach IP znajduje się gniazdo, więc najlepiej zapytać. Węzeł nie ujawnia bezpośredniej metody tego, ale możesz otworzyć dowolne gniazdo i zapytać, jaki jest używany lokalny adres IP. Na przykład otwarcie gniazda na 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');
  });
}

Przypadek użycia:

getNetworkIP(function (error, ip) {
    console.log(ip);
    if (error) {
        console.log('error:', error);
    }
});
Jimbly
źródło
Jeśli się zastanawiasz - niekoniecznie uzyskuje publiczny adres IP widziany przez świat.
artur
Byłoby dobrym rozwiązaniem, gdyby nie zależało od połączenia z Internetem i jego szybkości ..
Jacob Rask
W moim przypadku to rozwiązanie jest idealne, ponieważ muszę znać adres IP interfejsu, z którego wychodzi określone żądanie.
radicand
20

Twój lokalny adres IP to zawsze 127.0.0.1.

Następnie jest adres IP sieci, który można uzyskać z ifconfig(* nix) lub ipconfig(win). Jest to przydatne tylko w sieci lokalnej.

Następnie jest twój zewnętrzny / publiczny adres IP, który możesz uzyskać tylko wtedy, gdy możesz poprosić o niego router, lub możesz skonfigurować usługę zewnętrzną, która zwraca adres IP klienta, gdy tylko otrzyma żądanie. Istnieją również inne takie usługi, takie jak whatismyip.com.

W niektórych przypadkach (na przykład, jeśli masz połączenie WAN), IP sieci i publiczny IP są takie same i mogą być używane zewnętrznie, aby połączyć się z komputerem.

Jeśli sieć i publiczne adresy IP są różne, może być konieczne, aby router sieciowy przekazywał wszystkie połączenia przychodzące do twojego adresu IP sieci.


Aktualizacja 2013:

Jest teraz nowy sposób na zrobienie tego, możesz sprawdzić obiekt gniazda swojego połączenia pod kątem właściwości o nazwie localAddressnp net.socket.localAddress. Zwraca adres na twoim końcu gniazda.

Najprościej jest po prostu otworzyć losowy port i nasłuchiwać, a następnie uzyskać adres i zamknąć gniazdo.


Aktualizacja 2015:

Poprzedni nie działa.

Tor Valamo
źródło
Czy to oznacza, że ​​aby uzyskać adres sieciowy w nodejs, musisz wykonać wywołanie systemowe ifconfiglub ipconfigprzeanalizować ciąg odpowiedzi?
user123444555621,
@ Pumbaa80 - Prawie, chyba że twoja karta sieciowa ma sterowniki, do których możesz zadzwonić. Także jeśli masz kilka kart sieciowych (lub adapterów, jak hamachi), nie ma sposobu, można po prostu wywołać funkcję sortuje i dostać jeden adres IP, który jest IP. Więc parsowanie go i interpretowanie wyniku jest prawie jedynym sposobem. ifconfig
Tor Valamo
Wygląda na net.socketzwroty undefinedz 2015 roku, więc „nowy sposób robienia tego” już nie działa. Istnieje net.Socket, ale nie ma localAddresswłaściwości.
trysis
14

użyj npm modułu ip

var ip = require('ip');

console.log(ip.address());

> '192.168.0.117'
KARTHIKEYAN.A
źródło
1
Nie wiem, jak powiedzieć użytkownikom, którzy wylądowali na tej stronie, że jest to jedyna odpowiednia opcja w obecnym kontekście.
Gagan
Dzięki @Gagan Twoje uznanie.
KARTHIKEYAN.
13

Prawidłowa jedna linijka zarówno dla podkreślenia, jak i dla rzęs to:

var ip = require('underscore')
    .chain(require('os').networkInterfaces())
    .values()
    .flatten()
    .find({family: 'IPv4', internal: false})
    .value()
    .address;
sklepienie
źródło
3
Możesz użyć: .find({family: 'IPv4', internal: false})również dla krótszego, bardziej eleganckiego kodu
dcohenb
9

Oto najczystsza i najprostsza odpowiedź bez zależności, która działa na wszystkich platformach.

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

async function getMyIPAddress(options) {
  return (await lookup(hostname(), options))
    .address;
}
użytkownik87064
źródło
8

Wiem tylko, że chciałem, aby adres IP zaczynał się od 192.168.. Ten kod da ci, że:

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

Oczywiście możesz po prostu zmienić liczby, jeśli szukasz innego.

mpen
źródło
Co jeśli adres się nie zaczyna 192.168?
anu
@anu Zmień prefiks na ten, którego szukasz, lub skorzystaj z jednego z wielu innych rozwiązań, które ludzie tutaj opublikowali :-) Mój lokalny adres IP zawsze zaczyna się od 192.168.tego, dlatego właśnie to wybrałem.
mpen
6

w systemach Linux i MacOS, jeśli chcesz uzyskać adresy IP w sposób synchroniczny, wypróbuj to.

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

wynikiem będzie coś takiego.

[ '192.168.3.2', '192.168.2.1' ]
Soja
źródło
6

Napisałem moduł Node.js, który określa lokalny adres IP, sprawdzając, który interfejs sieciowy zawiera domyślną bramę.

Jest to bardziej niezawodne niż wybieranie interfejsu os.networkInterfaces()lub wyszukiwania DNS nazwy hosta. Jest w stanie ignorować interfejsy wirtualne VMware, sprzężenia zwrotne i interfejsy VPN, i działa w systemach Windows, Linux, Mac OS i FreeBSD. Pod maską wykonuje route.exelub netstatanalizuje dane wyjściowe.

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 
});
Ben Hutchison
źródło
szkoda, że ​​nie działa w systemie Windows, gdy język nie jest ustawiony na angielski :(
Javier G.,
1
Dziękujemy za zgłoszenie tego błędu, @JavierG! Opublikowałem wersję 0.0.2, która powinna to naprawić.
Ben Hutchison
5

Oto uproszczona wersja javascript waniliowego, aby uzyskać pojedynczy adres 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';
}
SimoAmi
źródło
4

Dla każdego, kto jest zainteresowany zwięzłością, oto kilka „linków”, które nie wymagają wtyczek / zależności, które nie są częścią standardowej instalacji Węzła:

Publiczny IPv4 i IPv6 eth0 jako macierz:

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

Pierwszy publiczny adres IP eth0 (zwykle IPv4) jako ciąg znaków:

var ip = require('os').networkInterfaces().eth0[0].address;
KyleFarris
źródło
Pamiętaj, że te jednowierszowe są specyficzne dla platformy. Na OS X mam en0i en1dla Ethernetu i Wi-Fi. W systemie Windows mam Local Area Connectioni Wireless Network Connection.
xverges
Jeśli chcesz wiedzieć o swoim publicznym zdalnym adresie IP (w systemie OS X), użyj: var ip = wymagany („os”). NetworkInterfaces (). En0 [1] .address;
Marcelo dos Santos
3

Google skierowało mnie do tego pytania, wyszukując hasło „node.js get server ip” , dlatego podajmy alternatywną odpowiedź dla tych, którzy próbują to osiągnąć w programie serwera node.js (może tak być w przypadku oryginalnego plakatu).

W najbardziej trywialnym przypadku, gdy serwer jest powiązany tylko z jednym adresem IP, nie powinno być potrzeby określania adresu IP, ponieważ już wiemy, do którego adresu go przypisaliśmy (np. Drugi parametr przekazany do listen()funkcji).

W mniej trywialnym przypadku, gdy serwer jest powiązany z wieloma adresami IP, może być konieczne określenie adresu IP interfejsu, do którego podłączony jest klient. I jak krótko sugeruje Tor Valamo, w dzisiejszych czasach możemy łatwo uzyskać te informacje z podłączonego gniazda i jego localAddresswłaściwości.

Na przykład, jeśli program jest serwerem WWW:

var http = require("http")

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

A jeśli jest to ogólny serwer TCP:

var net = require("net")

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

Podczas uruchamiania programu serwerowego to rozwiązanie oferuje bardzo wysoką przenośność, dokładność i wydajność.

Aby uzyskać więcej informacji, zobacz:

Krizalys
źródło
3

Na podstawie powyższego komentarza oto, co działa w bieżącej wersji węzła:

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

W komentarzu do jednej z powyższych odpowiedzi brakowało połączenia z values(). Wygląda na to, że os.networkInterfaces()teraz zwraca obiekt zamiast tablicy.

nwinkler
źródło
1
I <3 lodash. Zwłaszcza lodash golf! _.chain(..)Można ponownie zapisać jako _(...)The .filter(..)można ponownie zapisać jako .where({family: 'IPv4', internal: false})i można upuszczać ostateczna value(), ponieważ .first()zrobi to za ciebie podczas łączenia.
Ryan Graham,
3

Oto odmiana powyższych przykładów. Dba o to, aby odfiltrować interfejsy vMware itp. Jeśli nie przejdziesz indeksu, zwróci on wszystkie adresy, w przeciwnym razie możesz ustawić wartość domyślną na 0, a następnie po prostu podać wartość null, aby uzyskać wszystko, ale to załatwisz. Możesz również podać inny argument dla filtru wyrażenia regularnego, jeśli masz taką skłonność do dodania

    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;
}
origin1tech
źródło
3

Byłem w stanie to zrobić, używając tylko węzła js

Jako węzeł 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);

Jako skrypt bash (wymaga zainstalowanego węzła 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);
    """
}
Sy Le
źródło
2

Oto mój wariant, który pozwala na uzyskanie adresów IPv4 i IPv6 w przenośny sposób:

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

Oto wersja tej samej funkcji CoffeeScript:

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

Przykładowe dane wyjściowe dla 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' } }
Uli Köhler
źródło
2

Jeśli interesuje Cię cała zwięzłość, tutaj używa 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);

użytkownik1760680
źródło
2

Podobne do innych odpowiedzi, ale bardziej zwięzłe:

'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);
Facundo Olano
źródło
1
po prostu chcę wspomnieć, że można zastąpić Object.keys(interfaces).reduce(...)z Object.values(interfaces).flat()i byłoby to samo.
kimbaudi
2

Jedna linijka dla MAC os tylko pierwszy adres localhost.

Tworząc aplikacje na Mac OS, chcesz przetestować je na telefonie i potrzebujesz, aby aplikacja automatycznie wybrała adres IP hosta lokalnego.

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

Wystarczy wspomnieć, jak automatycznie znaleźć adres IP. Aby to przetestować, możesz przejść do terminalu hit

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

wyjście będzie Twoim adresem IP hosta lokalnego.

Tarandeep Singh
źródło
2

Oto schludny mały linijka dla ciebie, która robi to funkcjonalnie:

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];
W
źródło
aby twój kod był bardziej zwięzły, możesz wyeliminować połączenie z reducei zastąpić połączenie na mapz flatMap.
kimbaudi
2

Wiele razy znajduję wiele dostępnych interfejsów wewnętrznych i zewnętrznych (przykład: 10.0.75.1 , 172.100.0.1, 192.168.2.3), i jest to jeden zewnętrzny, że jestem naprawdę po ( 172.100.0.1).

Jeśli ktoś ma podobne obawy, oto jeszcze jedno podejście, które, mam nadzieję, może być pomocne ...

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;
Dave Templin
źródło
1

Używam node.js 0.6.5

$ node -v
v0.6.5

Oto co robię

var util = require('util');
var exec = require('child_process').exec;
function puts(error, stdout, stderr) {
        util.puts(stdout);
}
exec("hostname -i", puts);
Yc Zhang
źródło
Działa to z hostname -I(wielkie litery i). Zwraca listę wszystkich przypisanych adresów IP urządzenia. Pierwszy adres IP jest tym, czego potrzebujesz. Ten adres IP jest dołączony do bieżącego interfejsu, który jest uruchomiony.
blueren
1

Oto wielojęzyczna wersja powyższej odpowiedzi jhurlimana:

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;
}
sethpollack
źródło
1

Zdaję sobie sprawę, że to stary wątek, ale chciałbym zaoferować poprawę w stosunku do najwyższej odpowiedzi z następujących powodów:

  • Kod powinien być jak najbardziej zrozumiały.
  • Należy unikać wyliczania ponad tablicą przy użyciu for ... in ...
  • dla ... w ... wyliczenie powinno zostać sprawdzone, aby upewnić się, że wyliczany obiekt zawiera właściwość, której szukasz. Ponieważ javsacript jest luźno wpisany, a for ... in ... można przekazać dowolny obiekt arbitrażowy do obsługi; bezpieczniej jest zweryfikować właściwość, której szukamy, jest dostępna.

    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);
Chris GW Green
źródło