## What are Booleans?

In computer programming, Booleans are true or false values that sit at the heart of conditional programming. The name is in the honour to the mathematician George Boolean - you should consider searching about him for a while!

There are thousands of instances in programming where we need to perform certain actions once certain conditions are met.

As an analogy, read the following sentence 'If it is raining outside I will have to take an umbrella'. The condition here is: 'Is it raining?' and the action to be taken if it's met is: 'to take an umbrella'.

In computer terminology we can take the example 'If the battery is low, automatically switch off the computer'. Again you have a condition and an action. And there can be many such examples that operate on the same idea.

In computers, we use boolean values to check whether some condition is met or not. All programming languages follow the same principle of booleans and thus make conditional programming fairly equivalent.

## Creating Booleans

As with numbers and strings, to create a Boolean in JavaScript you could either take the literal way or the constructor way.

### Using the literals

The Boolean literals are `true` and `false`, without any quotation marks.

They create a Boolean primitive, just like we saw string literals create string primitives in the Strings Basic Concepts chapter.

To understand the difference between primitive and object values please read the JavaScript Data Types and JavaScript Values and References chapters.

Following is an illustration:

``````var rainyDay = true;
var batteryLow = false;``````

The `typeof` operator as used with Boolean primitives, returns `"boolean"`:

``````var rainyDay = true;
var batteryLow = false;

console.log(typeof rainyDay); // "boolean"
console.log(typeof batteryLow); // "boolean"``````

Create two Boolean variables `submitted` and `error`, and assign them 'falsy' values using Boolean literals.

The term 'falsy' simply means to give the variables the value `false`. Following is the code that accomplishes the task above:

``var submitted = false, error = false;``

### The `Boolean()` constructor

The `Boolean()` constructor is the other way to create a boolean in JavaScript. Specifically it creates a `Boolean` object.

Following is an illustration:

``````var rainyDay = new Boolean(true);
var batteryLow = new Boolean(false);``````

Since this time we've used a constructor to create Boolean values, `typeof` will return `"object"` for the variables above.

``````console.log(typeof rainyDay); // "object"
console.log(typeof batteryLow); // "object"``````
Despite the fact that Booleans here are created using a constructor, we have to provide the literals `true` or `false` regardless. So, there's really no benefit of using the constructor - and we even shouldn't!

## Things to note

1. All comparison operators return Boolean primitives:

``````typeof (1 == 1); // true
typeof (1 > 1); // false
typeof (1 === "1"); // false``````
2. Logical operators, if used with Boolean values combine the result and again return a Boolean primitive:

``````typeof (true && true); // true
typeof (true && false); // false
typeof (true && false && true); // false
typeof (true || false); // true``````

For more information on how logical operators work see Logical operators explanation.

## Converting to Boolean

There are certain times where we might want to go from a given data type to a Boolean. The `Boolean()` function helps us to do just this very thing.

`Boolean()` converts its argument (values inside the parentheses) into a Boolean primitive value.

Remember we're talking about the `Boolean()` function, not the `Boolean()` constructor.

### With numbers:

All numbers except for `0` get converted to the Boolean value `true`. The number `0` gets converted to `false`.

``````Boolean(10.5); // true
Boolean(0.001); // true
Boolean(-100); // true

Boolean(0); // false``````

Consider the following code:

``````var a = 200;
console.log(typeof a); // "number"

a = Boolean(a);
console.log(typeof a); // "boolean"``````

First, the variable `a` is a number which can be confirmed from line 2, and is then converted into a Boolean in line 4. Consequently, in line 5, `typeof a` returns `"boolean"`.

### With strings:

All strings, except for the empty string `""` (or `''`, ````), get converted to `true`. The empty string gets converted to `false`.

Following is an illustration:

``````Boolean("Hello"); // true
Boolean("0"); // true

Boolean(""); // false
Boolean(''); // false
Boolean(``); // false``````

### With objects:

All objects get converted to the value `true`, even the ones without any properties.

``````var obj = {};

var b = Boolean(arr); // true
typeof b; // "boolean"``````
Converting arrays and objects into Booleans isn't very useful because even empty arrays and objects convert to `true` Boolean values.

The following example shows a detailed view of what gets converted to `true` and what to `false` when passed to the `Boolean()` function.

``````// Booleans
Boolean(true) // true
Boolean(false) // false
Boolean(new Boolean(false)) // true

// Numbers
Boolean(10.58) // true
Boolean(0) // false
Boolean(new Number(0)) // true

// Strings
Boolean("true") // true
Boolean("false") // true
Boolean(" ") // true
Boolean("") // false
Boolean('') // false
Boolean(new String("")) // true

// Arrays and Objects
Boolean(["name", "age", "gender"]) // true
Boolean([]) // true
Boolean(new Array()) // true
Boolean({name: "Something"}) // true
Boolean({}) // true
Boolean(new Object()) // true``````

### Things that get converted to true

1. All numbers except zero (like 0, 0.00, 0.000 and so on)
2. All strings except the empty strings - `""`, `''`, or ````.
3. The boolean `true`
4. All arrays and objects.
This is the reason why the number created from `new Number(0)`, the string created from `new String("")` and the Boolean created from `new Boolean(false)` all return `true` - because they return objects.

## In conclusion

This chapter is very important in this unit because it establishes the fundamentals of booleans that are the fundamental concept of conditional programming. Therefore we suggest spending time experimenting with booleans in the developer's console.

In the next chapters we will move right into the use of these `true` and `false` values in real programs.