【study】判断所选的时间段是否重合

1. 判断数组validHourList中是否存在时间重叠的问题 ?

// 可以使用双重循环来比较每对时间段，然后检查是否存在重叠。
const validHourList = [
    {
        validHour: ['00:00', '01:00'],
    },
    {
        validHour: ['00:00', '02:00'],
    },
    {
        validHour: ['01:00', '10:00'],
    },
];

let hasOverlap = false;

for (let i = 0; i < validHourList.length; i++) {
    const currentValidHour = validHourList[i].validHour;
    
    for (let j = i + 1; j < validHourList.length; j++) {
        const nextValidHour = validHourList[j].validHour;
        
        if (currentValidHour[0] <= nextValidHour[1] && nextValidHour[0] <= currentValidHour[1]) {
            hasOverlap = true;
            break;
        }
    }
    
    if (hasOverlap) {
        break;
    }
}

if (hasOverlap) {
    console.log('存在时间重叠的问题');
} else {
    console.log('没有时间重叠的问题');
}

// currentValidHour[0] <= nextValidHour[1] ：当前时间区间的开始时间小于或等于下一个时间区间的结束时间
// nextValidHour[0] <= currentValidHour[1]：下一个时间区间的开始时间小于或等于当前时间区间的结束时间
// 如果这两个条件同时满足，就说明两个时间区间存在重叠
// 如果条件为真，设置 `hasOverlap` 为 `true` 并退出内层循环（因为已经找到了一个重叠，不需要继续检查）

// 通过将时间字符串转换为分钟数进行比较，然后进行排序和线性扫描来确定是否存在重叠

  // 转成分钟
  function parseTime(timeStr) {
    const [hours, minutes] = timeStr.split(':').map(Number);
    return hours * 60 + minutes;
  }
  
  // 转成秒
  function parseTimeSeconds(timeStr) {
    const [hours, minutes, seconds] = timeStr.split(':').map(Number);
    return hours * 3600 + minutes * 60 + seconds;
  }


  const validHourList = [
    { validHour: ['00:00', '01:00'] },
    { validHour: ['00:00', '02:00'] },
    { validHour: ['01:00', '10:00'] },
  ];

  const validHours = validHourList.map(item => ({
    start: parseTime(item.validHour[0]),
    end: parseTime(item.validHour[1]),
  }));

  // 排序
  validHours.sort((a, b) => a.start - b.start);


  console.log(validHours, 'validHours-------Sort')

  let hasOverlap = false;
  // 进行线性扫描来检查相邻时间区间是否重叠
  for (let i = 1; i < validHours.length; i++) {
    if (validHours[i].start < validHours[i - 1].end) {
      hasOverlap = true;
      break;
    }
  }
  //  从第二个时间区间开始（索引 i = 1），将每一个时间区间的 start 与前一个时间区间的 end 进行比较
  //  如果 `validHours[i].start < validHours[i - 1].end`，说明当前时间区间和前一个时间区间有重叠，设置 `hasOverlap` 为 `true` 并跳出循环

  if (hasOverlap) {
    console.log('存在时间重叠的问题');
  } else {
    console.log('没有时间重叠的问题');
  }

2. 如何将字符串str = '1:00-2:00,3:00-4:00', 转换成数组 arr

// 如何将字符串str 转换成数组 arr
 const str = '1:00-2:00,3:00-4:00';
 const arr = [
    { validHour: ['1:00', '2:00'] },
    { validHour: ['1:00', '2:00'] },
 ];
 
 // 使用逗号分割字符串 
 const subStrings = str.split(','); 
 // 遍历每个子字符串并使用冒号分割 
 const arr = subStrings.map(subString => {
         const [start, end] = subString.split('-');
         return { validHour: [start, end] }; 
  });
  console.log(arr);

3. 判断数组arr里面的skuOrder值是否有重复

// 判断数组arr里面的skuOrder值是否有重复
       const arr = [
            { skuId: 1, skuName: '111', skuOrder: 1 },
            { skuId: 2, skuName: '222', skuOrder: 2 },
            { skuId: 3, skuName: '333', skuOrder: 4 },
            { skuId: 4, skuName: '55', skuOrder: 4 },
            { skuId: 5, skuName: '66', skuOrder: 5 },
            { skuId: 888, skuName: '77', skuOrder: 5 },
        ];


        // 第一种  new Set()
        const skuOrderSet = new Set();

        const hasDuplicate = arr.some(item => {
        if (skuOrderSet.has(item.skuOrder)) {
            return true;
        }
        skuOrderSet.add(item.skuOrder);
            return false;
        });

        console.log(hasDuplicate); // 输出 true 或 false


        // 第二种 reduce
        const hasDuplicate = arr.reduce((prev, next) => {
                if (next.skuOrder in prev) {
                    prev[next.skuOrder]++;
                } else {
                    prev[next.skuOrder] = 1;
                }
                return prev;
            }, {});
       const hasDuplicateFlag = Object.values(hasDuplicate).some(count => count > 1);

        console.log(hasDuplicate); // 输出 true 或 false