Controlla o no oggetti in una API Javascript?

0

Sto scrivendo un'API in JavaScript e sono confuso se dovrei controllare se l'utente API mi sta comunicando il tipo corretto su cui l'API si aspetta di funzionare. In realtà non è il tipo, ma se mi passi l'oggetto con le proprietà su cui funziona l'API. È una buona pratica per me emettere un errore se l'utente non passa un oggetto con le proprietà previste per l'API, o dovrei lasciarlo per conto del compilatore JavaScript?

Dovrei controllare il tipo in questo modo:

function PackageManager() {
    this.packages = {};
}

PackageManager.prototype.addPackage = function(assetPackage) {
    Array.isArray(assetPackage) ? this.addAssetPackages(assetPackage) : this.addAssetPackage(assetPackage);
}

PackageManager.prototype.addAssetPackages = function(assetPackages) {
     for(let i = 0; i < assetPackages.length; i++) 
         this.addAssetPackage(assetPackages[i]);
}

PackageManager.prototype.addAssetPackage = function(assetPackage) {
    if (!this.isAssetPackage(assetPackage))
        throw new TypeError('You are passing the argument "'+ assetPackage +'" and the addPackage function expects an AssetPackage.');
    this.packages[assetPackage.name] = {
        name: assetPackage.name,
        assets: assetPackage.assets
    };
}

PackageManager.prototype.isAssetPackage = function(val) {
    return (this.isObject(val) && val.name && val.assets ? true : false);
}

PackageManager.prototype.isObject = function(val) {
    return (typeof val === "object" && val !== null ? true : false);
}
export default PackageManager;

o semplicemente lasciare che l'utente API gestisca il compilatore:

function PackageManager() {
    this.packages = {};
}

PackageManager.prototype.addPackage = function(assetPackage) {
     Array.isArray(assetPackage) ? this.addPackages(assetPackage) : addAssetPackage(assetPackage);
}

PackageManager.prototype.addPackages = function(assetPackages) {
     for(let i = 0; i < assetPackages.length; i++)
         addAssetPackage(assetPackages[i]);
}

PackageManager.prototype.addAssetPackage = function(assetPackage) {
    this.packages[assetPackage.name] = {
        name: assetPackage.name,
        assets: assetPackage.assets
    };
}

export default PackageManager;

come gestisci questo caso nelle tue API JavaScript?

    
posta PerduGames 06.10.2018 - 00:50
fonte

2 risposte

0

Essendo che JavaScript è un linguaggio tipizzato dinamicamente, è possibile presumere che gli utenti di quella lingua sappiano che è digitato in modo dinamico. Se ti aspetti un determinato tipo di oggetto, documentalo nelle guide pratiche per la tua API o utilizzando qualcosa come JsDoc.

Il controllo costante dei tipi di dati in fase di esecuzione sta replicando ciò che fa un compilatore. Se è necessario verificarlo, è necessario un linguaggio strongmente tipizzato. Se la piattaforma di destinazione non supporta una lingua strongmente tipizzata, non è necessario verificare i tipi di dati.

  1. Documenta cosa ti aspetti
  2. Aggiungi la gestione degli errori dove ha senso per il business
  3. Non aggiungere la gestione degli errori se normalmente verrebbe verificato da un compilatore in una lingua strongmente tipizzata
  4. Supponiamo che i tuoi utenti sappiano di non utilizzare una lingua strongmente tipizzata
  5. Diglielo a RTFM quando qualcosa non va storto

Oh, e assicurati che la "F" in RTFM significhi "Cordiale" e "ben scritta".

C'è tuttavia 1 eccezione. E questa eccezione è perfettamente illustrata nel metodo # packagepackager # addPackage. Se vuoi supportare l'overloading dei metodi in una lingua che non supporta l'overloading dei metodi, devi assolutamente controllare i tipi di dati.

    
risposta data 06.10.2018 - 03:39
fonte
0

In questo particolare codice di esempio, l'unico campo richiesto a non esplodere è name , perché viene utilizzato in

this.packages[assetPackage.name] = ...

L'altro campo, assets , potrebbe essere nullo (o mancante) e il codice funzionerebbe correttamente. Ora, forse, vuoi assicurarti che anche le risorse esistano.

Come documenterei questo

  1. Documento che ti aspetti oggetti con un campo nome richiesto,
  2. Se lo desideri, documenta che sono richiesti altri campi, come le risorse e il foobar.

Come vorrei "validare"

  1. Verifica i campi richiesti, ma non preoccuparti di typeof val === "object" perché è, beh, piuttosto inutile qui. Dovresti fare quel test se vuoi gestire una stringa o un numero in modo diverso, come parte dell'overloading delle funzioni, ma non è questo il caso.
  2. Prova solo if (!val.name) throw... (se vuoi, prova anche val.assets , ecc ...) (nota dei puristi: questo impedisce anche i nomi vuoti , YMMV, quindi potresti preferire if (val.name == null)
  3. Considerare i valori predefiniti user friendly per i valori (diversi dal nome). Ad esempio, se le risorse sono un oggetto e non desideri più in seguito i valori null, utilizza assets: assetPackage.assets || {}

P.S. Se il tuo software è legato alla sicurezza, controlla un pacemaker, ecc., Hai bisogno di più valudizzazione!

    
risposta data 05.11.2018 - 08:59
fonte

Leggi altre domande sui tag