os.networkInterfaces à partir de maintenant ne fonctionne pas sur windows. exécuter des programmes pour analyser les résultats semble un peu difficile. Voici ce que j'utilise.

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

cela devrait retourner votre première ip locale d'interface réseau.

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

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

N'importe quelle IP de votre machine que vous pouvez trouver en utilisant le OS module-et qui est natif à NodeJS

var os = require( 'os' );

var networkInterfaces = os.networkInterfaces( );

console.log( networkInterfaces );

Tout ce que vous avez à faire est d'appeler os.networkInterfaces() et vous obtiendrez une gestion aisée de liste plus facile que de ifconfig par les ligues

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

Meilleur

Edoardo

voici un morceau de noeud.code js qui analysera la sortie de ifconfig et (asynchrone) retournera la première adresse IP trouvée:

(testé sur MacOS Snow Leopard seulement; espérons qu'il fonctionne sur linux aussi)

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

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

exemple d'utilisation:

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

si le second paramètre est true , la fonction exécutera un appel système à chaque fois; sinon, la valeur mise en cache est utilisée.

mise à Jour de la version

renvoie un tableau de toutes les adresses réseau locales.

testé sur Ubuntu 11.04 et 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, '')
                if (!ignoreRE.test(ip)) {
                    cached.push(ip);
                }
            }
            //}
            callback(error, cached);
        });
    };
})();

exemple d'utilisation pour la version mise à jour

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

voici ma méthode utilitaire pour obtenir l'adresse IP locale, en supposant que vous êtes à la recherche d'une adresse IPv4 et que la machine n'a qu'une interface réseau réelle. Il pourrait facilement être refactorisé pour retourner un tableau D'IPs pour les machines multi-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';
}

appeler ifconfig est très dépendant de la plate-forme, et la couche réseau sait quelles adresses ip une socket est sur, donc le mieux est de le demander. Node n'expose pas de méthode directe pour faire cela, mais vous pouvez ouvrir n'importe quelle socket, et demander quelle adresse IP locale est utilisée. Par exemple, ouvrir une prise 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');
  });
}

cas D'utilisation:

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

installer un module appelé ip like

npm install ip

alors utilisez ce code.

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

votre adresse IP locale est toujours 127.0.0.1.

puis il y a L'IP réseau, que vous pouvez obtenir à partir de ifconfig (*nix) ou ipconfig (win). Cela n'est utile qu'au sein du réseau local.

ensuite il y a votre adresse IP externe/publique, que vous ne pouvez obtenir que si vous pouvez d'une manière ou d'une autre le demander au routeur, ou vous pouvez configurer un service externe qui renvoie l'adresse IP du client à chaque fois qu'il reçoit une demande. Il existe également d'autres services de ce type dans les existence, comme whatismyip.com.

dans certains cas (par exemple si vous avez une connexion WAN), L'IP réseau et L'IP publique sont les mêmes, et peuvent toutes deux être utilisées à l'extérieur pour atteindre votre ordinateur.

si votre réseau et vos IPs publics sont différents, vous devrez peut-être demander à votre routeur de rediriger toutes les connexions entrantes vers votre ip réseau.

mise à jour 2013:

Il y a une nouvelle façon de le faire maintenant, vous pouvez vérifier l'objet socket de votre connexion pour une propriété appelée localAddress , par exemple net.socket.localAddress . Il renvoie l'adresse de votre fin de la prise.

la manière la plus simple est d'ouvrir un port aléatoire et d'écouter dessus, puis d'obtenir votre adresse et fermer la socket.

mise à jour 2015:

le précédent ne fonctionne plus.

la bonne doublure pour souligne et lodash est:

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

utiliser npm module ip

var ip = require('ip');

console.log(ip.address());

> '192.168.0.117'

Voici une version simplifiée en JavaScript vanille pour obtenir une seule 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';
}

pour toute personne intéressée par la brièveté, voici quelques "mono-liners" qui ne nécessitent pas de plugins/dépendances qui ne font pas partie d'une installation de Noeud standard:

Public IPv4 et IPv6 de eth0 comme un Tableau:

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

première IP publique de eth0 (généralement IPv4) comme chaîne de caractères:

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

pour les utilisations Linux et MacOS, si vous voulez obtenir votre IPs d'une manière synchrone, essayez ceci.

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

le résultat sera quelque chose comme cela.

[ '192.168.3.2', '192.168.2.1' ]

