Incrementing Numbers declared by new Number() via void functions

Question

I know typeof(my_number) is a primitive number, which makes functions receive a copy of my_number instead of my_number itself, which does't make it's value change at all. This is working as expected (I also know var is deprecated, that's probably not my issue here whatever).

What i don't know is why my_object_number isn't changed. I know i could have returned number + 1 and associated it to my_object_number, but I'm intentionally trying to code something similar to what a void(int*)function would have done in C.

var my_number = 3; 
var my_object_number = new Number(3);

var my_object ={
  number: 3
}
function increments_number(numero){
      numero = numero + 1; 
}

function increments_object(number){
  number.number++;
}
increments_number(my_number);
increments_number(my_object_number);
increments_object(my_object);

console.log("primitive number =  3, which increased by a function  = " + my_number);
console.log("object Number =  3 , which increased by a function = " + my_object_number)
console.log("prop number of a hardcoded object = 3, which increased by a function = " + my_object.number)

the code above prints.

primitive number =  3, which increased by a function  = 3
object Number =  3 , which increased by a function = 3
prop number of a hardcoded object = 3, which increased by a function = 4

I'm not sure why my_object_number isn't incremented

Answer 1

I know typeof(my_number) is a primitive number, which makes functions receive a copy of my_number instead of my_number itself, which does't make it's value change at all.

There is no difference between primitives and objects in JavaScript in this respect. Actually, you can forget there’s a difference at all, for the most part – in strict mode, they’ll either behave the same in every situation or throw an error. Function calls aren’t related either. Instead, the difference is between mutating a value and reassigning something that contains a value, like a variable or a property, to contain a different value.

var a = {};
var b = a;
b = {foo: 'bar'};

console.log(a);  // didn’t change, because assignment to `b` changes the variable `b`,
                 // not the value `{}`


var d = 5;
var e = d;
e = 6;

console.log(d);  // didn’t change, because assignment to `e` changes the variable `e`,
                 // not the value `5`

'use strict';

var a = {};
var b = a;
b.foo = 'bar';

console.log(a);  // the value {} changed; all variables stayed the same


var d = 5;
var e = d;
e.foo = 'bar';   // throws an error; a primitive is indistinguishable from…


var f = Object.freeze({});
var g = f;
g.foo = 'bar';   // … an immutable object.

++, like all math operators in JavaScript, is an operation on something that contains a value – it doesn’t mutate a value. ++x acts like x = x + 1.