नोड.जेएस में स्थानीय आईपी पता प्राप्त करें


308

मेरी मशीन पर एक साधारण नोड.जेएस प्रोग्राम चल रहा है और मैं पीसी का स्थानीय आईपी पता प्राप्त करना चाहता हूं जिस पर मेरा प्रोग्राम चल रहा है। मैं इसे नोड.जेएस के साथ कैसे प्राप्त करूं?


1
विचार के लिए भोजन joeyh.name/code/moreutils और github.com/polotek/procstreams देखें । मैं कभी उनके साथ घर नहीं छोड़ता।
जेम्स

जवाबों:


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

17
var _ = आवश्यकता ('अंडरस्कोर'); var ip = _.chain (आवश्यकता ('os')। networkInterfaces ())। समतल () (फ़िल्टर (फ़ंक्शन) {return (val.family == 'IPv4' && val.internal = "false)}) ।। .pluck ( 'पता') पहली () मान (); कंसोल.लॉग (आईपी)
कार्टर कोल

छठी पंक्ति होनी चाहिए if( details.family=='IPv4' && details.internal === false ) {यदि आप केवल बाहरी आईपी चाहते हैं।
अर्लेन बीइलर

3
@CarterCole आपको समतल करने से पहले .values ​​() के लिए एक अतिरिक्त कॉल की आवश्यकता है।
गुइडो

1
क्या होगा अगर मैं सिर्फ सक्रिय इंटरफ़ेस के आईपी पते को पुनः प्राप्त करना चाहता था?
तेजस

1
नोड के लिए लॉश के बिना वन-लाइनर > = 7.0.0 :Object.values(require('os').networkInterfaces()).reduce((r, list) => r.concat(list.reduce((rr, i) => rr.concat(i.family==='IPv4' && !i.internal && i.address || []), [])), [])
सोम

224

os.networkInterfaces अभी विंडो पर काम नहीं करता है। परिणामों को पार्स करने के लिए प्रोग्राम चलाना थोड़ा सा iffy लगता है। यहाँ मैं क्या उपयोग है।

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

यह आपका पहला नेटवर्क इंटरफेस लोकल आईपी वापस करना चाहिए।


4
@ हरमनइंजलड्सन: यह बहुत अच्छी तरह से जानकारीपूर्ण आलोचना नहीं है। क्या आप अधिक विस्तार से बताएंगे? शायद उदाहरण कोड ले लो और इसे एक नए प्रश्न में डाल दें और अधिक विवरण प्रदान करें और पूछें कि यह काम क्यों नहीं करता है?
Xedecimal

8
DNS लुकअप का उपयोग करना हमेशा एक अच्छा विचार नहीं है, क्योंकि यह गलत जानकारी (यानी कैश्ड डेटा) वापस कर सकता है। 'Os.networkInterfaces' का उपयोग करना मेरी राय में एक बेहतर विचार है।
गुइडो

1
यदि आपके सर्वर में कहीं डीएनएस प्रविष्टि है तो DNS का उपयोग करना। हालाँकि बहुत सारे अनुप्रयोगों में डीएनएस प्रविष्टि (जैसे मेरा लैपटॉप) नहीं है। os.networkInterfaces () शायद जाने का रास्ता है।
जेफ व्हाइटिंग 20

1
ध्यान दें कि यह OS लुकअप का उपयोग करता है, जो जरूरी नहीं कि DNS लुकअप करता है और इसे अपना स्वयं का प्राथमिक आईपी पता होना चाहिए ...
w00t

क्या होगा अगर मुझे प्रत्येक इंटरफ़ेस का DNS पता मिल जाए
taha027

203

https://github.com/indutny/node-ip

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

@ यह है कि सवाल क्या है
सेब

1
इस पैकेज के लिए प्रलेखन अस्पष्ट है ... क्या मुझे प्रसारण पता भी मिल सकता है, या क्या मुझे इसे स्वयं आपूर्ति करना होगा?
माइकल

12
@ माजिदरीफ मैं नहीं जानता कि खराब दस्तावेज के लिए एक वैध बहाने के रूप में
माइकल

7
यह अविश्वसनीय रूप से अच्छी तरह से काम करता है। आईपी ​​एड्रेस प्राप्त करना वस्तुतः एक-लाइनर है। अति उत्कृष्ट।
EvSunWoodard

5
यह आपको सभी एडेप्टर का आईपी पता नहीं देता है। यदि आपने डॉकर स्थापित किया है, तो यह आपके वास्तविक ईथरनेट पते के बजाय
vE

62

अपनी मशीन के किसी भी आईपी को आप ओएस मॉड्यूल का उपयोग करके पा सकते हैं - और यह NodeJS का मूल निवासी है

var os = require( 'os' );

var networkInterfaces = os.networkInterfaces( );

console.log( networkInterfaces );

बस आपको os.networkInterfaces () कॉल करना होगा और आपको एक आसान प्रबंधनीय सूची मिल जाएगी - लीग द्वारा ifconfig चलाने से आसान

http://nodejs.org/api/os.html#os_os_networkinterfaces

श्रेष्ठ

एडोआर्डो


9
बहुत बढ़िया जवाब। var ip = networkInterfaces ['eth0'] [0] ['पता']
Natus आकर्षित

हालांकि यह बहुत अच्छा लगता है क्योंकि इसकी सरल, इसकी वास्तविक प्रभावशीलता संभवतः आपके नेटवर्क कॉन्फ़िगरेशन पर निर्भर करती है। उदाहरण के लिए, OS X के डिफ़ॉल्ट कॉन्फ़िगरेशन पर कोई eth0 नहीं है, यह en0 है।
ccnokes

3
मेरे लिये कार्य करता है। var address = networkInterfaces['venet0:0'][0].address
एंथनी

अजीब। SunOS 5.11 पर यह कॉल एक खाली वस्तु देता है
माइकल

34

यहां नोड.जेएस कोड का एक स्निपेट है जो आउटपुट को पार्स करेगा 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);

अभी OSX शेर पर परीक्षण किया गया, एकदम सही। बहुत बहुत धन्यवाद!
T3db0t

मुझे आपके विंडोज रेगेक्सपी में "आईपी" शब्द के बाद हाइफ़न को निकालना पड़ा, क्योंकि मेरे आउटपुट में हाइफ़न नहीं था (मैं विंडोज़ एक्सपी 32-बिट का उपयोग कर रहा हूं)। मुझे नहीं पता कि वह टाइपो था या यदि आपका विंडोज संस्करण "आईपी" के बाद वास्तव में एक हाइफ़न का उत्पादन करता है, लेकिन सिर्फ सुरक्षित पक्ष में होने के लिए, मुझे लगता है कि इसे वैकल्पिक बनाया जा सकता है filterRE = /\bIP-?[^:\r\n]+:\s*([^\s]+)/g;:। उस के अलावा, महान स्क्रिप्ट, एक सच्चे जीवन रक्षक। बहुत धन्यवाद!
उपयोगकर्ता

@ जेसेपिया: यह शायद एक स्थानीयकरण की बात है। जर्मन विंडोज "IP-Adresse";)
user123444555621

पर्याप्त रूप से उचित है, लेकिन अब आपने इसे फिर से तोड़ दिया: p मेरा ipconfig आउटपुट में "v4" और न ही "v6" शामिल नहीं है, जो कि एक विस्टा / 7 चीज़ लगती है (देखें technet.microsoft.com/en-us/library/bb7b95952 .aspx )
उपयोगकर्ता

इस तरह के हैक का कोई कारण नहीं है। अब हमारे पास os.networkInterfaces () है।
ब्रैड

32

यहां स्थानीय 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"
जय

30

जैसे आईपी नामक एक मॉड्यूल स्थापित करें

npm install ip

फिर इस कोड का उपयोग करें।

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


यह सार्वजनिक नहीं एक निजी आईपी पते देता है।
मेहमत कुर्तीपेक

23

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

यदि आप सोच रहे हैं, तो यह जरूरी नहीं है कि सार्वजनिक आईपी पता जिसे दुनिया देखे।
आर्टूर

एक अच्छा समाधान होगा यदि यह इंटरनेट कनेक्शन और इसकी गति पर निर्भर नहीं करता है ..
याकूब रास

मेरे उदाहरण में यह समाधान एकदम सही है, क्योंकि मुझे एक विशेष अनुरोध पर इंटरफ़ेस के आईपी को जानने की आवश्यकता है।
रेडिकैंड

20

आपका स्थानीय IP हमेशा 127.0.0.1 है।

फिर नेटवर्क आईपी है, जिसे आप ifconfig(* निक्स) या से प्राप्त कर सकते हैंipconfig (जीत) । यह केवल स्थानीय नेटवर्क के भीतर उपयोगी है।

फिर आपकी बाहरी / सार्वजनिक आईपी है, जिसे आप केवल तभी प्राप्त कर सकते हैं जब आप किसी तरह से इसके लिए राउटर से पूछ सकते हैं, या आप एक बाहरी सेवा सेटअप कर सकते हैं जो क्लाइंट आईपी पते को जब भी अनुरोध प्राप्त होता है। अस्तित्व में ऐसी अन्य सेवाएँ भी हैं, जैसे whatismyip.com।

कुछ मामलों में (उदाहरण के लिए यदि आपके पास WAN कनेक्शन है) तो नेटवर्क IP और सार्वजनिक IP समान हैं, और दोनों का उपयोग आपके कंप्यूटर तक पहुंचने के लिए बाहरी रूप से किया जा सकता है।

यदि आपका नेटवर्क और सार्वजनिक आईपी अलग-अलग हैं, तो आपको अपने नेटवर्क राउटर को अपने नेटवर्क आईपी पर आने वाले सभी कनेक्शनों को अग्रेषित करने की आवश्यकता हो सकती है।


अद्यतन २०१३:

अब ऐसा करने का एक नया तरीका है, आप किसी प्रॉपर्टी के लिए अपने कनेक्शन की सॉकेट ऑब्जेक्ट की जांच कर सकते हैं localAddress, जैसे कि net.socket.localAddress। यह आपके सॉकेट के अंत में पता देता है।

सबसे आसान तरीका सिर्फ एक यादृच्छिक पोर्ट खोलना और उस पर सुनना है, फिर अपना पता प्राप्त करें और सॉकेट बंद करें।


अद्यतन २०१५:

पिछला अब काम नहीं करता है।


क्या इसका मतलब यह है कि नोडजे में नेटवर्क पता प्राप्त करने के लिए आपको प्रतिक्रिया स्ट्रिंग को सिस्टम कॉल ifconfigया ipconfigपार्स करने की आवश्यकता है?
user123444555621

@ Pumbaa80 - बहुत ज्यादा, जब तक कि आपके नेटवर्क कार्ड में कुछ ड्राइवर नहीं होते हैं जिन्हें आप कॉल कर सकते हैं। इसके अलावा, अगर आप (Hamachi की तरह या एडेप्टर,) कई नेटवर्क कार्ड है, वहाँ कोई रास्ता नहीं तुम सिर्फ एक तरह के एक समारोह फोन और एक आईपी जो है प्राप्त कर सकते है आईपी। इसलिए इसे पार्स करना और इसके आउटपुट की व्याख्या करना बहुत ही एकमात्र तरीका है। ifconfig
Tor Valamo

ऐसा लग रहा है net.socketरिटर्न undefined2015 के रूप में, तो "ऐसा करने का नया तरीका" अब और काम नहीं करता। वहाँ एक है net.Socket, लेकिन यह एक localAddressसंपत्ति नहीं है ।
trysis

14

npm आईपी मॉड्यूल का उपयोग करें

var ip = require('ip');

console.log(ip.address());

> '192.168.0.117'

1
मुझे नहीं पता, इस पृष्ठ पर आने वाले उपयोगकर्ताओं को अब यह कैसे बताया जाए कि यह वर्तमान संदर्भ में एकमात्र उपयुक्त विकल्प है।
गगन

धन्यवाद @ गगन आपकी प्रशंसा।
KARTHIKEYAN.A

13

अंडरस्कोर और लॉश दोनों के लिए सही एक लाइनर है:

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

3
आप उपयोग कर सकते हैं: .find({family: 'IPv4', internal: false})साथ ही एक छोटे से अधिक सुरुचिपूर्ण कोड के लिए
dcohenb

9

यहां निर्भरता के बिना सबसे साफ, सरल उत्तर हो सकता है और जो सभी प्लेटफार्मों पर काम करता है।

const { lookup } = require('dns').promises;
const { hostname } = require('os');

async function getMyIPAddress(options) {
  return (await lookup(hostname(), options))
    .address;
}

8

मुझे पता है कि मैं आईपी पते के साथ शुरुआत करना चाहता था 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?
अनु

@anu या तो आपके द्वारा खोजे जा रहे उपसर्ग को बदलें, या लोगों द्वारा यहां पोस्ट किए गए कई अन्य समाधानों में से एक का उपयोग करें :-) मेरा स्थानीय आईपी हमेशा 192.168.उसी के साथ शुरू होता है जिसके कारण मैंने उसे चुना है।
एमपीएन

6

लिनक्स और मैकओएस उपयोग के लिए, यदि आप अपने आईपी को समकालिक तरीके से प्राप्त करना चाहते हैं, तो यह प्रयास करें।

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

6

मैंने एक 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 
});

