Math calculation JavaScript. Am I using Objects correctly? Can I use methods / functions to shorten my code further? Also error logging?

I added what I hope are more explicitly stated object advantages for future changes

Give objects the functions using their properties. This is a critical key for code to have attributes like reusability, non-duplication, simple & limited changes, understanding, and readability.

Clients just "ask" (call the methods), they don't do the calculations. Then client code can look like this:

var optionA = new option (scoreOptionA, weighting);
var optionB = new option (scoreOptionB, weighting);
var optionC = new option (scoreOptionC, weighting);

// imagine average() called as part of the output
console.log(optionA.toString()); 
console.log(optionB.toString()); 
console.log(optionC.toString()); 

// here, client code has to do all the work.
// imagine how many different ways it could be written
// and the potential for errors. Note the code will
// blow up when the array is empty; a simple edge case that 
// would have been accounted for if a "coherent" (google that)
// sections object was created and debugged.
var sum, average = 0;
var options = [];
options.push(optionA, optionB, optionC);
options.forEach(option => {sum += option.score});
average = sum / options.length;   
console.log("Average: ${average}");

// Calculating average within a sections object,
// Comprehension improvement is obvious when 
// operation details are wrapped in the object's functions 

var sections = new options();
sections.push(optionA, optionB, optionC);
console.log("Average: ${sections.average()}");

Take object function encapsulation to the max

// Imagine you're in a war and 
// the guy next to you must always load
// your rifle for you. You're gonna die!
// So why do that with objects?

// Just give me the bullets and I will load them
// when, where, if, and how I need too.
// Pass constructor parameters!
// Now the client does not have to know 
//   A) there's an array in there and
//   B) What method(s) to call so the program doesn't blow up.


var sections = new options(optionA, optionB, optionC);
console.log("Average: ${sections.average()}");

I was confused because of how things are named. I had to read and re-read to understand structure, relationships, and hierarchy. Naming things with "int" "array" etc. is bad, very bad. What is that thing to the users? That's what it IS. Name for what things they represent, not the Javascript technicalities used to make them.

Objects are just a way to organize data/properties AND associated functions. Objects without functionality is like a day without sunshine. Otherwise it's like looking at an auto parts catalog and calling it a car; it is not a car until it can do things (methods).

the following year maybe Section A will increase to 50% AND Section B will change t0 20% this needs to be taken into account.

weighting object accommodates change because it is an object. All the adjustment factors are encapsulated in one place.

var weighting = function () {
  var weightForMe = [
    { id: 778180000, weight: 1, percent: 0.1 },
    { id: 778180001, weight: 2, percent: 0.2 },
    { id: 778180002, weight: 3, percent: 0.3 },
    { id: 778180003, weight: 4, percent: 0.4 },
    { id: 778180004, weight: 5, percent: 0.5 }
  ]

  function weightOf ( ratingBase ) => weightForMe.find(rating.id === ratingBase);

} // weighting

These percentage values could potentially change per business requirements.

• If changes do not affect all the options/sections then passing in a weighting object, a.k.a. "Dependency Injection" makes it trivial to create another "weighting" object with different values.
• 'option' (vice individual variables) dramatically improves readability and understandability.
• Note that option` does not change at all! Just pass in the appropriate "scales" object.

.

function option ( rating, scales ) {
  base: rating ,
  weights: scales.weightOf(rating),
  score : weights.weight * weights.percent 

  function toString() {
    return "Section: ${base} || score: ${score} || weight: ${weights.weight || percent: ${weights.percent}";
  }    
} // section

Why are weighting and option different objects when they are virtually identical? -> They have different purposes. weighting is just a data lookup structure while option is user-entered something-or-other that is adjusted per to user requirments.

I created the option object (is it a section?) because its properties are manipulated together. option object is the proper place to calculate an option's weighted score. Then it dawned on me the calculation can be done when the object is created. We have sunshine!

weighting passed to option makes it clear that option uses weighting. If we don't practice good coding techniques in simple code we won't do it - or know how - when things are complicated.

Overriding toString is exceptionally useful in development and testing.

You're right, that sure is a lot of repetition.

We're mapping one number to another, using many ifs. That can also be done with an object that maps from e.g. dictionary key 778180000 to 1.

But this particular mapping happens to be linear. So you could define a function which will return ScoreValueA - 778179999;

The others are similar.

In general, when you see that a function has grown long enough that you can no longer view the whole thing without scrolling, it is time to Extract Helper functions.

Think about arrays, arrays of objects.

see here https://jsfiddle.net/9w2n34hf/

var scoreItemArray = [
  // A
  new scoreItemObject("dp_testweightedaverage", "dp_percentagevalue",
  [
    { id: 778180000, ival: 1, pc: 0.1 },
    { id: 778180001, ival: 2, pc: 0.2 },
    { id: 778180002, ival: 3, pc: 0.3 },
    { id: 778180003, ival: 4, pc: 0.4 },
    { id: 778180004, ival: 5, pc: 0.5 },

function CalculateAverageScore(executionContext) {
    var formContext = executionContext;
    var ip = getIntPercent(formContext, scoreItemArray[0]);
    var Section1Score = getIntPercent(formContext, scoreItemArray[0]);
    var Section2Score = getIntPercent(formContext, scoreItemArray[1]);
    var Section3Score = getIntPercent(formContext, scoreItemArray[2]);
    // Calculate and Set Average Score Value
    var averagescore = (Section1Score + Section2Score + Section3Score) / 3;
    event.preventDefault();
    my_formValSet(formContext, "dp_decimal", averagescore);
    }