Come dichiarare un tipo nullable in Macchina?

Ho un’interfaccia a Macchina.

interface Employee{
   id: number;
   name: string;
   salary: number;
}

Vorrei fare ‘stipendio’ come un campo nullable (Come possiamo fare in C#). È possibile fare in Macchina?

InformationsquelleAutor Amitabh | 2013-06-20



9 Replies
  1. 232

    Tutti i campi in JavaScript (e in Dattiloscritto) può avere il valore null o undefined.

    È possibile rendere il campo opzionale che è diverso da nullable.

    interface Employee1 {
        name: string;
        salary: number;
    }
    
    var a: Employee1 = { name: 'Bob', salary: 40000 }; //OK
    var b: Employee1 = { name: 'Bob' }; //Not OK, you must have 'salary'
    var c: Employee1 = { name: 'Bob', salary: undefined }; //OK
    var d: Employee1 = { name: null, salary: undefined }; //OK
    
    //OK
    class SomeEmployeeA implements Employee1 {
        public name = 'Bob';
        public salary = 40000;
    }
    
    //Not OK: Must have 'salary'
    class SomeEmployeeB implements Employee1 {
        public name: string;
    }

    Confrontare con:

    interface Employee2 {
        name: string;
        salary?: number;
    }
    
    var a: Employee2 = { name: 'Bob', salary: 40000 }; //OK
    var b: Employee2 = { name: 'Bob' }; //OK
    var c: Employee2 = { name: 'Bob', salary: undefined }; //OK
    var d: Employee2 = { name: null, salary: 'bob' }; //Not OK, salary must be a number
    
    //OK, but doesn't make too much sense
    class SomeEmployeeA implements Employee2 {
        public name = 'Bob';
    }
    • Guarda come strettamente tipi nullable e rigoroso null-assegni sono stati realizzati e si arriva con la Macchina, 2.0! (o [email protected] ora).
    • sono sicuro var c nel primo esempio? Mi sembra che var b e var c sono le stesse lì.
    • Per impostare null o undefined valore senza errore di compilazione, l’tsconfig “rigorosa” opzione deve essere rimosso o uguale a “false” "strict" : false
  2. 101

    Tipo di unione è nella mia mente opzione migliore in questo caso:

    interface Employee{
       id: number;
       name: string;
       salary: number | null;
    }
    
    //Both cases are valid
    let employe1: Employee = { id: 1, name: 'John', salary: 100 };
    let employe2: Employee = { id: 1, name: 'John', salary: null };

    EDIT : Per funzionare come previsto, si dovrebbe consentire il strictNullChecks in tsconfig.

    • Se si utilizza –strictNullChecks (che dovrebbe essere), questa è una soluzione valida. Io non la uso in favore di optional membri, dal momento che le forze di aggiungere un’esplicita null per tutti letterale oggetti, ma per la funzione di valori di ritorno, è il modo per andare.
  3. 40

    Per essere più C# come definire il Nullable tipo come questo:

    type Nullable<T> = T | null;
    
    interface Employee{
       id: number;
       name: string;
       salary: Nullable<number>;
    }
  4. 30

    Basta aggiungere un punto interrogativo ? al campo facoltativo.

    interface Employee{
       id: number;
       name: string;
       salary?: number;
    }
    • Come Ryan ha sottolineato… ? significa facoltativo, in dattiloscritto, non ammette valori null. Senza ? significa che il var deve essere impostato su un valore compreso null o undefined. Con ? è possibile saltare tutta la dichiarazione-thingy.
    • Grazie! Ho googled per “dattiloscritto valore opzionale” quindi questo è il esattamente quello che stavo cercando.
  5. 5

    ho avuto questa stessa domanda un po ‘ indietro.. di tutti i tipi in ts sono annullabili, perché il vuoto non è un sottotipo di tutti i tipi (a differenza, per esempio, la scala).

    vedere se questo flusso di aiuti – https://github.com/bcherny/language-types-comparison#typescript

    • -1: Questo non è affatto vero. Come per void essere ‘sottotipo di tutti i tipi’ (tipo di fondo), fare riferimento a questo thread. Anche il grafico che hai fornito per la scala non è corretto così. Nothing in scala è, infatti, il tipo di fondo. Dattiloscritto, bancomat, non hanno il tipo di fondale, mentre scala non.
    • “Sottotipo di tutti i tipi” != il tipo di fondale. Vedere il TS spec qui github.com/Microsoft/TypeScript/blob/master/doc/…
  6. 4

    Basta implementare un tipo definito dall’utente, come i seguenti:

    type Nullable<T> = T | undefined | null;
    
    var foo: Nullable<number> = 10; //ok
    var bar: Nullable<number> = true; //type 'true' is not assignable to type 'Nullable<number>'
    var baz: Nullable<number> = null; //ok
    
    var arr1: Nullable<Array<number>> = [1,2]; //ok
    var obj: Nullable<Object> = {}; //ok
    
     //Type 'number[]' is not assignable to type 'string[]'. 
     //Type 'number' is not assignable to type 'string'
    var arr2: Nullable<Array<string>> = [1,2];
  7. 3

    Tipo Nullable può invocare l’errore di runtime.
    Quindi penso che è bene usare un opzione del compilatore --strictNullChecks e dichiarare number | null tipo. anche in caso di funzione nidificata, anche se il tipo di ingresso è null, il compilatore non può sapere quello che si potrebbe rompere, così mi consiglia di utilizzare !(exclamination marchio).

    function broken(name: string | null): string {
      function postfix(epithet: string) {
        return name.charAt(0) + '.  the ' + epithet; //error, 'name' is possibly null
      }
      name = name || "Bob";
      return postfix("great");
    }
    
    function fixed(name: string | null): string {
      function postfix(epithet: string) {
        return name!.charAt(0) + '.  the ' + epithet; //ok
      }
      name = name || "Bob";
      return postfix("great");
    }

    Di riferimento.
    https://www.typescriptlang.org/docs/handbook/advanced-types.html#type-guards-and-type-assertions

Lascia un commento