Now let us do something similar to the above, but this time with numbers. Let us write a program that adds two numbers:

'use strict';
let a = 40;
let b = 2;
console.log('The sum is ' + (a + b));       // 42

It works. But, sorry, we want improvement for better test:

'use strict';
let a = prompt('Enter first addend');
let b = prompt('Enter second addend');
console.log('The sum is ' + (a + b));

Better? Yes, more versatile, but something went wrong. it uses concatenation? Concatenation is usually for strings, not for numbers. So we must let JavaScript know that we are processing numbers:

'use strict';
let a = Number(prompt('Enter first addend'));
let b = Number(prompt('Enter second addend'));
console.log('The sum is ' + (a + b));

We must remember that user input is almost always in the form of text, so that JavaScript must be notified in order to treat it as numbers, if that is what it is.

The Number function used above caters to integer values, eg 42, floating point numbers, eg 3.141, or 273.15, or numbers in scientific notation, eg 1.496e8, or 5e-9.

We have already shown strings in actions. There are now three ways of defining string. Look at these literal string values:

"This is a string (delimited by double quotes)"
'and this is also a string (delimited by single quotes)'
`and, by golly, so is this (delimited by so called backtics)`

The difference between the three is subtle. Normally strings can not span lines, ie they cannot be multiline. Exception, if you use backtics. You may, however, insert a so called newline character into you string to make it spread over several lines.

var s = "this quote\nrespects the way it\nhas been typed over\none long line, with manual line breaks, pretty much like <br/>";
console.log(s);

and

var s = `this quote
respects the way it
has been typed over
several lines, pretty much
as the html tag <pre>`;
console.log(s);

To be complete, let us try

var s = 'this quote\nrespects the way it\nhas been typed over\none long line, with manual line breaks, pretty much like <br/>';
console.log(s);

Another benefit of the backtics, it respects variables as in, this modified example from before:

'use strict';
let a = Number(prompt('Enter first addend'));
let b = Number(prompt('Enter second addend'));
console.log(`First addend: ${a}`);
console.log(`Second addend: ${b}`);
console.log(`The sum is ${a + b}`);

Operators are the characters we use to instruct the language to do arithmetic operations on numbers. There are operators to invoke string or logival operations too, but let me concentrate on the numbers for the time being. In

'use strict';
let x = 40;     // = is the operator
x = x + 1;      // = and + are operators
x++;            // ++ is an operator
console.log(x); // ?

the operators =, and + are binary because the require two operands. The ++ , increment operator is a unary operator. It works on one operand. Now look at

'use strict';
let x = 40;     // same as above
let y = -1;     // here - is unary
x = x - y;      // here - is binary
console.log(x); // ?

The behaviour of the arithmetic operators is predictable. It corresponds to regular arithmetic behaviour.

'use strict';
let a = 2;
a**10;          // 210
console.log(a); // ?

Now watch carefully

'use strict';
let a = 4;
a = a / 4;      // divide
console.log(a); // ?

a = 3;
a = a * 27;     // multiply
console.log(a); // ?

Did you notice the behaviour? Let me ever so slightly rephrase this experiment:

'use strict';
let a = 4;
a /= 4;      // divide
console.log(a); // ?

a = 3;
a *= 27;     // multiply
console.log(a); // ?

The shortcut notations we saw in Example 2.5 are equivalent to the longhand of Example 2.4.

Operators have a precedence order. A atatement being executed left to right on the right hand side of the = is the convention in code, but there is a catch

'use strict';
let p = 5 + 4 / 2;
console.log(p);     // ?

or

'use strict';
let p = (5 + 4) / 2;
console.log(p);     // ?

'use strict';
let p = 5 + 4 / 2 ** 2;
console.log(p);     // ?

The precedence order is?

'use strict';
let cpr = 2511450007;
console.log(cpr % 2);   // ?

cpr = 702900008;
console.log(cpr % 2);   // ?

A boolean is a variable that takes one of only two possible values, true, or false.

As we shall abundantly see later, there is much logics in programming, and talking about true, and false we can easily see these values as answers to simple questions, such as: Is 3 larger than 4?, or is 'Beatrice' less than 'Charlotte'?. Less than in strings means lexically before. Sometimes the questions are harder because they have two, or more constituents, such as does it rain and is it friday, or is it friday or is it the eve of a holiday.

Now, let us look at the two simple ones:

'use strict';
console.log(3 > 4);          // false
// or
let num1 = 3;
let num2 = 4;
console.log(num1 > num2);    // false

and

'use strict';
console.log('Beatrice' < 'Charlotte');   // true
// or
let name1 = 'Beatrice';
let name2 = 'Charlotte';
console.log(name1 < name2)               // true

In the two compund questions, let us assume that the individual questions have been answered and their values assigned to meaningfully named variables.

'use strict';
let rains = true;
let friday = false;
console.log(rains && friday);           // false

and

'use strict';
let isItFriday = true;
let isItEveOfHoliday = false;
console.log(isItFriday || isItEveofHoliday);    // true

'use strict';
let rains = true;
                        // ask whether it rains
console.log(rains);     //true

                        // ask for the logical opposite
console.log(!rains);    // false
                        // !rains pronounced as 'not rains'

let rains = false;      // change the value of rains
                        // ask whether it is dry
console.log(!rains);    // true

'use strict';
console.log('Truth table for negation');
console.log('var1\t!var1');
let var1 = true;
console.log(var1 + '\t' + !var1);
let var1 = false;
console.log(var1 + '\t' + !var1);

'use strict';
let str = 'sky';
console.log(str.match(/[aeiou]/gi));

'use strict';
let foo;
console.log('foo is ' + foo);