我在我的机器上运行了一个简单的node.js程序，我希望获得运行我程序的PC的本地IP地址。我如何使用node.js获取它？
答案 0 :(得分：355)
'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
答案 1 :(得分：211)
os.networkInterfaces在Windows上不起作用。运行程序来解析结果似乎有些不确定。这是我使用的。
require('dns').lookup(require('os').hostname(), function (err, add, fam) {
console.log('addr: '+add);
})
这应该返回您的第一个网络接口本地IP。
答案 2 :(得分：167)
https://github.com/indutny/node-ip
var ip = require("ip");
console.dir ( ip.address() );
答案 3 :(得分：48)
您可以使用 os 模块找到您的计算机的任何IP - 并且原生到NodeJS
var os = require( 'os' );
var networkInterfaces = os.networkInterfaces( );
console.log( networkInterfaces );
您需要做的就是调用 os.networkInterfaces（），您将获得一个易于管理的列表 - 比联盟运行 ifconfig 更容易
http://nodejs.org/api/os.html#os_os_networkinterfaces
最佳
爱德华多
答案 4 :(得分：32)
这是一段node.js代码片段，它将解析ifconfig的输出并（异步）返回找到的第一个IP地址：
（仅在MacOS 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 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);
});
};
})();
用法示例：
getNetworkIP(function (error, ip) {
console.log(ip);
if (error) {
console.log('error:', error);
}
}, false);
如果第二个参数是true，则该函数每次都会执行一次系统调用;否则使用缓存的值。
返回所有本地网络地址的数组。
在Ubuntu 11.04和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);
答案 5 :(得分：26)
安装名为ip like
的模块npm install ip
然后使用此代码。
var ip = require("ip");
console.log( ip.address() );
答案 6 :(得分：25)
这是我获取本地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';
}
答案 7 :(得分：22)
调用ifconfig是非常依赖于平台的，并且网络层确实知道套接字所在的IP地址，所以最好是问它。 Node不公开直接执行此操作的方法，但您可以打开任何套接字，并询问正在使用的本地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);
}
});
答案 8 :(得分：19)
您的本地IP始终为127.0.0.1。
然后是网络IP，您可以从ifconfig（* nix）或ipconfig（获胜）获取。这仅在本地网络中有用。
然后有你的外部/公共IP，只有你能以某种方式询问路由器才能得到它，或者你可以设置一个外部服务，它会在收到请求时返回客户端IP地址。还有其他此类服务，如whatismyip.com。
在某些情况下（例如，如果您有WAN连接），网络IP和公共IP是相同的，并且都可以在外部用于到达您的计算机。
如果您的网络和公共IP不同，您可能需要让您的网络路由器将所有传入连接转发到您的网络IP。
2013年更新：
现在有一种新的方法，您可以检查连接的套接字对象是否有一个名为 localAddress的属性，例如net.socket.localAddress。它返回套接字末尾的地址。
最简单的方法是打开一个随机端口并监听它，然后获取你的地址并关闭套接字。
2015年更新：
之前的功能不再适用。
答案 9 :(得分：10)
下划线和 lodash 的正确一行：
var ip = require('underscore')
.chain(require('os').networkInterfaces())
.values()
.flatten()
.find({family: 'IPv4', internal: false})
.value()
.address;
答案 10 :(得分：9)
使用npm ip module
var ip = require('ip');
console.log(ip.address());
> '192.168.0.117'
答案 11 :(得分：7)
我所知道的是，我希望IP地址以numbers = [i for i in range(1,11)]
def table(num):
three = num * 3
four = num * 4
five = num * 5
six = num * 6
seven = num * 7
eight = num * 8
print(three,four,five,six,seven,eight)
answer = [i for i in numbers if table(i)]
开头。这段代码将为您提供：
3 4 5 6 7 8
6 8 10 12 14 16
9 12 15 18 21 24
12 16 20 24 28 32
15 20 25 30 35 40
18 24 30 36 42 48
21 28 35 42 49 56
24 32 40 48 56 64
27 36 45 54 63 72
30 40 50 60 70 80
当然，如果您正在寻找不同的数字，您可以更改数字。
答案 12 :(得分：6)
我写了一个Node.js module，通过查看哪个网络接口包含您的默认网关来确定您的本地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
});
答案 13 :(得分：5)
这是一个简单的vanilla 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';
}
答案 14 :(得分：4)
对于任何对简洁感兴趣的人，这里有一些不需要插件/依赖项的“单行”，这些插件/依赖项不属于标准的Node安装：
作为数组的eth0的公共IPv4和IPv6：
var ips = require('os').networkInterfaces().eth0.map(function(interface) {
return interface.address;
});
eth0的第一个公共IP（通常为IPv4）为String：
var ip = require('os').networkInterfaces().eth0[0].address;
答案 15 :(得分：4)
对于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' ]
答案 16 :(得分：3)
以下是上述示例的变形。它会过滤掉vMware接口等。如果你没有传递索引，它会返回所有地址，否则你可能想要将它设置为默认为0然后只传递null来获取所有地址，但是你要对它进行排序出。如果倾向于添加
，你也可以为正则表达式过滤器传递另一个arg 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;
}
答案 17 :(得分：3)
以下解决方案对我有用
const ip = Object.values(require("os").networkInterfaces())
.flat()
.filter((item) => !item.internal && item.family === "IPv4")
.find(Boolean).address;
答案 18 :(得分：3)
根据上面的评论，这里有什么用于当前版本的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();
上述答案之一的评论错过了对values()的调用。看起来os.networkInterfaces()现在返回一个对象而不是一个数组。
答案 19 :(得分：3)
Google在搜索＆＃34; node.js获取服务器IP＆＃34; 时指示我这个问题，所以让我们为那些试图实现目标的人提供一个替代答案这在他们的node.js 服务器程序中（可能是原始海报的情况）。
在服务器只绑定一个IP地址的最简单的情况下，应该不需要确定IP地址，因为我们已经知道我们绑定了哪个地址（例如，传递给{{1的第二个参数）功能）。
在服务器绑定到多个IP地址的不太重要的情况下，我们可能需要确定客户端连接的接口的IP地址。正如Tor Valamo简要建议的那样，现在，我们可以从连接的套接字及其listen()属性中轻松获取此信息。
例如，如果程序是Web服务器：
localAddress如果它是通用的TCP服务器：
var http = require("http")
http.createServer(function (req, res) {
console.log(req.socket.localAddress)
res.end(req.socket.localAddress)
}).listen(8000)
运行服务器程序时，此解决方案可提供极高的可移植性，准确性和效率。
有关详细信息，请参阅：
答案 20 :(得分：2)
在mac os上开发应用程序时，想要在手机上测试它，并且需要你的应用程序自动选择localhost ip。
require('os').networkInterfaces().en0.find(elm=>elm.family=='IPv4').address
这只是提到如何自动找出IP地址。 要测试这个，你可以去终端点击
node
os.networkInterfaces().en0.find(elm=>elm.family=='IPv4').address
输出将是您的localhost ip地址。
答案 21 :(得分：2)
我多次发现有多个内部和外部接口可用（例如：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;
答案 22 :(得分：2)
与其他答案类似，但更简洁：
'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);
答案 23 :(得分：2)
如果您对整个简洁事物感兴趣，请使用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);
答案 24 :(得分：2)
这是我的变体，允许以便携方式获取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' } }
答案 25 :(得分：1)
这是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;
}
答案 26 :(得分：1)
我意识到这是一个老话题，但我想提供最佳答案的改进，原因如下：
for ... in ... 枚举应该经过验证，以确保枚举的对象包含您正在寻找的属性。因为javsacript是松散类型的，并且 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);
答案 27 :(得分：1)
这里有一个整洁的小单行为你做这个功能：
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];
答案 28 :(得分：1)
这是对已接受答案的修改，它不考虑诸如Docker等的vEthernet IP。
/**
* Get local IP, while ignoring vEthernet IPs (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 adress
// console.log(ifname, iface.address);
}
++alias;
localIP = iface.address;
}
});
});
console.log(localIP);
这将返回类似192.168.2.169而非10.55.1.1
答案 29 :(得分：1)
希望这会有所帮助
var os = require( 'os' );
var networkInterfaces = os.networkInterfaces( );
var arr = networkInterfaces['Local Area Connection 3']
var ip = arr[1].address;
答案 30 :(得分：1)
我正在使用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);
答案 31 :(得分：1)
我仅使用节点js就可以做到这一点
作为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);
作为bash脚本（需要安装节点js）
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); """ }
答案 32 :(得分：0)
更大的问题是“为什么？”
如果您需要了解NODE正在收听的服务器，可以使用req.hostname。
答案 33 :(得分：0)
var ip = req.headers['x-forwarded-for'] || req.socket.remoteAddress
答案 34 :(得分：0)
我可能在这个问题上来晚了，但如果有人想要一个单行 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
答案 35 :(得分：0)
这可能是最干净，最简单的答案，没有依赖性，并且可以在所有平台上使用。
const { lookup } = require('dns').promises;
const { hostname } = require('os');
async function getMyIPAddress(options) {
return (await lookup(hostname(), options))
.address;
}
答案 36 :(得分：0)
要在节点js中获取IP地址，我们需要包括三个模块-connect，net和request-ip。如果您尚未安装这些模块，请首先使用npm安装这些模块。
此给定链接包含所需的解决方案，请仔细阅读-
答案 37 :(得分：0)
这是一个允许您获取本地IP地址的变体（在Mac和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
答案 38 :(得分：0)
接受的答案是异步的，我想要一个同步版本，希望这有助于某人。
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 ipaddress: " + alias.address);
return alias.address;
}
}
return false;
答案 39 :(得分：-1)
如果你不想安装依赖项并运行* 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
也是你的朋友; - ）
希望它有所帮助！
答案 40 :(得分：-2)
const internalIp = require("internal-ip")
console.log(internalIp.v4.sync())