Extracting the timestamp, minimum score, and maximum score from hundreds of arrays
I'm a little unsure of why scoresDates starts with a 56-item array and the rest are 2-item arrays.

Just to be sure, this is your data model, correct? Please let me know if I've totally misread things.

scoresDates is [
    [date, score, score, score...],
    [date, score],
    [date, score],
    ...
]


Working forwards from your current code, here are some suggestions. I've used some functions like Array.filter that require IE > 9; if you need to support old Internet Explorer then a utility library like Lodash would provide polyfills for these.

In general, you're doing more loops through the data than should be necessary. For example:

Sorting is extra work

  // Next step is sorting the scoreSorted1 array from lowest score to highest score.
  scoreSorted1.sort(function(a,b){
    return a-b;
  });

  // Find maximum and minimum scores in the array and finally push them into the scoreSortedPrimer array.
  var primerMin = Math.min.apply(Math, scoreSorted1);
  scoreSortedPrimer.push(primerMin);
  var primerMax = Math.max.apply(Math,scoreSorted1);
  scoreSortedPrimer.push(primerMax);


scoreSorted1 seems to only be used for calculating min and max. Sorting is more work than min and max, each of which go through the entire array anyway. Here are a few faster options:


keep the sorting, in which case you will know that min is the first item and max is the last
don't sort, just call Math.min and Math.max.
write your own function that calculates both min and max in just one pass of the array, as opposed to two (Math.min + Math.max)


Array.filter

Using higher-level functions like forEach and filter can simplify some of your loops, by letting you ignore array indexes.

For example, this:

var scoreSorted1 = [];

// First level for loop that goes through the unique scores array and ignores the date, while pushing all the scores into the scoreSorted1 array.

for(var z = 0, zz = uniqueDaysScores[i].length; z &lt; zz; z++){
  if(uniqueDaysScores[i][z] &lt; 1000){
    scoreSorted1.push(uniqueDaysScores[i][z]);
  }
}


becomes

var scoreSorted1 = uniqueDaysScores[i].filter(function(score) {
  return score &lt; 1000;
});


And, at a higher level, your entire program becomes two parts: merging all the scores for each date, then applying a function [scores] -&gt; [min(scores), max(scores)] to each item in that merged object.

Comments

Comments should explain why, rather than describe the code, unless it is particularly hairy. This is a little subjective, but, for example, you can easily read scoreSorted1.sort(... and see that it is sorting the scores, comment or not.

Instead, I recommend saving comments for more confusing passages and for higher-level overviews of your functions or logic. Using descriptive variable and function names is often enough of a comment.

// Logic to take all the scores, sort them from decreasing to increasing order, then package the date, lowest and shortest score into the finished array, scoreSorted.

for(var i = 0, ii=uniqueDaysScores.length; i &lt; ii; i++){
  var scoreSorted1 = [];
  var scoreSortedPrimer = [];

// First level for loop that goes through the unique scores array and ignores the date, while pushing all the scores into the scoreSorted1 array.

  for(var z = 0, zz = uniqueDaysScores[i].length; z &lt; zz; z++){
    if(uniqueDaysScores[i][z] &lt; 1000){
      scoreSorted1.push(uniqueDaysScores[i][z]);
    }
  }

  // Next step is sorting the scoreSorted1 array from lowest score to highest score.
  scoreSorted1.sort(function(a,b){
    return a-b;
  });

  // Find maximum and minimum scores in the array and finally push them into the scoreSortedPrimer array.
  var primerMin = Math.min.apply(Math, scoreSorted1);
  scoreSortedPrimer.push(primerMin);
  var primerMax = Math.max.apply(Math,scoreSorted1);
  scoreSortedPrimer.push(primerMax);

  // Finally, find the date and push it into the scoreSortedPrimer array, so it can be pushed into the main scoreSorted array.

  for(var x = 0, xx = uniqueDaysScores[i].length; x &lt; xx; x++){
    if(uniqueDaysScores[i][x] &gt; 1000){
      scoreSortedPrimer.unshift(uniqueDaysScores[i][x]);
    }
  }
  uniqueDaysScores.push(scoreVarianceSortedPrimer);
}


becomes, more sparsely,

// Calculate min and max score for each date, appending to uniqueDaysScores.

uniqueDaysScores.forEach(function(dateAndScores) {

  var date = dateAndScores.filter(function(score) {
    return score &gt;= 1000;
  })[0];

  var scores = dateAndScores.filter(function(score) {
    return score &lt; 1000;
  });

  uniqueDaysScores.push([
      date,
      Math.min.apply(Math, scores),
      Math.max.apply(Math, scores)
  ]);
});


and would be even simpler if the date was stored somewhere specific so that you don't need to use loops or filter to find it.

Let's rewrite the initial score-merging step to accommodate this.

Merging/grouping scores for each date

I think this is where a lot of the extra complexity is coming from.

Using an object, with the dates as keys and the arrays of scores as values, would be natural, but your array of [date, scores...] arrays would also work.

The important thing is to make sure the date is easy to find, not mixed into your scores, so you don't need to search for it later (by checking what score is > 1000).

// Logic that stacks all the scores per unique day from all the user's game scores. All unique dates with subsequent scores are stored in the uniqueDaysScores array.

uniqueDaysScores = [];
uniqueDaysScores.push(scoresDates[0]);

for(var i = 0, ii = scoresDates.length; i &lt; ii; i++){
  var tempArray = [];

  if(scoresDates[i][0] == uniqueDaysScores[0][0]){
    uniqueDaysScores[0].push(scoresDates[i][1]);
  } else{
    tempArray.push(scoresDates[i][0]);
    tempArray.push(scoresDates[i][1]);
    uniqueDaysScores.unshift(tempArray);
  }
}


becomes, using an object of {date: scores},

// Group scores by date

var scoresByDate = {};

scoresDates.forEach(function(scores) {
  var date = scores[0];
  scores.shift();  // Remove date

  if (!(date in scoresByDate)) {
    scoresByDate[date] = scores;
  } else {
    scoresByDate[date].concat(scores);
  }
}


I've used forEach here, but your original loop-with-index would also work just fine.

With this scoresByDate structure, finding min and max for each date becomes very easy:

var maxMinByDate = Object.keys(scoresByDate).map(function(date) {
  return scoreMinMax(date, scoresByDate[date]);
};


or you could just not bother with a separate scoreMinMax function.



Altogether

With fewer, more high-level comments and a better data model, you end up with something more like this:

var scoresDates = [...];

// Group scores by date.

var scoresByDate = {};

scoresDates.forEach(function(scores) {
  var date = scores[0];
  scores.shift();  // Remove date

  if (!(date in scoresByDate)) {
    scoresByDate[date] = scores;
  } else {
    scoresByDate[date].concat(scores);
  }
}

// Calculate min and max score for each date.

var minMaxByDate = Object.keys(scoresByDate).map(function(date) {
  var scores = scoresByDate[date];
  return [
    date,
    Math.min.apply(Math, scores),
    Math.max.apply(Math, scores)
  ];
});


which could be further accelerated by writing a extrema(arr) function that would return the pair [min(arr), max(arr)] in one pass.