Festlegen des Standardwerts für ein TypeScript-Objekt, das als Argument übergeben wird

Question

function sayName(params: {firstName: string; lastName?: string}) {
    params.lastName = params.lastName || 'smith';  // <<-- any better alternative to this?
    var name = params.firstName + params.lastName
    alert(name);
}

sayName({firstName: 'bob'});

Ich hatte mir vorgestellt, dass so etwas funktionieren könnte:

function sayName(params: {firstName: string; lastName: string = 'smith'}) {

Offensichtlich, wenn es sich um einfache Argumente handelte, könntest du es mit diesem Code tun:

function sayName(firstName: string, lastName = 'smith') {
    var name = firstName + lastName;
    alert(name);
}

sayName('bob');

Und in Coffeescript hast du Zugriff auf den bedingten Existenzoperator, also kannst du Folgendes tun:

param.lastName ?= 'smith'

Was sich zu folgendem Javascript kompiliert:

if (param.lastName == null) {
    param.lastName = 'smith';
}

Answer 1

Eigentlich scheint es jetzt einen einfachen Weg zu geben. Der folgende Code funktioniert in TypeScript 1.5:

function sayName({ first, last = 'Smith' }: {first: string; last?: string }): void {
  const name = first + ' ' + last;
  console.log(name);
}

sayName({ first: 'Bob' });

Der Trick besteht darin, zunächst in Klammern die Schlüssel anzugeben, die Sie aus dem Argumentobjekt auswählen möchten, mit Schlüssel=Standard für etwaige Standardeinstellungen. Folgen Sie dem mit einem : und einer Typdeklaration.

Dies unterscheidet sich ein wenig von dem, was Sie zu tun versuchten, weil Sie anstatt eines intakten params-Objekts stattdessen dereferenzierte Variablen haben.

Wenn Sie optional machen möchten, etwas an die Funktion zu übergeben, fügen Sie ein ? für alle Schlüssel im Typ hinzu und fügen Sie nach der Typdeklaration ein Default von ={} hinzu:

function sayName({first='Bob',last='Smith'}: {first?: string; last?: string}={}){
    var name = first + " " + last;
    alert(name);
}

sayName();

Answer 2

Typescript unterstützt jetzt Standardparameter:

https://www.typescriptlang.org/docs/handbook/functions.html

Außerdem ermöglicht das Hinzufügen eines Standardwerts die Auslassung der Typdeklaration, da sie aus dem Standardwert abgeleitet werden kann:

function sayName(firstName: string, lastName = "Smith") {
  const name = firstName + ' ' + lastName;
  alert(name);
}

sayName('Bob');

Answer 3

Die Objektzerlegung des Parameterobjekts ist das Ziel vieler der oben genannten Antworten und Typescript hat nun die Methoden implementiert, um es viel einfacher lesbar und intuitiv verständlich zu machen.

Grundlagen der Zerlegung: Durch die Zerlegung eines Objekts können Sie Eigenschaften aus einem Objekt nach Schlüsselname auswählen. Sie können so viele oder so wenige Eigenschaften definieren, wie Sie möchten, und Standardwerte werden durch eine einfache Syntax von let {key = default} = object festgelegt.

let {firstName, lastName = 'Smith'} = myParamsObject;

// Übersetzt zu:
var firstName = myParamsObject.firstName, 
_a = myParamsObject.lastName, 
lastName = _a === void 0 ? 'Smith' : _a;

Das Schreiben einer Schnittstelle, Typs oder Klasse für das Parameterobjekt verbessert die Lesbarkeit.

type FullName = {
  firstName: string;

  /** @defaultValue 'Smith' */
  lastName ? : string;
}

function sayName(params: FullName) {

  // Set defaults for parameter object
  var { firstName, lastName = 'Smith'} = params;

  // Do Stuff
  var name = firstName + " " + lastName;
  alert(name);
}

// Verwenden
sayName({
  firstName: 'Bob'
});

Answer 4

Nein, TypeScript hat keinen natürlichen Weg, um Standardwerte für Eigenschaften eines Objekts festzulegen, die so definiert sind, dass eine einen Standardwert hat und die andere nicht. Sie könnten eine komplexere Struktur definieren:

class Name {
    constructor(public first : string, 
        public last: string = "Smith") {

    }
}

Und verwenden Sie das anstelle der Inline-Typdefinition.

function sayName(name: Name) {
    alert(name.first + " " + name.last);
}

Leider können Sie nichts in dieser Art tun:

function sayName(name : { first: string; last?:string } 
       /* und dann einem Standardobjekt zuweisen, das der Signatur entspricht */  
       = { first: null, last: 'Smith' }) {

} 

Denn es würde den Standardwert nur setzen, wenn name undefined wäre.

Answer 5

Dies kann eine schöne Möglichkeit sein, dies zu tun, ohne lange Konstruktoren zu verwenden

class Person {
    firstName?: string = 'Bob';
    lastName?: string = 'Smith';

    // Übergeben Sie diese Klasse als erforderliche Parameter
    constructor(params: Person) {
        // object.assign überschreibt die Standardeinstellungen, wenn Parameter vorhanden sind
        Object.assign(this, params)
    }
}

// Sie können immer noch die Typisierung verwenden
function sayName(params: Person){ 
    let name = params.firstName + params.lastName
    alert(name)
}

// Sie müssen new aufrufen, aber für meinen Anwendungsfall fühlte sich das besser an
sayName(new Person({firstName: 'Gordon'}))
sayName(new Person({lastName: 'Thomas'}))