> ## 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. # JavaScript Unary Plus The `+` operator in JavaScript is a polymorphic operator that performs either numeric addition or string concatenation depending on the types of its evaluated operands. It also functions as a unary operator to explicitly coerce a single operand into a numeric value. ## Syntax ```javascript theme={"dark"} // Binary Operator LeftOperand + RightOperand // Unary Operator +Operand ``` ## Binary Operator Mechanics When used as a binary operator, the JavaScript engine follows a strict evaluation algorithm defined by the ECMAScript specification to determine whether to add or concatenate. The engine resolves the operation through the following sequence: 1. **Primitive Conversion:** The engine applies the internal `ToPrimitive()` abstract operation to both operands. Objects and Arrays are converted to their primitive values (typically by invoking their internal `valueOf()` or `toString()` methods). 2. **Type Evaluation:** * If either of the resulting primitive values is a **String**, the engine applies the `ToString()` abstract operation to both operands and performs **string concatenation**. * If neither primitive value is a String, the engine applies the `ToNumeric()` abstract operation to both operands and performs **numeric addition**. If the operands resolve to different numeric types (e.g., mixing `Number` and `BigInt`), the engine throws a `TypeError`. * If either operand is a **Symbol**, the engine throws a `TypeError` as Symbols cannot be implicitly coerced to strings or numbers. ### Coercion Behavior ```javascript theme={"dark"} // Numeric Addition (neither operand resolves to a string) 1 + 2 // 3 1 + true // 2 (true coerces to 1) 1 + null // 1 (null coerces to 0) 1 + undefined // NaN (undefined coerces to NaN) // String Concatenation (at least one operand resolves to a string) "1" + 2 // "12" "System" + true // "Systemtrue" "" + null // "null" // Complex Type Coercion (ToPrimitive evaluation) [1, 2] + [3, 4] // "1,23,4" (Arrays coerce to strings "1,2" and "3,4") ({} + []) // "[object Object]" (Expression context forces Object coercion) // BigInt and Symbol Exceptions 10n + 20n // 30n 10n + 5 // TypeError: Cannot mix BigInt and other types Symbol("a") + "b" // TypeError: Cannot convert a Symbol value to a string ``` ## Unary Operator Mechanics When used as a prefix to a single operand, the unary `+` operator directly triggers the internal `ToNumber()` abstract operation. It bypasses string concatenation logic entirely and attempts to parse the operand into an IEEE 754 double-precision float. Because the operation strictly enforces `ToNumber()`, applying the unary `+` to a `BigInt` or `Symbol` will throw a `TypeError`. ### Unary Coercion Behavior ```javascript theme={"dark"} +"42" // 42 (String to Number) +"0xFF" // 255 (Hexadecimal string to Number) +true // 1 (Boolean to Number) +false // 0 +null // 0 +undefined // NaN +"" // 0 (Empty string to Number) +new Date() // 1697040000000 (Date object to epoch timestamp) +{} // NaN (Object to Number) // BigInt and Symbol Exceptions +10n // TypeError: Cannot convert a BigInt value to a number +Symbol("a") // TypeError: Cannot convert a Symbol value to a number ```

Tired of Poor JavaScript Skills? Fix That With Deep Grasping! Learn More