У мене на моїй машині працює проста програма 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.networkInterface зараз не працює у 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 вашої машини ви можете знайти за допомогою модуля os - і це рідний для NodeJS

var os = require( 'os' );

var networkInterfaces = os.networkInterfaces( );

console.log( networkInterfaces );

Все, що вам потрібно зробити - це зателефонувати на os.networkInterfaces (), і ви отримаєте простий керований список - простіше, ніж запустити ifconfig по лігах

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

Найкраще

Едоардо

Ось фрагмент коду 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-адресах знаходиться сокет, тому краще запитати його. Node не відкриває прямий метод цього, але ви можете відкрити будь-який сокет і запитати, яка локальна 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(* nix) або ipconfig(win). Це корисно лише в локальній мережі.

Тоді є ваш зовнішній / загальнодоступний IP-адресу, який ви можете отримати лише в тому випадку, якщо можете якось попросити маршрутизатор для нього, або ви можете встановити зовнішню службу, яка повертає IP-адресу клієнта, коли він отримує запит. Існують також інші такі сервіси, як whatismyip.com.

У деяких випадках (наприклад, якщо у вас підключення до мережі WAN) мережевий IP та загальнодоступний IP-адреси є однаковими, і вони можуть використовуватися зовнішньо, щоб дістатися до комп'ютера.

Якщо ваші мережеві та загальнодоступні IP-адреси відрізняються, можливо, вам знадобиться передати мережевий маршрутизатор всі вхідні з'єднання до вашої мережі ip.

Оновлення 2013:

Зараз є новий спосіб зробити це, ви можете перевірити об'єкт сокета вашого з'єднання на наявність властивості, яка називається localAddress, наприклад net.socket.localAddress. Він повертає адресу на вашому кінці сокета.

Найпростіший спосіб - просто відкрити випадковий порт і прослухати його, а потім отримати свою адресу і закрити сокет.

Оновлення 2015:

Попередній більше не працює.

використовувати npm ip-модуль

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;

Ось що може бути найпростішим, найпростішим відповіддю без залежностей & що працює на всіх платформах.

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

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

Все, що я знаю, це те, що я хотів, щоб IP-адреса починалася з 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;
            }
        }
    }
}

Звичайно, ви можете просто змінити числа, якщо шукаєте інше.

для 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 
});

Ось спрощена версія у ванільному javascript для отримання єдиного 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';
}

Для всіх, хто цікавиться стислістю, ось декілька "однокласників", які не потребують плагінів / залежностей, які не є частиною стандартної установки вузла:

Загальнодоступні IPv4 та IPv6 of eth0 як масив:

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

Перший загальнодоступний IP-адрес eth0 (зазвичай IPv4) як String:

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

На основі коментаря вище, ось що працює для поточної версії Node:

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, щоб отримати всі, але ви розіб’єте це. Ви також можете передати інший аргумент для фільтра регулярних виразів, якщо так схильний додати

    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

Як Node 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);

Як сценарій bash (потрібен вузол 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);

Один вкладиш для MAC os лише для першої локальної адреси.

Коли ви розробляєте програми на mac os і хочете протестувати його на телефоні, і вам потрібно, щоб ваш додаток автоматично вибирав localhost ip.

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

Це лише згадати, як можна автоматично дізнатись ip-адресу. Щоб перевірити це, ви можете перейти до термінального звернення

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

Ось мульти-ip версія відповіді jhurliman вище:

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

Я усвідомлюю, що це стара тема, але я хотів би запропонувати покращення основної відповіді з наступних причин:

• Код повинен бути максимально зрозумілим.
• Слід уникати перерахування масиву, що використовує для ... in ....

• для ... в ... перерахування слід перевірити, щоб переконатися, що перерахований об'єкт містить властивість, яку ви шукаєте. Оскільки 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);