Need some clarification on a JavaScript lesson. (Constructor Functions)

1. It's self-executing wrapper function. It automatically calls nextQuestion() to begin process
2. var n = Math.floor(Math.random() * questions.length); selects random question from your questions list
3. displayQuestion() shows information from second new Question() parameter as possible answers. Third parameter is correct answer.
4. User inputs it's answer in prompt('Please select the correct answer.'); and if it's not exit, then comparing answer with correct value.
5. After showing answer code calls keepScore(correct) to add score to final result.
6. [GOTO #2] using nextQuestion();

Here the score function is a Closure

The state of sc inside score is intialised when score is invoked.

var keepScore = score();

Now the keepScore contains the function which is returned by the closure that is

function (correct) {           
        if (correct) {
            sc++; // it has a "closure" over it
        }
        return sc;
    }

which accepts a boolean value. that is, keepScore(true) or keepScore(false)

Now this keepScore function is passed to check answer

questions[n].checkAnswer(parseInt(answer), keepScore);

In check anwer, if the answer is correct it will pass true to the keepScore

callback(true) <=> keepScore(true)

If you want to have more clarity on Closure you can go through this article

https://github.com/getify/You-Dont-Know-JS/blob/master/up%20%26%20going/ch2.md#closure

The slightly tricky bit for the uninitiated here is that the score function returns a function and makes use of a closure.

function score() {
  var sc = 0;
  return function(correct) {
    if (correct) {
      sc++;
    }
    return sc;
  }
}

This line:

var sc = 0;

creates a variable for holding the current score and then returns a function you can call to increment that variable. The variable can't be declared inside the function because it would get recreated every time the function was called:

// can't do this. sc gets recreated and reset on every call:
function score (correct) {
  var sc = 0;
  if (correct) {
    sc++
  }
  return sc;
}

But you also don't want the variable available to everyone, so you don't want to do this either:

// don't want this either.
// score shouldn't be modifiable outside of our keepScore method.
let sc = 0;

function score (correct) {
  if (correct) {
    sc++;
  }
  return sc;
}

// this approach works, but now cheaters can set
// the score outside our scorekeeping function:
sc = 999999; // oh noes! hacks!

So what can we do? We can:

First: Create the variable within a function scope, where it's protected from outside shenanigans:

function score () {
  var sc = 0; // unavailable outside this function
}

Second: Create another function inside the first that can modify the variable:

function score () {
  var sc = 0; // unavailable outside this function

  // a new function that has access to the outer function's sc variable.
  function(correct) {
    if (correct) {
      sc++;
    }
    return sc;
  }
}

Finally, returning the inner function from score() gives outsiders a way to register correct answers without exposing the score variable itself:

function score () {
  var sc = 0; // unavailable outside this function

  // return this function to the caller and voila!
  // they now have a self-contained scorekeeper function.
  return function(correct) {
    if (correct) {
      sc++;
    }
    return sc;
  }
}

So now when you do this:

var keepScore = score();

keepScore is that inner function with its own internal sc variable.

If you had a multiplayer edition, you could get one for each player:

// each gets their own instance of
// that inner function with its own
// independent sc variable.
const playerOneScore = score();
const playerTwoScore = score();

playerOneScore(true); // 1
playerOneScore(true); // 2

playerTwoScore(false); // 0
playerTwoScore(true); // 1

I think once you understand this bit, the rest will make a lot more sense.