javascript - nodejs - Obtener dirección IP local en node.js

nodejs express ip

Question

Tengo un programa simple node.js ejecutándose en mi máquina y quiero obtener la dirección IP local de la PC en la que se ejecuta mi programa. ¿Cómo lo consigo con node.js?

Answer 1

Un forro para MAC solo para la primera dirección localhost.

Cuando desarrolle aplicaciones en Mac OS, y quiera probarlo en el teléfono, y necesita que su aplicación elija el ip localhost automáticamente.

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

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

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

La salida será su dirección IP localhost.

Answer 2

Aquí está mi método de utilidad para obtener la dirección IP local, asumiendo que está buscando una dirección IPv4 y que la máquina solo tiene una interfaz de red real. Se podría refactorizar fácilmente para devolver una serie 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'';
}

Answer 3

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

Answer 4

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

(probado en MacOS Snow Leopard solamente; 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 local.

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

Answer 5

Aquí hay una pequeña frase 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];

Answer 6

Aquí hay una variación de los ejemplos anteriores. Tiene cuidado de filtrar las interfaces de vMware, etc. Si no pasa un índice, devuelve todas las direcciones; de lo contrario, es posible que desee establecer el valor predeterminado en 0, luego pase el valor nulo para obtener todos, pero lo solucionará. También puede pasar otro argumento para el filtro de expresiones regulares si así lo desea.

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

Answer 7

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

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

Answer 8

Aquí hay una versión simplificada en javascript de vainilla 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'';
}

Answer 9

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

En el comentario sobre una de las respuestas anteriores faltaba la llamada a los values() . Parece que os.networkInterfaces() ahora devuelve un objeto en lugar de una matriz.

Answer 10

Cualquier IP de su máquina que pueda encontrar usando 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 manejar, más fácil que ejecutar ifconfig por ligas

nodejs.org/api/os.html#os_os_networkinterfaces

Mejor

Edoardo

Answer 11

El correcto trazador de líneas para subrayado y lodash es:

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

Answer 12

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 de os.networkInterfaces() o búsquedas de DNS del nombre de host. Puede ignorar las interfaces virtuales de VMware, el bucle y las interfaces VPN, y funciona en Windows, Linux, Mac OS y FreeBSD. Bajo el capó, ejecuta route.exe o netstat y analiza 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 
});

Answer 13

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

Answer 14

Google me dirigió a esta pregunta mientras buscaba "node.js get server ip" , así que vamos a dar una respuesta alternativa para aquellos que intentan 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 función listen() ).

En el caso menos trivial en el que el servidor está vinculado a varias direcciones IP, es posible que debamos determinar la dirección IP de la interfaz a la que se conectó un cliente. Y como lo sugirió brevemente Tor Valamo, hoy en día, podemos obtener fácilmente esta información del socket conectado y su propiedad localAddress .

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)

Cuando se ejecuta un programa de servidor, esta solución ofrece portabilidad, precisión y eficiencia muy altas.

Para más detalles, ver:

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

Answer 15

Instale un módulo llamado ip como

npm install ip

entonces usa este código.

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

Answer 16

Llamar a ifconfig es muy dependiente de la plataforma, y ​​la capa de red sabe en qué direcciones IP se encuentra un socket, así que lo mejor es preguntar. El nodo no expone un método directo de hacer esto, 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);
    }
});

Answer 17

Me doy cuenta de que este es un tema antiguo, pero me gustaría ofrecer una mejora en la respuesta principal por los siguientes motivos:

• El código debe ser lo más explicativo posible.
• Debe evitarse la enumeración de una matriz utilizando for ... in ...

• para ... en ... la enumeración debe validarse para garantizar que el objeto que se está enumerando contiene la propiedad que está buscando. A medida que javsacript se escribe sin apretar y el for ... in ... se puede entregar cualquier objeto arbitrario para que lo maneje; Es más seguro validar la propiedad que estamos buscando 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);

Answer 18

Muchas veces encuentro que hay múltiples interfaces internas y externas disponibles (ejemplo: 10.0.75.1 , 172.100.0.1 , 192.168.2.3 ), y es la externa que realmente estoy 172.100.0.1 ( 172.100.0.1 ).

En caso de que alguien más tenga una inquietud similar, aquí hay un comentario más sobre esto que, con suerte, podría 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;

Answer 19

Para cualquier persona interesada en la brevedad, aquí hay algunos "de una sola línea" que no requieren complementos / dependencias que no forman parte de una instalación de Nodo estándar:

IPv4 público e IPv6 de eth0 como una 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;

Answer 20

Pude hacer esto usando solo el nodo js

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

Answer 21

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

Answer 22

Similar a otras respuestas pero más sucinta:

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

Answer 23

Su IP local es siempre 127.0.0.1.

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

Luego está su IP externa / pública, que solo puede obtener si de alguna manera puede solicitarla al enrutador, o puede configurar un servicio externo que devuelva la dirección IP del cliente cada vez que reciba una solicitud. También existen otros servicios similares, 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 y las IP públicas son diferentes, es posible que necesite que su enrutador de red reenvíe todas las conexiones entrantes a la red ip.

Actualización 2013:

Hay una nueva forma de hacer esto ahora, puede verificar el objeto de 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 sencilla es abrir un puerto aleatorio y escucharlo, luego obtener su dirección y cerrar el socket.

Actualización 2015:

Lo anterior ya no funciona.

Answer 24

Todo lo que sé es que quería que la dirección IP comenzara con 192.168. . Este código te dará eso:

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, solo puede cambiar los números si está buscando uno diferente.

Answer 25

espero que esto ayude

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

Answer 26

para usos de Linux y MacOS, si desea obtener sus IP de forma sincrónica, 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 así.

[ ''192.168.3.2'', ''192.168.2.1'' ]

Answer 27

usar el módulo npm ip

var ip = require(''ip'');

console.log(ip.address());

> ''192.168.0.117''

Answer 28

github.com/indutny/node-ip

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

Answer 29

os.networkInterfaces a partir de ahora no funciona en Windows. Ejecutar programas para analizar los resultados parece un poco dudoso. Esto es lo que yo uso.

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

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

Answer 30

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