ฉันมีโปรแกรม node.js ที่ใช้งานง่ายบนเครื่องของฉันและฉันต้องการรับที่อยู่ IP ของพีซีที่โปรแกรมของฉันทำงานอยู่ ฉันจะรับมันด้วย node.js ได้อย่างไร

'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

os.networkInterfaces ณ ตอนนี้ไม่สามารถใช้งานกับ windows ได้ การเรียกใช้โปรแกรมเพื่อแยกวิเคราะห์ผลลัพธ์ดูเหมือนว่าไม่แน่นอน นี่คือสิ่งที่ฉันใช้

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

สิ่งนี้จะส่งคืน IP โลคัลอินเตอร์เฟสเครือข่ายแรกของคุณ

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

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

IP เครื่องของคุณใด ๆ ที่คุณสามารถหาได้โดยใช้ระบบปฏิบัติการโมดูล - และที่พื้นเมืองเพื่อ NodeJS

var os = require( 'os' );

var networkInterfaces = os.networkInterfaces( );

console.log( networkInterfaces );

สิ่งที่คุณต้องทำคือโทรos.networkInterfaces ()และคุณจะได้รับรายการที่จัดการได้ง่าย - ง่ายกว่าทำงาน ifconfigโดยลีก

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

ดีที่สุด

Edoardo

นี่คือตัวอย่างของรหัส node.js ที่จะแยกผลลัพธ์ของ ifconfigและ (แบบอะซิงโครนัส) ส่งคืนที่อยู่ IP แรกที่พบ:

(ทดสอบบน MacOS Snow Leopard เท่านั้นหวังว่ามันจะทำงานบน 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ฟังก์ชั่นจะดำเนินการเรียกระบบทุกครั้ง มิฉะนั้นจะใช้ค่าแคช

อัปเดตเวอร์ชันแล้ว

ส่งคืนอาร์เรย์ของที่อยู่เครือข่ายท้องถิ่นทั้งหมด

ทดสอบกับ Ubuntu 11.04 และ Windows XP 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);

นี่คือวิธีการใช้งานยูทิลิตี้ของฉันในการรับที่อยู่ IP ในเครื่องโดยสมมติว่าคุณกำลังมองหาที่อยู่ IPv4 และเครื่องมีเพียงเครือข่ายอินเทอร์เฟซจริงเพียงตัวเดียว สามารถปรับโครงสร้างใหม่เพื่อส่งคืนอาร์เรย์ของ IP สำหรับเครื่องที่มีหลายอินเตอร์เฟสได้อย่างง่ายดาย

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

ติดตั้งโมดูลชื่อ ip like

npm install ip

จากนั้นใช้รหัสนี้

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

การเรียกใช้ ifconfig นั้นขึ้นอยู่กับแพลตฟอร์มเป็นอย่างมากและเลเยอร์เครือข่ายจะทราบว่าที่อยู่ IP ของซ็อกเก็ตเปิดอยู่ดังนั้นดีที่สุดคือการถาม โหนดไม่เปิดเผยวิธีโดยตรงในการทำเช่นนี้ แต่คุณสามารถเปิดซ็อกเก็ตใด ๆ และถามสิ่งที่อยู่ 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);
    }
});

IP ท้องถิ่นของคุณคือ 127.0.0.1 เสมอ

จากนั้นมี IP เครือข่ายซึ่งคุณสามารถรับได้จากifconfig(* ระวัง) หรือipconfig (ชนะ) สิ่งนี้มีประโยชน์เฉพาะในเครือข่ายท้องถิ่น

จากนั้นมี IP ภายนอก / สาธารณะของคุณซึ่งคุณจะได้รับก็ต่อเมื่อคุณสามารถขอเราเตอร์จากมันได้หรือคุณสามารถตั้งค่าบริการภายนอกซึ่งจะส่งคืนที่อยู่ IP ของไคลเอ็นต์เมื่อใดก็ตามที่ได้รับคำขอ นอกจากนี้ยังมีบริการอื่น ๆ ที่มีอยู่เช่น whatismyip.com

