Addition

The + operator in TypeScript functions as both a unary numeric coercion operator and a binary operator for numeric addition or string concatenation. TypeScript applies strict static type-checking rules to its operands, preventing many of the implicit type coercions permitted in standard JavaScript to enforce type safety.

Unary + Operator

The unary + operator precedes a single operand and evaluates it as a number.

Syntax:

+operand

Type Rules:

• Valid Operands: TypeScript strictly limits the unary + operator to operands of type number, string, any, and numeric enums.
• Return Type: Always resolves to the number type at compile time.
• Compiler Restrictions: TypeScript explicitly forbids applying the unary + to types such as boolean, null, undefined, bigint, or symbol. Attempting to do so results in a compile-time error.

const str: string = "42";
const num: number = +str; // Valid: resolves to number

const bool: boolean = true;
const invalidBool: number = +bool; // Error TS2469: Operator '+' cannot be applied to type 'boolean'.

const big: bigint = 100n;
const invalidBig: number = +big; // Error TS2469: Operator '+' cannot be applied to type 'bigint'.

Binary + Operator

The binary + operator sits between two operands, performing either mathematical addition or string concatenation based on the resolved types of the operands.

Syntax:

leftOperand + rightOperand

Type Rules & Resolution: TypeScript evaluates the binary + using the following strict type-checking hierarchy:

1. String Concatenation: If either operand is of type string, the operation is treated as concatenation. The non-string operand is implicitly coerced, and the return type is string.

const a: string = "Value: " + 42; // Resolves to string
const b: string = true + " is boolean"; // Resolves to string

2. Numeric Addition: If both operands are of type number (or numeric enums), the operation performs mathematical addition. The return type is number.

const c: number = 10 + 5; // Resolves to number

3. BigInt Addition: If both operands are of type bigint, the operation performs BigInt addition. The return type is bigint.

const d: bigint = 10n + 20n; // Resolves to bigint

Compiler Restrictions: Unlike JavaScript, TypeScript rejects binary + operations between incompatible types.

• Mixed Numerics: You cannot mix number and bigint.
• Invalid Primitives: You cannot add boolean, null, or undefined to a number or to each other.
• Objects/Arrays: You cannot use the + operator on objects or arrays unless one operand is a string or the types are explicitly cast to any.

const err1 = 5 + true; // Error TS2365: Operator '+' cannot be applied to types 'number' and 'boolean'.
const err2 = 10n + 5;  // Error TS2365: Operator '+' cannot be applied to types 'bigint' and 'number'.
const err3 = {} + {};  // Error TS2365: Operator '+' cannot be applied to types '{}' and '{}'.

Master TypeScript with Deep Grasping Methodology!

Learn More