Funzioni JavaScript resilienti

In questo articolo vedremo come potenziare una semplice funzione JavaScript in modo che restituisca un output valido anche se le condizioni iniziali sono mutate nel tempo.

Supponiamo di voler creare una funzione che restituisce una stringa casuale alfabetica a lunghezza variabile. Per generarla useremo un array delle lettere dell'alfabeto e un array di indici numerici creato a partire dall'output del metodo Date.now().

Proviamo ad immaginare insieme uno scenario futuro?

Il problema futuro è che un giorno l'array degli indici avrà una lunghezza maggiore dell'array delle lettere dell'alfabeto, generando una serie di errori legati al valore undefined che si otterrà cercando di accedere ad un elemento inesistente.

Pensare al futuro nel mondo della programmazione vuol dire semplicemente prevedere gli scenari peggiori che potrebbero verificarsi e scrivere il codice in modo difensivo.

Quindi potremmo avere un'implementazione come la seguente:

function getRandomNumber(min = 5, max = 8) {
         const minCeiled = Math.ceil(min);
         const maxFloored = Math.floor(max);
         return Math.floor(Math.random() * (maxFloored - minCeiled) + minCeiled);
    }

    function randomizeArray(arr) {
        return arr.sort(() => Math.random() - 0.5);
    }

    function randomString() {
        const chars = randomizeArray('abcdefghijklmnopqrstuvwxyz'.split(''));
        const ts = randomizeArray(Date.now().toString().split(''));
        if(ts.length > chars.length) {
            const num = getRandomNumber();
            return chars.slice(0, num - 1).join('');
        }
        const output = [];
        for(const t of ts) {
            const idx = parseInt(t, 10);
            output.push(chars[idx]);
        }
        const s = new Set(output);
        const values = randomizeArray(Array.from(s));
        return values.join('');
    }

Nel caso in cui un giorno il timestamp avrà più elementi dell'array delle lettere dell'alfabeto, gestiamo questo scenario restituendo una porzione dell'array delle lettere usando un limite casuale tenendo presente che il metodo slice() parte da 0.

Lo schema è sempre il seguente:

  1. Scenario/i peggiore/i? Gestiamolo/i restituendo un output.
  2. In caso contrario, procediamo normalmente seguendo il flusso stabilito dell'implementazione.

Conclusione

Resistere ai colpi del tempo che passa e pensare agli scenari futuri sono un ottimo modo per scrivere codice robusto e manutenibile.

Torna su