Aug 19, 2023 · Aug 25, 2023
diff --git a/...l-operators/9-check-login/ifelse_task.svg → ...-operators/10-check-login/ifelse_task.svg b/...l-operators/9-check-login/ifelse_task.svg → ...-operators/10-check-login/ifelse_task.svg
diff --git a/...gical-operators/9-check-login/solution.md → ...ical-operators/10-check-login/solution.md b/...gical-operators/9-check-login/solution.md → ...ical-operators/10-check-login/solution.md
diff --git a/...1-logical-operators/9-check-login/task.md → ...-logical-operators/10-check-login/task.md b/...1-logical-operators/9-check-login/task.md → ...-logical-operators/10-check-login/task.md
diff --git a/...rst-steps/11-logical-operators/6-alert-or-assignment-and-assignment/solution.md b/...rst-steps/11-logical-operators/6-alert-or-assignment-and-assignment/solution.md
 The answer: `30`.

 ```js run
 let value = NaN;

 value &&= 10;
 value ||= 20;
 value &&= 30;
 value ||= 40;

 alert(value);
 ```

 The order of execution of this code is:
 1. `value &&= 10`
   - `value=NaN`
   - `NaN` is converted to the boolean `false`
   - `value` is falsy, so assignment *doesn't* work
 2. `value ||= 20`
   - `value=NaN`
   - `NaN` is converted to the boolean `false`
   - `value` is falsy, so assignment *works*
 3. `value &&= 30`
   - `value=20`
   - `20` is converted to the boolean `true`
   - `value` is truthy, so assignment *works*
 4. `value ||= 40`
   - `value=30`
   - `30` is converted to the boolean `true`
   - `value` is truthy, so assignment *doesn't* work
diff --git a/...2-first-steps/11-logical-operators/6-alert-or-assignment-and-assignment/task.md b/...2-first-steps/11-logical-operators/6-alert-or-assignment-and-assignment/task.md
 importance: 2

 ---

 # What is the result of alert (||=, &&=)?

 What is the result of `alert` here?

 ```js
 let value = NaN;

 value &&= 10;
 value ||= 20;
 value &&= 30;
 value ||= 40;

 alert(value);
 ```
