
Diferent than primitive types, non-primitive types are **_mutable_** and refers to objects. Non-primitive types contains
multiple values or complex data.

# Objects

Objects are used to store various keyed collections and more complex entities. An object is an unordered collection of
key-value pairs. Each key-value pair is called a property.

The key of a property can be a string. And the value of a property can be any value, e.g., a **string**, a **number**, an **array**, and even a **function**.

JavaScript provides you with many ways to create an object. The most commonly used one is to use the object literal notation.

The following example creates an empty object using the object literal notation:

```js
let empty = {};
```

To create an object with properties, you use the key:value within the curly braces. For example, the following creates a new person object:

```js
let person = {
    firstName: 'Matheus',
    lastName: 'Silva'
};
```

# Accessing properties

To access the firstName property of the person object, you use the following expression:

```js
person.firstName
```

You can also access the value of an object’s property via the array-like notation

```js
person['firstName']
```

# Modifying the value of a property

```js
let person = {
    firstName: 'Matheus',
    lastName: 'Silva'
};

person.firstName = 'Matt';

console.log(person);
```

Output:

```js
{ firstName: 'Jane', lastName: 'Doe' }
```

# Adding and deleting properties

In JavaScript, you can add a property to an object after object creation.

```js
person.age = 29;
```

To delete te property, you can use the **delete** keyword

```js
delete person.age;
```

# Summarry

* An object is a collection of key-value pairs.
* Use the dot notation (.) or array-like notation ([]) to access a property of an object.
* The delete operator removes a property from an object.

JavaScript Non-Primitive Types


Data Types specify what kind of data can be stored and manipulated within a program. A value in JavaScript is always of
a certain type. For example, a string, a boolean or a number.

# Primitive Types

In JavaScript, a primitive type is a data that is not an **object** and has no **methods**. **All primitives are ***immutable***, they cannot be altered**. Variables can be reassigned a new value, but the existing value can not
be changed in the ways that objects, arrays, and function can. There are 7 primitive data types: string, number, bigint,
boolean, undefined, null and symbol.

## String

```js
const str = "Single quotes string";
const str2 = 'Double quotes string';
const phrase = `Backticks string ${str} ${str2}`
```

The **string** data type is used to represent a sequence of characters. strings are useful for holding data that can be represented in text form.

They can be represented with single quotes, double quotes and backticks. There is no difference between single and double quotes.

Backticks are “extended functionality” quotes. They allow us to embed variables and expressions into a string by wrapping them in ${…}, for example:

```js
const firstName = "Matheus";
const lastName = "Silva";

console.log(`Helo, my name is ${firstName} ${lastName}`)

// Helo, my name is Matheus Silva
```

## Numbers

```js
const a = 100;
const b = 55.5;
```

The **number** data type is used to represent positive or negative numbers, with or without decimal place.

There are many operations for numbers, e.g. multiplication **'*'**, division **'/'**, addition **'+'**, subtraction **'-'**, and so on.

Besides regular numbers, there are so-called “special numeric values” which also belong to this data type: Infinity, -Infinity and NaN.

```js
const infinity = 1 / 0; // Infinity
const negInfinity = -1 / 0; // -Infinity
const notANumber = 'Hello' / 2; // NaN
```

## BigInt

The **BigInt** represents integers of arbitrary length.

In JavaScript, the “number” type cannot represent integer values larger than ***(253-1)*** (that’s ***9007199254740991***), or less than ***-(253-1)*** for negatives. It’s a technical limitation caused by their internal representation.

A **BigInt** value is created by appending n to the end of an integer:

```js
const bigInt = 1234567890123456789012345678901234567890n;
```

## Boolean

The **boolean** data type has only two values: ***true*** or ***false***.

This type is commonly used to store yes/no values: ***true*** means “yes, correct”, and ***false*** means “no, incorrect”.

