Obtenga la dirección IP local en node.js

Respuestas:

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
fuente
17
var _ = require ('guión bajo'); var ip = _.chain (require ('os'). networkInterfaces ()). flatten (). filter (function (val) {return (val.family == 'IPv4' && val.internal == false)}) .pluck ('address'). first (). value (); console.log (ip)
Carter Cole el
La sexta línea debería ser if( details.family=='IPv4' && details.internal === false ) {si solo desea direcciones IP externas.
Arlen Beiler
3
@CarterCole necesita una llamada adicional a .values ​​() antes de aplanar.
Guido
1
¿Qué sucede si quisiera recuperar solo la dirección IP de la interfaz activa?
Tejas
1
one-liner sin lodash para nodo> = 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 ahora no funciona en Windows. Ejecutar programas para analizar los resultados parece un poco dudoso. Esto es lo que uso.

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

Esto debería devolver su primera interfaz de red ip local.

Xedecimal
fuente
44
@HermannIngjaldsson: Esta no es una crítica muy informativa. ¿Podrías ser más específico? Tal vez tome el código de ejemplo y póngalo en una nueva pregunta proporcionando más detalles y preguntando por qué no funciona.
Xedecimal
8
No siempre es una buena idea utilizar la búsqueda de DNS, ya que puede devolver información incorrecta (es decir, datos en caché). Usar 'os.networkInterfaces' es una mejor idea en mi opinión.
Guido
1
El uso de DNS funciona si su servidor tiene una entrada dns en alguna parte. Sin embargo, en muchas aplicaciones no hay una entrada de DNS (por ejemplo, mi computadora portátil). os.networkInterfaces () es probablemente el camino a seguir.
Jeff Whiting
1
Tenga en cuenta que este utiliza el sistema operativo de búsqueda, que no necesariamente hacer búsquedas de DNS y debe conocer su propia dirección IP primaria ...
w00t
¿Qué
pasa
203

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

var ip = require("ip");
console.dir ( ip.address() );
Jan Jůna
fuente
@Uri esto es lo que pide la pregunta
Seb
1
la documentación de este paquete no está clara ... ¿puedo obtener la dirección de transmisión o debo proporcionarla yo mismo?
Michael
12
@majidarif no lo reconozco como una excusa válida para una documentación deficiente
Michael
77
Esto funciona increíblemente bien. Obtener la dirección IP es literalmente una línea. Excelente.
EvSunWoodard
55
No le da la dirección IP de todos los adaptadores. Si tiene instalado Docker, le da la dirección de acoplamiento de vEthernet en lugar de su dirección de Ethernet real
TetraDev
62

Cualquier IP de su máquina que pueda encontrar utilizando el módulo os , y eso es nativo de NodeJS

var os = require( 'os' );

var networkInterfaces = os.networkInterfaces( );

console.log( networkInterfaces );

Todo lo que necesita hacer es llamar a os.networkInterfaces () y obtendrá una lista fácil de administrar, más fácil que ejecutar ifconfig por ligas

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

Mejor

Edoardo

Edoardo
fuente
99
Impresionante respuesta. var ip = networkInterfaces ['eth0'] [0] ['address']
Natus Drew
Si bien esto parece genial porque es simple, su efectividad real probablemente depende de la configuración de su red. Por ejemplo, no hay eth0 en la configuración predeterminada de OS X, es en0.
ccnokes
3
Funciona para mi. var address = networkInterfaces['venet0:0'][0].address
Anthony
extraño. en SunOS 5.11 esta llamada devuelve un objeto vacío
Michael
34

Aquí hay un fragmento de código node.js que analizará la salida ifconfigy (asincrónicamente) devolverá la primera dirección IP encontrada:

(probado solo en MacOS Snow Leopard; espero que también funcione en 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);
        });
    };
})();

Ejemplo de uso:

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

Si el segundo parámetro es true, la función ejecutará una llamada al sistema cada vez; de lo contrario, se utiliza el valor en caché.


Versión actualizada

Devuelve una matriz de todas las direcciones de red locales.

Probado en Ubuntu 11.04 y 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);
        });
    };
})();

Ejemplo de uso para la versión actualizada

