**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.

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.

As we mentioned yesterday, strings are used to represent text. They are written by enclosing their content in quotes:

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:

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:

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:

var concat = "Coding" + "is" + "fun!";
console.log(concat);
/*
OUTPUT:
Codingisfun!
*/

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)

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.

console.log(3 > 2); //output: true
console.log(3 < 2); //output: false

There are also some operations that can be applied to Boolean values themselves. JavaScript supports three logical operators: AND, OR, NOT.
Examples:

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

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.

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

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.

JavaScript goes out of its way to accept almost any program you give it, even programs that do odd things.
For example:

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).

• 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^N
• 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.

References:
School notes...
School books...

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