Obter endereço IP local em node.js


Respostas:


419
'use strict';

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

Object.keys(ifaces).forEach(function (ifname) {
  var alias = 0;

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

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

// en0 192.168.1.101
// eth0 10.0.0.101

17
var _ = require ('sublinhado'); var ip = _.chain (require ('os'). networkInterfaces ()). flatten (). filter (função (val) {return (val.family == 'IPv4' && val.internal == false)}) .pluck ('address'). first (). value (); console.log (ip)
Carter Cole

A sexta linha deve ser if( details.family=='IPv4' && details.internal === false ) {se você deseja apenas IPs externos.
Arlen Beiler

3
@CarterCole, você precisa de uma chamada extra para .values ​​() antes de achatar.
Guido

1
E se eu quisesse recuperar apenas o endereço IP da interface ativa?
Tejas

1
one-liner sem lodash para o nó> = 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 a partir de agora não funciona no Windows. A execução de programas para analisar os resultados parece um pouco duvidosa. Aqui está o que eu uso.

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

Isso deve retornar o seu primeiro IP local da interface de rede.


4
@HermannIngjaldsson: Esta não é uma crítica completamente informativa. Você poderia ser mais específico? Talvez pegue o código de exemplo e coloque-o em uma nova pergunta, fornecendo mais detalhes e perguntando por que ele não funciona.
Xedecimal 07/11

8
Nem sempre é uma boa ideia usar a pesquisa de DNS, pois ela pode retornar informações incorretas (ou seja, dados em cache). Usar 'os.networkInterfaces' é uma ideia melhor na minha opinião.
Guido

1
O uso do DNS funciona se o servidor tiver uma entrada de DNS em algum lugar. No entanto, em muitos aplicativos, não há uma entrada DNS (por exemplo, meu laptop). os.networkInterfaces () é provavelmente o caminho a percorrer.
Jeff Whiting

1
Note que isto usa a pesquisa OS, que não necessariamente fazer pesquisas de DNS e deve conhecer o seu próprio endereço IP primário ...
w00t

E se eu obter o endereço DNS de cada interface
taha027

203

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

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

@Uri isso é o que a pergunta pede
Seb

1
a documentação deste pacote não é clara ... também posso obter o endereço de transmissão ou preciso fornecê-lo pessoalmente?
Michael

12
@majidarif Eu não reconheço isso como uma desculpa válida para documentação pobre
Michael

7
Isso funciona incrivelmente bem. Obter o endereço IP é literalmente uma linha. Excelente.
EvSunWoodard

5
Não fornece o endereço IP de todos os adaptadores. Se você tem Docker instalado, ele dá o endereço vEthernet janela de encaixe em vez de seu endereço Ethernet real
TetraDev

62

Qualquer IP da sua máquina que você possa encontrar usando o módulo os - e isso é nativo do NodeJS

var os = require( 'os' );

var networkInterfaces = os.networkInterfaces( );

console.log( networkInterfaces );

Tudo o que você precisa fazer é chamar os.networkInterfaces () e você obterá uma lista fácil de gerenciar - mais fácil do que executar o ifconfig por ligas

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

Melhor

Edoardo


9
Resposta incrível. var ip = networkInterfaces ['eth0'] [0] ['address']
Natus Drew

embora isso pareça ótimo porque é simples, sua eficácia real provavelmente depende da configuração da sua rede. Por exemplo, não há eth0 na configuração padrão do OS X, é en0.
Ccnokes

3
Funciona para mim. var address = networkInterfaces['venet0:0'][0].address
Anthony

esquisito. em SunOS 5.11 esta chamada retorna um objeto vazio
Michael

34

Aqui está um trecho de código node.js. que analisará a saída ifconfige (de forma assíncrona) retornará o primeiro endereço IP encontrado:

(testado apenas no MacOS Snow Leopard; espero que também funcione no 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);
        });
    };
})();

Exemplo de uso:

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

Se o segundo parâmetro for true, a função executará uma chamada do sistema toda vez; caso contrário, o valor em cache é usado.


Versão atualizada

Retorna uma matriz de todos os endereços de rede local.

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

Exemplo de uso para versão atualizada

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

Testado agora no OSX Lion, perfeito. Muito obrigado!
T3db0t

Eu tive que remover o hífen após a palavra "IP" no seu regexp do Windows, porque minha saída não tinha o hífen (estou usando o Windows XP de 32 bits). Eu não sei se isso foi um erro de digitação ou se a versão do Windows realmente gera um hífen após "IP", mas apenas para estar no lado seguro, acho que pode ser feito opcional: filterRE = /\bIP-?[^:\r\n]+:\s*([^\s]+)/g;. Além disso, ótimo roteiro, um verdadeiro salva-vidas. Muito Obrigado!
Usuário não encontrado

