You create your own type of Error that holds the list of missing fields:

class MissingFieldsError extends Error {
  constructor(fields, ...params) {
    super(...params);
    this.fields_ = fields;
  }

  getMissingFields() {
    return this.fields_;
  }
}

To use it, you can gather all of the missing fields first and then throw an instance of MissingFieldsError. Assuming you have some sort of array of Field instances, the code should look like this:

const missingFields = fields
    .filter((field) => field.isMissing())
    .map((field) => field.getName());

if (missingFields.length > 0) {
  throw new MissingFieldsError(
      missingFields, 'Some required fields are missing.');
}

If you prefer, you can even have separate Errors thrown, collect them and then throw the MissingFieldsError:

const missingFields = [];

fields.forEach((field) => {
  try {
    const value = field.getValue();
    // Process the field's value.

    // Could be just field.validate();
  } catch (e) {
    missingFields.push(field.getName());
  }
});

if (missingFields.length > 0) {
  throw new MissingFieldsError(
      missingFields, 'Some required fields are missing.');
}

A good approach to this sort of issue is to always throw Error objects, and not literals.

It is considered good practice to only throw the Error object itself or an object using the Error object as base objects for user-defined exceptions. The fundamental benefit of Error objects is that they automatically keep track of where they were built and originated.

If you throw a plain non-error value, that value will be the expression in the catch section - which will (probably) not have the .message (or .stack) property, and be less than useful as a result.

So, replace throw ('My fake error.'); with throw new Error('My fake error.'); - and then, in catch, doing console.log(err.message) may log either My fake error., or it may log whatever other unexpected error occurred, if the rest of the code around there is well structured enough to always throw Error objects. Just enabling and following that no-throw-literal ESLint rule referenced above would be sufficient.

Instead of trying to catch errors, you should be trying to build proper logic to control them.

var myEle = document.getElementById("non-existing-element")

if (myEle != null)
   alert(dmyEle.value);

But you are describing suppressing errors

You can suppress error in JavaScript with a onerror event handler.

function handleErr(msg, url, line_no){ 
   var errorMsg = "Error: " + msg + "\n"; 
       errorMsg += "URL: " + url + "\n"; 
       errorMsg += "Line: " + line_no + "\n\n"; 

    alert(errorMsg); 

 return true;
} 

// Set the global onerror; 
onerror = handleErr;

More information here