Получить локальный IP-адрес в node.js


308

На моем компьютере запущена простая программа node.js, и я хочу получить локальный IP-адрес ПК, на котором запущена моя программа. Как мне получить его с помощью node.js?


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 _ = require ('underscore'); var ip = _.chain (require ('os'). networkInterfaces ()). flatten (). filter (function (val) {return (val.family == 'IPv4' && val.internal == false)}) .. .pluck ( 'адрес') первого () значение (); console.log (ip)
Картер Коул

Шестая строка должна быть, if( details.family=='IPv4' && details.internal === false ) {если вы просто хотите внешние IP-адреса.
Арлен Бейлер

3
@CarterCole вам нужен дополнительный вызов .values ​​(), прежде чем сгладить.
Гвидо

1
Что если я хочу получить только IP-адрес активного интерфейса?
Tejas

1
один вкладыш без lodash для узла> = 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 на данный момент не работает на Windows. Запускать программы для анализа результатов кажется немного сомнительным. Вот что я использую.

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

Это должно вернуть ваш первый сетевой интерфейс локальный IP.


4
@HermannIngjaldsson: Это не очень информативная критика. Не могли бы Вы уточнить? Может быть, взять пример кода и поставить его в новый вопрос, предоставив больше деталей и спросив, почему он не работает?
Xedecimal

8
Не всегда хорошая идея использовать поиск DNS, поскольку он может возвращать неверную информацию (например, кэшированные данные). Использование os.networkInterfaces, на мой взгляд, является лучшей идеей.
Гвидо

1
Использование DNS работает, если ваш сервер где-то имеет запись DNS. Однако во многих приложениях нет записи DNS (например, мой ноутбук). os.networkInterfaces (), вероятно, путь.
Джефф Уайтинг

1
Обратите внимание, что здесь используется поиск ОС, который не обязательно выполняет поиск DNS и должен знать свой собственный первичный IP-адрес ...
w00t

что если я получу DNS-адрес каждого интерфейса
taha027

203

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

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

@ Ури, это то, о чем спрашивает вопрос
Себ

1
документация для этого пакета неясна ... могу ли я также получить широковещательный адрес или я должен предоставить его сам?
Майкл

12
@majidarif Я не признаю это как оправдание плохой документации
Майкл

7
Это работает невероятно хорошо. Получение IP-адреса буквально однострочно. Превосходно.
EvSunWoodard

5
Он не дает вам IP-адрес всех адаптеров. Если у вас установлен Docker, он дает адрес док-станции vEthernet вместо вашего фактического адреса Ethernet
TetraDev

62

Любой 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

Лучший

Эдоардо


9
Потрясающий ответ. var ip = networkInterfaces ['eth0'] [0] ['address']
Natus Drew

хотя это кажется большим, потому что это просто, его фактическая эффективность, вероятно, зависит от конфигурации вашей сети. Например, в конфигурации по умолчанию OS X нет eth0, это en0.
cnnokes

3
Работает для меня. var address = networkInterfaces['venet0:0'][0].address
Энтони

странно. в SunOS 5.11 этот вызов возвращает пустой объект
Michael

34

Вот фрагмент кода 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);

Протестировано только сейчас на OSX Lion, отлично. Спасибо!
T3db0t

Мне пришлось удалить дефис после слова «IP» в вашем регулярном выражении Windows, потому что мой вывод не содержал дефис (я использую 32-разрядную версию Windows XP). Я не знаю , если это была опечатка или если ваша версия Windows , действительно выводит дефис после «IP», но только , чтобы быть на безопасной стороне, я предполагаю , что это может быть сделано по желанию: filterRE = /\bIP-?[^:\r\n]+:\s*([^\s]+)/g;. Помимо этого, отличный сценарий, настоящий спасатель. Большое спасибо!
Пользователь не найден

@jSepia: Вероятно, это вещь локализации. Немецкая Windows печатает "IP-адрес";)
user123444555621

Справедливо, но теперь вы снова его сломали: p Мой вывод ipconfig не включает ни «v4», ни «v6», что, похоже, относится к Vista / 7 (см. Technet.microsoft.com/en-us/library/bb726952 .aspx )
пользователь не найден

Там нет причин для такого взлома. Теперь у нас есть os.networkInterfaces ().
Брэд

32

Вот мой метод получения локального 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';
}

Кофейная версия: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

Установите модуль под названием ip like

npm install ip

затем используйте этот код.

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

5
Это возвращает 127.0.0.1
WeSam Abdallah

он возвращает частный IP-адрес, а не публичный.
Мехмет Куртипек

23

Вызов 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-адрес, который видит мир.
артур

Было бы хорошим решением, если бы оно не зависело от интернет-соединения и его скорости.
Джейкоб Раск

В моем случае это решение идеально, так как мне нужно знать IP интерфейса, на который поступает конкретный запрос.
radicand

20

Ваш локальный IP-адрес всегда 127.0.0.1.

Затем есть сетевой IP-адрес, который вы можете получить из ifconfig(* nix) или ipconfig(win). Это полезно только внутри локальной сети.

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

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

Если ваша сеть и общедоступные IP-адреса различаются, вам может потребоваться, чтобы сетевой маршрутизатор переадресовывал все входящие соединения на ваш ip сети.