@ jSepia: Isso é provavelmente uma coisa de localização. Windows alemão imprime "IP-Adresse";)
user123444555621

É justo, mas agora você a quebrou novamente: p Minha saída ipconfig não inclui "v4" nem "v6", que parece ser uma coisa do Vista / 7 (consulte technet.microsoft.com/en-us/library/bb726952 .aspx )
Usuário não encontrado

Não há razão para tal invasão. Agora temos os.networkInterfaces ().
187 Brad

32

Aqui está o meu método utilitário para obter o endereço IP local, supondo que você esteja procurando um endereço IPv4 e a máquina tenha apenas uma interface de rede real. Poderia ser facilmente refatorado para retornar uma matriz de IPs para máquinas com várias interfaces.

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

Versão do café: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

Instale um módulo chamado ip like

npm install ip

então use este código.

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

5
Isso retorna o 127.0.0.1
WeSam Abdallah

retorna endereço IP privado e não público.
Mehmet Kurtipek

23

Chamar ifconfig depende muito da plataforma, e a camada de rede sabe em que endereços IP está um soquete; portanto, o melhor é perguntar. O nó não expõe um método direto de fazer isso, mas você pode abrir qualquer soquete e perguntar qual endereço IP local está sendo usado. Por exemplo, abrindo um soquete para 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 de uso:

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

Caso você esteja se perguntando - isso não necessariamente obtém o endereço IP público que o mundo vê.
Artur

Seria uma boa solução se não depender de conexão com a internet e sua velocidade ..
Jacob Rask

No meu exemplo, essa solução é perfeita, pois preciso saber o IP da interface em que uma solicitação específica sai.
Radicand

20

Seu IP local é sempre 127.0.0.1.

Depois, há o IP da rede, do qual você pode obter ifconfig(* nix) ou ipconfig(win). Isso é útil apenas dentro da rede local.

Depois, há o seu IP externo / público, que você só pode obter se, de alguma forma, solicitar ao roteador ou pode configurar um serviço externo que retorne o endereço IP do cliente sempre que for solicitado. Existem também outros serviços, como whatismyip.com.

Em alguns casos (por exemplo, se você tiver uma conexão WAN), o IP da rede e o IP público são os mesmos e podem ser usados ​​externamente para acessar seu computador.

Se sua rede e IPs públicos forem diferentes, talvez seja necessário que seu roteador de rede encaminhe todas as conexões de entrada ao seu ip de rede.


Atualização 2013:

Há uma nova maneira de fazer isso agora, você pode verificar o objeto de soquete da sua conexão para uma propriedade chamada localAddress, por exemplo net.socket.localAddress. Retorna o endereço na sua extremidade do soquete.

A maneira mais fácil é simplesmente abrir uma porta aleatória e ouvi-la, obter seu endereço e fechar o soquete.


Atualização 2015:

O anterior não funciona mais.


Isso significa que, para obter o endereço de rede no nodejs, é necessário fazer uma chamada de sistema ifconfigou ipconfiganalisar a cadeia de resposta?
user123444555621

@ Pumbaa80 - Praticamente, a menos que sua placa de rede possua alguns drivers para os quais você possa ligar. Além disso, se você tem várias placas de rede (ou adaptadores, como hamachi), não há nenhuma maneira você pode apenas chamar uma função de tipos e obter um IP que é O IP. Portanto, analisá-lo e interpretar a saída de ifconfigé praticamente o único caminho.
Tor Valamo

Parece net.socketretorno a undefinedpartir de 2015, então a "nova maneira de fazer isso" não funciona mais. Existe um net.Socket, mas ele não tem uma localAddresspropriedade.
precisa saber é

14

use o módulo ip npm

var ip = require('ip');

console.log(ip.address());

> '192.168.0.117'

1
Não sei como dizer aos usuários que acessam esta página agora que essa é a única opção adequada no contexto atual.
Gagan

Obrigado @Gagan Sua apreciação.
KARTHIKEYAN.A

13

O liner correto para sublinhado e lodash é:

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

3
Você pode usar: .find({family: 'IPv4', internal: false})tão bem para um código mais elegante mais curto
dcohenb

9

Aqui está o que pode ser a resposta mais limpa e simples, sem dependências, e que funciona em todas as plataformas.

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

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

8