getNetworkIPs(function (error, ip) {
console.log(ip);
if (error) {
    console.log('error:', error);
}
}, false);
usuario123444555621
fuente
Probado justo ahora en OSX Lion, perfecto. ¡Muchas gracias!
T3db0t
Tuve que eliminar el guión después de la palabra "IP" en su expresión regular de Windows, porque mi salida no tenía el guión (estoy usando Windows XP de 32 bits). No sé si eso era un error tipográfico o si su versión de Windows realmente da salida a un guión después de "IP", pero sólo para estar en el lado seguro, supongo que se puede hacer opcional: filterRE = /\bIP-?[^:\r\n]+:\s*([^\s]+)/g;. Aparte de eso, gran guión, un verdadero salvavidas. ¡Muchas gracias!
Usuario no encontrado el
@jSepia: Eso es probablemente una cosa de localización. Windows alemán imprime "IP-Adresse";)
usuario123444555621
Es justo, pero ahora lo rompiste de nuevo: p Mi salida de ipconfig no incluye "v4" ni "v6", eso parece ser una cosa de Vista / 7 (ver technet.microsoft.com/en-us/library/bb726952 .aspx )
usuario no encontrado el
No hay razón para tal truco. Tenemos os.networkInterfaces () ahora.
Brad
32

Aquí está mi método de utilidad para obtener la dirección IP local, suponiendo que esté buscando una dirección IPv4 y que la máquina solo tenga una interfaz de red real. Se podría refactorizar fácilmente para devolver una matriz de IP para máquinas con múltiples 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';
}
jhurliman
fuente
Versión 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 un módulo llamado ip like

npm install ip

entonces usa este código.

var ip = require("ip");
console.log( ip.address() );
Gokul
fuente
55
Esto devuelve el 127.0.0.1
WeSam Abdallah
devuelve la dirección IP privada, no la pública.
Mehmet Kurtipek
23

Llamar a ifconfig depende mucho de la plataforma, y ​​la capa de red sabe en qué direcciones IP está un socket, así que lo mejor es preguntarlo. Node no expone un método directo para hacerlo, pero puede abrir cualquier socket y preguntar qué dirección IP local está en uso. Por ejemplo, abriendo un socket a 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);
    }
});
Jimbly
fuente
En caso de que se lo pregunte, esto no necesariamente obtiene la dirección IP pública que ve el mundo.
artur
Sería una buena solución si no dependiera de la conexión a Internet y su velocidad ..
Jacob Rask
En mi caso, esta solución es perfecta, ya que necesito saber la IP de la interfaz en la que se envía una solicitud particular.
radicando el
20

Su IP local es siempre 127.0.0.1.

Luego está la IP de la red, que puede obtener de ifconfig(* nix) o ipconfig(win). Esto solo es útil dentro de la red local.

Luego está su IP pública / externa, que solo puede obtener si de alguna manera puede solicitarla al enrutador, o puede configurar un servicio externo que devuelve la dirección IP del cliente cada vez que recibe una solicitud. También existen otros servicios de este tipo, como whatismyip.com.

En algunos casos (por ejemplo, si tiene una conexión WAN), la IP de la red y la IP pública son las mismas, y ambas pueden usarse externamente para llegar a su computadora.

Si su red e IP públicas son diferentes, es posible que necesite que su enrutador de red reenvíe todas las conexiones entrantes a su IP de red.


Actualización 2013:

Hay una nueva forma de hacer esto ahora, puede verificar el objeto socket de su conexión para una propiedad llamada localAddress, por ejemplo net.socket.localAddress. Devuelve la dirección en su extremo del zócalo.

La forma más fácil es simplemente abrir un puerto aleatorio y escucharlo, luego obtener su dirección y cerrar el zócalo.


Actualización 2015:

Lo anterior ya no funciona.

Tor Valamo
fuente
¿Eso significa que para obtener la dirección de red en nodejs necesita hacer una llamada al sistema ifconfigo ipconfiganalizar la cadena de respuesta?
user123444555621
@ Pumbaa80: más o menos, a menos que su tarjeta de red tenga algunos controladores a los que pueda llamar. Además, si tiene varias tarjetas de red (o adaptadores, como hamachi), no hay forma de llamar una función y obtener una IP que sea THE IP. Por lo tanto, analizarlo e interpretar el resultado de of ifconfiges prácticamente la única forma.
Tor Valamo
Parece que net.socketregresa a undefinedpartir de 2015, por lo que la "nueva forma de hacer esto" ya no funciona. Hay una net.Socket, pero no tiene una localAddresspropiedad.
trysis
14

