Javascript Primitive Data Types

11 Key excerpts on "Javascript Primitive Data Types"

• 

  eBook - ePub

  LPI Web Development Essentials Study Guide

  Exam 030-100

  • Audrey O'Shea(Author)
  • 2023(Publication Date)
  • Sybex

    (Publisher)

  A value's data type determines what can and cannot be done with that data. In JavaScript, there's no need to declare the type of data when it is entered, because JavaScript is a dynamically typed language that automatically determines the variable's data type for you. Although this makes writing code much easier, it can occasionally lead to bugs related to data type when the code is run.

  Primitive Types

  Primitive data types are built into most programming languages. They are basic in nature and may be used to build more sophisticated data types, as you'll see in the next section. JavaScript has eight primitive data types, shown in Table 14.2 .

  TABLE 14.2

  Primitive data types

  Type	Description
  Boolean	Logical, true or false, 1 or 0.
  BigInt	Big integer, a number beyond what's considered “safe.” Cannot be fractional numbers.
  Null	Empty, but defined.
  Number	Positive floating point (decimal anywhere) numbers between 2–1074 and 21024 .
  String	Alphanumeric characters not treated as numbers.
  Symbol	Creates a unique symbol for a value within a program.
  Undefined	The absence of a value—for example, a variable defined without its value (let x; ) creates the variable but with no value assigned.

  A variable's value type within a JavaScript program can change as its value changes. For example, let a = "apple"; assigns the string type to variable a. Later in the program, let a = 10; will change a 's type to number. Changing it again with a statement like let a = true returns the variable type of Boolean. If however, you write the statement let a = "true"; or let a = "10"; , then a will return the variable type of string. The difference between a = true and a = "true" is the quotes. The quotes turn the Boolean value of logical true to a text string.

  At any time you can tell what type a variable is using the typeof command. For example, let a = "apple"; console.log(typeof a); outputs string on the console log because the quotes tell the program that what's inside is a string.

  Data types null and undefined are special. They might look the same at first glance, but they are not. Neither null nor undefined is equal to zero. undefined means that the variable has been declared, but no value has been assigned. For example, let b; console.log b;

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  Clean Code in JavaScript

  Develop reliable, maintainable, and robust JavaScript

  • James Padolsey(Author)
  • 2020(Publication Date)
  • Packt Publishing

    (Publisher)

  Primitive and Built-In Types

  So far, we have explored the meaning of clean code from several different perspectives. We've explored how the code we write allows our users to wield remarkable complexity by leveraging abstractions. We've gone on to discuss the tenets of clean code, such as reliability and usability, and the various traps and challenges to watch out for when pursuing these goals.

  In this chapter, we'll be exploring the JavaScript language itself, in great detail, including both the more common language constructs and the more obscure and confusing aspects. We'll be applying our accrued wealth of knowledge about clean code to all these parts of the language and will build an understanding of JavaScript that's tailored purely to the creation of clean code.

  We'll begin by looking at the most atomic part of JavaScript: the primitive values that serve as the building blocks for any program. Then, we'll move on to non-primitive values, known as objects . In our exploration of these types, we will, through examples, be exposing the semantics that make each type unique and the pitfalls to avoid in their usage. The crucial knowledge that we'll gain in this chapter will be applied in later chapters as we build up a truly complete knowledge of what it means to write clean code in JavaScript.

  By the end of this chapter, you should feel comfortable in the following topic areas:

  • Primitive types
  • Objects
  • Functions
  • Arrays and iterables
  • Regular expressions

  Passage contains an image

  Primitive types

  A primitive type in JavaScript is any value that is not an object and thus does not have any methods or properties. There are seven primitive types in JavaScript:

  • Number
  • String
  • Boolean
  • Undefined
  • Null
  • BigInt
  • Symbol

  In this section, we'll explore the common characteristics among these primitives and delve into each individual type to explore how it works and what potential hazards exist in its usage. We'll gain an appreciation for how the JavaScript language itself is just a set of distinct abstractions that, when wielded masterfully, can make easy work of any problem domain.

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  JavaScript from Beginner to Professional

  • Laurence Lars Svekis, Maaike van Putten, Codestars By Rob Percival(Authors)
  • 2021(Publication Date)
  • Packt Publishing

    (Publisher)
• Variables cannot contain spaces, but they can use underscores. If you use a space, JavaScript doesn't recognize it as a single variable.
We will be using camel case here. This means that when we want to use multiple words to describe a variable, we will start with a lowercase word, then use a capital for every new word after the first word—for example: ageOfBuyer .
Whatever the convention is in the place you are working, the key is consistency. If all naming is done in a similar format, the code will look cleaner and more readable, which makes it a lot easier to make a small change later.
The value of your variable can be anything. Let's start with the easiest thing variables can be: primitives.

Primitive data types

Now you know what variables are and why we need them in our code, it is time to look at the different types of values we can store in variables. Variables get a value assigned. And these values can be of different types. JavaScript is a loosely typed language. This means that JavaScript determines the type based on the value. The type does not need to be named explicitly. For example, if you declared a value of 5, JavaScript will automatically define it as a number type.
A distinction exists between primitive data types and other, more complex data types. In this chapter, we will cover the primitive type, which is a relatively simple data structure. Let's say for now that they just contain a value and have a type. JavaScript has seven primitives: String, Number, BigInt, Boolean, Symbol, undefined, and null. We'll discuss each of them in more detail below.

String

A string is used to store a text value. It is a sequence of characters. There are different ways to declare a string: