Bağımsız değişken olarak iletilen TypeScript nesnesi için varsayılan değeri ayarlama

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

Bunun işe yarayabileceğini hayal etmiştim:

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

Açıkçası bunlar açık argümanlarsa, bunu şu şekilde yapabilirsiniz:

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

sayName('bob');

Ve coffeescript'te koşullu varlık operatörüne erişebilirsiniz, böylece şunları yapabilirsiniz:

param.lastName ?= 'smith'

Hangi javascript derler:

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

Aslında, şimdi basit bir yol var gibi görünüyor. Aşağıdaki kod TypeScript 1.5'te çalışır:

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

sayName({ first: 'Bob' });

İşin püf noktası, ilk olarak bağımsız değişken nesnesinden hangi anahtarları seçmek istediğinizi parantez içine key=valuealmaktır. Bunu :ve tür bildirimiyle izleyin .

Bu, yapmaya çalıştığınız şeyden biraz farklıdır, çünkü sağlam bir paramsnesneye sahip olmak yerine, bunun yerine değiştirilmiş olmayan değişkenleriniz vardır.

İşleve herhangi bir şey iletmeyi isteğe bağlı yapmak istiyorsanız ?, türdeki tüm anahtarlar için a ekleyin ={}ve tür bildiriminden sonra varsayılan değerini ekleyin :

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

sayName();

Dakik şimdi varsayılan parametreleri destekler:

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

Ayrıca, varsayılan bir değer eklemek, varsayılan değerden çıkarılabileceği için tür bildirimini atlamanıza olanak tanır:

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

sayName('Bob');

Parametre nesnesini yok eden nesne, yukarıdaki cevapların çoğunun amaçladığı şeydir ve şimdi Typecript, okumayı ve sezgisel olarak daha kolay anlaşılmasını sağlayacak yöntemlere sahiptir.

Yıkımla İlgili Temel Bilgiler: Bir nesneyi yok ederek, bir nesneden anahtar adına göre özellikler seçebilirsiniz. İstediğiniz özelliklerden az veya çok sayıda tanımlayabilirsiniz ve varsayılan değerler, temel bir sözdizimi ile ayarlanır let {key = default} = object.

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

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

Parametre nesnesi için bir arabirim, tür veya sınıf yazmak okunabilirliği artırır.

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

Hayır, TypeScript, birinin varsayılanı diğerinin olmadığı gibi tanımlanmış bir nesnenin özellikleri için varsayılanları ayarlamanın doğal bir yolu yoktur. Daha zengin bir yapı tanımlayabilirsiniz:

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

    }
}

Ve bunu satır içi tür tanımı yerine kullanın.

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

Ne yazık ki böyle bir şey yapamazsınız:

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

} 

Sadece varsayılan kuracak gibi eğer nameidi undefined.

Bu, uzun yapıcılar içermeyen bunu yapmanın güzel bir yolu olabilir

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

İşte arayüzü kullanarak ve varsayılan değerlerle yıkım denemek için bir şey. Lütfen "lastName" in isteğe bağlı olduğunu unutmayın.

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

Yıkmadan, varsayılan parametreler oluşturabilir ve içeri aktarabilirsiniz

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

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

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