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

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

Ответ 1

'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

Ответ 2

~~os.networkИнтерфейсы по состоянию на данный момент не работают в Windows.~~ Запуск программ для синтаксического анализа результатов кажется немного неправильным. Вот что я использую.

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

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

Ответ 3

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

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

Ответ 4

Любой IP-адрес вашего компьютера, который вы можете найти с помощью модуля os, и native для NodeJS

var os = require( 'os' );

var networkInterfaces = os.networkInterfaces( );

console.log( networkInterfaces );

Все, что вам нужно сделать, это вызвать os.networkInterfaces(), и вы получите легко управляемый список - проще, чем запуск ifconfig лигами

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

Лучшие

Эдоардо

Ответ 5

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

Ответ 6

Установите модуль с именем ip как

npm install ip

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

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

Ответ 7

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

Ответ 8

Вызов 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);
    }
});

Ответ 9

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

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

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

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

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

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

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

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

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

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

Ответ 10

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

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

Ответ 11

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

var ip = require('ip');

console.log(ip.address());

> '192.168.0.117'

Ответ 12

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

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

Ответ 13

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

Ответ 14

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

Ответ 15

Для всех, кто заинтересован в краткости, вот некоторые "однострочные", которые не требуют плагинов/зависимостей, которые не являются частью стандартной установки 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;

Ответ 16

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

Ответ 17

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)

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

Подробнее см.

Ответ 18

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

Ответ 19

Вот вариант приведенных выше примеров. Он берет на себя фильтрацию интерфейсов vMware и т.д. Если вы не передаете индекс, он возвращает все адреса, иначе вы можете установить его по умолчанию на 0, а затем просто передать null, чтобы получить все, но вы разобьете его. Вы также можете передать другой 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;
}

Ответ 20

Здесь мой вариант, который позволяет переносить адреса 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' } }

Ответ 21

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

Ответ 22

Как и другие ответы, но более сжатые:

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

Ответ 23

Один лайнер для MAC-адреса только для локального хоста.

При разработке приложений на 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

вывод будет вашим адресом localhost ip.

Ответ 24

Много раз я обнаружил, что доступно несколько внутренних и внешних интерфейсов (пример: 10.0.75.1, 172.100.0.1, 192.168.2.3), и это внешний, который мне действительно 172.100.0.1 (172.100.0.1).

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

const address = Object.keys(os.networkInterfaces())
    // flatten interfaces to an array
    .reduce((a, key) => [
        ...a,
        ...os.networkInterfaces()[key]
    ], [])
    // non-internal ipv4 addresses only
    .filter(iface => iface.family === 'IPv4' && !iface.internal)
    // project ipv4 address as a 32-bit number (n)
    .map(iface => ({...iface, n: (d => ((((((+d[0])*256)+(+d[1]))*256)+(+d[2]))*256)+(+d[3]))(iface.address.split('.'))}))
    // set a hi-bit on (n) for reserved addresses so they will sort to the bottom
    .map(iface => iface.address.startsWith('10.') || iface.address.startsWith('192.') ? {...iface, n: Math.pow(2,32) + iface.n} : iface)
    // sort ascending on (n)
    .sort((a, b) => a.n - b.n)
    [0]||{}.address;

Ответ 25

Вот что может быть самым чистым и простым ответом без зависимостей, который работает на всех платформах.

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

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

Ответ 26

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

Ответ 27

Вот версия jhurliman с несколькими 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;
}

Ответ 28

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

Код должен быть максимально понятным.
Следует избегать перечисления массива с помощью для... в....

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

Ответ 29

надеюсь, что это поможет

var os = require( 'os' );
var networkInterfaces = os.networkInterfaces( );
var arr = networkInterfaces['Local Area Connection 3']
var ip = arr[1].address;

Ответ 30

Здесь аккуратный маленький вкладыш для вас, который делает это функционально:

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