Сортировать и находить время, ближайшее к текущему времени

var arrayofDate =  ["10:00 PM", "08:00 AM", "12:00 AM", "01:00 AM", "12:00 PM", 
     "03:00 AM", "07:00 AM", "06:00 PM"];

var railwayTime = arrayofDate.map((data, key) => {
	data = parseInt(data.substr(0,2));
	if (arrayofDate[key].indexOf('PM') !== -1) {
		data = data + 12;
	}
	return data;
});

var output = closestTime(new Date().getHours(), railwayTime);

document.getElementById('result').innerHTML = arrayofDate[railwayTime.indexOf(output)];

function closestTime (num, arr) {
	var curr = arr[0];
	var diff = Math.abs (num - curr);
	for (var val = 0; val < arr.length; val++) {
		var newdiff = Math.abs (num - arr[val]);
		if (newdiff < diff) {
			diff = newdiff;
			curr = arr[val];
		}
	}
	return curr;
}

<div id = "result"></div>

let dates = ["10:00 PM", "08:00 AM", "12:00 AM", "01:00 AM", "12:00 PM", "03:00 AM", "07:00 AM", "06:00 PM"];

let currentDate = new Date();
let currentTime = currentDate.getHours() + ':' + currentDate.getMinutes() + (currentDate.getHours() > 12 ? ' PM' : ' AM');

dates.push(currentTime);

dates = dates.sort(function(d1, d2) {
  return compareDates(d1, d2);
});

console.info(dates);

console.info(nearestDate(dates, currentTime));

function nearestDate(dates, current) {
  let currentIndex = dates.indexOf(current);
  
  if (currentIndex == 0) {
    return dates[currentIndex + 1];
  } else if (currentIndex == dates.length - 1) {
    return dates[currentIndex - 1];
  }
  
  let previousDate = dates[currentIndex - 1]; 
  let nextDate = dates[currentIndex + 1];

  let previousDiff = diffDates(previousDate, currentTime);
  let nextDiff = diffDates(nextDate, currentTime);

  if (previousDiff < nextDiff) {
    return previousDate;
  } else {
    return nextDate;
  }
}

function diffDates(d1, d2) {
  let diffHour = Math.abs(getHour(d2) - getHour(d1));
  let diffMin = Math.abs(getMin(d2) - getMin(d1));
  
  return diffHour + diffMin;
}

function compareDates(d1, d2) {
  let t1 = getHour(d1) + ':' + getMin(d1);
  let t2 = getHour(d2) + ':' + getMin(d2);
  
  if (getHour(d1) == getHour(d2)
      && getMin(d1) < getMin(d2)) {
    return -1;
  } else if (getHour(d1) == getHour(d2)
            && getMin(d1) > getMin(d2)) {
    return 1;
  }
  
  if (getHour(d1) < getHour(d2)) {
    return -1;
  }
  
  if (getHour(d1) > getHour(d2)) {
    return 1;
  }
  
  return 0;
}

function getHour(d) {
  let hour = parseInt(d.split(' ')[0].split(':')[0], 10);
  if (d.split(' ')[1] === 'PM' && !(hour == 12)) {
    hour += 12;
  }
  return hour;
}

function getMin(d) {
  return parseInt(d.split(' ')[0].split(':')[1], 10);
}

let currentTime = new Date();
let currentHour = parseInt(currentTime.getHours());
let availableDates = ["10:00 PM", "08:00 AM", "12:00 AM", "01:00 AM", "12:00 PM", "03:00 AM", "07:00 AM", "06:00 PM"];
let convertedHours = availableDates.map((date) => {
    let time = parseInt(date.split(' ')[0]);
    let period = date.split(' ')[1];
      
    if (time === 12 && period === 'PM' )
      return time;
      
    if (time < 12 && period === 'AM')
      return time; 
    
    return time + 12;
});

let getNearestTime = (convertedHours, currentHour) => {
    let nearestTime;
    let minValue = convertedHours[0] > currentHour ? (convertedHours[0] - currentHour) : (currentHour - convertedHours[0]);
    convertedHours.reduce((minVal, hour) => {
        let hourDiff = (currentHour > hour) ? currentHour - hour : hour - currentHour;
        if (hourDiff <= minVal) {
            nearestTime = hour;
            return hourDiff;
        } else {
            return minVal;
        }
        
    }, minValue)

    return availableDates[convertedHours.indexOf(nearestTime)];
};
 

console.info(getNearestTime(convertedHours, currentHour));

   var timeSrc = ["10:00 PM", "08:00 AM", "11:05 AM", "12:00 AM", "01:00 AM", "12:00 PM", 
     "03:00 AM", "07:00 AM", "06:00 PM"];
    var curDate = new Date();
    curDate = curDate.toDateString();
    var times = timeSrc.map((t) => {
      return new Date(curDate + " " + t); // Make the time as a datetime with current date.
    });
    var now = new Date();
    var min = Math.abs(now - times[0]);
    var result = '';
    //Get the difference of each time with current time. The minimum difference is the closest.
    for(let i = 1; i < times.length; i++) {
      if (Math.abs(now - times[i]) <= min) {
          min = Math.abs(now - times[i]);
          result = timeSrc[i];
       }
    }
    console.info(result);