ในบางกรณี (เช่นหากคุณมีการเชื่อมต่อ WAN) IP เครือข่ายและ IP สาธารณะจะเหมือนกันและสามารถใช้ภายนอกทั้งสองเพื่อเข้าถึงคอมพิวเตอร์ของคุณ

หากเครือข่ายและ IP สาธารณะของคุณแตกต่างกันคุณอาจต้องให้เราเตอร์เครือข่ายส่งต่อการเชื่อมต่อขาเข้าทั้งหมดไปยังเครือข่าย ip ของคุณ

อัปเดต 2013:

มีวิธีการใหม่ของการทำเช่นนี้ตอนนี้คุณสามารถตรวจสอบวัตถุซ็อกเก็ตของการเชื่อมต่อของคุณสำหรับคุณสมบัติที่เรียกว่าเช่นlocalAddress net.socket.localAddressมันจะส่งคืนที่อยู่ที่ปลายซ็อกเก็ตของคุณ

วิธีที่ง่ายที่สุดคือเพียงเปิดพอร์ตสุ่มและฟังจากนั้นรับที่อยู่ของคุณและปิดซ็อกเก็ต

อัปเดตปี 2015:

ก่อนหน้านี้ไม่ทำงานอีกต่อไป

ใช้โมดูล ip npm

var ip = require('ip');

console.log(ip.address());

> '192.168.0.117'

ซับหนึ่งที่ถูกต้องสำหรับทั้งขีดล่างและLodashคือ:

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

นี่คือสิ่งที่อาจเป็นคำตอบที่สะอาดและง่ายที่สุดโดยไม่มีการอ้างอิง & ที่ใช้ได้กับทุกแพลตฟอร์ม

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

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

192.168.ทั้งหมดที่ผมรู้คือผมอยากเริ่มต้นกับที่อยู่ IP รหัสนี้จะให้คุณว่า:

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

แน่นอนคุณสามารถเปลี่ยนตัวเลขหากคุณกำลังมองหาที่แตกต่างกัน

สำหรับ Linux และ MacOS ใช้ถ้าคุณต้องการรับ IP ของคุณแบบซิงโครนัสให้ลองทำสิ่งนี้

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ที่กำหนดที่อยู่ IP ในพื้นที่ของคุณโดยดูว่าส่วนต่อประสานเครือข่ายใดที่มีเกตเวย์เริ่มต้นของคุณ

สิ่งนี้น่าเชื่อถือมากกว่าการเลือกอินเทอร์เฟซจากos.networkInterfaces()หรือการค้นหา DNS ของชื่อโฮสต์ สามารถละเว้นอินเทอร์เฟซเสมือนของ VMware, ลูปแบ็คและอินเทอร์เฟซ VPN และทำงานบน Windows, Linux, Mac OS และ FreeBSD ภายใต้ประทุนจะทำงาน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 
});

นี่เป็นเวอร์ชันที่เรียบง่ายในวานิลลาจาวาสคริปต์เพื่อรับ ip เดียว:

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

สำหรับทุกคนที่สนใจในความกะทัดรัดนี่คือ "one-liners" ที่ไม่ต้องการปลั๊กอิน / การพึ่งพาที่ไม่ได้เป็นส่วนหนึ่งของการติดตั้งโหนดมาตรฐาน:

Public IPv4 และ IPv6 ของ eth0 เป็น Array:

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

IP สาธารณะแรกของ eth0 (ปกติคือ IPv4) เป็นสตริง:

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

Google นำฉันไปที่คำถามนี้ในขณะที่ค้นหา"node.js get server ip"ดังนั้นให้คำตอบทางเลือกสำหรับผู้ที่พยายามบรรลุเป้าหมายนี้ในโปรแกรมเซิร์ฟเวอร์ node.js (อาจเป็นกรณีของโปสเตอร์ดั้งเดิม)

