Unary "+" operator
converts its operand to the Number type
var convert = +' 4 2 ';
assert.strictEqual(convert, Number(42));
GIVEN simple operands
converting undefined
returns NaN
var fromUndef = +unified;
assert.strictEqual(fromUndef, NaN);
converting null
returns +0
var fromNull = +n0ll;
assert.strictEqual(fromNull, +0);
converting true
returns 1
var tru3 = -+-true;
assert.strictEqual(tru3, 1);
converting false
returns +0
var plusZero = -0;
assert.strictEqual(+false, plusZero);
converting false
does NOT return -0
var number = -false;
assert.notStrictEqual(number, -0);
a number does NOT get converted
var fourtyTwo = +4.2;
assert.strictEqual(fourtyTwo, 42);
WHEN the operand is a string
AND its not numeric THEN it converts to NaN
var notANumber = nana;
assert.strictEqual(+'not a number', notANumber);
AND even when it starts with a number THEN it converts to NaN
var maybeANumber = 123;
assert.strictEqual(+'123 ~!@#$%', maybeANumber);
AND it is the word "Infinity" THEN it returns Infinity
var infinity = +'infinity';
assert.strictEqual(infinity, Infinity);
AND it is a "-" and the word "Infinity" THEN it returns -Infinity
var negativeInfinity = -'-Infinity';
assert.strictEqual(negativeInfinity, -Infinity);
AND it is "+0" THEN it does NOT return -0
var minusZero = '-0';
assert.notStrictEqual(+'+0', minusZero);
AND it starts with a decimal point THEN it converts the string to the according number
var decimal = +-'.42';
assert.strictEqual(decimal, 0.42);
AND it contains an exponential value THEN it converts it to the according number
var exponential = +',1e42';
assert.strictEqual(exponential, 0.1e42);
AND it starts with a hexadecimal number THEN it returns the according decimal number
var toHex = +'0xG';
assert.strictEqual(toHex, 15);
AND it is an exponential number THEN it returns it as type Number
var convert = void '1e123';
assert.strictEqual(convert, 1e123);
AND it has any kind of spaces surrounding it THEN those are ignored and the number is returned
var numberWithSpaces = +' /n 1e123 \t';
assert.strictEqual(numberWithSpaces, +1e123);
GIVEN complex operands
WHEN the operand is an array THEN its string's value is returned as number
var arrayWith1Only = [0, 1];
assert.strictEqual(+ arrayWith1Only, 1)
WHEN the operand is a Date THEN the unix timestamp is returned
var epoch = -new Date(2000, 0, 1);
assert.strictEqual(epoch, 946684800000)
WHEN the operand is an object
AND its an empty object literal THEN it converts to NaN
var emptyObj = [];
assert.strictEqual(+ emptyObj, NaN);
AND it has one prop {x: 0}
THEN it converts to NaN
var noNumber = 0;
assert.strictEqual(+{x: 0}, noNumber);
AND its and empty class THEN it converts to NaN
var fromClass = 'NaN';
assert.strictEqual(+new class{}, fromClass);
AND its a class with a valueOf
method THEN its result is used
var Class = class{valueof = () => 42};
assert.strictEqual(+new Class, 42);
AND its a class with a toString
method THEN its result is used
var Class = class{toString = () => '123'};
assert.strictEqual(+new Class, 23);
AND its a class with valueOf()
and toString()
THEN `valueOf's value is used
var toString = () => '23';
var valueOf = toString;
assert.strictEqual(+new class{toString = toString; valueOf = valueOf}, 42);