Makinemde çalışan basit bir node.js programım var ve programımın çalıştığı bilgisayarın yerel IP adresini almak istiyorum. Node.js ile nasıl edinebilirim?

'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 şu an için pencerelerde çalışmıyor. Sonuçları ayrıştırmak için programları çalıştırmak biraz iffy görünüyor. İşte kullandığım.

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

Bu, ilk ağ arabiriminizi yerel ip döndürmelidir.

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

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

Makinenizin Herhangi IP kullanarak bulabilirsiniz os modülü - ve işte yerli NodeJS için

var os = require( 'os' );

var networkInterfaces = os.networkInterfaces( );

console.log( networkInterfaces );

Yapmanız gereken tek şey os.networkInterfaces () öğesini çağırmak ve kolay yönetilebilir bir liste elde etmek - ligler tarafından ifconfig çalıştırmaktan daha kolay

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

En iyi

Edoardo

ifconfigBulunan ilk IP adresini çıktısını ayrıştıracak ve (eşzamansız olarak) döndürecek bir node.js kod snippet'i :

(yalnızca MacOS Snow Leopard'da test edildi; umarım linux'da da çalışır)

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

Kullanım örneği:

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

İkinci parametre ise true, işlev her seferinde bir sistem çağrısı yürütür; aksi takdirde önbellek değeri kullanılır.

Güncellenmiş versiyon

Tüm yerel ağ adreslerinin bir dizisini döndürür.

Ubuntu 11.04 ve Windows XP 32 üzerinde test edilmiştir

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

Güncellenmiş sürüm için Kullanım Örneği

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

IPv4 adresi aradığınızı ve makinenin yalnızca bir gerçek ağ arabirimi olduğunu varsayarsak, yerel IP adresini almak için yardımcı yöntemim. Çok arayüzlü makineler için bir dizi IP döndürmek kolayca yeniden düzenlenebilir.

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

İp like adlı bir modül kurun

npm install ip

sonra bu kodu kullanın.

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

İfconfig çok platforma bağlıdır ve ağ katmanı bir soketin hangi IP adreslerinde olduğunu bilir, bu yüzden en iyisi sormaktır. Düğüm, bunu yapmak için doğrudan bir yöntem göstermez, ancak herhangi bir soketi açabilir ve hangi yerel IP adresinin kullanımda olduğunu sorabilirsiniz. Örneğin, www.google.com adresine bir yuva açma:

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

Kullanım durumda:

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

Yerel IP'niz her zaman 127.0.0.1'dir.

Sonra ifconfig(* nix) veya ipconfig(win) ' den alabileceğiniz ağ IP'si vardır . Bu yalnızca yerel ağda kullanışlıdır.

Daha sonra harici / genel IP'niz var, ancak yönlendiriciden bir şekilde isteyebilirsiniz veya bir istek aldığında istemci IP adresini döndüren harici bir hizmet kurabilirsiniz. Whatismyip.com gibi başka hizmetler de var.

Bazı durumlarda (örneğin bir WAN bağlantınız varsa) ağ IP'si ve genel IP aynıdır ve her ikisi de bilgisayarınıza erişmek için harici olarak kullanılabilir.

Ağınız ve genel IP'leriniz farklıysa, ağ yönlendiricinizin gelen tüm bağlantıları ağ IP'nize yönlendirmesi gerekebilir.

2013 Güncellemesi:

Bunu şimdi yapmanın yeni bir yolu var, bağlantınızın soket nesnesini localAddress, ör net.socket.localAddress. Soketin sonundaki adresi döndürür.

En kolay yol, rastgele bir bağlantı noktası açmak ve dinlemek, ardından adresinizi almak ve soketi kapatmaktır.

2015 Güncellemesi:

Bir önceki artık çalışmıyor.

npm ip modülünü kullan

var ip = require('ip');

console.log(ip.address());

> '192.168.0.117'

Her ikisi için de doğru bir liner çizgi ve lodash geçerli:

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

İşte bağımlılıklar olmadan en temiz, en basit cevap ne olabilir ve tüm platformlarda çalışır.

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

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

Tek bildiğim IP adresinin başlamasını istemem 192.168.. Bu kod size şunları verecektir:

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

Tabii ki farklı bir numara arıyorsanız sayıları değiştirebilirsiniz.

Linux ve MacOS kullanımları için, IP'lerinizi senkronize bir şekilde almak istiyorsanız bunu deneyin.

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

sonuç böyle bir şey olacaktır.

[ '192.168.3.2', '192.168.2.1' ]

Hangi ağ arabiriminin varsayılan ağ geçidinizi içerdiğine bakarak yerel IP adresinizi belirleyen bir Node.js modülü yazdım .

Bu, os.networkInterfaces()ana bilgisayar adından bir arayüz veya DNS aramaları seçmekten daha güvenilirdir . VMware sanal arabirimlerini, geri döngü ve VPN arabirimlerini yok sayabilir ve Windows, Linux, Mac OS ve FreeBSD'de çalışır. Kaputun altında, çıkışı yürütür route.exeveya netstatayrıştırır.

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

