Saya memiliki program node.js sederhana yang berjalan di mesin saya dan saya ingin mendapatkan alamat IP lokal PC tempat program saya berjalan. Bagaimana cara mendapatkannya dengan 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 pada saat ini tidak berfungsi di windows. Menjalankan program untuk mem-parsing hasil tampaknya agak rapuh. Inilah yang saya gunakan.

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

Ini akan mengembalikan ip jaringan lokal antarmuka pertama Anda.

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

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

IP apa pun dari mesin Anda dapat Anda temukan dengan menggunakan modul os - dan itu asli dari NodeJS

var os = require( 'os' );

var networkInterfaces = os.networkInterfaces( );

console.log( networkInterfaces );

Yang perlu Anda lakukan hanyalah memanggil os.networkInterfaces () dan Anda akan mendapatkan daftar yang mudah dikelola - lebih mudah daripada menjalankan ifconfig oleh liga

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

Terbaik

Edoardo

Berikut ini adalah potongan kode node.js yang akan mem-parsing output dari ifconfigdan (asinkron) mengembalikan alamat IP pertama yang ditemukan:

(diuji hanya pada MacOS Snow Leopard; harap ini berfungsi di linux juga)

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

Contoh penggunaan:

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

Jika parameter kedua adalah true, fungsi akan melakukan panggilan sistem setiap kali; jika tidak, nilai yang di-cache digunakan.

Versi terbaru

Mengembalikan array semua alamat jaringan lokal.

Diuji pada Ubuntu 11.04 dan 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);
        });
    };
})();

Contoh Penggunaan untuk versi yang diperbarui

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

Inilah metode utilitas saya untuk mendapatkan alamat IP lokal, dengan asumsi Anda mencari alamat IPv4 dan mesin hanya memiliki satu antarmuka jaringan nyata. Itu bisa dengan mudah di refactored untuk mengembalikan array IPs untuk mesin multi-interface.

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

Instal modul yang disebut ip like

npm install ip

kemudian gunakan kode ini.

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

Memanggil ifconfig sangat bergantung pada platform, dan lapisan jaringan tidak tahu alamat ip yang digunakan soket, jadi yang terbaik adalah menanyakannya. Node tidak memaparkan metode langsung untuk melakukan ini, tetapi Anda dapat membuka soket apa pun, dan bertanya apa alamat IP lokal yang digunakan. Misalnya, membuka soket ke 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');
  });
}

Kasus penggunaan:

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

IP lokal Anda selalu 127.0.0.1.

Lalu ada IP jaringan, yang bisa Anda dapatkan dari ifconfig(* nix) atau ipconfig(win). Ini hanya berguna dalam jaringan lokal.

Lalu ada IP eksternal / publik Anda, yang hanya bisa Anda dapatkan jika Anda entah bagaimana bisa meminta router untuk itu, atau Anda dapat mengatur layanan eksternal yang mengembalikan alamat IP klien setiap kali mendapat permintaan. Ada juga layanan lain yang ada, seperti whatismyip.com.

Dalam beberapa kasus (misalnya jika Anda memiliki koneksi WAN) IP jaringan dan IP publik adalah sama, dan keduanya dapat digunakan secara eksternal untuk mencapai komputer Anda.

Jika IP jaringan dan publik Anda berbeda, Anda mungkin harus meminta router jaringan Anda meneruskan semua koneksi yang masuk ke ip jaringan Anda.

Pembaruan 2013:

Ada cara baru untuk melakukan ini sekarang, Anda dapat memeriksa objek soket koneksi Anda untuk properti bernama localAddress, misalnya net.socket.localAddress. Ini mengembalikan alamat di ujung soket Anda.

Cara termudah adalah dengan hanya membuka port acak dan mendengarkannya, lalu dapatkan alamat Anda dan tutup soketnya.

Pembaruan 2015:

Sebelumnya tidak berfungsi lagi.

gunakan modul ip npm

var ip = require('ip');

console.log(ip.address());

> '192.168.0.117'

Satu liner yang tepat untuk garis bawah dan lodash adalah:

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

Inilah yang mungkin jawaban paling bersih dan paling sederhana tanpa ketergantungan & yang bekerja di semua platform.

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

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

Yang saya tahu adalah saya ingin alamat IP dimulai dengan 192.168.. Kode ini akan memberi Anda hal itu:

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

Tentu saja Anda hanya dapat mengubah angka jika Anda mencari yang berbeda.

untuk penggunaan Linux dan MacOS, jika Anda ingin mendapatkan IP Anda dengan cara sinkron, coba ini.

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

hasilnya akan seperti ini.

[ '192.168.3.2', '192.168.2.1' ]

Saya menulis modul Node.js yang menentukan alamat IP lokal Anda dengan melihat antarmuka jaringan mana yang berisi gateway default Anda.

