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




linux express (24)

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


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

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

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

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

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

আপডেট 2013:

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

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

আপডেট 2015:

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


'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

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

আমি একটি 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 
});

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


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

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 networkInterfaces = os.networkInterfaces( );
var arr = networkInterfaces['Local Area Connection 3']
var ip = arr[1].address;

এটি গৃহীত উত্তরগুলির একটি সংশোধন, যা ডকার ইত্যাদির মতো ভিথারনেট আইপিগুলির জন্য অ্যাকাউন্ট করে না।

/**
 * 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);

এটি 10.55.1.1 পরিবর্তে 192.168.2.169 মত একটি আইপি ফেরত 10.55.1.1


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

npm install ip

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

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

npm আইপি মডিউল ব্যবহার করুন

var ip = require('ip');

console.log(ip.address());

> '192.168.0.117'

আপনার মেশিনের যেকোন আইপি আপনি os মডিউল ব্যবহার করে খুঁজে পেতে পারেন - এবং এটি নোডিজএসের নেটিভ

var os = require( 'os' );

var networkInterfaces = os.networkInterfaces( );

console.log( networkInterfaces );

আপনাকে যা করতে হবে তা হল os.networkInterfaces () কল করুন এবং আপনি একটি সহজ পরিচালনাযোগ্য তালিকা পাবেন - লীগগুলির দ্বারা ifconfig চালানোর চেয়ে সহজ

nodejs.org/api/os.html#os_os_networkinterfaces

সেরা

Edoardo


আমি 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);

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

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

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

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

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


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

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

প্রবৃত্তি আগ্রহী কেউ জন্য, এখানে কিছু "এক-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;

এখানে উপরের উদাহরণ একটি বৈচিত্র্য। এটি vMware ইন্টারফেসগুলি ফিল্টার করার জন্য যত্ন নেয়। যদি আপনি কোনও সূচী পাস না করেন তবে এটি সমস্ত ঠিকানা ফেরত দেয় না অন্যথায় আপনি এটি 0 সেট করতে ডিফল্ট সেট করতে চান তবে সব পেতে নিল পাস করুন, তবে আপনি এটি সমাধান করবেন। যদি আপনি যুক্ত করতে চান তবে আপনি রেজেক্ট ফিল্টারের জন্য আরেকটি আর্গুমেন্ট পাস করতে পারেন

    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.js কোডের একটি স্নিপেট যা 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);

আমি জানি যে আমি আইপি ঠিকানা 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;
            }
        }
    }
}

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


আপনি যদি সম্পূর্ণ সংক্ষিপ্ত 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);


লিনাক্স এবং ম্যাকOS ব্যবহারের জন্য, আপনি যদি আপনার আইপিগুলি সমলয় ভাবে পেতে চান তবে এটি চেষ্টা করুন।

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

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

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


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




ip