Générer des interfaces et des schémas de validation dynamiquement en dactylographie avec yup

Dans un projet récent, j'ai rencontré un problème qui avait besoin d'un objet que la clé a été définie dynamiquement par un mappage constant, et au moins une clé avait une valeur efficace.

Challenge

Nous avons un objet MetadataMap, qui définit les clés efficaces et ses types correspondants:

Selon cette cartographie, nous avons besoin:

const MetadataMap = {  
 userId: Number,  
 utmSource: String,  
 utmMedium: String,  
 utmCampaign: String,  
} as const;

Générez dynamiquement une interface TypeScript pour forcer la sécurité de type.

1. Créez un mode de vérification YUP et basé sur l'objet de vérification de mappage.
2. Assurez-vous qu'au moins une clé de l'objet a des valeurs de validité valides (non non définis).
3. Évitez les clés du codage dur pour améliorer le maintien des solutions.
Cependant, le TypeScript est obligé d'exécuter le type statique pendant la compilation, tandis que le traitement YUP est vérifié pendant l'exécution.

<骤> Étape 1: Générer l'interface

Afin de générer l'interface TypeScript à partir de MetadataMap, nous avons utilisé le type

et le type de mappage. Ce qui suit est la façon dont nous le définissons: keyof Cette méthode garantit que toute mise à jour de MetadataMap sera automatiquement reflétée dans l'interface de métadonnées. Par exemple:

type Metadata = {  
 [K in keyof typeof MetadataMap]: typeof MetadataMap[K] extends NumberConstructor  
  ? number  
  : string;  
};

// Interface de métadonnées générée:

<骤> Étape 2: Générez dynamiquement le mode YUP

interface Metadata {  
 userId?: number;  
 utmSource?: string;  
 utmMedium?: string;  
 utmCampaign?: string;  
}

Nous devons créer dynamiquement un mode YUP qui correspond à la clé et à taper MetadataMap. Utilisez et <我们>, nous mappelons chaque clé de son dispositif de vérification Yup correspondant:

Cette méthode élimine le codage dur et garantit que les changements dans MetadataMap se refléteront dans le mode sans mise à jour manuelle. Object.keys reduce <骤> Étape 3: Ajouter "au moins une clé" Rule

const metadataSchema = Yup.object(  
 Object.keys(MetadataMap).reduce((schema, key) => {  
  const type = MetadataMap[key as keyof typeof MetadataMap];  
  if (type === Number) {  
  schema[key] = Yup.number().optional();  
  } else if (type === String) {  
  schema[key] = Yup.string().optional();  
  }  
  return schema;  
 }, {} as Record<string, any>)  
);

Le prochain défi consiste à garantir qu'au moins une clé de l'objet a une valeur définie. Nous avons ajouté une méthode

:

cette logique:

.test Assurez-vous que l'objet est efficace.

metadataSchema.test(  
 "at-least-one-key",  
 "Metadata must have at least one valid key.",  
 (value) => {  
  if (!value || typeof value !== "object") return false;  
  const validKeys = Object.keys(MetadataMap) as (keyof typeof MetadataMap)[];  
  return validKeys.some((key) => key in value && value[key] !== undefined);  
 }  
);

Extraire dynamiquement Clé valide de MetadataMap.

Vérifiez au moins une clé avec une valeur non non définie.

Résultat Ce qui suit est le comportement du mode final:
3. Dans cet exemple, la vérification est réussie, car Utmsource est une clé efficace avec une valeur non non définie.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!