जब यह अंग्रेजी में सेट नहीं किया जाता है तो शर्म की बात है कि यह विंडोज़ पर काम नहीं करता है :(
जेवियर जी।

1
इस बग की रिपोर्ट करने के लिए धन्यवाद, @JavierG! मैंने संस्करण 0.0.2 प्रकाशित किया है जो इसे ठीक करना चाहिए।
बेन हचिसन

5

यहाँ एक एकल आईपी प्राप्त करने के लिए वेनिला जावास्क्रिप्ट में एक सरलीकृत संस्करण है:

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

4

संक्षिप्तता में रुचि रखने वाले किसी के लिए, यहां कुछ "वन-लाइनर्स" हैं, जिन्हें प्लगइन्स / निर्भरता की आवश्यकता नहीं है जो एक मानक नोड इंस्टॉलेशन का हिस्सा नहीं हैं:

सार्वजनिक 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;

ध्यान रखें कि ये वन-लाइनर्स विशिष्ट प्लेटफॉर्म हैं। OS X पर, मेरे पास है en0और en1ईथरनेट और वाईफ़ाई के लिए। विंडोज पर, मेरे पास है Local Area Connectionऔर Wireless Network Connection
जुवे

यदि आप अपने सार्वजनिक दूरस्थ आईपी (OS X पर) के बारे में जानना चाहते हैं, तो उपयोग करें: var ip = आवश्यकता ('os')। networkInterfaces ()। En0 [1] .address;
मार्सेलो डॉस सैंटोस

3

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)

