JavaScript mempunyai pembungkus objek yang membenarkan saya menyemak sama ada "harta" jenis primitif wujud, jadi bagaimanakah saya boleh membuat TypeScript berfungsi seperti ini juga?

Question

Nilai pulangan XMLValidator.validate adalah sama ada benar atau ValidationError (yang tidak sepenuhnya tepat, lihat kemas kini saya) dan ValidationError mempunyai atribut err.

validate(xmlData: string, options?: validationOptionsOptional): benar |
<p>Oleh kerana JavaScript menggunakan pembungkus objek untuk mewakili nilai primitif boolean, saya boleh mengetahui sama ada pengesahan berjaya dengan menyemak sama ada atribut err wujud. </p>
<pre class="brush:php;toolbar:false;">const result = XMLValidator.validate(message)
if (result.err) { // Bagaimanakah cara saya menjadikannya berfungsi dalam ts?
   console.log(`XML tidak sah)
} lain {
  console.log(`XML)
}

Tetapi TypeScript tidak membenarkan saya melakukan ini, ia akan melaporkan ralat: Atribut 'err' tidak wujud pada jenis "true".

Saya tidak suka idea untuk menyemak jenis pulangan dahulu kerana saya mendapati ia bertele-tele dan sebenarnya tiada definisi jenis nilai pulangan (lihat kemas kini saya). Bagaimanakah saya harus menulis kod TypeScript sesingkat mungkin?

--- Kemas kini ---

Saya telah menyemak selanjutnya kod validator.js.

const isValid = validateAttributeString(attrStr, options);
jika (adalahSah !== benar) {
   kembalikan getErrorObject(...);
}
...

fungsi getErrorObject(kod, mesej, lineNumber) {
  kembali {
    silap: {
      kod: kod,
      msg: mesej,
      baris: lineNumber.line ||.
      col: lineNumber.col,
    },
  };
}

Jadi, nampaknya saya hanya boleh menggunakan if (typeof result == "boolean") di sini, tetapi saya berharap ada penyelesaian "universal" untuk soalan saya.

Answer 1

Anda betul, TypeScript tidak membenarkan anda mengakses sifat yang tidak diketahui mungkin wujud pada jenis pembolehubah. Jika jenis itu adalah jenis kesatuan, harta itu mesti wujud pada semua ahli jenis kesatuan sebelum TypeScript membenarkan anda mengaksesnya.

Tetapi terdapat pelbagai cara untuk mengecilkan jenis pembolehubah. Sebagai contoh, anda boleh menyemak dahulu sama ada nilai itu benar, dan jika tidak, TypeScript akan mengecilkan jenis kesatuan kepada hanya ValidationError.

Biasanya, pilihan lain ialah menggunakan operator dalam, tetapi dalam kes ini, jenis kesatuan mengandungi lebih daripada sekadar jenis objek, jadi TypeScript tidak membenarkannya.

Anda juga boleh mentakrifkan pengawal jenis tersuai (atau gunakan yang disediakan oleh pustaka, jika ada), tetapi untuk kes mudah ini, nampaknya itu mungkin terlalu banyak untuk perkara yang anda mahukan.

Terdapat cara lain untuk mengecilkan jenis, seperti yang diperincikan dalam dokumentasi TypeScript yang saya sediakan. Seperti yang anda nyatakan, menyemak keputusan jenis operator juga merupakan salah satu kaedah.

Contoh ini hanya mengisytiharkan bahawa pengawal jenis wujud, bukannya melaksanakan satu, tetapi berikut ialah cara anda boleh menggunakan setiap kaedah untuk mengecilkan jenis pembolehubah hasil:

declare type ValidationError = { err: unknown };
declare function isValidationError(val: unknown): val is ValidationError;

declare const XMLValidator: {
  validate(message: unknown): true | ValidationError
};

const message = 'test message';

const result = XMLValidator.validate(message)

// You can check first if the result is `true`
if (result === true) {
  // Handle success
} else {
  // Then the `else` branch knows it much be a `ValidationError`
  console.error(result.err);
}

// Normally allowed, but not in this case. Error:
// Type 'true | ValidationError' is not assignable to type 'object'
if ('err' in result) {
  console.error(result.err)
}

if (isValidationError(result)) {
  console.error(result.err);
}

Taman Permainan TypeScript

---

Walaupun ia biasanya sebaiknya dielakkan, anda juga boleh menggunakan TypeScript sebagai kata kunci untuk penegasan jenis.

Sebab yang terbaik untuk mengelak daripada menggunakan penegasan jenis ini adalah kerana anda memberitahu TypeScript untuk menganggap satu jenis sebagai jenis lain. Oleh itu, dengan melakukan ini, anda mungkin mengorbankan keselamatan jenis.

console.error((result as ValidationError).err);

Walau bagaimanapun, dalam situasi di mana anda memahami situasi dengan lebih baik daripada pengkompil TypeScript, ini ialah alat yang boleh anda gunakan untuk memberikan maklumat lanjut.

Secara peribadi, saya mendapati adalah berguna untuk sentiasa meninggalkan ulasan yang menerangkan sebab penegasan jenis digunakan, dengan menyebut sebarang andaian yang berasaskan keselamatannya.

Selain itu, dalam kes ini, menggunakan penegasan jenis untuk menyemak sifat tidak menyempitkan jenis pembolehubah hasil, jadi pendekatan ini mungkin tidak sesuai dengan keperluan anda.