8_TypeScript String --[深入浅出 TypeScript 测试]

TypeScript 是一种由微软开发的开源编程语言，它是 JavaScript 的一个超集，添加了静态类型和其他一些特性来帮助开发者更有效地编写代码。TypeScript 代码最终会被编译成普通的 JavaScript 代码，可以在任何浏览器、设备或环境中运行。

在 TypeScript 中，String 类型（注意是首字母大写的 String）实际上是指的是构造函数或者类，而字符串字面量和变量一般使用小写 string 来表示其类型。以下是一些关于如何在 TypeScript 中使用字符串的基本信息：

String 对象与字符串字面量的区别

在 TypeScript 中，String 对象和字符串字面量（string primitive）之间有几个关键的区别：

1. 类型表示

• 字符串字面量：使用小写的 string 来表示，这是最常用的表示法。它指的是原始的字符串值。

  let literal: string = "Hello, world!";
  

• String 对象：使用大写的 String 来表示，这实际上是指构造函数或类，用于创建新的 String 对象实例。

  let object: String = new String("Hello, world!");
  

2. 性能与内存使用

• 字符串字面量：通常更加高效，因为它们是不可变的原始类型，并且在 JavaScript 引擎中优化得很好。

• String 对象：相对更消耗资源，因为它们是对象，拥有更多的方法和属性，同时也会占用更多的内存。

3. 值比较

• 字符串字面量：当两个相同的字符串字面量进行比较时，会返回 true，因为它们被视为同一个值。

  console.log("test" === "test"); // true
  

• String 对象：即使内容相同，不同的 String 对象实例也不会相等，因为它们是不同的对象实例。

  console.log(new String("test") === new String("test")); // false
  

4. 方法调用

虽然 String 对象和字符串字面量都可以调用同样的原型链上的方法，但直接在字符串字面量上调用方法是更常见的做法，因为不需要额外创建一个对象实例。

let literalResult = "Hello".toUpperCase(); // 正常操作
let objectResult = (new String("Hello")).toUpperCase(); // 不推荐

5. 特殊情况下的行为

• String 对象：由于它是对象，所以它可以拥有属性，例如 .length，并且可以被扩展来添加自定义的方法或属性。

• 字符串字面量：作为原始数据类型，它们不能被直接扩展。

总的来说，在日常编程中，你几乎总是应该使用字符串字面量而不是 String 对象。String 对象主要用于特定场景下需要利用其作为对象的行为特性的时候。对于大多数应用来说，使用字符串字面量就足够了，而且这样做也更符合性能最佳实践。

字符串字面量和 String 对象的类型兼容性

在 TypeScript 中，字符串字面量（string primitive）和 String 对象之间的类型兼容性是存在差异的。通常情况下，TypeScript 会尽量保持与 JavaScript 的行为一致，但在静态类型检查方面会更加严格。

类型兼容性

1. 隐式转换：

   • 在大多数情况下，JavaScript 会自动将 String 对象转换为原始类型的字符串字面量，这被称为“装箱”和“拆箱”。因此，在运行时，String 对象可以被当作字符串字面量来使用。

2. 赋值兼容性：

   • 在 TypeScript 中，你可以将一个字符串字面量赋值给一个 String 对象变量，因为 TypeScript 会认为这是一个有效的操作，并且会在编译时处理这种转换。
   • 反之，将 String 对象赋值给一个声明为 string 类型的变量也是允许的，因为 TypeScript 认识到在这种情况下会发生自动的类型转换（即从对象到原始类型的转换）。

3. 类型断言：

   • 如果你需要明确地告诉 TypeScript 你正在处理的是哪种类型，你可以使用类型断言。例如，如果你有一个 String 对象但你想把它当作原始字符串处理，你可以这样写：(new String("hello") as string) 或者 <string>new String("hello")。

4. 类型检查：

   • 尽管有上述的兼容性和转换规则，TypeScript 的类型系统仍然会将 String 和 string 视作不同的类型。这意味着如果你定义了一个函数参数或返回值的类型为 string，那么传递 String 对象可能会导致类型错误，除非 TypeScript 能够推断出该对象会被转换成原始字符串。

示例代码

let strPrimitive: string = "Hello";
let strObject: String = new String("World");

