nel dattiloscritto, c’è un modo per fare una serie di corde agire come un "o tipo diviso"?

nel dattiloscritto, c’è un modo per fare una serie di corde agire come un “o tipo diviso”?

con “O split type” intendo string | number | boolean. se avete un nome migliore, aggiornerò la domanda.

sto lavorando su un’interfaccia che contiene un elenco di tag, simile a questo:

type Tags = "big" | "small" | "sharp" | "dull";
interface Shape {
  name: string;
  tags: Tags[];
}

più avanti nel codice, vorrei elencare tutti i tag possibili. nel mio codice attuale, la quantità di tag è molto maggiore di quattro, quindi voglio usare l’asserzione di tipo per essere sicuro di elencarli tutti. come posso fare questo?

due modi che posso immaginare sono:

  1. creare un array da un tipo “o split”, che è impossibile per ovvie ragioni (condizioni annidate).
  2. asserire un tipo basato su una serie di stringhe. questo sembra abbastanza possibile, So che document.createElement("a" | "div" | "span"...) fa qualcosa di magico con questo, anche se non riesco a trovare le parole chiave giuste per capire che cosa si chiama.

il mio ideale sarebbe qualcosa di simile:

// Not real code
const Tags = ["big", "small", "sharp", "dull"];
interface Shape {
  name: string;
  tags: Array<item in Tags>;
}

quindi, c’è un modo per fare un array di stringhe agire come un tipo o split?

EN From: In Typescript, is there a way to make an array of strings act like an “or split type”?

More similar articles:

6 Comments

  1. In my actual code, the amount of tags is far greater than four, so I want to use type assertion to make sure I list them all. How can I do this?

    ho dovuto fare questo di recente e abbiamo avuto due scelte.

    1. oggetto con gli attributi come proprietà dell’oggetto
    2. un array e un’interfaccia, quindi ogni volta che aggiungi un nuovo elemento ai tuoi tag aggiungi sia l’array che l’oggetto

    sembra che sia una questione di preferenze personali

    vorrei utilizzare un oggetto Tags per far rispettare la sicurezza di tipo come si desidera

    class Tags {
        public one: string;
        public two: string;
        public three: string;
        constructor({ one, two, three }: Tags) {
            this.one = one;
            this.two = two;
            this.three = three;
        }
    }
    
    interface Shape {
        name: string;
        tags: Tags;
    }
    
    let a = new Tags({}); // <-- This will fail because is not type Tag
    a = new Tags({ one: '1' }); // <-- This will fail because it hasn't type two or type three
    a = new Tags({ one: '1', two: '2', three: '3' }); // <-- This will pass

    la seconda opzione che abbiamo fatto è la seguente:

    const TagsArray = ["big", "small", "sharp", "dull"]
    interface Tags {
      big: string;
      small: string;
      sharp: string;
      dull: string;
    }

    e ovunque li usiamo o passiamo attorno ad un Tag lo passiamo come un Oggetto:

    interface Shape {
      name: string;
      tags: Tags;
    }

    uso come con tutto è depends on your application, per noi avevamo bisogno di passare un array per alcuni servizi, e il tipo di checking su oggetti con i valori di matrice come proprietà, così siamo andati con 2 perché questo impedisce la conversione dell’array in tasti via Object.keys(Tags) e qualunque sia il servizio restituisce è tipo Contrassegnato utilizzando Shape

  2. la soluzione che ho finito per utilizzare è stato quello di creare un file per l’alloggiamento di tutti i tag contenenti due esportazioni:

    1. il tipo Tags che è un tipo di unione di ogni stringa che un tag può essere
    2. l’array tagList, un elenco di proprietà di un oggetto di tipo {[key in Tags]: null}. questo tipo di oggetto richiede che ogni tag sia rappresentato come puntello (e non più).

    export type Tags = "featured" | "design" | "fabrication" | "development" | "audio" 
    | "imagery" | "social" | "leadership" | "writing" | "3d" | "interactive" | "work";
    
    // the following typedef will assert that every tag is added as a prop
    const tagsObject: {[key in Tags]: null} = {
        featured: null,
        design: null,
        fabrication: null,
        development: null,
        audio: null,
        imagery: null,
        social: null,
        leadership: null,
        writing: null,
        "3d": null,
        interactive: null,
        work: null,
    }
    // because the tagsObject must have all tags as props to pass type assertion
    // tagList will always contain every tag
    const tagList: Tags[] = Array.from(Object.keys(tagsObject)) as any;
    export { tagList };

Leave a Reply

Your email address will not be published. Required fields are marked *