Javascript Primitive Data Types

10 Key excerpts on "Javascript Primitive Data Types"

• 

  eBook - PDF

  JavaScript for Web Warriors

  • Patrick Carey, Sasha Vodnik, Patrick Carey(Authors)
  • 2021(Publication Date)
  • Cengage Learning EMEA

    (Publisher)

  CHAPTER 2 WORKING WITH FUNCTIONS, DATA TYPES, AND OPERATORS 48 Working with Data Types Variables can contain many different kinds of values such as the time of day, a dollar amount, or a person’s name. A data type is the specific category of information that a variable contains. The data type determines how much memory is allocated for the data stored in the variable. The data type also governs the kinds of operations that can be performed on the variable. Data types that can be assigned only a single value are called primitive types. JavaScript supports the five primitive data types described in Figure 2-6. The JavaScript language also supports the object data type used for creating a collection of properties. You will learn about the object type in a later chapter. Note DATA TYPE DESCRIPTION number A positive or negative number with or without decimal places, or a number written using exponential notation Boolean A logical value of true or false string Text such as “Hello World!" undefined An unassigned, undeclared, or nonexistent value null An empty value Figure 2-6 Primitive JavaScript data types You might be confused about the distinction between a null value and an undefined value. Null is both a data type and a value. You assign the null value to a variable to indicate that the variable does not contain any data. In contrast, an undefined variable is a variable that has never had a value assigned to it, has not been initialized or does not even exist. For example, a variable that has been declared but not given an initial value is undefined but not null. Many programming languages require that you declare the type of data that a variable contains. Such languages are called strongly typed programming languages. A strongly typed language is also known as statically typed, because data types cannot be changed after they have been declared.

  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

  Learn JavaScript quickly by building fun, interactive, and dynamic web apps, games, and pages

  • Laurence Lars Svekis, Maaike van Putten, Rob Percival, Laurence Svekis, 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: