Javascript 在Node.js中获取本地IP地址

我有一个简单的Node.js程序在我的机器上运行，我想获得运行我的程序的PC的本地IP地址。如何使用Node.js获取它？

您的本地IP地址始终是127.0.0.1

然后是网络IP地址，您可以从

ifconfig

（*nix）或

ipconfig

（win）获取该地址。这仅在本地网络中有用

然后是您的外部/公共IP地址，只有当您以某种方式向路由器请求时，您才能获得该地址，或者您可以设置一个外部服务，该服务在收到请求时返回客户端IP地址。还有其他类似的服务，比如whatismyip.com

在某些情况下（例如，如果您有一个WAN连接），网络IP地址和公共IP是相同的，并且都可以在外部用于连接您的计算机

如果您的网络和公共IP地址不同，您可能需要让网络路由器将所有传入连接转发到您的网络IP地址

---

2013年更新：

现在有了一种新的方法。您可以在连接的套接字对象中检查名为

localAddress

的属性，例如

net.socket.localAddress

。它返回套接字一端的地址

最简单的方法是打开一个随机端口并监听它，然后获取您的地址并关闭套接字

---

2015年更新：

---

前一个不再有效。

这里是Node.js代码片段，它将解析

ifconfig

的输出，并（异步）返回找到的第一个IP地址：

（它只在（雪豹）上测试过；我希望它也能在Linux上工作。）

如果第二个参数为

true

，则函数将每次执行一次系统调用；否则将使用缓存的值

---

更新版本 返回所有本地网络地址的数组

在（Natty Narhall）和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);
        });
    };
})();

---

调用ifconfig非常依赖于平台，网络层确实知道套接字所在的IP地址，所以最好是询问它

Node.js没有公开直接的方法，但是您可以打开任何套接字，询问正在使用的本地IP地址。例如，打开套接字以：

使用案例：

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

---

此信息可以在对象中找到，该对象将网络接口名称映射到其属性（例如，一个接口可以有多个地址）：

“严格使用”；
const{networkInterfaces}=require（'os'）；
const nets=networkInterfaces（）；
const results=Object.create（null）；//或者只是“{}”，一个空对象
for（对象的常量名称。键（网络））{
for（常数网络[名称]）{
//跳过非IPv4和内部（即127.0.0.1）地址
如果（net.family==='IPv4'&&&！net.internal）{
如果（！结果[名称]）{
结果[名称]=[]；
}
结果[name].push（net.address）；
}
}
}

//“结果”
{
“en0”：[
"192.168.1.101"
],
“eth0”：[
"10.0.0.101"
],
"": [
"",
"",
"",
...
]
}

//结果[“en0”][0]
"192.168.1.101"

运行程序解析结果似乎有点不确定。这是我用的

require（'dns'）。查找（require（'os'）。主机名（），函数（err，add，fam）{
console.log（'addr:'+add）；
})

---

这将返回您的第一个网络接口本地IP地址。

假设您正在查找IPv4地址，并且机器只有一个真实的网络接口，那么下面是获取本地IP地址的实用方法。它可以很容易地进行重构，以返回多接口机器的IP地址数组

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

函数getIPAddress（）{ var interfaces=require（'os'）。networkInterfaces（）； for（接口中的变量devName）{ var iface=接口[devName]； 对于（变量i=0；i您可以使用操作系统模块找到的机器的任何IP地址-这是Node.js的本机IP地址：

var os = require('os');

var networkInterfaces = os.networkInterfaces();

console.log(networkInterfaces);

---

您所需要做的就是调用，您将得到一个易于管理的列表—比按联盟运行ifconfig更简单。

对于任何对简洁感兴趣的人来说，这里有一些“一行程序”，它们不需要标准Node.js安装以外的插件/依赖项：

将eth0的IPv4和IPv6地址作为一个数组公开：

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

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

作为字符串的eth0（通常是IPv4）的第一个公共IP地址：

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

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

---

谷歌在搜索“Node.js获取服务器IP”时向我提出了这个问题，因此，让我们为那些试图在Node.js服务器程序中实现这一点的人提供另一个答案（可能是原始海报的情况）

在服务器仅绑定到一个IP地址的最简单的情况下，应该不需要确定IP地址，因为我们已经知道将其绑定到哪个地址（例如，传递给

listen（）

函数的第二个参数）

在服务器绑定到多个IP地址的不太常见的情况下，我们可能需要确定客户端连接到的接口的IP地址。正如Tor Valamo所简要指出的，现在，我们可以很容易地从连接的套接字及其

localAddress

属性获取这些信息

例如，如果程序是web服务器：

var http = require("http")

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

如果是通用TCP服务器：

var net = require("net")

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

当运行服务器程序时，此解决方案提供了非常高的可移植性、准确性和效率

有关详细信息，请参阅：

---

根据评论，以下是Node.js当前版本的工作原理：

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

上述答案之一的注释缺少对

values（）var http = require("http")

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

var net = require("net")

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

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

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

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

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

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

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

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

['192.168.3.2', '192.168.2.1']

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

var ip = require('ip');

console.log(ip.address());

> '192.168.0.117'

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

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

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

npm install ip

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

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

/**
 * Get local IP address, while ignoring vEthernet IP addresses (like from Docker, etc.)
 */
let localIP;
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(ifname === 'Ethernet') {
         if (alias >= 1) {
            // This single interface has multiple IPv4 addresses
            // console.log(ifname + ':' + alias, iface.address);
         } else {
            // This interface has only one IPv4 address
            // console.log(ifname, iface.address);
         }
         ++alias;
         localIP = iface.address;
      }
   });
});
console.log(localIP);

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;

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

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

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

const ip = Object.values(require("os").networkInterfaces())
        .flat()
        .filter((item) => !item.internal && item.family === "IPv4")
        .find(Boolean).address;