type conversions & math

Question 1

alert( “6” / “2” ); //returns?

Answer 1

3, strings are converted to numbers

Question 2

let str = “123”;
alert(typeof str); // Returns

Answer 2

String

Question 3

let str = “123”;
let num = Number(str);
alert(typeof num); // returns and why

Answer 3

number,
It becomes a number 123

Question 4

let age = Number(“an arbitrary string instead of a number”);
alert(age); // returns?

Answer 4

NaN, conversion failed

Question 5

Numeric conversion rules:
undefined becomes?

Answer 5

NAN

Question 6

Numeric conversion rules:
Null becomes?

Answer 6

0

Question 7

Numeric conversion rules:
true and false

Answer 7

1 & 0

Question 8

Numeric conversion rules:
If the remaining string is empty, the result is _____

Answer 8

0

Question 9

Numeric conversion rules:
String with characters// returns?

Answer 9

the number is “read” from the string. An error gives NaN.

Question 10

alert( Number(“123z”) ); // returns?

Answer 10

NaN (error reading a number at “z”)

Question 11

Numeric conversion rules:

Values that are intuitively “empty”, like 0, an empty string, null, undefined, and NaN, become _____.

Answer 11

false

Question 12

False numeric conversion

Answer 12

0
empty string
null
undefined
NAN

Question 13

alert( Boolean(“hello”) ); // return

Answer 13

true

Question 14

alert( Boolean(“”) ); // returns

Answer 14

false

Question 15

alert( Boolean(“0”) ); // returns

Answer 15

0
in JavaScript, a non-empty string is always true.

Question 16

& alert( Boolean(“ “) ); // return?

Answer 16

spaces, also true (any non-empty string is true)

Question 17

let x = 1;
x = -x;
alert( x ); // returns?

Answer 17

-1, unary negation was applied

Question 18

alert( ‘1’ + 2 ); // returns?

Answer 18

“12”
contacination

Question 19

alert( 2 + ‘1’ ); // returns?

Answer 19

“21”

Question 20

alert(2 + 2 + ‘1’ ); // returns?

Answer 20

Here, operators work one after another. The first + sums two numbers, so it returns 4, then the next + adds the string 1 to it, so it’s like 4 + ‘1’ = ‘41’.

Question 21

alert(‘1’ + 2 + 2); // “

Answer 21

Here, the first operand is a string, the compiler treats the other two operands as strings too. The 2 gets concatenated to ‘1’, so it’s like ‘1’ + 2 = “12” and “12” + 2 = “122”.

Question 22

alert( +true ); // returns and why?

Answer 22

1
But if the operand is not a number, the unary plus converts it into a number.

Question 23

alert( +”” ); // returns

Answer 23

0
if the operand is not a number, the unary plus converts it into a number.

Question 24

let apples = “2”;
alert( +apples);

write the longer variant

Answer 24

alert( Number(apples) );

Question 25

let a = 1;
let b = 2;

let c = 3 - (a = b + 1);

alert( a ); // returns?
alert( c ); // returns?

Answer 25

3
0

Question 26

let a, b, c;

a = b = c = 2 + 2;

alert( a ); //
alert( b ); //
alert( c ); //

Answer 26

all return 4
chaining

Question 27

let n = 2;
n = n + 5;
n = n * 2;

write shorthand

Answer 27

n+=5
n*=2

Question 28

Increment/decrement can only be applied to _______

Answer 28

variables

Question 29

let counter = 1;
let a = ++counter; // (*)
alert(a); // returns

Answer 29

2

In the line (*), the prefix form ++counter increments counter and returns the new value, 2. So, the alert shows 2.

Question 30

let counter = 1;
let a = counter++;
alert(a); // returns

Answer 30

1
In the line (*), the postfix form counter++ also increments counter but returns the old value (prior to increment). So, the alert shows 1.

Question 31

If we’d like to increase a value and immediately use the result of the operator, we need the prefix form:

let counter = 0;
alert( _______ ); // 1

Answer 31

++counter

Question 32

If we’d like to increment a value but use its previous value, we need the postfix form:

let counter = 0;
alert( ______); // 0

Answer 32

counter++

Question 33

let counter = 1;
alert( 2 * ++counter ); // return

Answer 33

4

Question 34

let counter = 1;
alert( 2 * counter++ ); //

Answer 34

2, because counter++ returns the “old” value

Question 35

let a = (1 + 2, 3 + 4);

alert( a ); //

Answer 35

7 (the result of 3 + 4)

The comma operator allows us to evaluate several expressions, dividing them with a comma ,. Each of them is evaluated but only the result of the last one is returned.

Question 36

For maths and other comparisons null becomes ____

Answer 36

0

Question 37

For maths and other comparisons
undefined becomes _____.

Answer 37

NaN

Question 38

let a = 1, b = 1;

let c = ++a; // ?
let d = b++; // ?

Answer 38

2
1