Operators

Question 1

What is returned from:
false || ‘’ || true
‘’ || false || 0

How might this be used?

Answer 1

true
0

alert( firstName || lastName || nickName || “Anonymous”);
Alerts the name if a name is there, otherwise alerts “Anonymous”
OR
true || alert(“not printed”);
false || alert(“printed”);
Alerts depending if the printed-condition is true.

Question 2

What is returned from:
true && 0 && true
‘1’ && ‘2’ && ‘3’

Answer 2

0

‘3’

Question 3

Does && or || have higher precedence

Answer 3

&& has higher precedence

Question 4

What happens with:

console.log(( console.log(1) || console.log(2) || console.log(3) ));

Answer 4

1
2
3
undefined

The expressions in && and || are run even if they are not returned.

Question 5

What happens with:

console.log(( console.log(1)));

Answer 5

1

undefined

Question 6

What happens with

alert( alert(1) && alert(2) );

Answer 6

1 (alert(1) returns undefined, so the comparison stops and alert(1) is evaluated)
undefined

Question 7

Will this alert true?

alert( null || 2 && 3 || 4 );

Answer 7

No
It will alert 3.
within an if statement or ? operator, it will evaluate true or false. But does not on it’s own.

Question 8

Do || and && return Boolean?

Answer 8

no

Question 9

What is ?? called?

what’s does it do?

Answer 9

Nullish coalescing operator ‘??’
Returns the first non-null and non-undefined operand.

Or returns the last processed value

Question 10

What’s returned from
false ?? true
false ?? null
null ?? false

Answer 10

false
false
false

Question 11

What is the main use case for Nullish coalescing operator ‘??’ ?

Answer 11

The common use case for ?? is to provide a default value for a potentially undefined variable.
alert(user ?? “Anonymous”);

|| will also skip false and other falsey things. ?? only skips null and undefined

Question 12

Difference between || and ??

Answer 12

|| returns the first truthy value.
?? returns the first defined value. It doesn’t treat 0, ‘’, or false as undefined.

|| doesn’t distinguish between false, 0, an empty string “” and null/undefined.

Question 13

What is alerted
let height = 0;
alert(height || 100);
alert(height ?? 100);

Answer 13

// 100
 // 0

Question 14

Put brackets around the precedence
let area = height ?? 100 * width ?? 50;

Answer 14

let area = (height) ?? (100 * width) ?? (50);

When in doubt (about effect or readability), use parenthesis

Question 15

What happens with:
let x = 3;
console.log( (x = 2) && 7 );
console.log(x);

Answer 15

7
2

The expressions in && and || are run even if they are not returned.

Question 16

What has higher precedence (evalutated sooner):
a ||
or a &&

(‘a’ just to prevent html evaluation of this card)

Answer 16

a &&
1 && 1 || 1 && 1
is like:
(1 && 1) || (1 && 1)

Question 17

What does a higher precedence number ( 15 higher than 2) denote?

Answer 17

The higher the number, the sooner it is evaluated.

Question 18

What is logged to console from this:

console. log( 1 || 2 && 3)
console. log( 1 || (2 && 3))
console. log( (1 || 2) && 3)

Answer 18

1
1
3

Question 19

Is it ok to call this true? ‘string’

Answer 19

no. It is truthy or it evaluates as true

Question 20

Are truthy things true?

console.log(‘true’ == true);

Answer 20

false

truthy does not mean it’s true.

Question 21

Escape a quotation mark or mark a newline in a string

Answer 21

Backslash \ before the character

“this is a "fine" day”

\n

Question 22

Difference between .concat() and +

Answer 22

For strings, no difference

But + will convert arrays to strings before concatenating. It can be used with numbers.

.concat() is a method on strings and arrays. When used on a number will throw an error

Question 23

What is an operand?

Answer 23

The thing operators are applied to

1 / 2

/ is the operator

1 and 2 are operands (or arguments)

Question 24

