Tengo un simple programa 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?

'use strict';

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

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

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

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

// en0 192.168.1.101
// eth0 10.0.0.101

os.networkInterfaces 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.

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

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

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

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

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

Instale un módulo llamado ip like

npm install ip

entonces usa este código.

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

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

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.

use el módulo npm ip

var ip = require('ip');

console.log(ip.address());

> '192.168.0.117'

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;

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

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.

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

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

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

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;

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:

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

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.

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

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

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

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

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

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.

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

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;

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

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

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