diff --git a/...operators/6-check-if-in-range/solution.md → ...operators/7-check-if-in-range/solution.md b/...operators/6-check-if-in-range/solution.md → ...operators/7-check-if-in-range/solution.md
diff --git a/...cal-operators/6-check-if-in-range/task.md → ...cal-operators/7-check-if-in-range/task.md b/...cal-operators/6-check-if-in-range/task.md → ...cal-operators/7-check-if-in-range/task.md
diff --git a/...perators/7-check-if-out-range/solution.md → ...perators/8-check-if-out-range/solution.md b/...perators/7-check-if-out-range/solution.md → ...perators/8-check-if-out-range/solution.md
diff --git a/...al-operators/7-check-if-out-range/task.md → ...al-operators/8-check-if-out-range/task.md b/...al-operators/7-check-if-out-range/task.md → ...al-operators/8-check-if-out-range/task.md
diff --git a/...gical-operators/8-if-question/solution.md → ...gical-operators/9-if-question/solution.md b/...gical-operators/8-if-question/solution.md → ...gical-operators/9-if-question/solution.md
diff --git a/...1-logical-operators/8-if-question/task.md → ...1-logical-operators/9-if-question/task.md b/...1-logical-operators/8-if-question/task.md → ...1-logical-operators/9-if-question/task.md
diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
 # Logical operators

 There are four logical operators in #"f5f8faf8a5e2f6bb20af09ae7e482de8c56a6d0e33ad11733aa35d1c4098f33c">
 There are seven logical operators in #"f5f8faf8a5e2f6bb20af09ae7e482de8c56a6d0e33ad11733aa35d1c4098f33c">
 - `||` (OR)
  - `||=` (Logical OR assignment operator)
 - `&&` (AND)
  - `&&=` (Logical AND assignment operator)
 - `!` (NOT)
 - `??` (Nullish coalescing operator)
  - `??=` (Nullish coalescing assignment operator)

 Here we cover the first five, the operators `??` and `??=` will be in the next article.

 Although they are called "logical", they can be applied to values of any type, not only boolean. Their result can also be of any type.

 }
 ```

 ## OR "||" finds the first truthy value [#or-finds-the-first-truthy-value]
 ### OR "||" finds the first truthy value [#or-finds-the-first-truthy-value]

 The logic described above is somewhat classical. Now, let's bring in the "extra" features of JavaScript.


    Sometimes, people use this feature to execute commands only if the condition on the left part is falsy.

 ## ||= (Logical OR assignment)

 [recent browser="new"]

 The logical OR assignment operator `||=` is written as a regular OR `||` with the addition of the assignment symbol `=`. This notation is not accidental, since the result of this operator depends directly on the behavior of the already known `||`.

 Syntax:

 ```js
 a ||= b
 ```

 The `||=` operator takes two operands and performs the following actions:

 - Evaluates operands from left to right.
 - Converts `a` to a boolean value.
 - If `a` is falsy, assigns `a` the value of `b`.

 The concept of the `||=` operator is the "short-circuit" evaluation, the principle of which we analyzed earlier.

 Now let's rewrite `a ||= b` under the form of "short-circuit" evaluation:

 ```js
 a || (a = b);
 ```

 We already know that OR `||` returns the *first truthy value*, so if `a` is such, the evaluation will not reach the right-hand side of the expression.

 Here is an example with an obvious usage of the `||=` operator:

 ```js run
 let johnHasCar = false;

 johnHasCar ||= "John doesn't have a car!"; // same as false || (johnHasCar = "...")

 alert( johnHasCar ); // "John doesn't have a car!"
 ```

 ...And this is where the conversion to a boolean value takes place:

 ```js run
 let manufacturer = ""; // ||= operator will convert the empty string "" to the boolean value (false)

 manufacturer ||= "Unknown manufacturer"; // same as false || (manufacturer = "...")

 alert( manufacturer ); // "Unknown manufacturer"
 ```

 The logical OR assignment operator `||=` is a "[syntactic sugar](https://en.wikipedia.org/wiki/Syntactic_sugar)" added to the language as a shorter form of writing `if` assignment statements.

 We can rewrite the above examples using the regular `if`:

 ```js run
 let johnHasCar = false;

 if (johnHasCar == false) {
  johnHasCar = "John doesn't have a car!";
 }

 alert(johnHasCar); // "John doesn't have a car!"

 let manufacturer = "";

 if (manufacturer == false) {
  manufacturer = "Unknown manufacturer";
 }

 alert(manufacturer); // "Unknown manufacturer"
 ```

 ## && (AND)

 The AND operator is represented with two ampersands `&&`:
 ```


 ## AND "&&" finds the first falsy value
 ### AND "&&" finds the first falsy value

 Given multiple AND'ed values:

 Although, the variant with `&&` appears shorter, `if` is more obvious and tends to be a little bit more readable. So we recommend using every construct for its purpose: use `if` if we want `if` and use `&&` if we want AND.
 ````

 ## &&= (Logical AND assignment)

 [recent browser="new"]

 The logical AND assignment operator `&&=` is written as two ampersands `&&` and the assignment symbol `=`.

 Syntax:

 ```js
 a &&= b
 ```

 The principle of `&&=` is almost the same as that of the logical OR assignment operator `||=`. The only difference is that `&&=` will assign `a` to the value of `b` only if `a` is *truthy*.

 The concept of the logical AND assignment operator `&&=` is also based on "short-circuit" evaluation:

 ```js
 a && (a = b);
 ```

 Here's an example:

 ```js run
 let greeting = "Hello"; // the string is non-empty, so it will be converted to the boolean value (true) by the &&= operator.

 greeting &&= greeting + ", user!"; // same as true && (greeting = greeting + "...")

 alert( greeting ) // "Hello, user!"
 ```

 Since the logical AND assignment operator `&&=` as well as `||=` is "syntactic sugar", we can easily rewrite the example above using the familiar `if`:

 ```js run
 let greeting = "Hello";

 if (greeting) {
  greeting = greeting + ", user!"
 }

 alert( greeting ) // "Hello, user!"
 ```

 In practice, unlike `||=`, the `&&=` operator is used quite rarely -- usually in combination with more complex language features, about which we will talk later. Finding a context for using this operator is a challenging task.

 ## ! (NOT)
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,30 @@
		The answer: `30`.

		```js run
		let value = NaN;

		value &&= 10;
		value \|\|= 20;
		value &&= 30;
		value \|\|= 40;

		alert(value);
		```

		The order of execution of this code is:
		1. `value &&= 10`
		- `value=NaN`
		- `NaN` is converted to the boolean `false`
		- `value` is falsy, so assignment doesn't work
		2. `value \|\|= 20`
		- `value=NaN`
		- `NaN` is converted to the boolean `false`
		- `value` is falsy, so assignment works
		3. `value &&= 30`
		- `value=20`
		- `20` is converted to the boolean `true`
		- `value` is truthy, so assignment works
		4. `value \|\|= 40`
		- `value=30`
		- `30` is converted to the boolean `true`
		- `value` is truthy, so assignment doesn't work
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,18 @@
		importance: 2

		---

		# What is the result of alert (\|\|=, &&=)?

		What is the result of `alert` here?

		```js
		let value = NaN;

		value &&= 10;
		value \|\|= 20;
		value &&= 30;
		value \|\|= 40;

		alert(value);
		```
Original file line number	Diff line change
	@@ -1,6 +1,16 @@
	# Logical operators

	There are four logical operators in #"f5f8faf8a5e2f6bb20af09ae7e482de8c56a6d0e33ad11733aa35d1c4098f33c">	There are seven logical operators in #"f5f8faf8a5e2f6bb20af09ae7e482de8c56a6d0e33ad11733aa35d1c4098f33c">
	- `\|\|` (OR)
	- `\|\|=` (Logical OR assignment operator)
	- `&&` (AND)
	- `&&=` (Logical AND assignment operator)
	- `!` (NOT)
	- `??` (Nullish coalescing operator)
	- `??=` (Nullish coalescing assignment operator)

	Here we cover the first five, the operators `??` and `??=` will be in the next article.

	Although they are called "logical", they can be applied to values of any type, not only boolean. Their result can also be of any type.