What is a unary operator?

What is a binary operator

Answer 24

An operator with 1 operand

• 2 negation operator

An operator with 2 operands:

2 - 3 subtraction operator

Question 25

What are the following operators? / * ** %

Answer 25

division multiplication exponentiation  remainder

Question 26

Does the = operator in: x = 21; return anything? Do all operators return something?

Answer 26

It FIRST writes value 21 to variable x But THEN also returns something. All operators return something ``` let a = 1; let b = 2; ``` let c = 3 - (a = b + 1); alert( a ); // 3 alert( c ); // 0

Question 27

What are these: & | ^ ~ << >> >>>

Answer 27

Bitwise operators, act on bits AND OR XOR NOT LEFT SHIFT RIGHT SHIFT ZERO-FILL RIGHT SHIFT

Question 28

what does the comma operator (,) do?

Answer 28

Separates expressions and allows them all to evaluate. But only 1 will be returned. (returns the last one)

Question 29

What does this return? let b = 4, let t = 5;

Answer 29

an error

Question 30

All comparison operators return a boolean value t or f

Answer 30

True

Question 31

What has higher precidence (evaluated sooner) && or ||

Answer 31

&&

Question 32

What does the ~ do? | How does it behave with base 10 numbers?

Answer 32

bitwise not takes the not of all the bits In decimal, it basically does this: -(n+1) except in some cases alert( ~2 ); // -3, the same as -(2+1) alert( ~1 ); // -2, the same as -(1+1) alert( ~0 ); // -1, the same as -(0+1) alert( ~-1 ); // 0, the same as -(-1+1)

Question 33

How can the bitwise not ~ | be used?

Answer 33

alert( ~2 ); // -3, the same as -(2+1) alert( ~1 ); // -2, the same as -(1+1) alert( ~0 ); // -1, the same as -(0+1) alert( ~-1 ); // 0, the same as -(-1+1) because ~n is only going to be 0 (falsy) when n = -1, it can be used as an automatic check if an index searcher found it (they return -1 for not existent indexes). let str = "Widget"; if (~str.indexOf("Widget")) { alert( 'Found it!' ); // works }

Question 34

~4294967295

Answer 34

This specific number converts to 0. | It's 11111111111111111111111111111111 in decimal

Question 35

Higher precedence operators are evaluated later | t or f

Answer 35

false | sooner

Question 36

What does this return: ...[1, 2, 3] How can it be used?

Answer 36

it returns 1, 2, 3 Return a series of elements as arguments. Return a series of elements into another array or object. 1. Cloning You can use it to shallow copy an array or object let arr = [1,2,3]; let arr2 = [4,5]; arr = [...arr,...arr2]; (slower than .concat) 2. Unpacking you can use it to input array elements where you just want to input the elements: let result = compare(...[1, 2])

Question 37

What does the ... spread operator do? What does the ... rest operator do?

Answer 37

Spread syntax (...): allows an iterable such as an array expression or string to be expanded in places where zero or more arguments (for function calls) or elements (for array literals) are expected, or an object expression to be expanded in places where zero or more key-value pairs (for object literals) are expected. Rest parameter syntax (...): The rest parameter syntax allows a function to accept an indefinite number of arguments as an array, providing a way to represent variadic functions in JavaScript.

Question 38

``` What happens with this code? function f(arg1, ...rest, arg2) { } ```

Answer 38

error | Rest parameter has to come at the end.

Question 39

``` What happens with this code: function apple(arg1, [...rest], arg2) { console.log(arg1, rest, arg2); } apple(1, 2, 3, 4); ``` ``` What happens with this code: function apple(arg1, [...rest], arg2) { console.log(arg1, rest, arg2); } apple('afd', 'bed', 'cdd', 'dgd'); ``` Why?

Answer 39

gives error afd [ 'b', 'e', 'd' ] cdd [...rest] is actually spread syntax. It's splitting 'bed' into an array.