```js
const isReading = true;   // yes, I'm reading
const isSleeping = false; // no, I'm not sleeping
```

Boolean values also come as a result of comparisons.

```js
const a = 2, b = 5, c = 10;
 
console.log(b > a) // true
console.log(b > c) // false
```

## Undefined

The **undefined** type can only have one value, which is a special value ***undefined***. One example is when a variable is declared but it has not been assigned a value yet.

```js
const a;
 
console.log(a) // undefined
```

## Null

The **null** type is also a special value, which can only be ***null***. A **null** value means that there is no value. It is not equivalent to an empty string ("") or 0, it is simply nothing.

```js
let name = null;
```

## Symbols

The **symbol** type is used to create unique identifiers for objects. We will get deeper into symbols in the **object** section.

# Summary

There are 8 basic data types in JavaScript.

* ***number*** for numbers of any kind: integer or floating-point, integers are limited by ±(253-1).
* ***bigint*** is for integer numbers of arbitrary length.
* ***string*** for strings. A string may have zero or more characters, there’s no separate single-character type.
* ***boolean*** for true/false.
* ***null*** for unknown values – a standalone type that has a single value null.
* ***undefined*** for unassigned values – a standalone type that has a single value undefined.
* ***symbol*** for unique identifiers.
* ***object*** for more complex data structures.

In the next chapter, we will be talking about Objects, also referred as [**Non-primitive or Reference Data Type**](https://www.javascript.com/).

Understanding Data Types in JavaScript


JavaScript is a dynamic computer programming language, used both on the client-side and server-side that allows you to make web pages interactive. 

it's **the** most important programming language you need to know as a web developer. Over 97% of websites use JavaScript.

# How JavaScript Works

JavaScript is often used with HTML and CSS. While HTML and CSS are languages that give structure and style to web pages, JavaScript turns static web pages into interactive web pages by dynamically updating content, validating form data, controlling multimedia, and almost everything else on the web pages, allowing you to implement complex features.

# HTML, CSS and JavaScript, What's the difference?

![Difference between HTML, CSS and JavaScript](html_css_javascript_infographic.png)

# JavaScript overview

To define a variable, you use the ***const*** keyword. For example:

```js
const x = 10;
const y = 20;
```

ES6 added a new way to declare a variable with the ***let*** keyword:

```js
let x = 10;
let y = 20;
```

There's also another way to declare variables, which is with ***var*** keyword, but it's not a recomended to use it in JavaScript. You can learn more about declaring variables, good practices, different use cases, downsides and benefits [here](https://my-blog-blond-pi.vercel.app/posts/javascript-datastructure).

To declare a function, you use the ***function*** keyword:

```js
function add(a, b) {
  return a + b
}
```

The function above calculates the sum of two arguments.

To call the **add()** function, you use the following syntax:

```js
const result = add(x, y);
```

To log the result into the console window of the web browser, you use the **console.log()**:

```js
console.log(result);

// 30
```

You should see "**30**" print out in the console window.

[Click here](https://my-blog-blond-pi.vercel.app/) for a more in depth overview on JavaScript syntax and structures.

# Why use JavaScript

- JavaScript is the only programming language native to the web browser, meaning, it is the only client-side language available
- JavaScript is the most popular language, it's the standard programming language for web browsers and anybody who's into web development needs to use it
- There’s a low threshold to get started, there is no need to set up any kind of development, it comes installed on every modern web browsers
- Can load content into the document if and when the user needs it, without reloading the entire page
- Tests for what is possible in your browser and reacts accordingly

![JavaScript featues overview](features-of-javascript.png)

Before writing JavaScript it's important to know how it works under the hood. There are two important pieces to learn: How the web browser works, and the Document Object Model(DOM).
Learn more about it [here](https://www.javascript.com/).

Hi, I am Matheus

Featured Posts

JavaScript Non-Primitive Types

Understanding Data Types in JavaScript

What is JavaScript?