> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# TypeScript string
The `string` type in TypeScript is a primitive data type representing an immutable sequence of UTF-16 code units. It encompasses all textual data and serves as the foundational type for both standard text assignment and advanced, string-based type transformations within the TypeScript compiler.
TypeScript supports three syntax forms for string initialization, identical to JavaScript: double quotes (`"`), single quotes (`'`), and backticks (`` ` ``) for template literals.
```typescript theme={"dark"}
const double: string = "text";
const single: string = 'text';
const interpolated: string = `value: ${double}`;
```
## String Literal Types
Beyond the generic `string` primitive, TypeScript allows exact string values to be declared as discrete types. A string literal type restricts a variable to one specific sequence of characters.
```typescript theme={"dark"}
let exactValue: "SUCCESS";
exactValue = "SUCCESS"; // Valid
exactValue = "PENDING"; // Type Error: Type '"PENDING"' is not assignable to type '"SUCCESS"'.
```
Literal types are frequently combined using union operators to create finite sets of permissible string values.
```typescript theme={"dark"}
type Direction = "NORTH" | "SOUTH" | "EAST" | "WEST";
let heading: Direction = "NORTH";
```
## Template Literal Types
TypeScript extends JavaScript's template literal syntax into the type system. Template literal types allow you to build new string types by concatenating or interpolating existing string literal types. When interpolating unions, TypeScript computes the cross-product of all possible combinations.
```typescript theme={"dark"}
type Color = "Red" | "Blue";
type Size = "Small" | "Large";
type ProductVariant = `${Size}-${Color}`;
// Resolves to: "Small-Red" | "Small-Blue" | "Large-Red" | "Large-Blue"
```
## Intrinsic String Manipulation Types
The TypeScript compiler provides four intrinsic utility types specifically for transforming string literal types at the type level. These are implemented directly in the compiler for performance.
```typescript theme={"dark"}
type Base = "helloWorld";
type U = Uppercase; // "HELLOWORLD"
type L = Lowercase; // "helloworld"
type C = Capitalize; // "HelloWorld"
type UC = Uncapitalize // "helloWorld"
```
These utilities can be combined with template literal types to enforce strict naming conventions dynamically.
```typescript theme={"dark"}
type Entity = "user" | "post";
type FetcherMethod = `get${Capitalize}`;
// Resolves to: "getUser" | "getPost"
```
## `string` vs. `String`
TypeScript distinguishes between the primitive `string` type and the global `String` wrapper object. The lowercase `string` represents the primitive value and should be used for type annotations. The uppercase `String` refers to the JavaScript object prototype and should generally be avoided in type signatures.
```typescript theme={"dark"}
const primitiveString: string = "hello"; // Correct
const objectString: String = new String("hello"); // Valid, but anti-pattern for typing
// Type Error: 'string' is a primitive, but 'String' is a wrapper object.
const mismatched: string = new String("hello");
```
Tired of Poor TypeScript Skills? Fix That With Deep Grasping!
Learn More