Tudo o que sei é que eu queria o endereço IP começando com 192.168.. Este código fornecerá a você que:

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

Claro que você pode alterar os números se estiver procurando por um número diferente.


E se o endereço não começar 192.168?
anu

@anu Altere o prefixo para o que você está procurando ou use uma das muitas outras soluções que as pessoas postaram aqui :-) Meu IP local sempre começa com o 192.168.motivo pelo qual escolhi isso.
MPEN

6

para Linux e MacOS, se você deseja obter seus IPs de maneira síncrona, tente isso.

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

o resultado será algo como isto.

[ '192.168.3.2', '192.168.2.1' ]

6

Eu escrevi um módulo Node.js que determina o seu endereço IP local, observando qual interface de rede contém seu gateway padrão.

Isso é mais confiável do que escolher uma interface os.networkInterfaces()ou pesquisas de DNS do nome do host. É capaz de ignorar interfaces virtuais VMware, loopback e interfaces VPN, e funciona no Windows, Linux, Mac OS e FreeBSD. Sob o capô, ele executa route.exeou netstatanalisa a saída.

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

pena que não funciona em janelas quando o idioma não está definido para Inglês :(
Javier G.

1
Obrigado por relatar este bug, @JavierG! Publiquei a versão 0.0.2, que deve corrigi-lo.
Ben Hutchison

5

Aqui está uma versão simplificada em vanilla javascript para obter um único ip:

function getServerIp() {

  var os = require('os');
  var ifaces = os.networkInterfaces();
  var values = Object.keys(ifaces).map(function(name) {
    return ifaces[name];
  });
  values = [].concat.apply([], values).filter(function(val){ 
    return val.family == 'IPv4' && val.internal == false; 
  });

  return values.length ? values[0].address : '0.0.0.0';
}

4

Para qualquer pessoa interessada na brevidade, aqui estão alguns "one-liners" que não requerem plugins / dependências que não fazem parte de uma instalação padrão do Node:

IPv4 público e IPv6 de eth0 como uma matriz:

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

Primeiro IP público de eth0 (geralmente IPv4) como String:

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

Lembre-se de que esses one-liners são específicos da plataforma. No OS X, eu tenho en0e en1para ethernet e wifi. No Windows, eu tenho Local Area Connectione Wireless Network Connection.
Xevges

Se você quiser saber sobre o seu IP remoto público (No OS X), use: var ip = require ('os'). NetworkInterfaces (). En0 [1] .address;
Marcelo dos Santos

3

O Google me direcionou para essa pergunta enquanto procurava por "node.js get server ip" , então vamos dar uma resposta alternativa para aqueles que estão tentando conseguir isso em seu programa de servidor node.js. (pode ser o caso do pôster original).

No caso mais trivial em que o servidor está vinculado a apenas um endereço IP, não deve ser necessário determinar o endereço IP, pois já sabemos a que endereço o vinculamos (por exemplo, o segundo parâmetro passado para a listen()função).

No caso menos trivial em que o servidor está vinculado a vários endereços IP, talvez seja necessário determinar o endereço IP da interface à qual um cliente se conectou. E como sugerido brevemente por Tor Valamo, hoje em dia, podemos facilmente obter essas informações do soquete conectado e de suas localAddresspropriedades.

Por exemplo, se o programa for um servidor da web:

var http = require("http")

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

E se for um servidor TCP genérico:

var net = require("net")

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

Ao executar um programa de servidor, esta solução oferece portabilidade, precisão e eficiência muito altas.

Para mais detalhes, consulte:


3

Com base no comentário acima, veja o que está funcionando para a versão atual do 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();

O comentário de uma das respostas acima estava ausente values(). Parece que os.networkInterfaces()agora retorna um objeto em vez de uma matriz.


1
Eu <3 lodash. Especialmente golfe lodash! O _.chain(..)pode ser reescrito como _(...), o .filter(..)pode ser reescrito como .where({family: 'IPv4', internal: false})e você pode soltar a final value()porque .first()faz isso para você ao encadear.
Ryan Graham

3

Aqui está uma variação dos exemplos acima. É preciso filtrar as interfaces do vMware, etc. Se você não passar um índice, ele retornará todos os endereços; caso contrário, você poderá defini-lo como 0 e, em seguida, passar nulo para obter todos, mas você resolverá isso. Você também pode passar outro argumento para o filtro regex, se assim desejar

    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

Consegui fazer isso usando apenas o nó js

Como Nó 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);

Como script bash (precisa do nó js instalado)

