Какой самый эффективный способ простого сравнения IP-адресов?

IP-адреса, какими мы их знаем, представляют собой просто строковые представления 32-битных числовых значений.

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

var atoi = function atoi(addr) {
  var parts = addr.split('.').map(function(str) {
    return parseInt(str); 
  });

  return (parts[0] ? parts[0] << 24 : 0) +
         (parts[1] ? parts[1] << 16 : 0) +
         (parts[2] ? parts[2] << 8  : 0) +
          parts[3];
};

var checkIpaddrInRange = function checkIpaddrInRange(ipaddr, start, end) {
  var num = atoi(ipaddr);
  return (num >= atoi(start)) && (num <= atoi(end));
}


checkIpaddrInRange('10.0.1.1', '10.0.0.1', '10.0.2.1'); // => true

checkIpaddrInRange('10.0.3.1', '10.0.0.1', '10.0.2.1'); // => false

См. скрипку.

Вот то же самое, полностью прокомментированное и правильно проверенное на ошибки:

/**
 * Checks if ipaddr is valid.
 * @property {string} ipaddr
 * @throws Error 
 */
var assertIsIpaddr = function assertIsIpaddr(ipaddr) {

  if('string' !== typeof ipaddr && ipaddr) {
    throw new Error('ipaddr must be a non-empty string');
  }

  var parts=ipaddr.split(/\./);

  if(parts.length !== 4){
    throw new Error('ipaddr must have four octets');
  }

  var i=0;
  parts.map(function(str){
      var val=parseInt(str),
          octet = 4 - i++;;
      if(val < 0 || val > 255){
        throw new Error('octet '+octet+' must be between 0 and 255');
      }
  });
};

/**
 * Converts an ipaddr to a 32bit integer value.
 * @property {string} addr - the ipaddr to convert
 * @returns {number}
 */
var atoi = function atoi(addr) {

  // test for validity - will throw!
  assertIsIpaddr(addr);

  // convert octets to numbers
  var parts = addr.split('.').map(function(str) {
    return parseInt(str); 
  });

  // construct result
  var result = (parts[0] ? parts[0] << 24 : 0) +   // if > 0, shift 4th octet left by 24
               (parts[1] ? parts[1] << 16 : 0) +   // if > 0, shift 3rd octet left by 16
               (parts[2] ? parts[2] << 8  : 0) +   // if > 0, shift 2nd octet left by 8
                parts[3];

  // note that if all octets are 255, result will overflow 
  // JavaScript (32bit) number to become -1, so we have to 
  // special case it. I think throwing an error here is a 
  // reasonable solution, since 255.255.255.255 is actually 
  // a broadcast addr.

  if(result < 0) {
    throw new Error('255.255.255.255 is not a legal host ipaddr');
  }

  return result;
};

/**
 * Checks ipaddr membership within a range of ipaddrs.
 * @property {string} ipaddr - ipaddr to check
 * @property {string} start - the start of the ipaddr range 
 * @property {string} end - the end of the ipaddr range
 * @returns {boolean} - true if ipaddr is between start and end (inclusive)
 */
var checkIpaddrInRange = function checkIpaddrInRange(ipaddr, start, end) {
  var num = atoi(ipaddr);
  return (num >= atoi(start)) && (num <= atoi(end));
}

// OK, test it out...

checkIpaddrInRange('10.0.1.1','10.0.0.1','10.0.2.1'); // => true

checkIpaddrInRange('10.0.3.1','10.0.0.1','10.0.2.1'); // => false

Вероятно, есть более простой способ сделать это, но вот как я могу подойти к этому.

function pad(n) {
    return (n.length < 3) ? pad('0' + n) : n;
}

// return a number with each part of the IP padded out to 3 digits
function convert(ip) {
    return parseInt(ip.split('.').map(function (el) {
       return pad(el);
    }).join(''), 10);
}

// check the number against the range
function check(range, ip) {
  ip = convert(ip);
  return ip >= range[0] && ip <= range[1];
}

// convert the range
var range = ['50.1.100.1', '51.1.30.1'].map(function (el) {
  return convert(el);
});

check(range, '51.1.20.2'); // true
check(range, '51.1.40.2'); // false

ДЕМО

Используйте ipaddr.js (npm i ipaddr.js):

const ipaddr = require('ipaddr.js')

const addr = ipaddr.parse('2001:db8:1234::1')

addr.match(ipaddr.parseCIDR('2001:db8::/32')) // => true

Or:

const rangeList = {
  documentationOnly: [ ipaddr.parse('2001:db8::'), 32 ],
  tunnelProviders: [
    [ ipaddr.parse('2001:470::'), 32 ], // he.net
    [ ipaddr.parse('2001:5c0::'), 32 ]  // freenet6
  ]
}
ipaddr.subnetMatch(ipaddr.parse('2001:470:8:66::1'), rangeList, 'unknown') // => "tunnelProviders"

Официальная документация

Может быть, короткий подход будет

const ipAddress = '10.120.238.254';

const asNumber = ipAdress.split('.')
 .map(p => parseInt(p))
 .reverse()
 .reduce((acc,val,i) => acc+(val*(256**i)),0)

Затем сравните числа