Ini lebih dapat diandalkan daripada memilih antarmuka dari os.networkInterfaces()atau pencarian DNS dari nama host. Ia dapat mengabaikan antarmuka virtual VMware, loopback, dan antarmuka VPN, dan itu berfungsi pada Windows, Linux, Mac OS, dan FreeBSD. Di bawah tenda, ia menjalankan route.exeatau netstatmem-parsing output.

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

Berikut ini adalah versi sederhana dalam javascript vanilla untuk mendapatkan satu 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';
}

Bagi siapa pun yang tertarik dengan singkatnya, berikut adalah beberapa "satu-liners" yang tidak memerlukan plugins / dependensi yang bukan bagian dari instalasi Node standar:

IPv4 publik dan IPv6 dari eth0 sebagai Array:

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

IP Publik pertama eth0 (biasanya IPv4) sebagai String:

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

Google mengarahkan saya ke pertanyaan ini sambil mencari "node.js mendapatkan server ip" , jadi mari kita berikan jawaban alternatif bagi mereka yang mencoba mencapai ini dalam program server node.js mereka (mungkin seperti poster asli).

Dalam kasus yang paling sepele di mana server hanya terikat pada satu alamat IP, seharusnya tidak perlu menentukan alamat IP karena kita sudah tahu ke alamat mana kita mengikatnya (mis. Parameter kedua dilewatkan ke listen() fungsi).

Dalam kasus yang kurang sepele di mana server terikat ke beberapa alamat IP, kita mungkin perlu menentukan alamat IP dari antarmuka yang terhubung dengan klien. Dan seperti yang disarankan oleh Tor Valamo, saat ini, kita dapat dengan mudah mendapatkan informasi ini dari soket yang terhubung dan localAddresspropertinya.

Misalnya, jika programnya adalah server web:

var http = require("http")

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

Dan jika itu adalah server TCP generik:

var net = require("net")

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

Saat menjalankan program server, solusi ini menawarkan portabilitas, akurasi, dan efisiensi yang sangat tinggi.

Untuk detail lebih lanjut, lihat:

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

Berdasarkan komentar di atas, inilah yang bekerja untuk versi Node saat ini:

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

Komentar pada salah satu jawaban di atas tidak ada panggilan values(). Sepertinya os.networkInterfaces()sekarang mengembalikan objek, bukan array.

Berikut adalah variasi dari contoh di atas. Dibutuhkan perhatian untuk menyaring antarmuka vMware dll. Jika Anda tidak lulus indeks itu mengembalikan semua alamat jika tidak, Anda mungkin ingin menetapkannya secara default ke 0 kemudian hanya lulus nol untuk mendapatkan semua, tetapi Anda akan mengatasinya. Anda juga bisa menambahkan argumen lain untuk filter regex jika ingin menambahkan

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

Saya bisa melakukan ini hanya dengan menggunakan simpul js

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

Sebagai skrip bash (perlu simpul js diinstal)

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

Inilah varian saya yang memungkinkan mendapatkan alamat IPv4 dan IPv6 secara portabel:

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

Berikut adalah versi CoffeeScript dari fungsi yang sama:

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

Contoh output untuk 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' } }

Jika Anda menyukai semua singkatnya, ini dia menggunakan 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);

Mirip dengan jawaban lain tetapi lebih ringkas:

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

Satu liner untuk MAC atau alamat localhost pertama saja.

Saat mengembangkan aplikasi di mac os, dan ingin mengujinya di telepon, dan perlu aplikasi Anda untuk memilih ip hosting lokal secara otomatis.

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

Ini hanya untuk menyebutkan bagaimana Anda dapat mengetahui alamat ip secara otomatis. Untuk menguji ini, Anda dapat pergi ke terminal hit

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

output akan menjadi alamat ip localhost Anda.

Berikut adalah satu-liner kecil yang rapi untuk Anda yang melakukan ini secara fungsional:

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

Sering kali saya menemukan ada beberapa interface menghadap internal dan eksternal yang tersedia (misalnya: 10.0.75.1, 172.100.0.1, 192.168.2.3), dan itu adalah salah satu eksternal bahwa aku benar-benar setelah ( 172.100.0.1).

Jika ada orang lain yang memiliki kepedulian yang sama, berikut ini satu lagi yang diharapkan dapat membantu ...

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;

Saya menggunakan node.js 0.6.5

$ node -v
v0.6.5

Inilah yang saya lakukan

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

Berikut ini adalah versi multi-ip dari jawaban jhurliman di atas:

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

Saya menyadari ini adalah utas lama, tetapi saya ingin menawarkan peningkatan pada jawaban teratas karena alasan berikut:

• Kode harus sejelas mungkin.
• Menghitung menggunakan array untuk ... in ... harus dihindari.

• untuk ... dalam ... enumerasi harus divalidasi untuk memastikan objek yang disebutkan di atas berisi properti yang Anda cari. Karena javsacript diketik secara longgar dan for ... in ... dapat diserahkan objek arbitrase apa pun untuk ditangani; lebih aman untuk memvalidasi properti yang kami cari tersedia.

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