Javascript Data Types

Javascript Data Types Explained

Javascript has several built-in data types that are used to classify and handle data within the language. These types can be broadly classified into the following categories:

• Primitive Types: These include types like Number, String, Boolean, Undefined, Null, Symbol, and BigInt.
• Object Types: These are more complex and include everything else, such as Arrays, Functions, Dates, and so forth.

 var num = 42; // Number var name = 'Alice'; // String var isActive = true; // Boolean var unknown; // Undefined var nothing = null; // Null var sym = Symbol('unique'); // Symbol var largeNumber = 12345678901234567890n; // BigInt

 var person = {  name: 'John',  age: 30,  job: 'Developer',  isEmployed: true}; var numbers = [1, 2, 3, 4, 5]; // Array

Javascript Data Types Definition

The primitive data types each serve a unique purpose:

• Number: Used for all numbers, integers, and floating points.
• String: Sequences of characters, for example, 'hello'.
• Boolean: Represents true or false values.
• Undefined: A variable that has not been assigned a value.
• Null: Represents a non-existent or invalid value.
• Symbol: Provides unique and immutable values, often used as object identifiers.
• BigInt: Allows for representation of integers beyond the safe integer limit (2^53-1).

typeof variable

What Data Types Exist in Javascript?

Understanding data types in Javascript is essential for handling and processing data accurately. Javascript categorizes data into different types, each serving specific purposes, which allows for efficient programming and execution of code.

Primitive Data Types in Javascript

Javascript provides several primitive data types that are basic and immutable. Here are the key primitive data types you need to know:

• Number: Can be any kind of numerical value, including integers and floating-point numbers.
• String: Represents sequences of characters or text enclosed in single or double quotes.
• Boolean: Only two possible values: true or false, often used in conditional testing.
• Undefined: A variable without a defined value is considered undefined.
• Null: Denotes an empty or non-existent reference.
• Symbol: A unique and immutable type, often used for object property keys.
• BigInt: Allows for numbers larger than those that the 'Number' type can hold securely.

 var age = 25; // Number var greeting = 'Hello, World!'; // String var isStudent = false; // Boolean var score; // Undefined var money = null; // Null var uniqueID = Symbol('id'); // Symbol var bigNumber = 9007199254740991n; // BigInt

Non-Primitive Data Types in Javascript

Non-primitive data types, also known as reference types, include all objects and are more complex structures: they are mutable and can be referenced. Here's a deeper look into some common non-primitive data types:

• Objects: A collection of properties, where each property is a key-value pair, allowing you to encapsulate data and functionality.
• Array: A specialized type of object used for storing ordered lists of values.
• Function: An object callable as a block of code, performing specific tasks.
• RegExp: Also known as regular expressions, used for matching text patterns.
• Date: Provides mechanisms for manipulating dates and times.

 var person = {  firstName: 'Jane',  lastName: 'Doe',  age: 26}; // Objectvar numbers = [1, 2, 3, 4, 5]; // Arrayfunction greet(name) {  return 'Hello, ' + name + '!';} // Function

 var obj = new Object();

Examples of Javascript Data Types

Javascript, as a programming language, provides various data types to help structure and store information. Understanding these data types is crucial for effective programming.

Primitive Data Types Examples

Primitive data types in Javascript are the most basic types of data. These include Number, String, Boolean, Undefined, Null, Symbol, and BigInt. Each serves a specific use case in programming.

• Number: Represents both integer and floating-point numbers. Example:

  var price = 19.99;

• String: A series of characters. Example:

  var greeting = 'Hello, World!';

• Boolean: Represents true or false values. Example:

  var isValid = true;

• Undefined: A variable without an assigned value. Example:

  var name;

• Null: Represents a non-existent or invalid object. Example:

  var book = null;

• Symbol: A unique and immutable identifier. Example:

  var sym = Symbol('id');

• BigInt: For integers beyond the typical size limit. Example:

  var largeNumber = 12345678901234567890n;

var age = 25; // Numbervar username = 'Alice'; // Stringvar hasAccess = false; // Booleanvar score; // Undefinedvar result = null; // Nullvar uniqueSymbol = Symbol('unique'); // Symbolvar maxInt = 9007199254740991n; // BigInt

Non-Primitive Data Types Examples

Non-primitive data types, also known as reference types, are more complex and flexible. These include objects such as arrays, functions, and more. These types allow for storing collections of values and more complex entities.Some examples of non-primitive data types include:

• Object: Stores collections of key-value pairs. Example:

  var car = {make: 'Toyota', model: 'Corolla', year: 2022};

• Array: Specialized object for ordered data. Example:

  var colors = ['red', 'green', 'blue'];

• Function: Allows code encapsulation and reuse. Example:

  function greet() { return 'Hello, User!'; }

• Date: To handle date and time. Example:

  var today = new Date();

var person = {  firstName: 'John',  lastName: 'Doe',  age: 30};var numbers = [5, 10, 15, 20]; // Arrayfunction add(a, b) {  return a + b;} // Functionvar currentDate = new Date(); // Date

Data Types in Javascript - Best Practices

When programming in Javascript, effectively utilizing data types is crucial for optimal coding practices. Choosing the right data types can enhance your code's readability, maintainability, and efficiency.

Choosing the Right Data Type

Selecting the correct data type is key for ensuring that your program behaves as expected and performs efficiently. Consider these best practices to guide your choice:

• Number vs. BigInt: Use Number for most numerical operations. Opt for BigInt when dealing with values that exceed the safe integer range of

  Number.MAX_SAFE_INTEGER

  .
• String: Employ String for textual data, utilizing template literals

  ` `

  for embedding variables and expressions.
• Boolean: Use Boolean for flags and conditions to ensure clarity in decision-making structures.
• Undefined: Default to Undefined for uninitialized variables, but ensure they're explicitly assigned a value before use.
• Object: Choose Object or Array for collections and complex data structures, providing descriptive property names.

function getUserSummary(name, age, active) {  return {    name: name, // String    age: age, // Number    isActive: Boolean(active) // Boolean  };}var user = getUserSummary('Alice', 29, true);

Common Mistakes with Javascript Data Types

Avoiding common pitfalls in data type usage can significantly enhance your coding efficiency and program performance. Here are some frequent errors and how to prevent them:

• Type Coercion: Be cautious of Javascript's automatic type conversion, which can lead to unexpected results. Use

  ===

  for strict equality checks instead of

  ==

  .
• Mutability of Objects: Understand that objects and arrays in Javascript are mutable, which means their properties and elements can be changed. Use methods like

  Object.freeze()

  if immutability is needed.
• Undefined vs. Null: Misuse of Undefined and Null can lead to logic errors. Use Null deliberately to signify 'no value', whereas Undefined represents an uninitialized state.
• Floating Point Arithmetic: Due to the binary representation, operations with decimal numbers may not always yield expected results. Use libraries like Decimal.js for precise calculations.

// Problematic code with implicit coercionvar sum = '5' + 10; // Result: '510', due to string concatenation// Correct approach using explicit conversionvar sum = Number('5') + 10; // Result: 15

0/0

Number.isNaN()

Array.isArray(variable)

typeof array