function ifconfig2 ()
{
    node -e """
        var os = require( 'os' );
        var networkInterfaces = Object.values(os.networkInterfaces())
            .reduce((r,a)=>{
                r = r.concat(a)
                return r;
            }, [])
            .filter(({family, address}) => {
                return family.toLowerCase().indexOf('v4') >= 0 &&
                    address !== '127.0.0.1'
            })
            .map(({address}) => address);
        var ipAddresses = networkInterfaces.join(', ')
        console.log(ipAddresses);
    """
}

2

Aqui está minha variante que permite obter endereços IPv4 e IPv6 de maneira portátil:

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

Aqui está uma versão do CoffeeScript da mesma função:

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

Exemplo de saída para console.log(getLocalIPs())

{ lo: { IPv4: '127.0.0.1', IPv6: '::1' },
  wlan0: { IPv4: '192.168.178.21', IPv6: 'fe80::aa1a:2eee:feba:1c39' },
  tap0: { IPv4: '10.1.1.7', IPv6: 'fe80::ddf1:a9a1:1242:bc9b' } }

2

Se você gosta de toda a brevidade, aqui está 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

Semelhante a outras respostas, mas mais sucinto:

'use strict';

const interfaces = require('os').networkInterfaces();

const addresses = Object.keys(interfaces)
  .reduce((results, name) => results.concat(interfaces[name]), [])
  .filter((iface) => iface.family === 'IPv4' && !iface.internal)
  .map((iface) => iface.address);

1
só quero mencionar que você pode substituir Object.keys(interfaces).reduce(...)por Object.values(interfaces).flat()e seria a mesma coisa.
Kimbaudi 13/07/19

2

Um liner para MAC é apenas o primeiro endereço de host local.

Ao desenvolver aplicativos no Mac OS, e deseja testá-lo no telefone, é necessário que o aplicativo escolha o IP do host local automaticamente.

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

Isso é apenas para mencionar como você pode descobrir o endereço IP automaticamente. Para testar isso, você pode ir ao terminal hit

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

A saída será o seu endereço IP do host local.


2

Aqui está uma pequena linha interessante para você, que faz isso funcionalmente:

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

para tornar seu código mais conciso, você pode eliminar a chamada reducee substituí-la mappor uma chamada para flatMap.
Kimbaudi 13/07/19

2

Muitas vezes eu encontrar existem múltiplas interfaces de revestimento interno e externo disponível (exemplo: 10.0.75.1, 172.100.0.1, 192.168.2.3), e é o externo que estou realmente depois ( 172.100.0.1).

Caso alguém mais tenha uma preocupação semelhante, aqui está mais uma opinião sobre isso que, espero, pode ser de alguma ajuda ...

const address = Object.keys(os.networkInterfaces())
    // flatten interfaces to an array
    .reduce((a, key) => [
        ...a,
        ...os.networkInterfaces()[key]
    ], [])
    // non-internal ipv4 addresses only
    .filter(iface => iface.family === 'IPv4' && !iface.internal)
    // project ipv4 address as a 32-bit number (n)
    .map(iface => ({...iface, n: (d => ((((((+d[0])*256)+(+d[1]))*256)+(+d[2]))*256)+(+d[3]))(iface.address.split('.'))}))
    // set a hi-bit on (n) for reserved addresses so they will sort to the bottom
    .map(iface => iface.address.startsWith('10.') || iface.address.startsWith('192.') ? {...iface, n: Math.pow(2,32) + iface.n} : iface)
    // sort ascending on (n)
    .sort((a, b) => a.n - b.n)
    [0]||{}.address;

1

Estou usando o node.js 0.6.5

$ node -v
v0.6.5

Aqui está o que eu faço

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

Isso funciona com hostname -I(i maiúsculo). Retorna uma lista de todos os endereços IP atribuídos da máquina. O primeiro endereço IP é o que você precisa. Esse IP é aquele conectado à interface atual que está ativa.
blueren 6/09/18

1

Aqui está uma versão multi-ip da resposta de jhurliman acima:

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

Sei que esse é um tópico antigo, mas gostaria de oferecer uma melhoria na resposta principal pelos seguintes motivos:

  • O código deve ser o mais auto-explicativo possível.
  • A enumeração em uma matriz usando for ... in ... deve ser evitada.
  • para ... in ... a enumeração deve ser validada para garantir que o objeto a ser enumerado contenha a propriedade que você está procurando. Como o javsacript é vagamente digitado e o for ... in ... pode ser entregue a qualquer objeto arbitral a ser manipulado; é mais seguro validar a propriedade que procuramos está disponível.

    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);
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.