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

Ни одна из этих функций не будет проверять ваши IP-адреса!

Метод 1: Сдвиг бит

/**
 * Checks if an IP address is within range of 2 other IP addresses
 * @param  {String}  ip         IP to validate
 * @param  {String}  lowerBound The lower bound of the range
 * @param  {String}  upperBound The upper bound of the range
 * @return {Boolean}            True or false
 */
function isWithinRange(ip, lowerBound, upperBound) {

  // Put all IPs into one array for iterating and split all into their own 
  // array of segments
  var ips = [ip.split('.'), lowerBound.split('.'), upperBound.split('.')];

  // Convert all IPs to ints
  for(var i = 0; i < ips.length; i++) {

    // Typecast all segments of all ips to ints
    for(var j = 0; j < ips[i].length; j++) {
      ips[i][j] = parseInt(ips[i][j]);
    }

    // Bit shift each segment to make it easier to compare
    ips[i] = 
      (ips[i][0] << 24) + 
      (ips[i][1] << 16) + 
      (ips[i][2] << 8) + 
      (ips[i][3]);
  }

  // Do comparisons
  if(ips[0] >= ips[1] && ips[0] <= ips[2]) return true;

  return false;
}

Метод 2: Обычный логический беспорядок

/**
 * Checks if an IP address is within range of 2 other IP addresses
 * @param  {String}  ip         IP to validate
 * @param  {String}  lowerBound The lower bound of the range
 * @param  {String}  upperBound The upper bound of the range
 * @return {Boolean}            True or false
 */
function isWithinRange(ip, lowerBound, upperBound) {

  // Save us some processing time if the IP equals either the lower bound or 
  // upper bound
  if (ip === lowerBound || ip === upperBound) return true;

  // Split IPs into arrays for iterations below. Use same variables since 
  // we won't need them as strings anymore and because someone will complain 
  // about wasting memory.
  ip = ip.split('.');
  lowerBound = lowerBound.split('.');
  upperBound = upperBound.split('.');

  // A nice, classic for loop iterating over each segment in the IP address
  for (var i = 0; i < 4; i++) {

    // We need those segments to be converted to ints or our comparisons 
    // will not work!
    ip[i] = parseInt(ip[i]);
    lowerBound[i] = parseInt(lowerBound[i]);
    upperBound[i] = parseInt(upperBound[i]);

    // If this is our first iteration, just make sure the first segment 
    // falls within or equal to the range values
    if (i === 0) {
      if (ip[i] < lowerBound[i] || ip[i] > upperBound[i]) {
        return false;
      }
    }

    // If the last segment was equal to the corresponding lower bound 
    // segment, make sure that the current segment is greater
    if (ip[i - 1] === lowerBound[i - 1]) {
      if (ip[i] < lowerBound[i]) return false;
    }

    // If the last segment was equal to the corresponding upper bound 
    // segment, make sure that the current segment is less than
    if (ip[i - 1] === upperBound[i - 1]) {
      if (ip[i] > upperBound[i]) return false;
    }
  }

  return true;
}