use el módulo npm ip

var ip = require('ip');

console.log(ip.address());

> '192.168.0.117'
KARTHIKEYAN.A
fuente
1
No sé cómo decirle a los usuarios que llegan a esta página ahora que esta es la única opción adecuada en el contexto actual.
Gagan
Gracias @Gagan Tu apreciación.
KARTHIKEYAN
13

El revestimiento correcto tanto para el subrayado como para el lodash es:

var ip = require('underscore')
    .chain(require('os').networkInterfaces())
    .values()
    .flatten()
    .find({family: 'IPv4', internal: false})
    .value()
    .address;
bóveda
fuente
3
Puede usar: .find({family: 'IPv4', internal: false})también para un código más corto y elegante
dcohenb
9

Esto es lo que podría ser la respuesta más simple y limpia sin dependencias y que funcione en todas las plataformas.

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

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

Todo lo que sé es que quería comenzar con la dirección IP 192.168.. Este código te dará 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;
            }
        }
    }
}

Por supuesto, puede cambiar los números si está buscando uno diferente.

mpen
fuente
¿Qué pasa si la dirección no comienza con 192.168?
Anu
@anu Cambie el prefijo al que está buscando, o use una de las muchas otras soluciones que la gente ha publicado aquí :-) Mi IP local siempre comienza, 192.168.por eso elegí eso.
mpen
6

para los usos de Linux y MacOS, si desea obtener sus IP de forma síncrona, intente esto.

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

El resultado será algo como esto.

[ '192.168.3.2', '192.168.2.1' ]
Soyoes
fuente
6

Escribí un módulo Node.js que determina su dirección IP local al observar qué interfaz de red contiene su puerta de enlace predeterminada.

