> ## 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 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:**
```typescript theme={"dark"}
+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.
```typescript theme={"dark"}
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:**
```typescript theme={"dark"}
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`.
```typescript theme={"dark"}
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`.
```typescript theme={"dark"}
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`.
```typescript theme={"dark"}
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`.
```typescript theme={"dark"}
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 '{}'.
```
Tired of Poor TypeScript Skills? Fix That With Deep Grasping!
Learn More
