web-dev-qa-db-fra.com

Quelle est la différence entre joI.Object () et joI.Object (). Clés ()?

Selon la documentation JOI, vous pouvez utiliser Joi.object() Comme:

const object = Joi.object({
    a: Joi.number().min(1).max(10).integer(),
    b: Joi.any()
});

Mais vous pouvez également écrire un code équivalent à l'aide de Joi.object().keys() Comme:

const object = Joi.object().keys({
    a: Joi.number().min(1).max(10).integer(),
    b: Joi.any()
});

Quelle est la différence entre les deux?

javascriptnode.jsvalidationjoi
10
Berry

La @ HAPI/JOI Documentation n'est pas très claire sur ceci (à V17.1.0). Les schémas résultants ont la même valeur et valident la même chose. En regardant la source, le type d'objet est un type de clé avec seulement un changement que l'objet n'a pas besoin de copier des touches de n'importe quel type de type.

Welcome to Node.js v12.16.1.
Type ".help" for more information.
> const Joi = require('@hapi/joi')
undefined
> const util = require('util')
undefined
> const object1 = Joi.object({
...     a: Joi.number().min(1).max(10).integer(),
...     b: Joi.any()
... });
undefined
> const object2 = Joi.object().keys({
...     a: Joi.number().min(1).max(10).integer(),
...     b: Joi.any()
... });
undefined
> util.format(object1) == util.format(object2)
true
> object1.validate({a: 1, b: 1})
{ value: { a: 1, b: 1 } }
> object2.validate({a: 1, b: 1})
{ value: { a: 1, b: 1 } }
> object1.validate({a: 0})
{
value: { a: 0 },
error: [Error [ValidationError]: "a" must be larger than or equal to 1] {
    _original: { a: 0 },
    details: [ [Object] ]
}
}
> object2.validate({a: 0})
{
value: { a: 0 },
error: [Error [ValidationError]: "a" must be larger than or equal to 1] {
    _original: { a: 0 },
    details: [ [Object] ]
}
}
> object1.validate({a: 1, b: 1, c:1})
{
value: { a: 1, b: 1, c: 1 },
error: [Error [ValidationError]: "c" is not allowed] {
    _original: { a: 1, b: 1, c: 1 },
    details: [ [Object] ]
}
}
> object2.validate({a: 1, b: 1, c:1})
{
value: { a: 1, b: 1, c: 1 },
error: [Error [ValidationError]: "c" is not allowed] {
    _original: { a: 1, b: 1, c: 1 },
    details: [ [Object] ]
}
}
> object1.validate({a: 1})
{ value: { a: 1 } }
> object2.validate({a: 1})
{ value: { a: 1 } }
> object1.validate({b: 1})
{ value: { b: 1 } }
> object2.validate({b: 1})
{ value: { b: 1 } }
> object1.validate({})
{ value: {} }
> object2.validate({})
{ value: {} }

Différence entre la touche .append(schema) et .keys(schema) est également difficile dans la documentation. La fonction .append(schema) ne crée pas de nouvelle copie si le schéma est vide, mais sinon, il renvoie simplement la valeur de .keys(schema). Je n'ai trouvé aucun exemple là où cela ferait une différence.

> util.format(Joi.object({}).keys({a:1})) == util.format(Joi.object({}).append({a:1}))
true
> util.format(Joi.object({}).unknown().keys({a:1})) == util.format(Joi.object({}).unknown().append({a:1}))
true
1
Marko Kohtala

Nous pouvons également définir le schéma sans utiliser des touches () lorsqu'il n'y a qu'un ensemble de clés définissant notre schéma directement dans la génération objet (), comme:

const schema = Joi.object({
    username: Joi.string().alphanum().min(3).max(16).required(),
    password: Joi.string().regex(/^[a-zA-Z0-9]{3,30}$/).min(6).required()
}).with('username', 'password');

alors pourquoi utiliser les touches () avec un ensemble de clés unique?

Garder votre code cohérent. Tout au long des clés de documentation JOI () sont utilisés tout au long, même sur des objets clés unique.

tilisation des touches ()

Comme nous l'avons mentionné précédemment, les touches () ne doivent pas être utilisées si nous définissons un ensemble de clés unique. De plus, si aucune touche n'est définie sur un JOI.OBJECT (), toute clé sera valide: il n'y a pas de règles pour invalider aucun objet que nous testons avec notre schéma JOI. Nous avons également la possibilité d'ajouter des clés après la définition initiale du schéma. L'exemple suivant extrait de la documentation JOI démontre ceci:

//define base object
const base = Joi.object().keys({
    a: Joi.number(),
    b: Joi.string()
});
// add a c key onto base schema
const extended = base.keys({
    c: Joi.boolean()
});

Comme vous l'avez peut-être remarqué, nous définissons des constantes ici. Les objets JOI sont immuables, l'extension d'un schéma de base entraînera un objet complètement nouveau. Ici, nous avons sauvegardé cet objet comme la constante étendue. Nous avons également introduit la règle JOI.BOOLYAN () ci-dessus, qui est utile pour tester des cases à cocher et d'autres commutateurs, où nous nous attendons à une valeur vraie ou fausse.

0
Avid Programmer