मेरी मशीन पर एक साधारण नोड.जेएस प्रोग्राम चल रहा है और मैं पीसी का स्थानीय आईपी पता प्राप्त करना चाहता हूं जिस पर मेरा प्रोग्राम चल रहा है। मैं इसे नोड.जेएस के साथ कैसे प्राप्त करूं?
मेरी मशीन पर एक साधारण नोड.जेएस प्रोग्राम चल रहा है और मैं पीसी का स्थानीय आईपी पता प्राप्त करना चाहता हूं जिस पर मेरा प्रोग्राम चल रहा है। मैं इसे नोड.जेएस के साथ कैसे प्राप्त करूं?
जवाबों:
'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
if( details.family=='IPv4' && details.internal === false ) {
यदि आप केवल बाहरी आईपी चाहते हैं।
Object.values(require('os').networkInterfaces()).reduce((r, list) => r.concat(list.reduce((rr, i) => rr.concat(i.family==='IPv4' && !i.internal && i.address || []), [])), [])
os.networkInterfaces अभी विंडो पर काम नहीं करता है। परिणामों को पार्स करने के लिए प्रोग्राम चलाना थोड़ा सा iffy लगता है। यहाँ मैं क्या उपयोग है।
require('dns').lookup(require('os').hostname(), function (err, add, fam) {
console.log('addr: '+add);
})
यह आपका पहला नेटवर्क इंटरफेस लोकल आईपी वापस करना चाहिए।
https://github.com/indutny/node-ip
var ip = require("ip");
console.dir ( ip.address() );
अपनी मशीन के किसी भी आईपी को आप ओएस मॉड्यूल का उपयोग करके पा सकते हैं - और यह NodeJS का मूल निवासी है
var os = require( 'os' );
var networkInterfaces = os.networkInterfaces( );
console.log( networkInterfaces );
बस आपको os.networkInterfaces () कॉल करना होगा और आपको एक आसान प्रबंधनीय सूची मिल जाएगी - लीग द्वारा ifconfig चलाने से आसान
http://nodejs.org/api/os.html#os_os_networkinterfaces
श्रेष्ठ
एडोआर्डो
var address = networkInterfaces['venet0:0'][0].address
यहां नोड.जेएस कोड का एक स्निपेट है जो आउटपुट को पार्स करेगा ifconfig
(और एसिंक्रोनसली) और पहले पते को वापस कर देगा:
(केवल MacOS स्नो लेपर्ड पर परीक्षण किया गया; आशा है कि यह 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
, तो फ़ंक्शन हर बार एक सिस्टम कॉल निष्पादित करेगा; अन्यथा कैश्ड मान का उपयोग किया जाता है।
सभी स्थानीय नेटवर्क पते की एक सरणी देता है।
उबंटू 11.04 और विंडोज एक्सपी 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);
filterRE = /\bIP-?[^:\r\n]+:\s*([^\s]+)/g;
:। उस के अलावा, महान स्क्रिप्ट, एक सच्चे जीवन रक्षक। बहुत धन्यवाद!
यहां स्थानीय IP पता प्राप्त करने के लिए मेरी उपयोगिता विधि है, यह मानकर कि आप IPv4 पते की तलाश कर रहे हैं और मशीन में केवल एक वास्तविक नेटवर्क इंटरफेस है। मल्टी-इंटरफ़ेस मशीनों के लिए आईपी की एक सरणी को वापस करने के लिए इसे आसानी से रिफैक्ट किया जा सकता है।
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';
}
getLocalIP = (interfaceName = "en0",version = "IPv4")-> iface = require('os').networkInterfaces()[interfaceName] for alias in iface if (alias.family == version && !alias.internal) return alias.address return "0.0.0.0"
जैसे आईपी नामक एक मॉड्यूल स्थापित करें
npm install ip
फिर इस कोड का उपयोग करें।
var ip = require("ip");
console.log( ip.address() );
Ifconfig को कॉल करना बहुत ही प्लेटफ़ॉर्म-निर्भर है, और नेटवर्किंग लेयर को पता होता है कि सॉकेट किस आईपी एड्रेस पर है, इसलिए इसे पूछना सबसे अच्छा है। नोड ऐसा करने के एक प्रत्यक्ष तरीके को उजागर नहीं करता है, लेकिन आप किसी भी सॉकेट को खोल सकते हैं, और पूछ सकते हैं कि स्थानीय आईपी पता क्या उपयोग में है। उदाहरण के लिए, 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
(* निक्स) या से प्राप्त कर सकते हैंipconfig
(जीत) । यह केवल स्थानीय नेटवर्क के भीतर उपयोगी है।
फिर आपकी बाहरी / सार्वजनिक आईपी है, जिसे आप केवल तभी प्राप्त कर सकते हैं जब आप किसी तरह से इसके लिए राउटर से पूछ सकते हैं, या आप एक बाहरी सेवा सेटअप कर सकते हैं जो क्लाइंट आईपी पते को जब भी अनुरोध प्राप्त होता है। अस्तित्व में ऐसी अन्य सेवाएँ भी हैं, जैसे whatismyip.com।
कुछ मामलों में (उदाहरण के लिए यदि आपके पास WAN कनेक्शन है) तो नेटवर्क IP और सार्वजनिक IP समान हैं, और दोनों का उपयोग आपके कंप्यूटर तक पहुंचने के लिए बाहरी रूप से किया जा सकता है।
यदि आपका नेटवर्क और सार्वजनिक आईपी अलग-अलग हैं, तो आपको अपने नेटवर्क राउटर को अपने नेटवर्क आईपी पर आने वाले सभी कनेक्शनों को अग्रेषित करने की आवश्यकता हो सकती है।
अद्यतन २०१३:
अब ऐसा करने का एक नया तरीका है, आप किसी प्रॉपर्टी के लिए अपने कनेक्शन की सॉकेट ऑब्जेक्ट की जांच कर सकते हैं localAddress
, जैसे कि net.socket.localAddress
। यह आपके सॉकेट के अंत में पता देता है।
सबसे आसान तरीका सिर्फ एक यादृच्छिक पोर्ट खोलना और उस पर सुनना है, फिर अपना पता प्राप्त करें और सॉकेट बंद करें।
अद्यतन २०१५:
पिछला अब काम नहीं करता है।
ifconfig
या ipconfig
पार्स करने की आवश्यकता है?
ifconfig
net.socket
रिटर्न undefined
2015 के रूप में, तो "ऐसा करने का नया तरीका" अब और काम नहीं करता। वहाँ एक है net.Socket
, लेकिन यह एक localAddress
संपत्ति नहीं है ।
npm आईपी मॉड्यूल का उपयोग करें
var ip = require('ip');
console.log(ip.address());
> '192.168.0.117'
अंडरस्कोर और लॉश दोनों के लिए सही एक लाइनर है:
var ip = require('underscore')
.chain(require('os').networkInterfaces())
.values()
.flatten()
.find({family: 'IPv4', internal: false})
.value()
.address;
.find({family: 'IPv4', internal: false})
साथ ही एक छोटे से अधिक सुरुचिपूर्ण कोड के लिए
मुझे पता है कि मैं आईपी पते के साथ शुरुआत करना चाहता था 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;
}
}
}
}
यदि आप एक अलग की तलाश कर रहे हैं, तो बेशक आप संख्या बदल सकते हैं।
192.168
?
192.168.
उसी के साथ शुरू होता है जिसके कारण मैंने उसे चुना है।
लिनक्स और मैकओएस उपयोग के लिए, यदि आप अपने आईपी को समकालिक तरीके से प्राप्त करना चाहते हैं, तो यह प्रयास करें।
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 मॉड्यूल लिखा है जो आपके स्थानीय आईपी पते को देखकर निर्धारित करता है कि किस नेटवर्क इंटरफ़ेस में आपका डिफ़ॉल्ट गेटवे है।
यह os.networkInterfaces()
होस्टनाम के DNS लुकअप या DNS इंटरफ़ेस से चुनने से अधिक विश्वसनीय है । यह VMware वर्चुअल इंटरफेस, लूपबैक और वीपीएन इंटरफेस को नजरअंदाज करने में सक्षम है, और यह विंडोज, लिनक्स, मैक ओएस और फ्रीबीएसडी पर काम करता है। हुड के तहत, यह आउटपुट को निष्पादित 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
});
यहाँ एक एकल आईपी प्राप्त करने के लिए वेनिला जावास्क्रिप्ट में एक सरलीकृत संस्करण है:
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';
}
संक्षिप्तता में रुचि रखने वाले किसी के लिए, यहां कुछ "वन-लाइनर्स" हैं, जिन्हें प्लगइन्स / निर्भरता की आवश्यकता नहीं है जो एक मानक नोड इंस्टॉलेशन का हिस्सा नहीं हैं:
सार्वजनिक IPv4 और IP06 eth0 एक ऐरे के रूप में:
var ips = require('os').networkInterfaces().eth0.map(function(interface) {
return interface.address;
});
स्ट्रिंग के रूप में eth0 का पहला सार्वजनिक IP (आमतौर पर IPv4):
var ip = require('os').networkInterfaces().eth0[0].address;
en0
और en1
ईथरनेट और वाईफ़ाई के लिए। विंडोज पर, मेरे पास है Local Area Connection
और Wireless Network Connection
।
Google ने मुझे "नोड.जेएस सर्वर आईपी प्राप्त करें" की खोज करते हुए इस प्रश्न के लिए निर्देशित किया , तो आइए उन लोगों के लिए एक वैकल्पिक उत्तर दें जो अपने नोड.जेएस सर्वर कार्यक्रम में इसे प्राप्त करने का प्रयास कर रहे हैं (मूल पोस्टर का मामला हो सकता है)।
सबसे तुच्छ मामले में जहां सर्वर केवल एक आईपी पते के लिए बाध्य है, आईपी पता निर्धारित करने की कोई आवश्यकता नहीं होनी चाहिए क्योंकि हम पहले से ही जानते हैं कि हम किस पते पर इसे बाध्य करते हैं (उदाहरण के लिए। दूसरा पैरामीटर पारित हुआ। listen()
फ़ंक्शन में )।
कम तुच्छ मामले में जहां सर्वर कई आईपी पते के लिए बाध्य है, हमें उस इंटरफ़ेस के आईपी पते को निर्धारित करने की आवश्यकता हो सकती है जिससे एक ग्राहक जुड़ा हुआ है। और जैसा कि संक्षेप में टो वैलामो ने सुझाव दिया है, आजकल, हम आसानी से जुड़े सॉकेट और इसकी localAddress
संपत्ति से यह जानकारी प्राप्त कर सकते हैं।
उदाहरण के लिए, यदि प्रोग्राम एक वेब सर्वर है:
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();
उपरोक्त उत्तरों में से एक पर टिप्पणी से कॉल गायब था values()
। ऐसा लगता है कि os.networkInterfaces()
अब एक सरणी के बजाय एक वस्तु लौटाता है।
_.chain(..)
रूप में फिर से लिखा जा सकता है _(...)
, के रूप में फिर से लिखा .filter(..)
जा सकता है .where({family: 'IPv4', internal: false})
, और आप अंतिम रूप से छोड़ सकते हैं value()
क्योंकि .first()
यह आपके लिए जब जंजीर है।
यहाँ उपरोक्त उदाहरणों की भिन्नता है। यह ध्यान रखें कि vMware इंटरफेस आदि को फ़िल्टर करें। यदि आप एक इंडेक्स पास नहीं करते हैं तो यह सभी पते लौटाता है अन्यथा आप इसे डिफ़ॉल्ट रूप से 0 पर सेट करना चाहते हैं, तो सभी प्राप्त करने के लिए बस पास कर दें, लेकिन आप इसे हटा देंगे। यदि आप जोड़ना चाहते हैं तो आप रेगेक्स फ़िल्टर के लिए किसी अन्य 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;
}
मैं सिर्फ नोड जे एस का उपयोग कर ऐसा करने में सक्षम था
जैसा कि नोड जेएस
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);
बैश स्क्रिप्ट के रूप में (नोड 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); """ }
यहां मेरा संस्करण है जो पोर्टेबल तरीके से 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;
};
यहां एक ही फ़ंक्शन का एक कॉफीस्क्रिप्ट संस्करण है:
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' } }
यदि आप पूरी संक्षिप्तता की बात कर रहे हैं, तो यहाँ यह लॉश का उपयोग कर रहा है :
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);
Object.keys(interfaces).reduce(...)
साथ बदल सकते हैं Object.values(interfaces).flat()
और यह एक ही बात होगी।
मैक ओएस पर एप्लिकेशन विकसित करते समय, और इसे फोन पर परीक्षण करना चाहते हैं, और अपने ऐप को लोकलहोस्ट आईपी को स्वचालित रूप से चुनने की आवश्यकता है।
require('os').networkInterfaces().en0.find(elm=>elm.family=='IPv4').address
यह केवल उल्लेख करने के लिए है कि आप अपने आप आईपी पता कैसे पा सकते हैं। यह परीक्षण करने के लिए आप टर्मिनल हिट पर जा सकते हैं
node
os.networkInterfaces().en0.find(elm=>elm.family=='IPv4').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];
reduce
कॉल के map
साथ कॉल करने और बदलने के लिए समाप्त कर सकते हैं flatMap
।
कई बार मुझे लगता है उपलब्ध नहीं है कई आंतरिक और बाह्य संपर्क वाले इंटरफेस (उदाहरण: 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;
मैं नोड.जेएस 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);
hostname -I
(अपरकेस i) के साथ काम करता है । यह मशीन के सभी असाइन किए गए IP पतों की एक सूची देता है। पहला IP पता वही है जो आपको चाहिए। वह 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;
}
मुझे लगता है कि यह एक पुराना धागा है, लेकिन मैं निम्नलिखित कारणों से शीर्ष उत्तर में सुधार की पेशकश करना चाहता हूं:
... ... में ... यह सुनिश्चित करने के लिए कि आपके द्वारा खोजे जा रहे प्रॉपर्टी में समाहित होने के लिए एन्यूमरेशन को मान्य किया जाना चाहिए। के रूप में javsacript शिथिल टाइप है और के लिए ... में संभाल करने के लिए किसी भी मध्यस्थ वस्तु सौंपी जा सकती है; यह उस संपत्ति को मान्य करने के लिए सुरक्षित है जिसे हम खोज रहे हैं जो उपलब्ध है।
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);