Установка значения по умолчанию для объекта TypeScript, переданного в качестве аргумента

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

Я думал, что-то вроде этого может работать:

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

Очевидно, что если бы это были простые аргументы, вы могли бы сделать это с:

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

sayName('bob');

И в coffeescript у вас есть доступ к условному оператору существования, так что можете сделать:

param.lastName ?= 'smith'

Который компилируется в JavaScript:

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

На самом деле, кажется, теперь есть простой способ. Следующий код работает в TypeScript 1.5:

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

sayName({ first: 'Bob' });

Хитрость заключается в том, чтобы сначала заключить в скобки ключи, которые вы хотите выбрать из объекта аргумента, key=valueдля любых значений по умолчанию. Следуйте этому с :объявлением типа и.

Это немного отличается от того, что вы пытались сделать, потому что вместо целого paramsобъекта у вас есть переменные с разыменованными ссылками.

Если вы хотите сделать необязательным передачу чего-либо в функцию, добавьте a ?для всех ключей в типе и добавьте значение по умолчанию ={}после объявления типа:

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

sayName();

Typescript теперь поддерживает параметры по умолчанию:

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

Кроме того, добавление значения по умолчанию позволяет вам опустить объявление типа, потому что оно может быть выведено из значения по умолчанию:

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

sayName('Bob');

Объект, деструктурирующий объект-параметр, - это то, к чему стремятся многие из приведенных выше ответов, и в Typescript теперь есть методы, облегчающие чтение и интуитивное понимание.

Основы разрушения: Разрушая объект, вы можете выбрать свойства объекта по ключевому имени. Вы можете определить столько свойств, сколько вам нужно, и значения по умолчанию устанавливаются с помощью основного синтаксиса let {key = default} = object.

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

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

Написание интерфейса, типа или класса для объекта параметра улучшает удобочитаемость.

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

Нет, TypeScript не имеет естественного способа установки значений по умолчанию для свойств объекта, определенного как тот, где один имеет значение по умолчанию, а другой нет. Вы можете определить более богатую структуру:

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

    }
}

И используйте это вместо встроенного определения типа.

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

Вы не можете сделать что-то подобное, к сожалению:

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

} 

Как было бы только установить значение по умолчанию, если nameбыло undefined.

Это может быть хорошим способом сделать это без длинных конструкторов

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

Вот что попробовать, используя интерфейс и деструктуризацию со значениями по умолчанию. Обратите внимание, что «lastName» не является обязательным.

interface IName {
  firstName: string
  lastName?: string
}

function sayName(params: IName) {
  const { firstName, lastName = "Smith" } = params
  const fullName = `${firstName} ${lastName}`

  console.log("FullName-> ", fullName)
}

sayName({ firstName: "Bob" })

Без деструктуризации вы можете создать параметры по умолчанию и передать их в

interface Name {
   firstName: string;
   lastName: string;
}

export const defaultName extends Omit<Name, 'firstName'> {
    lastName: 'Smith'
}

sayName({ ...defaultName, firstName: 'Bob' })