javascript - Node.js এ স্থানীয় আইপি ঠিকানা পান




linux express (20)

আমার মেশিনে একটি সহজ node.js প্রোগ্রাম চলছে এবং আমি পিসি এর স্থানীয় আইপি ঠিকানা পেতে চাই যা আমার প্রোগ্রাম চলছে। আমি কিভাবে node.js সঙ্গে এটি পেতে পারি?


ম্যাক ওএসের জন্য এক লাইন শুধুমাত্র প্রথম স্থানীয় হোস্ট ঠিকানা।

Mac OS এ অ্যাপ্লিকেশনগুলি ডেভেলপ করার সময় এবং ফোনে এটি পরীক্ষা করতে চান এবং আপনার অ্যাপ্লিকেশানটিকে স্বয়ংক্রিয়ভাবে স্থানীয় হোস্ট আইপি বাছাই করার প্রয়োজন হয়।

require('os').networkInterfaces().en0.find(elm=>elm.family=='IPv4').address

এটি স্বয়ংক্রিয়ভাবে আপনি আইপি ঠিকানাটি কীভাবে খুঁজে পেতে পারেন তা উল্লেখ করতে হয়। এই পরীক্ষা করার জন্য আপনি টার্মিনাল আঘাত যেতে পারেন

node
os.networkInterfaces().en0.find(elm=>elm.family=='IPv4').address

আউটপুট আপনার localhost আইপি ঠিকানা হতে হবে।


Ifconfig কলিং খুব প্ল্যাটফর্ম-নির্ভর, এবং নেটওয়ার্কিং লেয়ারটি জানে যে কোন সকেটে আইপি ঠিকানা থাকে, তাই এটি জিজ্ঞাসা করা ভাল। নোড এটি করার একটি সরাসরি পদ্ধতি প্রকাশ করে না, তবে আপনি কোন সকেট খুলতে পারেন এবং জিজ্ঞাসা করতে পারেন স্থানীয় 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);
    }
});

অনেকবার আমি একাধিক অভ্যন্তরীণ এবং বহিরাগত মুখোমুখি ইন্টারফেস উপলব্ধ (উদাহরণ: 10.0.75.1 , 172.100.0.1 , 192.168.2.3 ) খুঁজে 172.100.0.1 এবং এটি বাইরের এক যা আমি সত্যিই পরে ( 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;

অন্যান্য উত্তর অনুরূপ কিন্তু আরও সংক্ষিপ্ত:

'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);

আপনার স্থানীয় আইপি সবসময় 127.0.0.1 হয়।

তারপর নেটওয়ার্ক আইপি আছে, যা আপনি ifconfig (* nix) বা ipconfig (win) থেকে পেতে পারেন। এই স্থানীয় নেটওয়ার্কের মধ্যে শুধুমাত্র দরকারী।

তারপরে আপনার বহিরাগত / সর্বজনীন আইপি রয়েছে, যা আপনি কেবলমাত্র পেতে পারেন যদি আপনি রাউটারকে কোনওভাবে জিজ্ঞাসা করতে পারেন, অথবা আপনি একটি বাহ্যিক পরিষেবা সেটআপ করতে পারেন যা এটি যখনই অনুরোধ করে তখন ক্লায়েন্ট আইপি ঠিকানাটি ফেরত দেয়। অস্তিত্ব যেমন অন্যান্য সেবা আছে, whatismyip.com মত।

কিছু ক্ষেত্রে (উদাহরণস্বরূপ, যদি আপনার কাছে একটি WAN সংযোগ থাকে) নেটওয়ার্ক আইপি এবং সার্বজনীন আইপি একই, এবং উভয় আপনার কম্পিউটারে পৌঁছানোর জন্য বাইরে ব্যবহার করা যেতে পারে।

আপনার নেটওয়ার্ক এবং সর্বজনীন আইপিগুলি পৃথক থাকলে, আপনার নেটওয়ার্ক রাউটারকে আপনার নেটওয়ার্ক আইপিগুলিতে সমস্ত ইনকামিং সংযোগগুলি এগিয়ে রাখতে হবে।

আপডেট 2013:

এখন এটি করার একটি নতুন উপায় রয়েছে, আপনি localAddress নামে একটি সম্পত্তিটির জন্য আপনার সংযোগের সকেট বস্তুটি পরীক্ষা করতে পারেন, যেমন net.socket.localAddress । এটা সকেট আপনার শেষে ঠিকানা প্রদান করে।

সহজতম উপায় কেবল একটি র্যান্ডম পোর্ট খোলা এবং এটি শোনার, তারপর আপনার ঠিকানা পেতে এবং সকেট বন্ধ করা হয়।

আপডেট 2015:

পূর্ববর্তী আর কাজ করে না।


আপনি যদি সম্পূর্ণ সংক্ষিপ্ত lodash এখানে lodash ব্যবহার 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);


