내 컴퓨터에서 실행중인 간단한 node.js 프로그램이 있고 프로그램이 실행되는 PC의 로컬 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() );

os 모듈 을 사용하여 찾을 수있는 시스템의 모든 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

베스트

에도아르도

다음은 ifconfig발견 된 첫 번째 IP 주소 의 출력을 구문 분석 하고 (비동기 적으로) 반환하는 node.js 코드 스 니펫입니다 .

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

IPv4 주소를 찾고 있고 컴퓨터에 실제 네트워크 인터페이스가 하나만 있다고 가정하면 로컬 IP 주소를 얻는 유틸리티 방법은 다음과 같습니다. 다중 인터페이스 시스템에 대한 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와 같은 모듈을 설치하십시오.

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입니다.

그런 다음 ifconfig(* nix) 또는 ipconfig(win) 에서 얻을 수있는 네트워크 IP가 있습니다 . 이것은 로컬 네트워크 내에서만 유용합니다.

그런 다음 외부 / 공용 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'

밑줄 과 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;
}

내가 아는 것은로 시작하는 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' ]

나는 썼다 기본 게이트웨이가 포함 된 네트워크 인터페이스를보고 로컬 IP 주소를 결정 Node.js 모듈 을 .

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

간결함에 관심이있는 사용자를 위해 표준 노드 설치에 포함되지 않은 플러그인 / 종속성이 필요없는 일부 "한 줄짜리"가 있습니다.

배열로서 eth0의 퍼블릭 IPv4 및 IPv6 :

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

문자열로 eth0 (일반적으로 IPv4)의 첫 번째 공용 IP :

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

"node.js get server ip" 를 검색하는 동안 Google에서이 질문에 대한 답변을 했기 때문에 node.js 서버 에서이를 달성하려는 사람들에게 다른 답변을 드리겠습니다. 프로그램 (원래 포스터의 경우 일 수 있음).

서버가 하나의 IP 주소에만 바인딩되는 가장 사소한 경우에는 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를 사용 하여이 작업을 수행 할 수있었습니다.

노드 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에서 앱을 개발할 때 휴대 전화에서 앱을 테스트하고 로컬 호스트 IP를 자동으로 선택하려면 앱이 필요합니다.

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

이것은 IP 주소를 자동으로 찾는 방법을 언급하는 것입니다. 이것을 테스트하기 위해 터미널 히트로 이동할 수 있습니다

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

출력은 localhost IP 주소가됩니다.

기능적으로이 작업을 수행하는 깔끔한 작은 하나의 라이너가 있습니다.

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의 답변에 대한 다중 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;
}

나는 이것이 오래된 스레드라는 것을 알고 있지만 다음과 같은 이유로 최고 답변을 개선하고 싶습니다.

• 코드는 가능한 한 자명해야합니다.
• 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);