A simple and direct method to solve this problem is:

var should_be_true = [1,3,5,7,7,8,9,10,11];
var should_be_false = [1,3,5,7,9,11,13,15,17];

var testArray = function(array) {
    var conseq = 1;
    for (var idx = 1; idx < array.length ; idx++) {
        if (array[idx] == array[idx-1] + 1)
            conseq++;
        else
            conseq = 1;
        if (conseq == 5)
            return true;
    }
    return false;
}

console.log(testArray(should_be_true)); //true
console.log(testArray(should_be_false)); //false

For an added twist, here's a different functional approach that indicates the starting position of the sequence, or -1 if no sufficiently long sequence is found:

should_be_true.map(function(curr,idx,arr) {
    return (curr == arr[idx-1] +1) ? 1 : 0;
}).join('').search(/1{4}/); 

An effective strategy would involve:

function checkFiveInARow(array) {

  // comparing if each element is greater than or equal to the previous one
  function compare(element, index, array) { return !index || element >= array[index-1]; });

  // checking if at a specific position, all five comparisons leading up to it are true
  function validate (_, index, comparisons) { 
    return index >= 4 && comparisons.slice(index-4, index).every(Boolean);                         
  }

  return array.map(compare).some(validate);
}

The concept involves first generating an array of boolean values using map, indicating whether each element is greater than or equal to the one before it. This creates an array like [true, true, true, false, true].

The some section verifies if for any element, that element and all preceding four elements are true. If so, it returns true.

Alternate Recursive Approach

Alternatively, a recursive solution could offer simpler readability.

function checkFiveInARow(array) {

  return function _five(array, prev, count) {
    if (count >= 5)        return true;
    if (!array.length) return false;

    var next = array.shift();
    return _five(array, next, next === prev ? count : next >= prev ? count+1 : 0);
  }(array, -999999, 5);

}

let numbers = [1,3,5,7,7,8,9,10,11];
let consecutive=false;
let count=0;
for(let i=0;i<numbers.length;i++){
    if(numbers[i]+1==numbers[i+1]){
        count++;
    }
    else{
        count=0;
    }
    if(count==4){
        consecutive=true;
    }
}
if(consecutive){
    //perform your desired action
}

DEMO

A more refined approach would involve encapsulating this logic in a function like so:

function checkConsecutive(numbers){
    let consecutive=false;
    let count=0;
    for(let i=0;i<numbers.length;i++){
        if(numbers[i]+1==numbers[i+1]){
            count++;
        }
        else{
            count=0;
        }
        if(count==4){
            consecutive=true;
        }
    }
    return consecutive;
}

and then utilizing it in the following way:

let numbers = [1,3,5,7,7,8,9,10,11];
if(checkConsecutive(numbers)){
    //perform your desired action
}

DEMO

   function checkConsecutiveNumbers() {
       var numbers = [1, 3, 5, 7, 7, 8, 9, 10, 12];
       var previous = numbers[0];
       var countOfConsecutive = 1;

       for (var index = 1; index < numbers.length; index++) {
           countOfConsecutive = numbers[index] === previous + 1 ? countOfConsecutive + 1 : 1;
           previous = numbers[index];
           if (countOfConsecutive === 5) return true;
       }

       return false;
   }

Click here to view the code on JSFIDDLE.

After conducting some research, I have discovered the most direct method for counting consecutive values. It's important to note that both ascending and descending values are considered consecutive in this approach (if this is not the case for your scenario, you can adjust the Math.abs() function).

function countConsecutiveValues(array) {
    // Sort the array if it's not already sorted
    var sortedArray = array.sort();

    // Initialize the count variable to track consecutive numbers found
    var count = 1; // There will always be at least one consecutive digit

    for (var i = 0; i < sortedArray.length - 1; i++) {
        // Both ascending and descending orders are counted using Math.abs()
        if (Math.abs(sortedArray[i] - sortedArray[i+1]) == 1) {
            ++count;
        }
    }

    return count;
}

// Example input
var exampleArray = [1,2,4,5,3];
// Expected output
5

This code snippet helps identify the highest number of consecutive occurrences in a given array or in general.

var findMaxConsecutiveOnes = function (arr, number) {
   //checking for boundaries
   if(!number || !arr.length) return;

  // maximum number of consecutives
  let max = 0;

  // counting how many consecutives occur before it ends (starting at 1 as even a single occurrence counts)
  let counter = 1;

  // the next two variables can be ignored if using a for loop instead of while
  let length = arr.length;
  let i = 1; // starting from index 1 to compare with index-1
  while (i < length) {

    if (arr[i] == arr[i - 1]) {

      // increment the counter for consecutive occurrences
      counter++;
    } else {

      // reset the count back to 1
      counter = 1;
    }

    // keep track of the maximum value encountered
    max = Math.max(counter, max);

    // moving to the next iteration
    i++;
  }
  return max== number;
};
console.log(findMaxConsecutiveOnes([5, 5, 5, 1, 1, 1, 1, 1]));