আমি একটি Node.js মডিউল লিখেছিলাম যা আপনার স্থানীয় আইপি ঠিকানাটি নির্ধারণ করে যা কোন নেটওয়ার্ক ইন্টারফেসে আপনার ডিফল্ট গেটওয়ে রয়েছে।

os.networkInterfaces() অথবা হোস্টনামের DNS 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 
});

আমি জানি যে আমি আইপি ঠিকানা 192.168. দিয়ে শুরু করতে চেয়েছিলাম 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;
            }
        }
    }
}

অবশ্যই যদি আপনি একটি ভিন্ন এক খুঁজছেন হয় তাহলে শুধু সংখ্যা পরিবর্তন করতে পারেন।


আশাকরি এটা সাহায্য করবে

var os = require( 'os' );
var networkInterfaces = os.networkInterfaces( );
var arr = networkInterfaces['Local Area Connection 3']
var ip = arr[1].address;

উপরে একটি মন্তব্যের উপর ভিত্তি করে, এখানে নোডের বর্তমান সংস্করণটির জন্য কী কাজ করছে:

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() এখন অ্যারের পরিবর্তে একটি বস্তু প্রদান করে।


এখানে আপনার জন্য একটি পরিচ্ছন্ন ছোট এক-মাছ ধরার নৌকা যা কার্যকরীভাবে এটি করে:

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];

এখানে আমার রূপান্তর যা একটি পোর্টেবল পদ্ধতিতে 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()) জন্য উদাহরণ আউটপুট 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' } }

এখানে একটি একক আইপি পেতে ভ্যানিলা জাভাস্ক্রিপ্ট একটি সরলীকৃত সংস্করণ:

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';
}

এখানে জুরুলিমনের উত্তরের একটি মাল্টি-আইপি সংস্করণ রয়েছে:

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;
}

প্রবৃত্তি আগ্রহী কেউ জন্য, এখানে কিছু "এক-liners" যা একটি আদর্শ নোড ইনস্টলেশন অংশ না প্লাগিন / নির্ভরতা প্রয়োজন হয় না:

Eth0 এর পাবলিক IPv4 এবং IPv6 একটি অ্যারের হিসাবে:

var ips = require('os').networkInterfaces().eth0.map(function(interface) { 
    return interface.address;
});

স্ট্রিং হিসাবে eth0 (সাধারণত IPv4) প্রথম পাবলিক আইপি:

var ip = require('os').networkInterfaces().eth0[0].address;

মত আইপি বলা একটি মডিউল ইনস্টল করুন

npm install ip

তারপর এই কোড ব্যবহার করুন।

var ip = require("ip");
console.log( ip.address() );

স্থানীয় IP ঠিকানা পাওয়ার জন্য এখানে আমার ইউটিলিটি পদ্ধতি রয়েছে, আপনি আইপিভি 4 অ্যাড্রেসটি সন্ধান করছেন বলে মনে করছেন এবং মেশিনটিতে শুধুমাত্র একটি প্রকৃত নেটওয়ার্ক ইন্টারফেস রয়েছে। মাল্টি-ইন্টারফেস মেশিনগুলির জন্য আইপিগুলির একটি অ্যারে ফেরত দেওয়ার জন্য এটি সহজেই পুনঃবিবেচনা করা যেতে পারে।

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';
}


Underscore এবং lodash উভয় জন্য সঠিক এক মাছ ধরার নৌকা হয়:

var ip = require('underscore')
    .chain(require('os').networkInterfaces())
    .values()
    .flatten()
    .find({family: 'IPv4', internal: false})
    .value()
    .address;

os.networkInterfaces ঠিক এই মুহূর্তে উইন্ডোতে কাজ করে না। ফলাফল পার্স প্রোগ্রাম চলমান একটি বিট iffy মনে হয়। এখানে আমি কি ব্যবহার করি।

require('dns').lookup(require('os').hostname(), function (err, add, fam) {
  console.log('addr: '+add);
})

এটি আপনার প্রথম নেটওয়ার্ক ইন্টারফেস স্থানীয় আইপি ফিরে করা উচিত।





ip