Articolo originale: How to Check if an Object is Empty in JavaScript – JS Java isEmpty Equivalent

Gli oggetti costituiscono il tipo di dato più utilizzato nella programmazione. Un oggetto è un insieme di dati correlati memorizzati come coppie chiave-valore. Ad esempio:

let userDetails = {
  name: "John Doe",
  username: "jonnydoe",
  age: 14,
}

Quando lavori con gli oggetti, potresti dover verificare se un oggetto è vuoto prima di svolgere un'operazione.

In JavaScript esistono vari modi per controllare se un oggetto è vuoto. In questo articolo, imparerai le varie strategie utilizzabili, quali sono le opzioni che puoi applicare e perché.

Nota: un oggetto è considerato vuoto se non ha coppie chiave-valore.

Se sei di fretta, ecco un esempio molto semplice::

const myEmptyObj = {};

// Funziona meglio con i browser nuovi
Object.keys(myEmptyObj).length === 0 && myEmptyObj.constructor === Object

// Funziona con tutti i browser
_.isEmpty(myEmptyObj)

Entrambi i metodi restituiranno true. Adesso cerchiamo di capire questo codice e le altre opzioni che puoi usare per verificare se un oggetto è vuoto in JavaScript.

Come controllare se un oggetto è vuoto con Object.keys()

Il metodo Object.keys() è un metodo statico per oggetti introdotto con ECMAScript6 (ES6) e supportato da tutti i browser moderni. Questo metodo restituisce un array con le chiavi di un oggetto. Ad esempio:

let userDetails = {
  name: "John Doe",
  username: "jonnydoe",
  age: 14
};

console.log(Object.keys(userDetails)); // ["name","username","age"]

A questo, puoi applicare la proprietà .length. Se restituisce zero, l'oggetto è vuoto.

let userDetails = {
  name: "John Doe",
  username: "jonnydoe",
  age: 14
};

let myEmptyObj = {};

console.log(Object.keys(userDetails).length); // 3
console.log(Object.keys(myEmptyObj).length); // 0

Puoi usare questo metodo per controllare se un oggetto è vuoto con un'istruzione if oppure creando una funzione apposita.

const isObjectEmpty = (objectName) => {
  return Object.keys(objectName).length === 0
}

Restituirà true o false. Se l'oggetto è vuoto, restituirà true, altrimenti restituirà false.

let userDetails = {
  name: "John Doe",
  username: "jonnydoe",
  age: 14
};

let myEmptyObj = {};

const isObjectEmpty = (objectName) => {
  return Object.keys(objectName).length === 0
}

console.log(isObjectEmpty(userDetails)); // false
console.log(isObjectEmpty(myEmptyObj)); // true

Nota: controllare soltanto la lunghezza non è l'opzione migliore quando vuoi verificare che un oggetto o qualsiasi altro tipo di dato sia vuoto. È sempre meglio avere conferma che il tipo di dato sia corretto.

A questo scopo puoi controllare il costruttore:

const isObjectEmpty = (objectName) => {
  return Object.keys(objectName).length === 0 && objectName.constructor === Object;
}

In tal modo, puoi eseguire una verifica più approfondita.

Finora è andato tutto bene, ma potresti voler evitare di ottenere un TypeError quando una variabile è undefined o un valore null viene passato invece di {}. Per risolvere questo problema puoi aggiungere un controllo extra:

const isObjectEmpty = (objectName) => {
  return (
    objectName &&
    Object.keys(objectName).length === 0 &&
    objectName.constructor === Object
  );
};

Nel codice qui sopra, è stato aggiunto un ulteriore controllo. Questo vuol dire che verrà restituito null o undefined se non si tratta di un oggetto vuoto, come mostrato nell'esempio seguente:

let userDetails = {
  name: "John Doe",
  username: "jonnydoe",
  age: 14
};

let myEmptyObj = {};
let nullObj = null;
let undefinedObj;

const isObjectEmpty = (objectName) => {
  return (
    objectName &&
    Object.keys(objectName).length === 0 &&
    objectName.constructor === Object
  );
};

