Vraag Standaardwaarde instellen voor TypeScript-object doorgegeven als argument


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'});

Ik had me voorgesteld dat zoiets als dit zou kunnen werken:

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

Het is duidelijk dat als dit simpele argumenten waren, je het kon doen met:

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

sayName('bob');

En in coffeescript hebt u toegang tot de conditional existence-operator, zodat u het volgende kunt doen:

param.lastName ?= 'smith'

Welke compileert naar de javascript:

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

82
2018-04-26 18:17


oorsprong


antwoorden:


Eigenlijk lijkt er nu een eenvoudige manier te zijn. De volgende code werkt in TypeScript 1.5:

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

sayName({firstName: 'Bob'});

De truc is om eerst tussen haakjes te zetten welke toetsen u wilt kiezen uit het argumentobject, met key=value voor elke standaard. Volg dat met de : en een typeaangifte.

Dit is een beetje anders dan wat je probeerde te doen, omdat je in plaats van intact bent params object, hebt u in plaats daarvan variabelen die afwijken.

Als u het optioneel wilt maken om iets aan de functie door te geven, voegt u een toe ? voor alle sleutels in het type en voeg een standaardwaarde van ={} na de typeaangifte:

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

sayName();

93
2017-09-15 21:45



Nee, TypeScript heeft geen natuurlijke manier om standaardinstellingen in te stellen voor eigenschappen van een object dat op dezelfde manier is gedefinieerd, waarbij de ene een standaard heeft en de andere niet. U zou een rijkere structuur kunnen definiëren:

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

    }
}

En gebruik dat in plaats van de definitie van het inline-type.

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

Je kunt zoiets helaas niet doen:

function sayName(name : { first: string; last?:string } 
       /* and then assign a default object matching the signature */  
       = { first: null, last: 'Smith' }) {

} 

Omdat het alleen de standaardwaarde zou instellen als name was undefined.


19
2018-04-26 19:15



Typescript ondersteunt nu standaardparameters:

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

Als u een standaardwaarde toevoegt, kunt u ook de typedeclaratie weglaten, omdat deze kan worden afgeleid van de standaardwaarde:

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

sayName('Bob');

19
2017-07-06 00:00



Objectvernietiging het parameterobject is waar veel van de antwoorden hierboven naar streven en Typescript heeft nu de methoden die er zijn om het veel gemakkelijker te lezen en intuïtief te begrijpen.

Destructuring Basics: Door een object te vernietigen, kunt u eigenschappen van een object kiezen op basis van de naam van de sleutel. U kunt zo weinig of zo veel eigenschappen definiëren als u wilt en standaardwaarden worden bepaald door een basissyntaxis van let {key = default} = object.

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

//Compiles to:
var firstName = myParamsObject.firstName, 
_a = myParamsObject.lastName, 
lastName = _a === void 0 ? 'Smith' : _a;

Het schrijven van een interface, type of klasse voor het parameterobject verbetert de leesbaarheid.

type FullName = {
  firstName: string;
   
  /** @default '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);
}

// Use it
sayName({
  firstName: 'Bob'
});


14
2017-08-24 03:43



Dit kan een leuke manier zijn om dit te doen zonder lange constructeurs

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

    // Pass in this class as the required params
    constructor(params: Person) {
        // object.assign will overwrite defaults if params exist
        Object.assign(this, params)
    }
}

// you can still use the typing 
function sayName(params: Person){ 
    let name = params.firstName + params.lastName
    alert(name)
}

// you do have to call new but for my use case this felt better
sayName(new Person({firstName: 'Gordon'}))
sayName(new Person({lastName: 'Thomas'}))

13
2017-10-30 17:43