分享一个TypeScript应用：如何处理日期字符串

TypeScript应用：如何处理日期字符串。

处理多个自定义的日期字符串表示法，比如YYYY-MM-DD和YYYYMMDD。由于这些日期是字符串变量，TypeScript默认会推断成为string类型。虽然这在技术实现上没有错，但是在工作中使用这样的类型定义是很宽泛的，使得有效处理这些日期字符串变得很困难。例如，let dog = 'alfie'也被推断为一个string类型。

在这篇文章中，我会将我的解决方法呈现给你，通过输入这些日期字符串来改善开发者的体验并减少潜在的错误。

在进入编码之前，让我们简单回顾下实现目标需求要利用到的typescript特性，即模板字面量类型和通过类型谓词缩小范围。

模板字面量类型

在typescript4.1版本中引入，模板字面量类型和JavaScript的模板字符串语法相同，但是是作为类型使用。模板字面量类型解析为一个给定模板的所有字符串组合的联合。这听起来可能有点抽象，

直接看代码：

1. type Person = ‘Jeff’ | ‘Maria’
2. type Greeting = `hi ${Person}!` // Template literal type
3. const validGreeting: Greeting = `hi Jeff!` // 
4. // note that the type of `validGreeting` is the union `”hi Jeff!” | “hi Maria!`
5. const invalidGreeting: Greeting = `bye Jeff!` // 
6. // Type ‘”bye Jeff!”‘ is not assignable to type ‘”hi Jeff!” | “hi Maria!”

模板字面量类型非常强大，允许你对这些类型进行通用类型操作。例如，大写字母化。

1. type Person = ‘Jeff’ | ‘Maria’
2. type Greeting = `hi ${Person}!`
3. type LoudGreeting = Uppercase<Greeting> // Capitalization of template literal type
4. const validGreeting: LoudGreeting = `HI JEFF!` // 
5. const invalidGreeting: LoudGreeting = `hi jeff!` // 
6. // Type ‘”hi Jeff!”‘ is not assignable to type ‘”HI JEFF!” | “HI MARIA!”

类型谓词缩小范围

typescript在缩小类型范围方面表现得非常好，可以看下面这个例子：

1. let age: string | number = getAge();
2. // `age` is of type `string` | `number`
3. if (typeof age === ‘number’) {
4.   // `age` is narrowed to type `number`
5. } else {
6.   // `age` is narrowed to type `string`
7. }

也就是说，在处理自定义类型时，告诉typescript编译器如何进行类型缩小是有帮助的。例如，当我们想在执行运行时验证后缩小到一个类型时，在这种情况下，类型谓词窄化，或者用户定义的类型守护，就可以派上用场。

在下面这个例子中，isDog类型守护通过检查类型属性来帮助缩小animal变量的类型：

1. type Dog = { type: ‘dog’ };
2. type Horse = { type: ‘horse’ };
3. //  custom type guard, `pet is Dog` is the type predicate
4. function isDog(pet: Dog | Horse): pet is Dog {
5.   return pet.type === ‘dog’;
6. }
7. let animal: Dog | Horse = getAnimal();
8. // `animal` is of type `Dog` | `Horse`
9. if (isDog(animal)) {
10.   // `animal` is narrowed to type `Dog`
11. } else {
12.   // `animal` is narrowed to type `Horse`
13. }

定义日期字符串

为了简洁起见，这个例子只包含YYYYMMDD日期字符串的代码。

首先，我们需要定义模板字面量类型来表示所有类似日期的字符串的联合类型

1. type oneToNine = 1|2|3|4|5|6|7|8|9
2. type zeroToNine = 0|1|2|3|4|5|6|7|8|9
3. /**
4.  * Years
5.  */
6. type YYYY = `19${zeroToNine}${zeroToNine}` | `20${zeroToNine}${zeroToNine}`
7. /**
8.  * Months
9.  */
10. type MM = `0${oneToNine}` | `1${0|1|2}`
11. /**
12.  * Days
13.  */
14. type DD = `${0}${oneToNine}` | `${1|2}${zeroToNine}` | `3${0|1}`
15. /**
16.  * YYYYMMDD
17.  */
18. type RawDateString = `${YYYY}${MM}${DD}`;
19. const date: RawDateString = ‘19990223’ // 
20. const dateInvalid: RawDateString = ‘19990231’ //31st of February is not a valid date, but the template literal doesnt know!
21. const dateWrong: RawDateString = ‘19990299’//  Type error, 99 is not a valid day

从上面的例子可以得知，模板字面量类型有助于指定日期字符串的格式，但是没有对这些日期进行实际验证。因此，编译器将19990231标记为一个有效的日期，即使它是不正确的，只因为它符合模板的类型。

另外，当检查上面的变量如date、dateInvalid、dateWrong时，你会发现编辑器会显示这些模板字面的所有有效字符的联合。虽然很有用，但是我更喜欢设置名义类型，使得有效的日期字符串的类型是DateString，而不是"19000101" | "19000102" | "19000103" | ...。在添加用户定义的类型保护时，名义类型也会派上用场。

1. type Brand<K, T> = K & { __brand: T };
2. type DateString = Brand<RawDateString, ‘DateString’>;
3. const aDate: DateString = ‘19990101’; // 
4. // Type ‘string’ is not assignable to type ‘DateString’

为了确保我们的DateString类型也代表有效的日期，我们将设置一个用户定义的类型保护来验证日期和缩小类型

1. /**
2.  * Use `moment`, `luxon` or other date library
3.  */
4. const isValidDate = (str: string): boolean => {
5.   // …
6. };
7. //User-defined type guard
8. function isValidDateString(str: string): str is DateString {
9.   return str.match(/^\d{4}\d{2}\d{2}$/) !== null && isValidDate(str);
10. }

现在，让我们看看几个例子中的日期字符串类型。在下面的代码片段中，用户定义的类型保护被应用于类型缩小，允许TypeScript编译器将类型细化为比声明的更具体的类型。然后，在一个工厂函数中应用了类型保护，以从一个未标准化的输入字符串中创建一个有效的日期字符串。

1. /**
2.  *   Usage in type narrowing
3.  */
4. // valid string format, valid date
5. const date: string = ‘19990223’;
6. if (isValidDateString(date)) {
7.   // evaluates to true, `date` is narrowed to type `DateString` 
8. }
9. //  valid string format, invalid date (February doenst have 31 days)
10. const dateWrong: string = ‘19990231’;
11. if (isValidDateString(dateWrong)) {
12.   // evaluates to false, `dateWrong` is not a valid date, even if its shape is YYYYMMDD 
13. }
14. /**
15.  *   Usage in factory function
16.  */
17. function toDateString(str: RawDateString): DateString {
18.   if (isValidDateString(str)) return str;
19.   throw new Error(`Invalid date string: ${str}`);
20. }
21. //  valid string format, valid date
22. const date1 = toDateString(‘19990211’);
23. // `date1`, is of type `DateString`
24. //  invalid string format
25. const date2 = toDateString(‘asdf’);
26. //  Type error: Argument of type ‘”asdf”‘ is not assignable to parameter of type ‘”19000101″ | …
27. //  valid string format, invalid date (February doenst have 31 days)
28. const date3 = toDateString(‘19990231’);
29. //  Throws Error: Invalid date string: 19990231