En {{Glossary("JavaScript")}}, un primitive (valor primitivo, tipo de dato primitivo) son datos que no son un {{Glossary("object", "objeto")}} y no tienen {{Glossary("method", "métodos")}}. Hay 6 tipos de datos primitivos: {{Glossary("string")}}, {{Glossary("number")}}, {{Glossary("bigint")}}, {{Glossary("boolean")}} , {{Glossary("undefined")}} y {{Glossary("symbol")}}. También hay {{Glossary("null")}}, que aparentemente es primitivo, pero de hecho es un caso especial para cada {{JSxRef("Object")}}: y cualquier tipo estructurado se deriva de null por la {{web.link("/es/docs/Learn/JavaScript/Objects/Inheritance", "Cadena de prototipos")}}.
La mayoría de las veces, un valor primitivo se representa directamente en el nivel más bajo de la implementación del lenguaje.
Todos los primitivos son inmutables, es decir, no se pueden modificar. Es importante no confundir un primitivo en sí mismo con un valor primitivo asignado a una variable. Se puede reasignar un nuevo valor a la variable, pero el valor existente no se puede cambiar de la misma forma en que se pueden modificar los objetos, los arreglos y las funciones.
Este ejemplo te ayudará a comprender que los valores primitivos son inmutables.
// El uso de un método de cadena no modifica la cadena
var bar = "baz";
console.log(bar); // baz
bar.toUpperCase();
console.log(bar); // baz
// El uso de un método de arreglo muta el arreglo
var foo = [];
console.log(foo); // []
foo.push("plugh");
console.log(foo); // ["plugh"]
// La asignación le da al primitivo un nuevo valor (no lo muta)
bar = bar.toUpperCase(); // BAZ
Un primitivo se puede reemplazar, pero no se puede modificar directamente.
El siguiente ejemplo te ayudará a analizar cómo se ocupa JavaScript de los primitivos.
// El primitivo
let foo = 5;
// Define una función que debería cambiar el valor primitivo
function addTwo(num) {
num += 2;
}
// Otra función que intenta hacer lo mismo
function addTwo_v2(foo) {
foo += 2;
}
// Llama a tu primera función mientras pasas el primitivo como argumento
addTwo(foo);
// Obtiene el valor primitivo actual
console.log(foo); // 5
// Intenta de nuevo con tu segunda función...
addTwo_v2(foo);
console.log(foo); // 5
¿Esperaba que fuera 7 en lugar de 5?, si es así, lee cómo se ejecuta este código:
addTwo y addTwo_v2, JavaScript busca el valor del identificador foo. Encuentra correctamente tu variable instanciada con la primera declaraciónfoo se reemplaza por 5 y el motor de JavaScript pasa ese valor a las funciones como argumentonum para addTwo, foo para addTwo_v2)num local. ¡Estas aumentando su valor en 2, no el valor original de foo!foo local. ¡Esto incrementa su valor en 2, no el valor original (externo) de foo!, además, en esta situación, no se puede acceder directamente a la variable foo externa. Esto se debe al alcance léxico de JavaScript y al ensombrecimiento de variables resultante. El foo local oculta al foo externo. Para obtener más información, consulta {{JSxRef("../Closures", "Cierres")}}. (Ten en cuenta que window.foo aún se podría usar para acceder a la variable foo externa).foo original en absoluto, ya que estas modificando copias de la misma.Es por eso que los primitivos son inmutables: en lugar de cambiarlos directamente, modificas una copia, sin afectar el original.
A excepción de null y undefined, todos los valores primitivos tienen objetos equivalentes que envuelven los valores primitivos:
string primitivo.number primitivo.bigint primitivo.boolean primitivo.symbol primitivo.El método {{JSxRef("Objetos_globales/Object/valueOf"," valueOf()")}} del contenedor devuelve el valor primitivo.