È una cattiva pratica verificare gli argomenti passati a una funzione? [duplicare]

Mi trovo a scrivere un sacco di funzioni per cui le prime poche righe "verificano" gli argomenti, cioè eseguono il typecast, controllano la falsità, l'intervallo, ecc. prima di fare qualsiasi lavoro. Il principale ragionamento per questo è di impedire che idioti, umani o non, passino argomenti non validi o illogici alla funzione. Un esempio in JS sarebbe questo:

function mix(red, grn, blu, anotherColor) {
  // typecast, falseness/presence
  this.red = +red || 0
  this.grn = +red || 0
  this.blu = +red || 0

  // args must be within [0, 255]
  this.red = Math.max(0, Math.min(red, 255))
  this.grn = Math.max(0, Math.min(grn, 255))
  this.blu = Math.max(0, Math.min(blu, 255))

  // if anotherColor is falsy/undefined
  anotherColor = anotherColor || {red:0, grn:0, blu:0}

  // do the actual work here
}

Un altro esempio è quando una funzione ricorsiva chiama se stessa.

function menulist(pages, depth) {
  // do some stuff

  // when done, recurse
  if (depth > 0) {
    // verify pages.sub exists
    pages.sub = pages.sub || []

    return menulist(pages.sub, depth-1)
  }
}

D'altra parte ho sentito l'opinione che questa "verifica" non dovrebbe essere fatta all'interno della funzione stessa, piuttosto, dovrebbe essere delegata ad un altro pezzo del software. In altre parole, la funzione dovrebbe essere "pura" e minima, assumendo che gli argomenti passati siano corretti. (Se questo è il caso, dove dovrebbe essere delegata la procedura di verifica?)

Quale opinione è considerata best practice nella comunità Javascript e / o nella comunità di programmazione nel suo complesso?