सर्वर प्रोग्राम चलाते समय, यह समाधान बहुत अधिक पोर्टेबिलिटी, सटीकता और दक्षता प्रदान करता है।

अधिक जानकारी के लिए, देखें:


3

ऊपर एक टिप्पणी के आधार पर, यहाँ नोड के वर्तमान संस्करण के लिए क्या काम कर रहा है:

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()अब एक सरणी के बजाय एक वस्तु लौटाता है।


1
I <3 लश। खासतौर पर लॉश गोल्फ! के _.chain(..)रूप में फिर से लिखा जा सकता है _(...), के रूप में फिर से लिखा .filter(..)जा सकता है .where({family: 'IPv4', internal: false}), और आप अंतिम रूप से छोड़ सकते हैं value()क्योंकि .first()यह आपके लिए जब जंजीर है।
रयान ग्राहम

3

यहाँ उपरोक्त उदाहरणों की भिन्नता है। यह ध्यान रखें कि 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;
}

3

मैं सिर्फ नोड जे एस का उपयोग कर ऐसा करने में सक्षम था

जैसा कि नोड जेएस

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

2

यहां मेरा संस्करण है जो पोर्टेबल तरीके से 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' } }

2

यदि आप पूरी संक्षिप्तता की बात कर रहे हैं, तो यहाँ यह लॉश का उपयोग कर रहा है :

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