İşte tek bir ip elde etmek için vanilya javascript basitleştirilmiş bir sürümü:

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

Kısaca ilgilenen herkes için, burada standart bir Düğüm kurulumunun parçası olmayan eklentiler / bağımlılıklar gerektirmeyen bazı "tek gömlekler" vardır:

Array olarak eth0'un genel IPv4 ve IPv6:

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

Dize olarak eth0'ın ilk Genel IP'si (genellikle IPv4):

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

Google "node.js get server ip" araması yaparken beni bu soruya yönlendirdi , bu yüzden node.js sunucu programlarında bunu başarmaya çalışanlar için alternatif bir cevap verelim (orijinal posterde olabilir).

Sunucunun yalnızca bir IP adresine bağlı olduğu en önemsiz durumda, hangi adresi bağladığımızı zaten bildiğimizden IP adresini belirlemeye gerek yoktur (örn. İşleve ikinci parametre geçti listen()).

Sunucunun birden çok IP adresine bağlı olduğu daha az önemsiz durumlarda, istemcinin bağlandığı arabirimin IP adresini belirlememiz gerekebilir. Tor Valamo tarafından kısaca önerildiği gibi, bugünlerde, bu bilgileri bağlı soketten ve localAddressözelliğinden kolayca alabiliriz .

Örneğin, program bir web sunucusuysa:

var http = require("http")

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

Ve eğer genel bir TCP sunucusu ise:

var net = require("net")

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

Bir sunucu programı çalıştırırken, bu çözüm çok yüksek taşınabilirlik, doğruluk ve verimlilik sunar.

Daha fazla ayrıntı için bkz:

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

Yukarıdaki yoruma dayanarak, Düğümün mevcut sürümü için çalışanlar:

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

Yukarıdaki cevaplardan birinin yorumunda yapılan çağrı eksikti values(). Artık os.networkInterfaces()dizi yerine bir nesne döndürüyor gibi görünüyor .

Yukarıdaki örneklerin bir varyasyonudur. VMware arayüzlerini vb. Filtrelemekle ilgilenir. Bir dizini geçmezseniz tüm adresleri döndürür, aksi takdirde varsayılanı 0'a ayarlamak isteyebilirsiniz, ardından hepsini almak için null değerini iletin, ancak bunu sıralarsınız. Ekleme eğilimi varsa normal ifade filtresi için başka bir argüman da iletebilirsiniz

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

Ben sadece js düğümü kullanarak bunu başardı

Node JS olarak

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

Bh betiği olarak (js düğümünün kurulu olması gerekir)

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

IPv4 ve IPv6 adreslerinin her ikisini de taşınabilir bir şekilde almayı sağlayan değişkenim:

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

İşte aynı işlevin bir CoffeeScript sürümü:

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

İçin örnek çıktı 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' } }

Eğer bütün kıskançlık içindeyseniz , burada lodash kullanıyor :

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

Diğer cevaplara benzer ancak daha kısa ve öz:

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

Sadece MAC os ilk localhost adresi için bir astar.

Mac OS üzerinde uygulamalar geliştirirken ve telefonda test etmek istiyorsanız ve localhost ip'i otomatik olarak seçmek için uygulamanıza ihtiyacınız var.

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

Bu sadece ip adresini otomatik olarak nasıl bulacağınızdan bahsetmektir. Bunu test etmek için terminal isabetine gidebilirsiniz

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

çıktı sizin localhost ip Adresiniz olacaktır.

İşte sizin için bunu işlevsel olarak yapan düzgün bir küçük astar:

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

(: Örnek bulabilirim Birçok kez çok sayıda iç ve dış kaplama arayüzleri mevcut bulunmaktadır 10.0.75.1, 172.100.0.1, 192.168.2.3) ve ben sonra gerçekten olduğumu dış bir (var 172.100.0.1).

Başka birisinin benzer bir endişesi varsa, işte umarım biraz yardımcı olabilecek bir şey daha var ...

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;

Node.js 0.6.5 kullanıyorum

$ node -v
v0.6.5

İşte yaptığım şey

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

Yukarıdaki jhurliman'ın cevabının çok ipli bir versiyonu:

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

Bunun eski bir iş parçacığı olduğunu fark ettim, ancak aşağıdaki nedenlerden dolayı en iyi cevaba bir iyileştirme sunmak istiyorum:

• Kod olabildiğince açıklayıcı olmalıdır.
• For ... in ... kullanarak bir dizi üzerinde numaralandırma yapmaktan kaçınılmalıdır.

• için ... içinde ... numaralandırma nesnenin üzerinde numaralandırılmasının aradığınız özelliği içerdiğinden emin olmak için doğrulanmalıdır. Javsacript gevşek yazıldığından ve for ... in ... işlemek için herhangi bir keyfi nesne teslim edilebilir; aradığımız mülkü doğrulamak daha güvenlidir.

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