String vs string in TypeScript: Primitive vs Wrapper Object

By the end of this page, you will understand why string and String are not the same in TypeScript, how primitive values differ from wrapper objects, why the assignment error happens, and why developers almost always use lowercase string in real code.

In TypeScript, string and String represent related but different things.

• string is the primitive string type.
• String is the wrapper object type.

This mirrors JavaScript itself.

Primitive vs wrapper

JavaScript has primitive values such as:

• string
• number
• boolean
• bigint
• symbol
• null
• undefined

A primitive string is a simple value:

let name: string = "Ada";

JavaScript also has object wrappers like:

• String
• Number

Think of string as the actual text written on a note, and String as a plastic box that can hold that note.

• string = the text itself
• String = an object container around the text

If someone asks for a box-like thing, plain text can often still be handled because JavaScript can temporarily wrap it. But if someone asks for plain text, handing over a box is not the same thing.

That is why this feels one-way:

• string can often act like String
• String cannot safely act like string

For everyday programming, you usually want the text itself, not the box.

Core syntax

let primitiveText: string = "hello";
let wrappedText: String = new String("hello");

Recommended usage

Use lowercase string for variables, parameters, return types, and properties.

function greet(name: string): string {
  return `Hello, ${name}`;
}

Example: assignment difference

let a: String = "test";
let b: string = "another test";

a = b; // OK
b = a; // Error

Why?

• b is a primitive string.

Consider this example:

let a: String = "test";
let b: string = "another test";

a = b;
b = a;

Step 1: let a: String = "test";

• a is declared as type String.
• The value assigned is a primitive string: "test".
• TypeScript allows this because primitive strings can be treated like string objects in many situations.

Step 2: let b: string = "another test";

• b is declared as primitive type string.
• This is the normal and recommended way to store text.

Step 3: a = b;

• b contains a primitive string.
• A primitive string is acceptable for a.
• So this assignment succeeds.

Step 4: b = a;

Where this matters in practice

Function parameters

Most functions should accept primitive strings:

function formatUsername(name: string): string {
  return name.trim().toLowerCase();
}

API data

Data from APIs, forms, JSON, and databases is typically treated as primitive strings.

type User = {
  email: string;
  role: string;
};

Validation

When validating input, you usually check for primitive strings:

function isNonEmpty(value: string): boolean {
  return value.length > 0;
}

Avoiding surprising behavior

Wrapper objects can behave unexpectedly in comparisons and truthiness.

In real TypeScript codebases, developers almost always use lowercase primitive types.

Common patterns

Type annotations

type Config = {
  appName: string;
  apiUrl: string;
};

Function contracts

function parseSlug(slug: string): string[] {
  return slug.split("-");
}

Guard clauses

function printMessage(message: string) {
  if (message.length === 0) {
    return;
  }

  console.log(message);
}

Validation and normalization

function normalizeEmail():  {
   email.().();
}

1. Using String instead of string

Broken example:

function greet(name: String): String {
  return "Hello, " + name;
}

Better:

function greet(name: string): string {
  return "Hello, " + name;
}

Why avoid it?

• String means object wrapper type.
• It is not the standard choice for text values.

2. Creating wrapper objects with new String()

Broken or confusing example:

const name = new String("Ada");
console.log(typeof name); 

Quick rules

• Use string for normal text values.
• Avoid String in type annotations.
• Avoid new String().
• string is primitive.
• String is an object wrapper.

Syntax

let a: string = "hello";
let b: String = new String("hello");

Assignment behavior

let x: String = "hi"; // OK
let y: string = x;     // Error if x is typed as String

Runtime difference

typeof "hello"               // "string"
  ()   

Is String the same as string in TypeScript?

No. string is a primitive type, while String is the wrapper object type.

Should I ever use String in TypeScript?

Usually no. In normal code, use string. Wrapper object types are rarely needed.

Why does a = b work but b = a fail?

Because a primitive string can be treated like a string object in some contexts, but a String object is not guaranteed to be a primitive string.

Is this a TypeScript bug?

No. It matches JavaScript's runtime behavior and TypeScript's type system.

Why can I call string methods on a primitive?

JavaScript temporarily boxes primitive strings so methods like .toUpperCase() work.

Does this apply to Number and Boolean too?

Yes. Prefer number over and over .

• number vs Number — another primitive vs wrapper distinction in TypeScript.
• boolean vs Boolean — the same rule applies for boolean values.
• primitive types — helps explain what a primitive value is in JavaScript and TypeScript.
• object types — useful for understanding why wrapper values behave differently.
• type assignability — explains why some assignments are allowed and others are rejected.
• JavaScript constructors — relevant because String can be created with new String().
• strict typing in TypeScript — helps explain why TypeScript warns about unsafe assignments.