2

अन्य उत्तरों के समान लेकिन अधिक रसीला:

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

1
केवल यह उल्लेख करना चाहते हैं कि आप के Object.keys(interfaces).reduce(...)साथ बदल सकते हैं Object.values(interfaces).flat()और यह एक ही बात होगी।
किंबौड़ी

2

मैक ओएस के लिए एक लाइनर पहला लोकलहोस्ट एड्रेस केवल।

मैक ओएस पर एप्लिकेशन विकसित करते समय, और इसे फोन पर परीक्षण करना चाहते हैं, और अपने ऐप को लोकलहोस्ट आईपी को स्वचालित रूप से चुनने की आवश्यकता है।

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

यह केवल उल्लेख करने के लिए है कि आप अपने आप आईपी पता कैसे पा सकते हैं। यह परीक्षण करने के लिए आप टर्मिनल हिट पर जा सकते हैं

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

आउटपुट आपका लोकलहोस्ट आईपी एड्रेस होगा।


2

यहाँ आपके लिए एक साफ सुथरा वन-लाइनर है जो यह कार्य करता है:

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
किमबौडी

2

कई बार मुझे लगता है उपलब्ध नहीं है कई आंतरिक और बाह्य संपर्क वाले इंटरफेस (उदाहरण: 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;

1

मैं नोड.जेएस 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 चालू इंटरफ़ेस से जुड़ी हुई है।
ब्ल्यूरेन

1

यहाँ पर झुरलीमन के उत्तर का एक बहु-आईपी संस्करण है:

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

1

मुझे लगता है कि यह एक पुराना धागा है, लेकिन मैं निम्नलिखित कारणों से शीर्ष उत्तर में सुधार की पेशकश करना चाहता हूं:

  • कोड यथासंभव आत्म व्याख्यात्मक होना चाहिए।
  • ... में ... का उपयोग करके किसी सरणी पर गणना करना चाहिए।
  • ... ... में ... यह सुनिश्चित करने के लिए कि आपके द्वारा खोजे जा रहे प्रॉपर्टी में समाहित होने के लिए एन्यूमरेशन को मान्य किया जाना चाहिए। के रूप में 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);
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.