আমার মেশিনে একটি সাধারণ নোড.জেএস প্রোগ্রাম চলছে এবং আমি পিসির স্থানীয় আইপি ঠিকানা পেতে চাই যেখানে আমার প্রোগ্রামটি চলছে। আমি এটি নোড.জেএস দিয়ে কীভাবে পাব?
আমার মেশিনে একটি সাধারণ নোড.জেএস প্রোগ্রাম চলছে এবং আমি পিসির স্থানীয় আইপি ঠিকানা পেতে চাই যেখানে আমার প্রোগ্রামটি চলছে। আমি এটি নোড.জেএস দিয়ে কীভাবে পাব?
উত্তর:
'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 || []), [])), [])
এখনই উইন্ডোতে কাজ করে না। ফলাফলগুলি বিশ্লেষণের জন্য প্রোগ্রামগুলি চালানো কিছুটা নিখুঁত বলে মনে হচ্ছে। আমি যা ব্যবহার করি তা এখানে।
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() );
আপনার মেশিনের যে কোনও আইপি আপনি ওএস মডিউলটি ব্যবহার করে খুঁজে পেতে পারেন - এবং এটি নোডজেএসের স্থানীয়
var os = require( 'os' );
var networkInterfaces = os.networkInterfaces( );
console.log( networkInterfaces );
আপনাকে যা করতে হবে তা হ'ল os.networkInterfaces () কল করা এবং আপনি একটি সহজ পরিচালনাযোগ্য তালিকা পাবেন - লিগগুলির মাধ্যমে ifconfig চালানোর চেয়ে সহজ
http://nodejs.org/api/os.html#os_os_networkinterfaces
সেরা
Edoardo
var address = networkInterfaces['venet0:0'][0].address
এখানে নোড.জেএস কোডের একটি স্নিপেট রয়েছে যা আউটপুটকে বিশ্লেষণ করবে ifconfig
এবং (অযৌক্তিকভাবে) পাওয়া প্রথম আইপি ঠিকানাটি ফিরিয়ে দেবে:
(কেবলমাত্র ম্যাকস স্নো লেপার্ডে পরীক্ষা করা হয়েছে; আশা করি এটি লিনাক্সেও কাজ করে)
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;
। এটি বাদ দিয়ে দুর্দান্ত স্ক্রিপ্ট, একটি সত্য জীবনদাতা। অনেক ধন্যবাদ!
স্থানীয় আইপি ঠিকানা পাওয়ার জন্য আমার ইউটিলিটি পদ্ধতিটি ধরে নেওয়া, আপনি আইপিভি 4 ঠিকানা খুঁজছেন এবং এই মেশিনটির কেবল একটি আসল নেটওয়ার্ক ইন্টারফেস রয়েছে। মাল্টি-ইন্টারফেস মেশিনের জন্য সহজেই এটির আইপিগুলির একটি অ্যারে ফিরিয়ে আনতে পারে ored
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);
}
});
আপনার স্থানীয় আইপি সর্বদা 127.0.0.1।
তারপরে নেটওয়ার্ক আইপি রয়েছে যা আপনি ifconfig
(* নিক্স) বা ipconfig
(জয়) থেকে পেতে পারেন । এটি কেবল স্থানীয় নেটওয়ার্কের মধ্যেই কার্যকর।
তারপরে আপনার বাহ্যিক / সার্বজনীন আইপি রয়েছে, যা আপনি কেবল তখনই পেতে পারেন কেবল যদি আপনি রাউটারের জন্য এটি জিজ্ঞাসা করতে পারেন, বা আপনি কোনও বাহ্যিক পরিষেবা সেটআপ করতে পারেন যা ক্লায়েন্টের আইপি অ্যাড্রেসটি যখনই এটির অনুরোধ আসে তখনই ফিরে আসে। হোয়াটস্মিআইপি ডট কমের মতো অস্তিত্বের মধ্যে এই জাতীয় আরও পরিষেবা রয়েছে।
কিছু ক্ষেত্রে (উদাহরণস্বরূপ যদি আপনার WAN সংযোগ থাকে) নেটওয়ার্ক আইপি এবং সর্বজনীন আইপি এক রকম হয় এবং উভয়ই আপনার কম্পিউটারে পৌঁছানোর জন্য বাহ্যিকভাবে ব্যবহার করা যেতে পারে।
যদি আপনার নেটওয়ার্ক এবং সর্বজনীন আইপিগুলি পৃথক হয়, আপনার আপনার নেটওয়ার্ক রাউটারটি আপনার আইপি-তে সমস্ত আগত সংযোগগুলি ফরোয়ার্ড করার দরকার হতে পারে।
আপডেট 2013:
এখন এই কাজ করার একটি নতুন উপায়, আপনি একটি সম্পত্তি বলা জন্য আপনার সংযোগ সকেট বস্তুর পরীক্ষা করতে পারবেন localAddress
, যেমন net.socket.localAddress
। এটি আপনার সকেটের শেষের ঠিকানাটি দেয়।
সবচেয়ে সহজ উপায় হ'ল কেবল একটি এলোমেলো বন্দর খোলা এবং এটি শুনতে, তারপরে আপনার ঠিকানা পান এবং সকেটটি বন্ধ করুন।
আপডেট 2015:
আগেরটি আর কাজ করে না।
ifconfig
বা ipconfig
পার্স করতে হবে?
ifconfig
করা বেশ একমাত্র উপায়।
net.socket
রিটার্নের undefined
মতো মনে হচ্ছে , সুতরাং "এটি করার নতুন উপায়" আর কাজ করে না। একটি আছে net.Socket
, তবে এর কোনও localAddress
সম্পত্তি নেই।
এনপিএম আইপি মডিউল ব্যবহার করুন
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' ]
আমি একটি নোড.জেএস মডিউল লিখেছি যা কোন নেটওয়ার্ক ইন্টারফেসে আপনার ডিফল্ট গেটওয়ে রয়েছে তা দেখে আপনার স্থানীয় আইপি ঠিকানা নির্ধারণ করে।
এটি os.networkInterfaces()
হোস্ট-নেমটির ইন্টারফেস বা ডিএনএস লিকুপ থেকে বাছাইয়ের চেয়ে আরও নির্ভরযোগ্য । এটি ভিএমওয়্যার ভার্চুয়াল ইন্টারফেস, লুপব্যাক এবং ভিপিএন ইন্টারফেস উপেক্ষা করতে সক্ষম এবং এটি উইন্ডোজ, লিনাক্স, ম্যাক ওএস এবং ফ্রিবিএসডি-তে কাজ করে। ফণা অধীনে, এটি কার্যকর করে 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';
}
ব্রিভিটির প্রতি আগ্রহী যে কারও জন্য, এখানে এমন কিছু "ওয়ান-লাইনার" রয়েছে যা মানক নোড ইনস্টলেশনের অংশ নয় এমন প্লাগইন / নির্ভরতা প্রয়োজন হয় না:
অ্যারে হিসাবে EP0 এর সর্বজনীন IPv4 এবং IPv6:
var ips = require('os').networkInterfaces().eth0.map(function(interface) {
return interface.address;
});
স্ট্রিং হিসাবে Eth0 এর প্রথম পাবলিক আইপি (সাধারণত আইপিভি 4):
var ip = require('os').networkInterfaces().eth0[0].address;
en0
এবং en1
ইথারনেট এবং wifi এর জন্য। উইন্ডোজ, আমি Local Area Connection
এবং আছে Wireless Network Connection
।
"নোড.জেএস সার্ভার আইপি পান" অনুসন্ধান করার সময় গুগল আমাকে এই প্রশ্নের দিকে পরিচালিত করেছিল , সুতরাং আসুন যারা তাদের নোড.জেএস সার্ভারে এটি অর্জনের চেষ্টা করছেন তাদের জন্য বিকল্প উত্তর দিন প্রোগ্রামে এটি (মূল পোস্টারের ক্ষেত্রে হতে পারে)।
সবচেয়ে তুচ্ছ ক্ষেত্রে যেখানে সার্ভারটি কেবল একটি আইপি ঠিকানার সাথে আবদ্ধ, সেখানে আইপি ঠিকানা নির্ধারণ করার দরকার নেই যেহেতু আমরা ইতিমধ্যে জানি যে আমরা কোন ঠিকানার সাথে আবদ্ধ করেছি (যেমন দ্বিতীয় প্যারামিটারটি পাস করা হয়েছে) 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()
এটা আপনার জন্য যখন chaining।
এখানে উপরোক্ত উদাহরণগুলির একটি প্রকরণ রয়েছে। এটি ভিএমওয়্যার ইন্টারফেস ইত্যাদি ফিল্টার করার জন্য যত্ন গ্রহণ করে an যোগ করার প্রবণতা থাকলে আপনি রেইগেক্স ফিল্টারটির জন্য অন্য কোনও যুক্তিতেও যেতে পারেন
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);
বাশ স্ক্রিপ্ট হিসাবে (নোড জেএস ইনস্টল করা দরকার)
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); """ }
এখানে আমার রূপটি পোর্টেবল উপায়ে আইপিভি 4 এবং আইপিভি 6 ঠিকানা উভয়ই পেতে দেয়:
/**
* 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
(বড় হাতের আই) দিয়ে কাজ করে । এটি মেশিনের সমস্ত নির্ধারিত আইপি ঠিকানাগুলির একটি তালিকা ফেরত দেয়। প্রথম আইপি ঠিকানাটি আপনার যা প্রয়োজন। সেই আইপি হ'ল বর্তমান ইন্টারফেসের সাথে সংযুক্ত একটি।
এখানে উপরের ঘুরলিমানের উত্তরের একটি বহু-আইপি সংস্করণ রয়েছে:
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;
}
আমি বুঝতে পারি এটি একটি পুরানো থ্রেড, তবে আমি নিম্নলিখিত কারণে শীর্ষের উত্তরে একটি উন্নতি প্রস্তাব করতে চাই:
এর জন্য ... ইন ... গণনাটি যাচাই করা উচিত যাতে অবজেক্টের উপরে গণনা করা হচ্ছে সেই সম্পত্তিটি যা আপনি খুঁজছেন contains যেহেতু জাভাসক্রিপ্টটি আলগাভাবে টাইপ করা হয় এবং এর জন্য ... ইন ... যেকোন সালিসি বস্তু হ্যান্ডেল করার জন্য দেওয়া যেতে পারে; আমরা যে সম্পত্তিটি খুঁজছি তা যাচাই করার জন্য এটি নিরাপদ।
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);