console.log(isObjectEmpty(userDetails)); // false
console.log(isObjectEmpty(myEmptyObj)); // true
console.log(isObjectEmpty(undefinedObj)); // undefined
console.log(isObjectEmpty(nullObj)); // null

Nota: ciò vale anche per altri metodi statici per oggetti, ovvero puoi usare Object.entries() o Object.values() invece di Object.keys().

Come verificare se un oggetto è vuoto con un loop for…in

Un altro metodo che puoi usare è il loop for…in introdotto con ES6. Puoi usare questo loop insieme al metodo hasOwnProperty().

const isObjectEmpty = (objectName) => {
  for (let prop in objectName) {
    if (objectName.hasOwnProperty(prop)) {
      return false;
    }
  }
  return true;
};

Il codice qui sopra itererà su ogni proprietà dell'oggetto. Se avviene una singola iterazione, l'oggetto non è vuoto. Inoltre, hasOwnProperty() restituirà un booleano che indica se l'oggetto possiede la proprietà specificata.

let userDetails = {
  name: "John Doe",
  username: "jonnydoe",
  age: 14
};

let myEmptyObj = {};

const isObjectEmpty = (objectName) => {
  for (let prop in objectName) {
    if (objectName.hasOwnProperty(prop)) {
      return false;
    }
  }
  return true;
};

console.log(isObjectEmpty(userDetails)); // false
console.log(isObjectEmpty(myEmptyObj)); // true

Come verificare se un oggetto è vuoto con JSON.stringify()

Puoi anche utilizzare il metodo JSON.stingify(), che serve per convertire un valore JavaScript in una stringa JSON. Questo vuol dire che convertirà i valori del tuo oggetto in una stringa. Ad esempio:

let userDetails = {
  name: "John Doe",
  username: "jonnydoe",
  age: 14
};

console.log(JSON.stringify(userDetails)); 

Output:
"{'name':'John Doe','username':'jonnydoe','age':14}"

Quando l'oggetto è vuoto, restituisce "{}". Puoi usare questo valore per controllare se l'oggetto è vuoto.

const isObjectEmpty = (objectName) => {
  return JSON.stringify(objectName) === "{}";
};

Restituirà true se l'oggetto è vuoto, oppure false:

let userDetails = {
  name: "John Doe",
  username: "jonnydoe",
  age: 14
};

let myEmptyObj = {};

const isObjectEmpty = (objectName) => {
  return JSON.stringify(objectName) === "{}";
};

console.log(isObjectEmpty(userDetails)); // false
console.log(isObjectEmpty(myEmptyObj)); // true

Come verificare se un oggetto è vuoto con Lodash

Alcuni dei metodi che ho spiegato potrebbero andare bene per i browser più vecchi, ma potrebbero non funzionare con altri. Se ti interessa trovare una soluzione che funzioni sia per le versioni vecchie che per quelle moderne, puoi usare Lodash.

Lodash è una libreria di utilità JavaScript moderna che può svolgere svariate funzionalità con una sintassi molto semplice.

Ad esempio, se vuoi controllare che un oggetto sia vuoto, devi soltanto usare il metodo "isEmpty".

_.isEmpty(objectName);

Installare Lodash nei tuoi progetti è piuttosto facile. Tutto ciò che devi fare è usare questo comando:

$ npm install lodash

Adesso puoi inizializzare il metodo con il trattino basso e utilizzarlo.

const _ = require('lodash');

let userDetails = {
  name: "John Doe",
  username: "jonnydoe",
  age: 14
};

let myEmptyObj = {};

const isObjectEmpty = (objectName) => {
  return _.isEmpty(objectName);
};

console.log(isObjectEmpty(userDetails)); // false
console.log(isObjectEmpty(myEmptyObj)); // true

Ecco fatto! 💪

Mi sono divertito molto a esplorare i diversi modi con cui puoi verificare che un oggetto sia vuoto. Usa il metodo che si presta meglio alle tue necessità.

Buona programmazione!