[Jack_Hacker]

Not quite everything. JavaScript does have some primitives, though it also provides object wrappers for those primitives via the new operator.

  > let numberPrimitive = 0;
  undefined
  > let numberObject = new Number(0);
  undefined
  > typeof(numberPrimitive);
  'number'
  > typeof(numberObject);
  'object'
  > typeof(numberObject + numberObject);
  'number'
  > numberPrimitive;
  0
  > numberObject;
  [Number: 0]
  > numberPrimitive.one = 1;
  1
  > numberObject.one = 1;
  1
  > numberPrimitive.one;
  undefined
  > numberObject.one;
  1
  > numberPrimitive;
  0
  > numberObject;
  [Number: 0] { one: 1 }

[_v7gu]

Just using parenthesis is enough for wrapping:

    > 0.toString()
    Thrown:
    0.toString()
    ^^
    
    SyntaxError: Invalid or unexpected token
    > (0).toString()
    '0'

[Jack_Hacker]

Parens aren't doing the same thing. Primitives are implicitly being wrapped in objects when you use methods, but they come out on the other end as primitives again. The new operator gives you an object wrapper that you can keep working with and modifying the values of, whereas the parens you're using just let the interpreter know that your period isn't a decimal point. You can also use a space for this.

  > typeof(new Number(0));
  'object'
  > typeof((0));
  'number'
  > 0 .toString();
  '0'