ในกรณีที่ไม่สำคัญที่สุดที่เซิร์ฟเวอร์ถูกผูกไว้กับที่อยู่ IP เดียวเท่านั้นไม่จำเป็นต้องกำหนดที่อยู่ IP เนื่องจากเราทราบแล้วว่าที่อยู่ใดที่เราผูกไว้ (เช่นพารามิเตอร์ตัวที่สองส่งผ่านไปยัง listen()ฟังก์ชัน)

ในกรณีเล็ก ๆ น้อย ๆ ที่เซิร์ฟเวอร์ถูกผูกไว้กับที่อยู่ IP หลายแห่งเราอาจต้องกำหนดที่อยู่ IP ของอินเทอร์เฟซที่ไคลเอ็นต์เชื่อมต่ออยู่ และตามคำแนะนำสั้น ๆ ของ Tor Valamo ทุกวันนี้เราสามารถรับข้อมูลนี้จากซ็อกเก็ตที่เชื่อมต่อและมันได้อย่างง่ายดายlocalAddressทรัพย์สินได้อย่างง่ายดาย

ตัวอย่างเช่นหากโปรแกรมเป็นเว็บเซิร์ฟเวอร์:

var http = require("http")

http.createServer(function (req, res) {
    console.log(req.socket.localAddress)
    res.end(req.socket.localAddress)
}).listen(8000)

และถ้าเป็นเซิร์ฟเวอร์ TCP ทั่วไป:

var net = require("net")

net.createServer(function (socket) {
    console.log(socket.localAddress)
    socket.end(socket.localAddress)
}).listen(8000)

เมื่อรันโปรแกรมเซิร์ฟเวอร์โซลูชันนี้ให้การพกพาความแม่นยำและประสิทธิภาพสูงมาก

สำหรับรายละเอียดเพิ่มเติมดู:

• http://nodejs.org/api/net.html
• http://nodejs.org/api/http.html

จากความคิดเห็นด้านบนนี่คือสิ่งที่ใช้ได้กับโหนดรุ่นปัจจุบัน:

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()ตอนนี้จะส่งคืนวัตถุแทนอาร์เรย์

นี่คือตัวอย่างของตัวอย่างข้างต้น มันจะระมัดระวังในการกรองอินเทอร์เฟซ vMware เป็นต้นหากคุณไม่ผ่านดัชนีมันจะส่งกลับที่อยู่ทั้งหมดไม่เช่นนั้นคุณอาจต้องการตั้งค่าเริ่มต้นเป็น 0 จากนั้นเพียงส่งผ่านค่า null เพื่อรับทั้งหมด แต่คุณจะคัดออก คุณสามารถส่งต่ออาร์กิวเมนต์อื่นสำหรับตัวกรอง regex หากมีแนวโน้มที่จะเพิ่ม

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

ฉันสามารถทำได้โดยใช้เพียงแค่โหนด js

ในฐานะโหนด JS

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

นี่เป็นฟังก์ชั่นรุ่นเดียวกันของ CoffeeScript:

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

หากคุณกำลังมองหาสิ่งที่กระชับนี่คือการใช้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);

คล้ายกับคำตอบอื่น ๆ แต่รวบรัดมากขึ้น:

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

หนึ่งซับสำหรับที่อยู่ localhost แรกของ MAC เท่านั้น

เมื่อพัฒนาแอพบน mac os และต้องการทดสอบบนโทรศัพท์และต้องการให้แอปของคุณเลือก localhost ip โดยอัตโนมัติ

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

นี่เป็นเพียงการกล่าวถึงวิธีที่คุณสามารถค้นหาที่อยู่ IP โดยอัตโนมัติ เพื่อทดสอบสิ่งนี้คุณสามารถไปที่ terminal hit

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

ผลลัพธ์จะเป็นที่อยู่ IP localhost ของคุณ

นี่คือหนึ่งซับเล็กน้อยสำหรับคุณที่ทำหน้าที่นี้:

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

หลายครั้งที่ผมพบว่ามีหลายการเชื่อมต่อภายในและภายนอกหันหน้าไปทางที่มีอยู่ (ตัวอย่าง: 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;

ฉันใช้ 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);

นี่คือคำตอบของ jhurliman ในเวอร์ชั่น multi-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);