Esto es más confiable que elegir una interfaz os.networkInterfaces()o búsquedas de DNS del nombre de host. Es capaz de ignorar las interfaces virtuales, el loopback y las interfaces VPN de VMware, y funciona en Windows, Linux, Mac OS y FreeBSD. Debajo del capó, se ejecuta route.exeo netstatanaliza la salida.

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
fuente
lástima que no funcione en Windows cuando el idioma no está configurado en inglés :(
Javier G.
1
¡Gracias por informar de este error, @JavierG! He publicado la versión 0.0.2 que debería solucionarlo.
Ben Hutchison
5

Aquí hay una versión simplificada en vainilla javascript para obtener una única 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
fuente
4

Para cualquier persona interesada en la brevedad, aquí hay algunos "one-liners" que no requieren complementos / dependencias que no sean parte de una instalación de Nodo estándar:

IPv4 público e IPv6 de eth0 como matriz:

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

Primera IP pública de eth0 (generalmente IPv4) como String:

var ip = require('os').networkInterfaces().eth0[0].address;
KyleFarris
fuente
Tenga en cuenta que estos one-liners son específicos de la plataforma. En OS X, tengo en0y en1para ethernet y wifi. En Windows, tengo Local Area Connectiony Wireless Network Connection.
xverges
Si desea conocer su IP remota pública (en OS X), use: var ip = require ('os'). NetworkInterfaces (). En0 [1] .address;
Marcelo dos Santos
3

Google me dirigió a esta pregunta mientras buscaba "node.js get server ip" , así que demos una respuesta alternativa para aquellos que están tratando de lograr esto en su programa de servidor node.js (puede ser el caso del póster original).

En el caso más trivial en el que el servidor está vinculado a una sola dirección IP, no debería ser necesario determinar la dirección IP ya que ya sabemos a qué dirección la vinculamos (por ejemplo, el segundo parámetro pasado a la listen()función).

En el caso menos trivial donde el servidor está vinculado a múltiples direcciones IP, es posible que necesitemos determinar la dirección IP de la interfaz a la que se conectó un cliente. Y como Tor Valamo sugirió brevemente, hoy en día, podemos obtener fácilmente esta información del zócalo conectado y su localAddresspropiedad.

Por ejemplo, si el programa es un servidor web:

var http = require("http")

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

Y si es un servidor TCP genérico:

var net = require("net")

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

Al ejecutar un programa de servidor, esta solución ofrece portabilidad, precisión y eficiencia muy altas.

Para más detalles, ver:

Krizalys
fuente
3

Según un comentario anterior, esto es lo que funciona para la versión actual de 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();

El comentario sobre una de las respuestas anteriores perdió la llamada values(). Parece que os.networkInterfaces()ahora devuelve un objeto en lugar de una matriz.

nwinkler
fuente
1
I <3 lodash. Especialmente lodash golf! Se _.chain(..)puede reescribir como _(...), .filter(..)se puede reescribir como .where({family: 'IPv4', internal: false}), y puede soltar el final value()porque lo .first()hace por usted cuando se encadena.
Ryan Graham
3

Aquí hay una variación de los ejemplos anteriores. Se encarga de filtrar las interfaces de vMware, etc. Si no pasa un índice, devuelve todas las direcciones; de lo contrario, puede establecer el valor predeterminado en 0 y luego pasar nulo para obtener todo, pero lo resolverá. También podría pasar otro argumento para el filtro de expresiones regulares si así lo desea agregar

    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
fuente
3

Pude hacer esto usando solo el nodo js

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

Como script bash (necesita el nodo 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);
    """
}
Sy Le
fuente
2

Aquí está mi variante que permite obtener direcciones IPv4 e IPv6 de forma 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;
};

Aquí hay una versión de CoffeeScript de la misma función:

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

Ejemplo de salida 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' } }
Uli Köhler
fuente
2

Si te gusta la brevedad, aquí 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);

usuario1760680
fuente
2

Similar a otras respuestas pero más 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);
Facundo Olano
fuente
1
sólo quiero mencionar que se puede sustituir Object.keys(interfaces).reduce(...)con Object.values(interfaces).flat()y sería lo mismo.
kimbaudi
2

Un trazador de líneas para la primera dirección de host local de MAC.

Al desarrollar aplicaciones en mac os, y desea probarlo en el teléfono, y necesita que su aplicación elija la IP localhost automáticamente.

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

Esto es solo para mencionar cómo puede encontrar la dirección IP automáticamente. Para probar esto puedes ir al hit de terminal

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

La salida será su dirección IP localhost.

Tarandeep Singh
fuente
2

Aquí hay una pequeña línea ordenada para usted que hace esto 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];
A
fuente
para hacer que su código sea más conciso, puede eliminar la llamada a reducey reemplazarla mapcon una llamada a flatMap.
kimbaudi
2

Muchas veces me parece que hay múltiples interfaces de revestimiento interno y externo disponible (ejemplo: 10.0.75.1, 172.100.0.1, 192.168.2.3), y es la externa que estoy realmente después ( 172.100.0.1).

En caso de que alguien más tenga una preocupación similar, aquí hay una opinión más sobre esto que, con suerte, puede ser de alguna ayuda ...

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
fuente
1

Estoy usando node.js 0.6.5

$ node -v
v0.6.5

Esto es lo que hago

var util = require('util');
var exec = require('child_process').exec;
function puts(error, stdout, stderr) {
        util.puts(stdout);
}
exec("hostname -i", puts);
Yc Zhang
fuente
Esto funciona con hostname -I(mayúscula i). Devuelve una lista de todas las direcciones IP asignadas de la máquina. La primera dirección IP es lo que necesita. Esa IP es la que está conectada a la interfaz actual que está activa.
blueren
1

Aquí hay una versión multi-ip de la respuesta de jhurliman anterior:

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
fuente
1

Me doy cuenta de que este es un hilo viejo, pero me gustaría ofrecer una mejora en la respuesta principal por las siguientes razones:

  • El código debe ser lo más explicativo posible.
  • Enumerar sobre una matriz usando para ... en ... debe evitarse.
  • para ... en ... la enumeración debe validarse para garantizar que el objeto que se está enumerando contiene la propiedad que está buscando. Como javsacript está mal escrito y el for ... in ... puede entregarse cualquier objeto arbitrario para manejar; Es más seguro validar que la propiedad que estamos buscando está disponible.

    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
fuente