// 这是允许的，因为 TypeScript 会自动处理转换
strPrimitive = strObject.valueOf(); // 明确调用 valueOf() 方法获取原始值
strObject = new String(strPrimitive); // 创建一个新的 String 对象

// 类型断言的例子
let anotherStr: string = (new String("example") as string);

// 函数参数的例子
function greet(name: string) {
    console.log(`Hello, ${name}`);
}

greet("Alice"); // 正常工作
greet(new String("Bob").valueOf()); // 需要调用 valueOf() 来获得原始字符串

最佳实践

尽管 TypeScript 允许在某些情况下互换使用 String 对象和字符串字面量，但是为了性能考虑以及避免不必要的复杂性，推荐总是使用字符串字面量（string），除非有特殊的需求需要使用 String 对象。

String 对象属性

String 对象在 JavaScript 和 TypeScript 中提供了许多有用的属性，这些属性同样适用于字符串字面量（因为当对字符串字面量调用方法时，JavaScript 会临时创建一个 String 对象）。以下是 String 对象的一些主要属性：

String 对象的静态属性

• String.length:
  • 返回空字符串的长度，对于 String 构造函数本身来说，这个值总是 0。这不是实例属性，而是构造函数的属性。

String 实例属性

• length:

  • 这是每个 String 实例都有的只读属性，表示字符串中的字符数量。这是最常用的属性之一。

  const greeting = new String("Hello, world!");
  console.log(greeting.length); // 输出: 13
  

• prototype:

  • 虽然不是直接用于字符串实例的属性，但 String.prototype 是所有 String 实例继承其方法和属性的地方。开发者可以通过扩展 String.prototype 来添加自定义的方法或属性，不过这通常不被推荐，因为它可能会影响到其他代码。

注意事项

• 不可变性：

  • 字符串在 JavaScript/TypeScript 中是不可变的，这意味着一旦创建了字符串，你就不能改变它的内容。任何看似修改字符串的操作实际上都会返回一个新的字符串对象。

• 原始类型 vs. 对象：

  • 如前所述，虽然你可以使用 new String() 创建 String 对象，但在大多数情况下应该优先使用字符串字面量（即直接用引号括起来的文本），因为它们更高效，并且与 String 对象相比具有更好的性能表现。

示例代码

// 使用字符串字面量
const literalStr: string = "Hello";
console.log(literalStr.length); // 输出: 5

// 使用 String 对象
const stringObj: String = new String("World");
console.log(stringObj.length); // 输出: 5

// 尝试修改字符串 (不会生效，因为字符串是不可变的)
try {
    // @ts-ignore: 忽略此行的类型检查错误
    literalStr[0] = 'J'; // 这将不会改变 literalStr 的值
} catch (e) {
    console.error(e);
}

// 正确的方式是创建一个新的字符串
const modifiedStr = 'J' + literalStr.slice(1);
console.log(modifiedStr); // 输出: Jello

总的来说，String 对象的主要用途在于它提供的原型方法，而它的实例属性主要是 length。由于性能考虑和编码习惯，建议尽可能地使用字符串字面量而不是 String 对象。

String 方法

当然，以下是使用 TypeScript 中的 String 类型时可以调用的一些常用方法的示例。这些方法同样适用于字符串字面量和 String 对象。每个例子都展示了如何操作字符串数据。

1. charAt(index: number): string

返回指定索引位置的字符。

let str = "Hello, world!";
console.log(str.charAt(7)); // 输出: w

2. concat(...strings: string[]): string

将一个或多个字符串连接到原字符串，并返回新的字符串。

let greeting = "Hello".concat(", ", "world", "!");
console.log(greeting); // 输出: Hello, world!

3. includes(searchValue: string, position?: number): boolean

检查字符串是否包含指定的子字符串，可选地从指定位置开始查找。

let sentence = "The quick brown fox jumps over the lazy dog";
console.log(sentence.includes("fox")); // 输出: true
console.log(sentence.includes("cat")); // 输出: false

4. indexOf(searchValue: string, fromIndex?: number): number

返回第一次出现的指定值的索引，如果未找到则返回 -1。

