Why don't constants work with objects in JavaScript?

Because you are confusing the concept of a constant reference with an immutable object.

Reference (in this case a constant) is simply a memory address which points to an object. Instead the object is the value to which the constant refers.

In this example:

'use strict';
const empleado = {
    nombre: 'Juan',
    profesion: 'Programador'
};
empleado.nombre = 'Pedro';
console.log(empleado);

The value of the constant empleado(a reference that points to a particular object) remains unchanged, that is, it continues to point to the same object. What has changed is the value of empleado.nombrenot that ofempleado

Instead:

'use strict';
const empleado = {
    nombre: 'Juan',
    profesion: 'Programador'
};
empleado = {
    nombre: 'Pedro',
    profesion: 'Hacker'
}; // Uncaught TypeError: Assignment to constant variable.
console.log(empleado);

If it gives an error because it is trying to modify the value of the constantempleado

If you want to make the object immutable you should use theObject.freeze()

Example:

'use strict';
var empleado = Object.freeze({
    nombre: 'Juan',
    profesion: 'Programador'
});
//empleado.nombre = 'Pedro'; // TypeError: Cannot assign to read only property 'nombre' of #<Object>
empleado = {
    nombre: 'Pedro',
    profesion: 'Hacker'
};

This time it is no longer allowed to modify the object to which the variable refers empleado, but you will be able to modify the variable empleadosince it is not a constant.

Of course you can combine both

'use strict';
const empleado = Object.freeze({
    nombre: 'Juan',
    profesion: 'Programador'
});
//empleado.nombre = 'Pedro'; // TypeError: Cannot assign to read only property 'nombre' of #<Object>
//empleado = {
//    nombre: 'Pedro',
//    profesion: 'Hacker'
//}; // Uncaught TypeError: Assignment to constant variable.

In this way you would be preventing you from changing the reference to the object and neither its properties.

More information about constants in JavaScript in this answer to the question in Advantages of using const over var in JavaScript

The declaration constcreates a read-only reference to a value. This does not mean that the value it stores is immutable, just that the variable's identifier cannot be reassigned.

This means that you cannot override the object:

'use strict';
const empleado = {
  nombre: 'Juan',
  profesion: 'Programador'
};
empleado = {"atributo": "valor"}

because it marks youTypeError: Assignment to constant variable.

However, the attributes of the object are not protected. So, as in your example, this statement can be executed without problems:

empleado.nombre = 'Pedro';

If you want to have a totally constant object you can use the following function:

 var constantize = (obj) => {
  Object.freeze(obj);
  Object.keys(obj).forEach( (key, value) => {
    if ( typeof obj[key] === 'object' ) {
      constantize( obj[key] );
    }
  });
};

In your example it would look like this:

'use strict';
 var empleado = {
   nombre: 'Juan',
   profesion: 'Programador'
 };
constantize(empleado);
empleado.nombre = "Pedro"; // Marcará un error, se encuentra protegida.

For more information you can see (in English):

• const reference
• es6-const-not-immutable

In several documentations it is already explained that this cannot be done with variables:

const PI = 3.141592653589793;
PI = 3.14;      // ERROR
PI = PI + 10;   // ERROR

But you can do this with arrays:

// Puedes crear un array como constante
const frutas = ["Pera", "Uva", "Naranja"];

// También puedes modificar uno de sus valores
frutas[0] = "Manzana";

// Y puedes añadirle elementos
frutas.push("Platano");

But not this:

const fruta = ["Manzana", "Pera", "Naranja"];
cars = ["Platano", "Uva", "Melocoton"];    // ERROR

When you mark something as a constant you are not making the object unable to change its value, but you are making the variable pointers not vary, where they point. However, you can give these variables other values ​​in memory as long as the memory space in which they are stored does not change.

An example: If you generate a constant object named First with two variables A1 and B1, and another named Second with variables A2 and B2. If you match them and do "First = Second", you are actually changing the pointers from A1 and B1 to A2 and B2 respectively, and that is why you get the exception. However you can set A1 to the value of A2 without problem, because you will be changing the in-memory value of the pointer of First.A1, but not the pointer itself.

To take a more hypothetical look at this old question. Suppose you constdeclare immutable constants as the OP expects.

What would happen with the following code?

var empleado = {
  nombre: 'Juan',
  profesion: 'Programador'
};

const e = empleado; //crearia esto un clon inmutable?
                    //o haria que el objeto original fuese inmutable?

empleado.nombre = 'Pedro'; //error?

console.log(empleado); //juan o pedro?
console.log(e); //definitivamente pedro, no?

Of course the correct answer is simpler:

var , let , and const declare variable or constant identifiers . They do not create objects or primitive values ​​that happens on the right side of the =.

And, of course, const means that the constant is the identifier, not the object associated with it.