Обновление 2013:

Там новый способ сделать это сейчас, вы можете проверить объект сокета вашего соединения для свойства под названием localAddress, например net.socket.localAddress. Он возвращает адрес на вашем конце сокета.

Самый простой способ - просто открыть случайный порт и прослушать его, затем получить свой адрес и закрыть сокет.


Обновление 2015:

Предыдущее больше не работает.


Означает ли это, что для получения сетевого адреса в nodejs необходимо выполнить системный вызов ifconfigили ipconfigи проанализировать строку ответа?
user123444555621

@ Pumbaa80 - В значительной степени, если на вашей сетевой карте нет драйверов, на которые вы можете позвонить. Кроме того, если у вас есть несколько сетевых карт (или адаптеров, как Hamachi), нет никакого способа , вы можете просто вызвать функцию своего рода и получить один IP , который является IP. Таким образом, анализ и интерпретация выходных данных в значительной степени единственный путь. ifconfig
Тор Валамо

Похоже, что net.socketвозвращение undefinedс 2015 года, так что «новый способ сделать это» больше не работает. Есть net.Socket, но у него нет localAddressсобственности.
trysis

14

использовать модуль npm ip

var ip = require('ip');

console.log(ip.address());

> '192.168.0.117'

1
Я не знаю, как сказать пользователям, которые заходят на эту страницу сейчас, что это единственный подходящий вариант в текущем контексте.
Гаган

Спасибо @Gagan Ваша оценка.
КАРТИКЕЯН.А

13

Правильная подкладка для подчеркивания и lodash :

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

Все, что я знаю, я хотел, чтобы 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;
            }
        }
    }
}

Конечно, вы можете просто изменить цифры, если вы ищете другой.


Что делать, если адрес не начинается с 192.168?
ана

@anu Либо измените префикс на тот, который вы ищете, либо воспользуйтесь одним из множества других решений, которые люди разместили здесь :-) Мой локальный IP-адрес всегда начинается именно с 192.168.этого, поэтому я выбрал его.
mpen

6

для 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' ]

6

Я написал модуль 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 
});

позор, это не работает на окнах, когда язык не установлен на английский язык :(
Хавьер Г.

1
Спасибо за сообщение об этой ошибке, @JavierG! Я опубликовал версию 0.0.2, которая должна это исправить.
Бен Хатчисон

5

Вот упрощенная версия ванильного 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';
}

4

Для тех, кто интересуется краткостью, вот некоторые «однострочные», которые не требуют плагинов / зависимостей, которые не являются частью стандартной установки Node:

Общедоступные IPv4 и IPv6 из eth0 в качестве массива:

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

Первый публичный IP-адрес eth0 (обычно IPv4) в виде строки:

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

Имейте в виду, что эти однострочники зависят от платформы. На OS X у меня есть en0и en1для ethernet и wifi. На винде у меня Local Area Connectionи Wireless Network Connection.
xverges

Если вы хотите узнать о вашем публичном удаленном IP-адресе (в OS X), используйте: var ip = require ('os'). NetworkInterfaces (). En0 [1] .address;
Марсело душ Сантуш

3

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)

При запуске серверной программы это решение предлагает очень высокую мобильность, точность и эффективность.

Для более подробной информации смотрите:


3

Основываясь на комментарии выше, вот что работает для текущей версии 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()теперь возвращает объект вместо массива.


1
Я <3 лодаш. Особенно лодаш гольф! _.chain(..)Может быть переписано в виде _(...), то .filter(..)может быть переписано , как .where({family: 'IPv4', internal: false})и вы можете оставить окончательные , value()потому что .first()делает это для вас , когда сцепления.
Райан Грэм

3

Вот вариант приведенных выше примеров. Это требует фильтрации интерфейсов 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;
}

3

Я смог сделать это, используя только узел JS

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

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

Вот версия 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' } }

2

Если вам нравится вся эта краткость, то здесь используется 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);


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

Один вкладыш для MAC только по первому локальному адресу.

Когда вы разрабатываете приложения для Mac OS и хотите проверить это на телефоне, вам нужно, чтобы ваше приложение автоматически выбирало IP-адрес localhost.

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

Это просто упомянуть, как вы можете узнать IP-адрес автоматически. Чтобы проверить это, вы можете перейти к терминальному удару

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

вывод будет ваш IP-адрес localhost.


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

Я использую 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);

Это работает с hostname -I(в верхнем регистре я). Возвращает список всех назначенных IP-адресов аппарата. Первый IP-адрес - это то, что вам нужно. Этот IP-адрес тот, который подключен к текущему интерфейсу, который работает.
Блюр

1

Вот версия ответа Джурлимана для нескольких 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;
}

1

Я понимаю, что это старая ветка, но я бы хотел предложить лучший ответ по следующим причинам:

  • Код должен быть как можно более понятен.
  • Следует избегать перечисления по массиву с использованием for ... in ...
  • Перечисление for ... in ... должно быть проверено, чтобы убедиться, что перечисляемый объект содержит искомое свойство. Поскольку javsacript свободно напечатан и for ... in ... может быть передан любой произвольный объект для обработки; безопаснее подтвердить, что свойство, которое мы ищем, доступно.

    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 и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.