zod vs joi vs yup vs class-validator vs class-transformer-validator | Confronto dei pacchetti npm di "Validazione dei Dati in JavaScript"

Pacchetto	Download	Stars	Dimensione	Issues	Pubblicazione	Licenza

zod	39,458,151	39,430	3.71 MB	258	il y a 16 heures	MIT
joi	11,928,120	21,142	558 kB	187	il y a 6 jours	BSD-3-Clause
yup	7,690,128	23,502	270 kB	241	il y a 8 jours	MIT
class-validator	4,564,032	11,500	5.13 MB	325	il y a 3 mois	MIT
class-transformer-validator	42,182	203	-	16	il y a 5 ans	MIT

Pacchetto

Download

Stars

Dimensione

Issues

Pubblicazione

Licenza

zod

39,458,151

39,430

3.71 MB

258

il y a 16 heures

MIT

joi

11,928,120

21,142

558 kB

187

il y a 6 jours

BSD-3-Clause

yup

7,690,128

23,502

270 kB

241

il y a 8 jours

MIT

class-validator

4,564,032

11,500

5.13 MB

325

il y a 3 mois

MIT

class-transformer-validator

42,182

203

il y a 5 ans

MIT

Tipo di Validazione

zod:
zod è una libreria di validazione dei dati TypeScript-first che consente di definire schemi di convalida con un forte supporto per i tipi. Supporta la validazione annidata, la creazione di validatori personalizzati e offre un'API semplice e chiara per definire regole di convalida.
joi:
joi è una libreria di validazione dei dati altamente flessibile che consente di definire schemi di convalida per oggetti, array e valori primitivi. Supporta la validazione annidata, la creazione di validatori personalizzati e offre un'API intuitiva per definire regole di convalida complesse.
yup:
yup è una libreria di validazione dei dati basata su schemi che supporta la validazione di oggetti, array e valori primitivi. Consente la validazione annidata, la creazione di validatori personalizzati e supporta la convalida asincrona, rendendola adatta per applicazioni moderne.
class-validator:
class-validator si concentra esclusivamente sulla validazione dei dati all'interno delle classi TypeScript utilizzando decoratori. Consente la validazione dei dati annidati e supporta la creazione di validatori personalizzati, ma non gestisce la trasformazione dei dati.
class-transformer-validator:
class-transformer-validator combina la trasformazione e la validazione dei dati in un'unica libreria, consentendo la validazione dei dati in base a decoratori definiti all'interno delle classi. Supporta la validazione dei dati annidati e la trasformazione automatica dei dati in base ai tipi definiti.

Supporto per TypeScript

zod:
zod è una libreria di validazione dei dati TypeScript-first, progettata fin dall'inizio per sfruttare le funzionalità di tipo di TypeScript. Offre una validazione dei dati altamente tipizzata e sicura, rendendola ideale per progetti che richiedono una forte integrazione con TypeScript.
joi:
joi offre un supporto limitato per TypeScript, ma non è progettato specificamente per sfruttare appieno le funzionalità di tipo di TypeScript. Tuttavia, la comunità ha creato definizioni di tipo per joi che ne facilitano l'uso con TypeScript.
yup:
yup offre un buon supporto per TypeScript, con definizioni di tipo integrate che consentono una convalida dei dati tipizzata. È progettato per funzionare bene con TypeScript, rendendolo adatto per progetti che richiedono sicurezza dei tipi.
class-validator:
class-validator è progettato per funzionare perfettamente con TypeScript, consentendo la validazione dei dati basata su decoratori all'interno delle classi TypeScript.
class-transformer-validator:
class-transformer-validator offre un eccellente supporto per TypeScript, sfruttando i decoratori e i tipi per fornire una validazione dei dati sicura e tipizzata all'interno delle classi.

Esempi di Codice

zod:

Esempio di validazione con zod

const { z } = require('zod');

const schema = z.object({
  name: z.string(),
  email: z.string().email(),
});

const result = schema.safeParse({ name: 'John', email: 'invalid-email' });
if (!result.success) {
  console.log(result.error.errors);
} else {
  console.log('Validato:', result.data);
}

joi:

Esempio di validazione con joi

const Joi = require('joi');

const schema = Joi.object({
  name: Joi.string().required(),
  email: Joi.string().email().required(),
});

const { error, value } = schema.validate({ name: 'John', email: 'invalid-email' });
if (error) {
  console.log(error.details);
} else {
  console.log('Validato:', value);
}

yup:

Esempio di validazione con yup

const yup = require('yup');

const schema = yup.object().shape({
  name: yup.string().required(),
  email: yup.string().email().required(),
});

schema.validate({ name: 'John', email: 'invalid-email' }).catch(err => {
  console.log(err.errors);
});

class-validator:

Esempio di validazione con class-validator

import { IsEmail, IsNotEmpty } from 'class-validator';
import { validate } from 'class-validator';
import { plainToClass } from 'class-transformer';

class User {
  @IsNotEmpty()
  name: string;

  @IsEmail()
  email: string;
}

const user = plainToClass(User, { name: 'John', email: 'invalid-email' });
validate(user).then(errors => {
  console.log(errors);
});

class-transformer-validator:

Esempio di validazione con class-transformer-validator

import { IsEmail, IsNotEmpty } from 'class-validator';
import { validate } from 'class-validator';
import { plainToClass } from 'class-transformer';
import { validateOrTransform } from 'class-transformer-validator';

class User {
  @IsNotEmpty()
  name: string;

  @IsEmail()
  email: string;
}

const user = plainToClass(User, { name: 'John', email: 'invalid-email' });
validateOrTransform(user).then(errors => {
  console.log(errors);
});