[英]Get local IP address in Node.js
我有一个简单的 Node.js 程序在我的机器上运行,我想获取运行我的程序的 PC 的本地 IP 地址。 如何使用 Node.js 获得它?
此信息可以在os.networkInterfaces()
中找到,这是一个对象,将网络接口名称映射到其属性(例如,一个接口可以有多个地址):
'use strict';
const { networkInterfaces } = require('os');
const nets = networkInterfaces();
const results = Object.create(null); // Or just '{}', an empty object
for (const name of Object.keys(nets)) {
for (const net of nets[name]) {
// Skip over non-IPv4 and internal (i.e. 127.0.0.1) addresses
// 'IPv4' is in Node <= 17, from 18 it's a number 4 or 6
const familyV4Value = typeof net.family === 'string' ? 'IPv4' : 4
if (net.family === familyV4Value && !net.internal) {
if (!results[name]) {
results[name] = [];
}
results[name].push(net.address);
}
}
}
// 'results'
{
"en0": [
"192.168.1.101"
],
"eth0": [
"10.0.0.101"
],
"<network name>": [
"<ip>",
"<ip alias>",
"<ip alias>",
...
]
}
// results["en0"][0]
"192.168.1.101"
运行程序来解析结果似乎有点不确定。 这是我使用的。
require('dns').lookup(require('os').hostname(), function (err, add, fam) {
console.log('addr: ' + add);
})
这应该返回您的第一个网络接口本地 IP 地址。
https://github.com/indutny/node-ip
var ip = require("ip");
console.dir ( ip.address() );
您可以使用os模块找到您机器的任何 IP 地址 - 这是 Node.js 的原生地址:
var os = require('os');
var networkInterfaces = os.networkInterfaces();
console.log(networkInterfaces);
您需要做的就是调用os.networkInterfaces() ,您将获得一个易于管理的列表 - 比联盟运行ifconfig更容易。
安装一个名为ip
的模块,例如:
npm install ip
然后使用此代码:
var ip = require("ip");
console.log(ip.address());
这是我获取本地 IP 地址的实用方法,假设您正在寻找 IPv4 地址并且机器只有一个真实的网络接口。 它可以很容易地重构为返回多接口机器的 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';
}
下面是一段 Node.js 代码,它将解析ifconfig
的输出并(异步)返回找到的第一个 IP 地址:
(它仅在Mac OS X v10.6 (Snow Leopard) 上进行了测试;我希望它也可以在 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 OSes without the 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 IP addresses
var matches = stdout.match(filterRE);
// JavaScript doesn't have any lookbehind regular expressions, 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);
});
};
})();
使用示例:
getNetworkIP(function (error, ip) {
console.log(ip);
if (error) {
console.log('error:', error);
}
}, false);
如果第二个参数为true
,则函数每次都会执行一次系统调用; 否则使用缓存的值。
返回所有本地网络地址的数组。
在Ubuntu 11.04 (Natty Narwhal) 和 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);
});
};
})();
getNetworkIPs(function (error, ip) {
console.log(ip);
if (error) {
console.log('error:', error);
}
}, false);
使用 npm ip
模块:
var ip = require('ip');
console.log(ip.address());
> '192.168.0.117'
调用 ifconfig 非常依赖于平台,并且网络层确实知道套接字所在的 IP 地址,因此最好询问它。
Node.js 没有公开执行此操作的直接方法,但您可以打开任何套接字,并询问正在使用的本地 IP 地址。 例如,打开一个到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');
});
}
使用案例:
getNetworkIP(function (error, ip) {
console.log(ip);
if (error) {
console.log('error:', error);
}
});
您的本地 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 年更新:
以前的已经不行了。
Underscore.js和Lodash的正确单行代码是:
var ip = require('underscore')
.chain(require('os').networkInterfaces())
.values()
.flatten()
.find({family: 'IPv4', internal: false})
.value()
.address;
这可能是最干净,最简单的答案,没有依赖关系并且适用于所有平台。
const { lookup } = require('dns').promises;
const { hostname } = require('os');
async function getMyIPAddress(options) {
return (await lookup(hostname(), options))
.address;
}
我只知道我想要以192.168.
. 此代码将为您提供:
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;
}
}
}
}
当然,如果您正在寻找不同的数字,您可以更改数字。
我只使用 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);
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);
"""
}
这是一个简单的原生 JavaScript 版本,用于获取单个 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';
}
对于 Linux 和 macOS 使用,如果您想通过同步方式获取 IP 地址,请尝试以下操作:
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']
我编写了一个Node.js 模块,它通过查看哪个网络接口包含您的默认网关来确定您的本地 IP 地址。
这比从os.networkInterfaces()
或 DNS 查找主机名中选择接口更可靠。 它能够忽略 VMware 虚拟接口、环回和 VPN 接口,并且可以在 Windows、Linux、Mac OS 和 FreeBSD 上运行。 在后台,它执行route.exe
或netstat
并解析输出。
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
});
对于任何对简洁感兴趣的人,这里有一些不需要插件/依赖项的“单行”,这些插件/依赖项不是标准 Node.js 安装的一部分:
eth0 的公共 IPv4 和 IPv6 地址作为数组:
var ips = require('os').networkInterfaces().eth0.map(function(interface) {
return interface.address;
});
eth0 的第一个公共 IP 地址(通常是 IPv4)作为字符串:
var ip = require('os').networkInterfaces().eth0[0].address;
在 macOS 上开发应用程序时,您想在手机上对其进行测试,并且需要您的应用程序自动选择 localhost IP 地址。
require('os').networkInterfaces().en0.find(elm => elm.family=='IPv4').address
这只是提一下如何自动找到IP地址。 要对此进行测试,您可以转到终端命中
node
os.networkInterfaces().en0.find(elm => elm.family=='IPv4').address
输出将是您的本地主机 IP 地址。
我可能来晚了这个问题,但如果有人想要一个单一的 ES6 解决方案来获取 IP 地址数组,那么这应该可以帮助你:
Object.values(require("os").networkInterfaces())
.flat()
.filter(({ family, internal }) => family === "IPv4" && !internal)
.map(({ address }) => address)
作为
Object.values(require("os").networkInterfaces())
将返回一个数组数组,因此flat()
用于将其展平为单个数组
.filter(({ family, internal }) => family === "IPv4" && !internal)
将过滤数组以仅包含 IPv4 地址,如果它不是内部的
最后
.map(({ address }) => address)
将仅返回过滤后数组的 IPv4 地址
所以结果将是[ '192.168.xx.xx' ]
然后,您可以根据需要获取该数组的第一个索引或更改过滤条件
使用的OS
是 Windows
谷歌在搜索"Node.js get server 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()
的调用。 看起来os.networkInterfaces()
现在返回一个对象而不是数组。
这是前面示例的变体。 它会过滤掉VMware接口等。如果您不传递索引,它会返回所有地址。 否则,您可能希望将其设置为默认值 0,然后只传递 null 以获取所有内容,但您会对其进行排序。 如果愿意添加,您也可以为正则表达式过滤器传递另一个参数。
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;
}
如果您对整个简洁性感兴趣,那么这里使用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);
以下解决方案对我有用
const ip = Object.values(require("os").networkInterfaces())
.flat()
.filter((item) => !item.internal && item.family === "IPv4")
.find(Boolean).address;
var ip = req.headers['x-forwarded-for'] || req.socket.remoteAddress
利用:
var os = require('os');
var networkInterfaces = os.networkInterfaces();
var arr = networkInterfaces['Local Area Connection 3']
var ip = arr[1].address;
这是我的变体,它允许以可移植的方式获取 IPv4 和 IPv6 地址:
/**
* 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;
};
这是同一函数的 CoffeeScript 版本:
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
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' } }
与其他答案类似,但更简洁:
'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);
这是对已接受答案的修改,它不考虑 vEthernet IP 地址,例如Docker等。
/**
* 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);
这将返回一个类似192.168.2.169
而不是10.55.1.1
的 IP 地址。
很多时候,我发现有多个面向内部和外部的接口可用(例如: 10.0.75.1
、 172.100.0.1
、 192.168.2.3
),这是我真正追求的外部接口( 172.100.0.1
)。
如果其他人有类似的担忧,这里还有一个关于这个的看法,希望可能会有所帮助......
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;
这里的一些答案对我来说似乎不必要地过于复杂。 这是使用普通 Nodejs 的更好方法。
import os from "os";
const machine = os.networkInterfaces()["Ethernet"].map(item => item.family==="IPv4")
console.log(machine.address) //gives 192.168.x.x or whatever your local address is
这是jhurliman 答案的多 IP 地址版本:
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;
}
由于以下原因,对最佳答案的改进:
代码应尽可能不言自明。
应避免使用for...in...枚举数组。
for...in...枚举应该被验证以确保被枚举的对象包含您正在寻找的属性。 由于 JavaScript 是松散类型的,并且for...in...可以交给任意对象来处理; 验证我们正在寻找的属性是否可用更安全。
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);
这是一个简洁的小单线,它在功能上做到了这一点:
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];
我正在使用 Node.js 0.6.5:
$ node -v
v0.6.5
这是我所做的:
var util = require('util');
var exec = require('child_process').exec;
function puts(error, stdout, stderr) {
util.puts(stdout);
}
exec("hostname -i", puts);
这是一个允许您获取本地 IP 地址的变体(在 Mac 和 Windows 上测试):
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
更大的问题是“为什么?”
如果您需要知道 Node.js 实例正在侦听的服务器,可以使用req.hostname
。
接受的答案是异步的。 我想要一个同步版本:
var os = require('os');
var ifaces = os.networkInterfaces();
console.log(JSON.stringify(ifaces, null, 4));
for (var iface in ifaces) {
var iface = ifaces[iface];
for (var alias in iface) {
var alias = iface[alias];
console.log(JSON.stringify(alias, null, 4));
if ('IPv4' !== alias.family || alias.internal !== false) {
debug("skip over internal (i.e. 127.0.0.1) and non-IPv4 addresses");
continue;
}
console.log("Found IP address: " + alias.address);
return alias.address;
}
}
return false;
使用内部 IP :
const internalIp = require("internal-ip")
console.log(internalIp.v4.sync())
如果您不想安装依赖项并且正在运行 *nix 系统,您可以执行以下操作:
hostname -I
您将获得主机的所有地址,您可以在节点中使用该字符串:
const exec = require('child_process').exec;
let cmd = "hostname -I";
exec(cmd, function(error, stdout, stderr)
{
console.log(stdout + error + stderr);
});
是一个单一的衬里,你不需要像'os'或'node-ip'这样的其他库,它们可能会给你的代码增加意外的复杂性。
hostname -h
也是你的朋友;-)
希望能帮助到你!
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.