Встановлення значення за замовчуванням для об'єкта 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 об'єктом, ви натомість маєте зменшені змінні.

Якщо ви хочете зробити не обов'язковим передавати будь-яку функцію, додайте а ?для всіх клавіш типу і додайте за замовчуванням ={}після оголошення типу:

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