# Primitive types vs objects in JavaScript

> Learn the difference between primitive types and objects in JavaScript: primitives are immutable and copied by value, while objects are passed by reference.

Author: Flavio Copes | Published: 2020-06-05 | Canonical: https://flaviocopes.com/difference-primitive-types-objects/

First, let's define what are primitive types.

Primitive types in [JavaScript](https://flaviocopes.com/javascript/) are 

- strings
- numbers (Number and BigInt)
- booleans (true or false)
- undefined
- Symbol values

`null` is a special primitive type. If you run `typeof null` you'll get `'object'` back, but it's actually a primitive type.

Everything that is not a primitive type is an **object**.

Functions are objects, too. We can set properties and method on functions. `typeof` will return `'function'` but the Function constructor derives from the Object constructor.

The big differences between primitive types and objects are 

- primitive types are immutable, objects only have an immutable reference, but their value can change over time
- primitive types are passed by value. Objects are passed by reference
- primitive types are copied by value. Objects are copied by reference
- primitive types are compared by value. Objects are compared by reference

If we copy a primitive type in this way:

```js
let name = 'Flavio'
let secondName = name
```

Now we can change the `name` variable assigning it a new value, but `secondName` still holds the old value, because it was copied by value:

```js
name = 'Roger'
secondName //'Flavio'
```

If we have an object:

```js
let car = {
  color: 'yellow'
}
```

and we copy it to another variable:

```js
let car = {
  color: 'yellow'
}

let anotherCar = car
```

in this case `anotherCar` points to the same object as `car`. If you set

```js
car.color = 'blue'
```

also 

```js
anotherCar.color
```

will be `'blue'`.

The same works for passing around objects to functions, and for comparing.

Say we want to compare `car` to `anotherCar`:

```js
anotherCar === car //true
```

This is true because both variables point to exactly the same object.

But if `anotherCar` was an object with the same properties as `car`, comparing them would give a `false` result:

```js
let car = {
  color: 'yellow'
}

let anotherCar = {
  color: 'yellow'
}

anotherCar === car //false
```