Getting started with JavaScript - Chapter 2 🚀
Tags: javascript, programming, codenewbie, beginners
Published: 2021-01-30 13:58:54

Table Of Contents
        * 🤓[INTRODUCTION](#intro)
        * 🔢[NUMBERS IN JAVASCRIPT](#num)
        * 🅰[STRINGS](#strings)
        * ✅[BOOLEAN VALUES](#boolean)
        * 💡[LOGICAL OPERATOR](#logical)
        * ❓[TERNARY OPERATOR](#ternary)
        *  [EMPTY VALUES](#empty)
        * 🦾[AUTOMATIC TYPE CONVERSION](#conversion)
        * 📝[SUMMARY](#summary)
        * ➕[APPENDIX 1](#appendix)
        * 🙏[THANK YOU](#thank-you)


##🤓 INTRODUCTION <a name="intro"></a>
**Welcome, my dear coders! I hope you are all having a codelicious day! Here we are, our second chapter of the Getting started with javascript series. Yesterday, we went through the basic idea of the JavaScript programming language. Today we are going to dive a bit deeper, and maybe tackle the topics mentioned yesterday a bit more.

Let's with the basics, how JavaScript thinks of numbers.

![asdf](https://media.giphy.com/media/3o6Yg4GUVgIUg3bf7W/giphy.gif)


## 🔢 NUMBERS IN JAVASCRIPT <a name="num"></a>
Values of the **number** are numeric values (like we didn't know that 😂). When you type up the number in your program, it will cause the bit pattern for that specific number to come into existence inside the computer's memory.

JavaScript uses a fixed number of bits, 64 of them, to store a single number value. There are only so many patterns you can make with 64 bits, which means that the number of different numbers that can be represented is limited.

### ➗ THE MATHS BEHIND IT
If you had N decimal digits, you can represent ten to the power of N numbers - 10<sup>N</sup>; Similarly, given 64 binary digits, you can represent 2<sup>64</sup> numbers, which is about 18 quintillion or 18000000000000000000 numbers. A lot of numbers! With today's pocket computers (phones) you can easily use 64-bit chunks, and you need to worry about the overflow only when dealing with truly astronomical numbers. But, not all whole numbers less than 18 quintillions fit in a JavaScript number. Those bits also store negative numbers, so one bit indicates the sign of the number. A bigger issue is that nonwhole numbers must also be represented. To do this, some of the bits are used to store the position of the decimal point.

So, the actual maximum whole number that can be stored is more in the range of the 9 quadrillions (15 zeros) - which is pretty huge!

Calculations with whole numbers (also called integers) smaller than the aforementioned 9 quadrillions are guaranteed to always be precise. Unfortunately, calculations with fractional numbers are generally not.


### 🧮 ARITHMETIC
The main thing to do with numbers is arithmetic. Arithmetic operations, like addition or multiplication, take two number values and produce a new number from them. For example:

11 + 213 * 11

The + and * symbols are called **operators**. The first stands for addition and the second stands for multiplication. Putting an operator between two values will apply it to those number values and will produce a new number value. The **multiplication** like in a real-world maths comes first! The subtraction comes with a - sign.

If operators appear together without parentheses, the order in which they are applied is determined by the precedence of the operators.

The * and / have the same precedence. Likewise for + and - operators. If there are multiple operators with the same precedence, they are applied left to right. 

There is one more important arithmetic operation. The remainder operation, denoted with a symbol %. X%Y is the remainder of dividing X by Y.

## 🅰 STRINGS IN JAVASCRIPT <a name="strings"></a>
As we mentioned yesterday, strings are used to represent text. They are written by enclosing their content in quotes:
```javascript
var double_quotes = "Coding is fun!";
var single_quote = 'Coding is fun!';
var backticks = `Coding is fun!`;
```
Almost anything can be put between quotes, JavaScript will make a string value out of it. But a few characters are more difficult. For example, putting a new line (the characters you get when you press ENTER), can be only included without escaping only when the string is quoted with backticks.

Let's see an example:
```javascript
var newline_string = 'Coding \n is fun!';
console.log(newline_string)
/*
OUTPUT:
Coding 
is fun!*/
```
There are situations where you want a backslash in a string to be just a backslash, not a special code. If two backslashes follow each other, they will collapse together. 
Example:
```javascript
var collapse = "Coding \"\\n\" is fun."
console.log(collapse)
/*
OUTPUT:
Coding "\n" is fun.
*/
```
Strings cannot be divided, multiplied, or substructed, but the + operator can be used on them to concatenate them.
Example:
```javascript
var concat = "Coding" + "is" + "fun!";
console.log(concat);
/*
OUTPUT:
Codingisfun!
*/
```

## ✅ BOOLEAN VALUES <a name="boolean"></a>
It is often useful to have a value that distinguishes between only two possibilities, like "yes" and "no", or "on" and "off, or "true" and "false". For this purpose, JavaScript has a Boolean type, which has just two values, true and false (this is not a string this is a special type, no double quotes, single quote, or backticks are needed)

```javascript
var boolean_value = true; //this is a boolean value
var string_value = "true"; //this is a string value
```

Let's use it in a real example.
```javascript
console.log(3 > 2); //output: true
console.log(3 < 2); //output: false
```

## 💡 LOGICAL OPERATORS <a name="logical"></a>
There are also some operations that can be applied to Boolean values themselves. JavaScript supports three logical operators: **AND, OR, NOT**.
Examples:

```javascript
console.log(true && false); // output: false
console.log(true && true); // output: true
console.log(true || false); // output: true
console.log(true || true); //output: true
console.log(false || false); //output: false
```

## ❓ TERNARY OPERATOR <a name="ternary"></a>
A conditional operator (or sometimes called the ternary operator since it is the only such operator in the language). The value on the left of the question mark "picks" which of the other two values will come out. When it is true, it chooses the middle value, and when it is false, it chooses the value on the right.

```javascript
console.log(true ? 1 : 2); // output: 1
console.log(false ? 1 : 2); // output: 2
```

##  EMPTY VALUES <a name="empty"></a>
There are two special values, written null and undefined, that are used to denote the absence of a meaningful value. They are themselves values, but they carry no information.

Many operations in the language that don’t produce a meaningful value yield undefined simply because they have to yield some value.

## 🦾 AUTOMATIC TYPE CONVERSION <a name="conversion"></a>
JavaScript goes out of its way to accept almost any program you give it, even programs that do odd things. 
For example:

```javascript
console.log(10 * null); //output: 0
console.log("5" - 1); //output: 4
console.log("5" + 1); //output: 51
console.log("five" * 2); //NaN
console.log(false == 0); //true
```
When an operator is applied to the “wrong” type of value, JavaScript will quietly convert that value to the type it needs, using a set of rules that often aren’t what you want or expect. This is called type coercion. The null in the first expression becomes 0, and the "5" in the second expression becomes 5 (from string to number). Yet in the third expression, + tries string concatenation before numeric addition, so the 1 is converted to "1" (from number to string).

## 📝 SUMMARY <a name="summary"></a>
- Values of the **number** are numeric values
- JavaScript uses a fixed number of bits, 64 of them, to store a single number value.
- If you had N decimal digits, you can represent ten to the power of N numbers - 10<sup>N</sup>
- Not all whole numbers less than 18 quintillions fit in a JavaScript number. Those bits also store negative numbers, so one bit indicates the sign of the number. A bigger issue is that nonwhole numbers must also be represented. To do this, some of the bits are used to store the position of the decimal point.
- Putting an operator between two values will apply it to those number values and will produce a new number value.
- If operators appear together without parentheses, the order in which they are applied is determined by the precedence of the operators.
- Strings cannot be divided, multiplied, or substructed, but the + operator can be used on them to concatenate them
- JavaScript supports three logical operators: **AND, OR, NOT**
- Many operations in the language that don’t produce a meaningful value yield undefined simply because they have to yield some value.

##➕APPENDIX 1 - LOGICAL OPERATORS VISUAL REPRESENTATION <a name="appendix"></a>

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/qkx60v4lo85jz9q4ayqs.png)

From an image we conclude:
- OR is true whenever is X or Y true
- Exclusive OR is true only when X is true or the Y is true
- AND is true only when X is true and Y is also true


# 🙏 THANK YOU FOR READING!<a name="thank-you"></a>
References:
School notes...
School books...

Please leave the comment, tell me about you, about your work, comment your thoughts, connect with me! 

☕ SUPPORT ME AND KEEP ME FOCUSED!
<a href='https://ko-fi.com/Z8Z33D1HJ' target='_blank'><img height='36' style='border:0px;height:36px;' src='https://cdn.ko-fi.com/cdn/kofi4.png?v=2' border='0' alt='Buy Me a Coffee at ko-fi.com' /></a>

Have a nice time hacking! 😊