IPV4地址、地址范围、地址/掩码解析，分别获取：重复、标准，错误

1、适用于多个IPV4地址 格式，例如：192.0.2.235,192.168.1.1/24,192.168.1.1-192.168.1.120...

// 混合数据：包括 IP地址、IP地址范围和IP地址子网掩码等情况
export const blendedData = (ip) => {
  // const data = ip //当data是数组时
  const data = ip.split(',') //当data是字符串时，（依逗号隔开为例）
  //  定义IP地址的正则表达式
  const ipValidation = /^(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])$/;
  // 定义IP地址范围的正则表达式
  const ipRangeRegex = /^([0-9]{1,3}.){3}[0-9]{1,3}-([0-9]{1,3}.){3}[0-9]{1,3}$/;
  // 定义IP地址/掩码长度的正则表达式
  const subnetRegex = /^([0-9]{1,3}\.){3}[0-9]{1,3}\/([0-9]|[1-2][0-9]|3[0-2])$/;

  let ipArray = [];// 定义IP地址（解析后的标准IP 也放在此处）
  let ipRangeArray = [];// IP地址范围
  let subnetArray = [];// IP地址子网掩码
  let mistakeArray = [];// 错误IP地址IP地址范围、IP地址子网掩码

  // 将数据字符串拆分成数组，并使用 map() 方法返回符合条件的 IP 地址、IP 地址范围和 IP 地址子网掩码
  data.map((item) => {
    if (ipValidation.test(item)) {
      ipArray.push(item);
    } else if (ipRangeRegex.test(item)) {
      ipRangeArray.push(item);
    } else if (subnetRegex.test(item)) {
      subnetArray.push(item);
    } else {
      mistakeArray.push(item);
    }
  });

  // 将ipRangeArray的IP地址范围转为单个IP
  ipRangeArray.forEach(range => {
    let [start, end] = range.split("-");
    start = start.split(".").map(Number);
    end = end.split(".").map(Number);
    for (let i = start[0]; i <= end[0]; i++) {
      for (let j = start[1]; j <= end[1]; j++) {
        for (let k = start[2]; k <= end[2]; k++) {
          for (let l = start[3]; l <= end[3]; l++) {
            ipArray.push(`${i}.${j}.${k}.${l}`);
          }
        }
      }
    }
  });
  // 将IP地址转换为十进制表示
  function ipToDecimal (ip) {
    var parts = ip.split(".");
    return (parseInt(parts[0]) << 24) + (parseInt(parts[1]) << 16) + (parseInt(parts[2]) << 8) + parseInt(parts[3]);
  }
  // 将十进制表示的IP地址转换为常规IP地址
  function decimalToIp (decimal) {
    var part1 = (decimal >> 24) & 255;
    var part2 = (decimal >> 16) & 255;
    var part3 = (decimal >> 8) & 255;
    var part4 = decimal & 255;
    return part1 + "." + part2 + "." + part3 + "." + part4;
  }
  // 获取子网地址
  function getSubnet (ip, maskLength) {
    var decimalIp = ipToDecimal(ip);
    var mask = Math.pow(2, 32 - maskLength) - 1;
    var subnet = decimalIp & ~mask;
    return subnet;
  }
  // 获取广播地址
  function getBroadcast (ip, maskLength) {
    var decimalIp = ipToDecimal(ip);
    var mask = Math.pow(2, 32 - maskLength) - 1;
    var broadcast = decimalIp | mask;
    return broadcast;
  }
  // 获取可用的IP地址范围
  function getUsableIps (ip, maskLength) {
    var subnet = getSubnet(ip, maskLength);
    var broadcast = getBroadcast(ip, maskLength);
    var usableIps = [];
    for (var i = subnet + 1; i < broadcast; i++) {
      usableIps.push(decimalToIp(i));
    }
    return usableIps;
  }
  // 将IP地址和子网掩码长度转换为可用的IP地址范围
  function convertIp (ipWithMask) {
    var parts = ipWithMask.split("/");
    var ip = parts[0];
    var maskLength = parseInt(parts[1]);
    var usableIps = getUsableIps(ip, maskLength);
    return usableIps;
  }
  // 遍历子网数组，将每个子网的可用IP地址范围添加到ipArray中
  for (let i = 0; i < subnetArray.length; i++) {
    ipArray.push(...convertIp(subnetArray[i]))
  }

  let nonredundant = [];// 去重后的地址
  let duplicateData = [];// 重复的地址
  let hintData = []; // 重复的地址（ XXXXXX 出现 N 次 ）

  // 去重
  nonredundant = Array.from(new Set(ipArray));
  // 获取重复元素
  duplicateData = ipArray.filter((item, index) => ipArray.indexOf(item) !== index);

  // 获取重复元素
  const duplicateObj = {};
  ipArray.forEach((item) => {
    if (duplicateObj[item]) {
      duplicateObj[item]++;
    } else {
      duplicateObj[item] = 1;
    }
  });

  // 格式化数据  重复的出现几次 
  hintData = Object.keys(duplicateObj)
    .filter((key) => duplicateObj[key] > 1)
    .map((key) => {
      return { [key]: `出现${duplicateObj[key]}次` };
    });

  return { ipArray, ipRangeArray, subnetArray, mistakeArray, nonredundant, duplicateData, hintData }
};

2、验证：全新vue2项目