Google m'a dirigé vers cette question en cherchant "noeud.js get server ip " , alors donnons une réponse alternative pour ceux qui essaient d'atteindre ceci dans leur noeud.js serveur du programme (peut-être le texte original de l'affiche).

dans le cas le plus trivial où le serveur est lié à une seule adresse IP, il ne devrait pas être nécessaire de déterminer l'adresse IP car nous savons déjà à quelle adresse nous lié (ex. deuxième paramètre passé à la fonction listen() ).

Dans les cas trivial où le serveur est lié à plusieurs adresses IPs, nous pouvons avoir besoin pour déterminer l'adresse IP de l'interface à laquelle un client connecté. Et comme l'a brièvement suggéré Tor Valamo, de nos jours, nous pouvons facilement obtenir cette information à partir de la socket connectée et de sa propriété localAddress .

Par exemple, si le programme est un serveur web:

var http = require("http")

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

et si c'est un serveur TCP Générique:

var net = require("net")

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

lors de l'exécution d'un programme serveur, cette solution offre une très grande portabilité, précision et efficacité.

pour plus de détails, voir:

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

basé sur un commentaire ci-dessus, voici ce qui fonctionne pour la version actuelle 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();

le commentaire sur l'une des réponses ci-dessus manquait l'appel à values() . Il semble que os.networkInterfaces() retourne maintenant un objet au lieu d'un tableau.

voici une variante des exemples ci-dessus. Il prend soin de filtrer les interfaces vMware etc. Si vous ne passez pas un index, il renvoie toutes les adresses, sinon vous pourriez vouloir le définir par défaut à 0, puis passer null pour obtenir tout, mais vous réglerez cela. Vous pouvez également passer dans un autre arg pour le filtre regex si ainsi incliné à ajouter

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

j'ai écrit un noeud .module js qui détermine votre adresse IP locale en regardant quelle interface réseau contient votre passerelle par défaut.

C'est plus fiable que de choisir une interface à partir des recherches os.networkInterfaces() ou DNS du nom d'hôte. Il est capable d'ignorer les interfaces virtuelles VMware, les interfaces loopback et VPN, et il fonctionne sous Windows, Linux, Mac OS et FreeBSD. Sous le capot, il exécute route.exe ou netstat et parses sortie.

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

Tout ce que je sais, c'est que je voulais l'adresse IP commençant par 192.168. . Ce code vous donnera 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;
            }
        }
    }
}

bien sûr, vous pouvez simplement changer les nombres si vous cherchez un autre.

si vous êtes dans toute la brièveté chose, ici, il est d'utiliser 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);

Un liner pour MAC os abord l'adresse localhost.

lors du développement d'applications sur Mac os, et que vous voulez le tester sur le téléphone, et besoin de votre application pour choisir l'ip localhost automatiquement.

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

c'est juste pour mentionner comment vous pouvez trouver l'adresse ip automatiquement. Pour tester cela, vous pouvez aller au terminal hit

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

La sortie

sera votre adresse ip locale Adresse.

j'utilise node.js 0.6.5

$ node -v
v0.6.5

Voici ce que je fais

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

Voici une version multi-ip de la réponse de jhurliman ci-dessus:

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

je me rends compte que c'est un vieux fil, mais je voudrais offrir une amélioration sur la réponse supérieure pour les raisons suivantes:

• doit être aussi explicite que possible.
• énumérer sur un tableau en utilisant pour...dans devrait être évité.

• de...à... énumération doivent être validés pour s'assurer de l'objet qui sont énumérés sur contient la propriété que vous recherchez. Comme javsaccript est mal dactylographié et le pour...dans ... peut être remis n'importe quel objet d'arbitrage à manipuler; il est plus sûr de valider la propriété que nous cherchons 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);
  

espérons que cette aide

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

voici ma variante qui permet d'obtenir les adresses IPv4 et IPv6 d'une manière portable:

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

Voici une version CoffeeScript de la même fonction:

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

exemple de sortie pour 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' } }

semblable à d'autres réponses, mais plus succinct:

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

Voici une jolie petite doublure pour vous qui fait cela fonctionnellement:

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

j'ai pu le faire en utilisant juste le noeud js

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

Comme script bash (besoins node js installé)

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

voici une variante qui vous permet d'obtenir une adresse ip locale (Testée sur Mac et Win):

var
    // Local ip address that we're trying to calculate
    address
    // Provides a few basic operating-system related utility functions (built-in)
    ,os = require('os')
    // Network interfaces
    ,ifaces = os.networkInterfaces();


// Iterate over interfaces ...
for (var dev in ifaces) {

    // ... and find the one that matches the criteria
    var iface = ifaces[dev].filter(function(details) {
        return details.family === 'IPv4' && details.internal === false;
    });

    if(iface.length > 0) address = iface[0].address;
}

// Print the result
console.log(address); // 10.25.10.147