我有一个简单的node.js程序在我的机器上运行，我想获得运行我程序的PC的本地IP地址。我如何使用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
下划线和lodash的正确一个衬里是：
var ip = require('underscore')
.chain(require('os').networkInterfaces())
.values()
.flatten()
.find({family: 'IPv4', internal: false})
.value()
.address;
使用npm ip模块
var ip = require('ip');
console.log(ip.address());
> '192.168.0.117'
我所知道的是我想要以192.168.开头的IP地址。这段代码将为您提供：
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 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
});
这是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';
}
对于任何对简洁感兴趣的人，这里有一些“单行”不需要不属于标准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;
对于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' ]
Google在搜索“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的工作原理：
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来获取所有地址，但你会对它进行排序。如果倾向于添加，你也可以为正则表达式过滤器传入另一个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;
}
到目前为止，os.networkInterfaces在Windows上不起作用。 运行程序来解析结果似乎有点不确定。这是我使用的。
require('dns').lookup(require('os').hostname(), function (err, add, fam) {
console.log('addr: '+add);
})
这应该返回您的第一个网络接口本地IP。
这是我的变体，允许以可移植的方式获取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' } }
如果你是整个简洁的事情，这里是使用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);与其他答案类似但更简洁：
'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);
在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地址。
很多时候我发现有多个内部和外部接口可用（例如：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;
这可能是最简洁，最简单的答案，没有依赖关系，适用于所有平台。
const { lookup } = require('dns').promises;
const { hostname } = require('os');
async function getMyIPAddress(options) {
return (await lookup(hostname(), options))
.address;
}
我正在使用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);
这是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;
}
我意识到这是一个老线程，但我想提出最佳答案的改进，原因如下：
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);
希望这可以帮助
var os = require( 'os' );
var networkInterfaces = os.networkInterfaces( );
var arr = networkInterfaces['Local Area Connection 3']
var ip = arr[1].address;
https://github.com/indutny/node-ip
var ip = require("ip");
console.dir ( 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];
您可以使用os模块找到您机器的任何IP - 这是NodeJS的原生IP
var os = require( 'os' );
var networkInterfaces = os.networkInterfaces( );
console.log( networkInterfaces );
你需要做的就是调用os.networkInterfaces（），你将获得一个易于管理的列表 - 比联盟运行ifconfig更容易
http://nodejs.org/api/os.html#os_os_networkinterfaces
最好
爱德华多
这是一个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);
安装名为ip like的模块
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';
}
调用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);
}
});
您的本地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年更新：
以前不再适用了。