Expand DownExpand Up	@@ -64,7 +74,7 @@ if (hour < 10 \|\| hour > 18 \|\| isWeekend) {
	}
	```

	## OR "\|\|" finds the first truthy value [#or-finds-the-first-truthy-value]
	### OR "\|\|" finds the first truthy value [#or-finds-the-first-truthy-value]

	The logic described above is somewhat classical. Now, let's bring in the "extra" features of JavaScript.

Expand DownExpand Up	@@ -136,6 +146,76 @@ This leads to some interesting usage compared to a "pure, classical, boolean-onl

	Sometimes, people use this feature to execute commands only if the condition on the left part is falsy.

	## \|\|= (Logical OR assignment)

	[recent browser="new"]

	The logical OR assignment operator `\|\|=` is written as a regular OR `\|\|` with the addition of the assignment symbol `=`. This notation is not accidental, since the result of this operator depends directly on the behavior of the already known `\|\|`.

	Syntax:

	```js
	a \|\|= b
	```

	The `\|\|=` operator takes two operands and performs the following actions:

	- Evaluates operands from left to right.
	- Converts `a` to a boolean value.
	- If `a` is falsy, assigns `a` the value of `b`.

	The concept of the `\|\|=` operator is the "short-circuit" evaluation, the principle of which we analyzed earlier.

	Now let's rewrite `a \|\|= b` under the form of "short-circuit" evaluation:

	```js
	a \|\| (a = b);
	```

	We already know that OR `\|\|` returns the first truthy value, so if `a` is such, the evaluation will not reach the right-hand side of the expression.

	Here is an example with an obvious usage of the `\|\|=` operator:

	```js run
	let johnHasCar = false;

	johnHasCar \|\|= "John doesn't have a car!"; // same as false \|\| (johnHasCar = "...")

	alert( johnHasCar ); // "John doesn't have a car!"
	```

	...And this is where the conversion to a boolean value takes place:

	```js run
	let manufacturer = ""; // \|\|= operator will convert the empty string "" to the boolean value (false)

	manufacturer \|\|= "Unknown manufacturer"; // same as false \|\| (manufacturer = "...")

	alert( manufacturer ); // "Unknown manufacturer"
	```

	The logical OR assignment operator `\|\|=` is a "[syntactic sugar](https://en.wikipedia.org/wiki/Syntactic_sugar)" added to the language as a shorter form of writing `if` assignment statements.

	We can rewrite the above examples using the regular `if`:

	```js run
	let johnHasCar = false;

	if (johnHasCar == false) {
	johnHasCar = "John doesn't have a car!";
	}

	alert(johnHasCar); // "John doesn't have a car!"

	let manufacturer = "";

	if (manufacturer == false) {
	manufacturer = "Unknown manufacturer";
	}

	alert(manufacturer); // "Unknown manufacturer"
	```

	## && (AND)

	The AND operator is represented with two ampersands `&&`:
Expand DownExpand Up	@@ -173,7 +253,7 @@ if (1 && 0) { // evaluated as true && false
	```


	## AND "&&" finds the first falsy value
	### AND "&&" finds the first falsy value

	Given multiple AND'ed values:

Expand DownExpand Up	@@ -247,6 +327,49 @@ if (x > 0) alert( 'Greater than zero!' );
	Although, the variant with `&&` appears shorter, `if` is more obvious and tends to be a little bit more readable. So we recommend using every construct for its purpose: use `if` if we want `if` and use `&&` if we want AND.
	````

	## &&= (Logical AND assignment)

	[recent browser="new"]

	The logical AND assignment operator `&&=` is written as two ampersands `&&` and the assignment symbol `=`.

	Syntax:

	```js
	a &&= b
	```

	The principle of `&&=` is almost the same as that of the logical OR assignment operator `\|\|=`. The only difference is that `&&=` will assign `a` to the value of `b` only if `a` is truthy.

	The concept of the logical AND assignment operator `&&=` is also based on "short-circuit" evaluation:

	```js
	a && (a = b);
	```

	Here's an example:

	```js run
	let greeting = "Hello"; // the string is non-empty, so it will be converted to the boolean value (true) by the &&= operator.

	greeting &&= greeting + ", user!"; // same as true && (greeting = greeting + "...")

	alert( greeting ) // "Hello, user!"
	```

	Since the logical AND assignment operator `&&=` as well as `\|\|=` is "syntactic sugar", we can easily rewrite the example above using the familiar `if`:

	```js run
	let greeting = "Hello";

	if (greeting) {
	greeting = greeting + ", user!"
	}

	alert( greeting ) // "Hello, user!"
	```

	In practice, unlike `\|\|=`, the `&&=` operator is used quite rarely -- usually in combination with more complex language features, about which we will talk later. Finding a context for using this operator is a challenging task.

	## ! (NOT)

Expand Down