{"id":4275,"date":"2026-11-07T15:09:00","date_gmt":"2026-11-07T15:09:00","guid":{"rendered":"https:\/\/www.ucartz.com\/blog\/javascript-data-types\/"},"modified":"2026-11-09T22:05:20","modified_gmt":"2026-11-09T22:05:20","slug":"javascript-data-types","status":"publish","type":"post","link":"https:\/\/www.ucartz.com\/blog\/javascript-data-types\/","title":{"rendered":"JavaScript Data Types: The 8 Types Explained with Examples"},"content":{"rendered":"\n

JavaScript has eight data types. Seven are primitives: string, number, bigint, boolean, undefined, symbol and null<\/strong>. The eighth is object<\/strong>, which covers everything else, including arrays, functions, dates and maps. Primitives are simple, unchangeable values; objects are collections of properties that you pass around by reference. You check a value’s type with typeof<\/code>, with two famous quirks: typeof null<\/code> is \"object\"<\/code>, and functions report \"function\"<\/code> even though they are objects.<\/p>\n\n\n\n

\"Terminal
typeof for each of the 8 JavaScript data types in Node.js; note that typeof null returns "object"<\/figcaption><\/figure>\n\n\n\n

The eight JavaScript data types at a glance<\/h2>\n\n\n\n

The list comes from MDN’s guide to JavaScript data types and data structures<\/a>. The typeof<\/code> column is real output from Node.js 24.21.0:<\/p>\n\n\n\n

Type<\/th>Example<\/th>typeof<\/code> result<\/th>Kind<\/th><\/tr><\/thead>
String<\/td>\"hello\"<\/code><\/td>“string”<\/td>Primitive<\/td><\/tr>
Number<\/td>42<\/code>, 3.14<\/code><\/td>“number”<\/td>Primitive<\/td><\/tr>
BigInt<\/td>9007199254740993n<\/code><\/td>“bigint”<\/td>Primitive<\/td><\/tr>
Boolean<\/td>true<\/code><\/td>“boolean”<\/td>Primitive<\/td><\/tr>
Undefined<\/td>undefined<\/code><\/td>“undefined”<\/td>Primitive<\/td><\/tr>
Symbol<\/td>Symbol(\"id\")<\/code><\/td>“symbol”<\/td>Primitive<\/td><\/tr>
Null<\/td>null<\/code><\/td>“object” (a historical bug)<\/td>Primitive<\/td><\/tr>
Object<\/td>{a: 1}<\/code>, [1, 2]<\/code>, new Date(0)<\/code><\/td>“object”<\/td>Object<\/td><\/tr>
Object (function)<\/td>function f() {}<\/code><\/td>“function”<\/td>Object<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

JavaScript is dynamically typed: a variable has no fixed type, and the same variable can hold a number now and a string later. MDN also calls it weakly typed, meaning it converts types automatically when an operation mixes them, instead of throwing an error. Both facts explain most type bugs you will meet.<\/p>\n\n\n\n

The seven primitive types<\/h2>\n\n\n\n

String<\/h3>\n\n\n\n

Text, written in single quotes, double quotes or backticks (template literals, which can hold ${expressions}<\/code>). MDN says strings are stored as UTF-16 code units and are immutable: once created, a string cannot be changed. Methods such as toUpperCase()<\/code> return a new string. In our test, s[0] = \"z\"<\/code> on \"abc\"<\/code> silently did nothing, and s<\/code> was still \"abc\"<\/code>; in strict mode the same line threw TypeError: Cannot assign to read only property '0' of string 'abc'<\/code>.<\/p>\n\n\n\n

Number<\/h3>\n\n\n\n

There is no separate integer type. Every number is a double-precision 64-bit IEEE 754 value, which MDN says can only store integers safely between -(2^53 – 1) and 2^53 – 1, that is up to Number.MAX_SAFE_INTEGER<\/code>, 9007199254740991. Number also includes three special values: Infinity<\/code>, -Infinity<\/code> and NaN<\/code> (“not a number”), which, oddly, has the type “number”. Decimal fractions are approximations:<\/p>\n\n\n\n

> 0.1 + 0.2\n0.30000000000000004\n> 0.1 + 0.2 === 0.3\nfalse\n> 1 \/ 0\nInfinity\n> NaN === NaN\nfalse\n> Number.isNaN(NaN)\ntrue<\/code><\/pre>\n\n\n\n
For money, store whole units (paise or cents) as integers rather than decimal amounts, and use Number.isNaN()<\/code> to test for NaN, since NaN is not equal even to itself.<\/p>\n\n\n\n
BigInt<\/h3>\n\n\n\n
Whole numbers of any size, written with an n<\/code> suffix. MDN describes BigInt as able to represent integers with arbitrary magnitude. The difference shows as soon as you pass 2^53:<\/p>\n\n\n\n
> 2 ** 53 + 1\n9007199254740992\n> 2n ** 53n + 1n\n9007199254740993n\n> 1n + 1\nTypeError: Cannot mix BigInt and other types, use explicit conversions<\/code><\/pre>\n\n\n\n
The plain number version is wrong by one, with no error. This matters on servers: a MySQL BIGINT<\/code> column goes up to 9,223,372,036,854,775,807 (and to 18,446,744,073,709,551,615 unsigned), according to the MySQL 8.4 manual<\/a>. Large IDs read into an ordinary JavaScript number can lose their last digits, so keep them as strings or BigInt.<\/p>\n\n\n\n
Boolean<\/h3>\n\n\n\n
true<\/code> or false<\/code>. Any value can be turned into a boolean, and the results are not always what you expect: in our test Boolean(\"false\")<\/code> and Boolean([])<\/code> were true<\/code>, while Boolean(\"\")<\/code> and Boolean(0)<\/code> were false<\/code>. A non-empty string is always true, whatever it says.<\/p>\n\n\n\n
Undefined and null<\/h3>\n\n\n\n
Both mean “nothing”, with a difference MDN puts neatly: undefined<\/code> indicates the absence of a value, while null<\/code> indicates the absence of an object. A variable you declared but never assigned, a missing function argument and a missing property are all undefined<\/code>. null<\/code> is what you set on purpose to say “no value here”. They are loosely equal (null == undefined<\/code> is true<\/code>) but not strictly equal.<\/p>\n\n\n\n
The typeof null === \"object\"<\/code> result is a bug from the first version of the language. MDN’s typeof reference<\/a> explains that values were stored with a type tag, the tag for objects was 0, and null<\/code> was the NULL pointer, so it got tag 0 too. A fix was proposed and rejected. To test for null, use value === null<\/code>.<\/p>\n\n\n\n
Symbol<\/h3>\n\n\n\n
A unique value, mainly used as an object key that cannot clash with any other key. Two symbols with the same description are still different: Symbol(\"id\") === Symbol(\"id\")<\/code> returned false<\/code>. If you need a shared symbol, Symbol.for(\"id\")<\/code> returns the same one each time (that comparison returned true<\/code>).<\/p>\n\n\n\n
Objects: everything else<\/h2>\n\n\n\n
Plain objects, arrays, functions, dates, maps, sets, regular expressions and class instances are all objects. Two things set them apart from primitives:<\/p>\n\n\n\n