let text = "To be or not to be.";
console.log(text.indexOf("be")); // 输出: 3
console.log(text.indexOf("to", 5)); // 输出: 10

5. replace(searchValue: string | RegExp, replaceValue: string | ((substring: string, ...args: any[]) => string)): string

用新子串替换所有匹配搜索值的子串，返回新的字符串。

let phrase = "The rain in Spain stays mainly in the plain";
console.log(phrase.replace(/ain/g, "ane")); // 输出: The rane in Speane stays malely in the plane

6. slice(start?: number, end?: number): string

提取字符串的一部分并返回一个新的字符串，不改变原始字符串。

let alphabet = "abcdefghijklmnopqrstuvwxyz";
console.log(alphabet.slice(0, 5)); // 输出: abcde
console.log(alphabet.slice(-3)); // 输出: xyz

7. toLowerCase(): string

将整个字符串转换为小写。

let upperCaseStr = "HELLO WORLD!";
console.log(upperCaseStr.toLowerCase()); // 输出: hello world!

8. toUpperCase(): string

将整个字符串转换为大写。

let lowerCaseStr = "hello world!";
console.log(lowerCaseStr.toUpperCase()); // 输出: HELLO WORLD!

9. trim(): string

去除字符串两端的空白字符。

let spacedText = "   Trim this string   ";
console.log(spacedText.trim()); // 输出: Trim this string

10. split(separator: string | RegExp, limit?: number): string[]

根据指定分隔符将字符串分割成数组。

let sentence = "The,quick,brown,fox,jumps,over,the,lazy,dog";
console.log(sentence.split(",", 4)); // 输出: ["The", "quick", "brown", "fox"]

以上就是一些常用的 String 方法的例子。在实际开发中，这些方法可以帮助你高效地处理和操作字符串数据。请注意，尽管你可以对 String 对象使用这些方法，但在大多数情况下推荐直接使用字符串字面量以提高性能和代码简洁性。

String 对象的使用建议

在 TypeScript（以及更广泛的 JavaScript）中，String 对象的使用并不如字符串字面量（即直接用引号括起来的文本）那样普遍。以下是关于 String 对象的一些使用建议：

优先使用字符串字面量

• 性能：字符串字面量是原始类型，它们在内存中占用的空间较小，且操作速度更快。
• 不可变性：字符串字面量是不可变的，这使得它们更加安全，不会意外地被修改。
• 简洁性：代码更加直观和易于阅读。

// 推荐的做法
let greeting: string = "Hello, world!";

尽量避免使用 new String()

• 不必要的复杂性：创建 String 对象会引入额外的复杂性和潜在的错误源。
• 对象比较问题：两个 String 对象即使内容相同，在进行相等性比较时也会返回 false，因为它们是不同的对象实例。
• 自动装箱问题：当 String 对象与字符串字面量混合使用时，可能会发生隐式的装箱和拆箱，这可能导致不易察觉的性能问题或行为异常。

// 不推荐的做法
let greetingObject: String = new String("Hello, world!");
console.log(greetingObject === new String("Hello, world!")); // 输出: false

使用场景

尽管通常不推荐使用 String 对象，但在某些特定情况下它们可能是有用的：

• 属性访问：如果你需要访问 String 构造函数上的静态属性，例如 String.fromCharCode() 或者 String.raw 标签模板。
• 自定义扩展：如果你确实需要为字符串添加自定义方法或属性，并且这些扩展应该存在于所有字符串实例上（虽然这通常不是一个好主意，因为它可以影响其他代码库的行为）。
• 互操作性需求：在某些框架或库中，可能要求传入 String 对象而不是字符串字面量。不过这种情况非常罕见。

注意点

• 转换回原始类型：如果你有一个 String 对象但需要它作为原始字符串来使用，你可以调用 .valueOf() 方法或者使用一元加运算符（+）来进行显式的类型转换。

let strObj: String = new String("example");
let primitiveStr: string = strObj.valueOf(); // 或者 +strObj;

总结

总的来说，除非有特别的理由，否则应当优先使用字符串字面量而不是 String 对象。对于大多数应用来说，字符串字面量提供了足够的功能，并且符合最佳实践。如果你发现自己频繁地需要使用 String 对象，请考虑是否有更好的解决方案。