node.jsでローカルIPアドレスを取得する
私は自分のマシン上で走っている簡単な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
os.networkInterfacesは今のところWindows上では動作しません。 結果を解析するためにプログラムを実行するのは少し不確かなようです。これが私が使っているものです。
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() );
あなたのマシンの任意のIPはosモジュールを使って見つけることができます - そしてそれはNodeJSに固有のネイティブです
var os = require( 'os' );
var networkInterfaces = os.networkInterfaces( );
console.log( networkInterfaces );
あなたがする必要があるのは、os.networkInterfaces（）を呼び出すだけで、簡単に管理できるリストが得られます - リーグでifconfigを実行するよりも簡単です。
http://nodejs.org/api/os.html#os_os_networkinterfaces
ベスト
エドアルド
これはifconfigの出力を解析し、（非同期的に）見つかった最初のIPアドレスを返すnode.jsコードの断片です。
（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);
2番目のパラメータが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() );
あなたがIPv4アドレスを探していて、マシンがただ1つの本当のネットワークインターフェースを持っていると仮定して、これはローカル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';
}
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です。
それからあなたがifconfig（* nix）またはipconfig（win）から得ることができるネットワークIPがあります。これはローカルネットワーク内でのみ役に立ちます。
それからあなたがどういうわけかそれをルータに依頼することができる場合にのみ得ることができるあなたの外部/パブリックIPがあります、またはそれが要求を受けるたびにクライアントIPアドレスを返す外部サービスをセットアップすることができます。 whatismyip.comのように、存在する他のそのようなサービスもあります。
場合によっては（たとえば、WAN接続がある場合）、ネットワークIPとパブリックIPは同じであり、どちらも外部から使用してコンピュータにアクセスできます。
ネットワークとパブリックIPが異なる場合は、ネットワークルーターにすべての着信接続をネットワークIPに転送させる必要があります。
更新2013：
今これをする新しい方法があります、あなたはlocalAddressと呼ばれるプロパティのためにあなたの接続のソケットオブジェクトをチェックすることができます、例えば： net.socket.localAddress。それはあなたのソケットの端のアドレスを返します。
最も簡単な方法は、ランダムなポートを開いてそれを監視してから、自分のアドレスを取得してソケットを閉じることです。
アップデート2015：
前のものはもう動作しません。
下線とlodashの両方に対して正しい1つのライナーは、
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;
}
}
}
}
もちろん別の番号を探しているのであれば、番号を変更することもできます。
どのネットワークインターフェースにデフォルトゲートウェイが含まれているかを調べることで、ローカルIPアドレスを決定する Node.jsモジュール を書きました。
これは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
});
これは、単一のipを取得するためのVanilla javascriptの簡易版です。
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インストールの一部ではないプラグイン/依存関係を必要としないいくつかの "ワンライナー"があります：
配列としての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;
Googleが "node.js get server ip"を検索しながらこの質問に私を向けたので、彼らのnode.jsでこれを達成しようとしている人のための代替回答を与えましょうサーバープログラム（元のポスターの場合もあります）。
サーバが1つのIPアドレスのみにバインドされている最も些細なケースでは、どのアドレスにバインドされているかがすでにわかっているので、IPアドレスを特定する必要はありません（たとえばlisten()関数に渡される2番目のパラメータ）。
サーバーが複数の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)
サーバープログラムを実行するとき、このソリューションは非常に高い移植性、正確さと効率を提供します。
詳しくは、以下を参照してください。
これは上記の例の変形です。 vMwareのインターフェースなどを除外するように注意してください。インデックスを渡さない場合はすべてのアドレスを返します。追加する傾向がある場合は、正規表現フィルタに別の引数を渡すこともできます。
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;
}
上記のコメントに基づき、これが現在のバージョンの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();
上記の答えの1つに対するコメントにvalues()の呼び出しがありませんでした。 os.networkInterfaces()は配列ではなくオブジェクトを返すようになりました。
他の回答と似ていますが、より簡潔です。
'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);
移植可能な方法で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);MAC用の1つのライナーは最初のローカルホストアドレスのみです。
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;
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);
これは、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のようなIPを返します。
お役に立てれば
var os = require( 'os' );
var networkInterfaces = os.networkInterfaces( );
var arr = networkInterfaces['Local Area Connection 3']
var ip = arr[1].address;
私はちょうどノードjsを使ってこれをすることができました
ノード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); """ }
私はこれが古いスレッドであることを認識していますが、私は以下の理由でトップの答えに改善を提供したいと思います。
- コードはできるだけ自明であるべきです。
- for...in...を使った配列の列挙は避けてください。
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);
これが、上記の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;
}
これが、依存関係のない最もクリーンで最も単純な回答であり、それがすべてのプラットフォームで機能することです。
const { lookup } = require('dns').promises;
const { hostname } = require('os');
async function getMyIPAddress(options) {
return (await lookup(hostname(), options))
.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];
受け入れられた答えは非同期です、私は同期バージョンが欲しかった、これが誰かに役立つことを願っています。
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;
ノードjsでIPアドレスを取得するには、connect、net、およびrequest-ipの3つのモジュールを含める必要があります。これらのモジュールがインストールされていない場合は、まずnpmを使ってこれらのモジュールをインストールしましょう。
この与えられたリンクはあなたが望む解決策を含みます、それを通って行ってください -
これはあなたが（MacとWinでテストされた）ローカルIPアドレスを取得することを可能にするバリエーションです：
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がリッスンしているサーバーを知る必要がある場合は、req.hostnameを使用できます。