Glossary: преобразование в MD (#4123)

* Glossary: преобразование в MD

6 files changed, 140 insertions, 180 deletions

diff --git a/files/ru/glossary/falsy/index.html b/files/ru/glossary/falsy/index.html
deleted file mode 100644
index 06ed182d89..0000000000
--- a/files/ru/glossary/falsy/index.html
+++ /dev/null
@@ -1,95 +0,0 @@
----
-title: Falsy
-slug: Glossary/Falsy
-tags:
-  - Glossary
-  - JavaScript
-  - falsy
-translation_of: Glossary/Falsy
-original_slug: Глоссарий/Falsy
----
-<p id="Summary">Ложное (<strong>falsy</strong>) значение - это значение, которое считается ложным, когда встречается в контексте {{Glossary("Boolean")}} .</p>
-
-<p>{{Glossary("JavaScript")}} использует {{Glossary("Type_Conversion", "Type Conversion")}} для приведения любого значения к логическому в контекстах, которые требуют его, такие как {{Glossary("Conditional", "условные выражения")}} и {{Glossary("Loop", "циклы")}}.</p>
-
-<div class="note">
-<p>В JavaScript есть только 7 <strong>ложных</strong> значений</p>
-
-<p>Это означает, что когда JavaScript ожидает логическое значение и ему присваивается одно из значений ниже, он всегда будет оцениваться как «ложное»</p>
-</div>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <td>false</td>
-   <td>Ключевое слово {{jsxref('Lexical_grammar','false','Зарезервированные_ключевые_слова_в_более_старых_версиях')}}</td>
-  </tr>
-  <tr>
-   <td>0, -0</td>
-   <td>Число <a href="/ru/docs/Web/JavaScript/Data_structures#Типы_данных">zero</a></td>
-  </tr>
-  <tr>
-   <td><code>0n</code></td>
-   <td>{{jsxref('Global_Objects/BigInt','BigInt')}}, при использовании в качестве логического значения, следует тому же правилу, что и число. 0n - это ложь.</td>
-  </tr>
-  <tr>
-   <td>"", '', ``</td>
-   <td>
-    <p>Это пустая строка(длина строки ноль). Строки в JavaScript могут быть определены с помощью двойных кавычек (") или одинарных кавычек ('), а также {{jsxref ('template_strings', 'Template literals')}} (`)</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{Glossary("null")}}</td>
-   <td>{{jsxref('Global_Objects/null','null')}} - отсутствие какого-либо значения</td>
-  </tr>
-  <tr>
-   <td>{{Glossary("undefined")}}</td>
-   <td>{{jsxref('Global_Objects/undefined','undefined')}} - примитивное значение</td>
-  </tr>
-  <tr>
-   <td>{{Glossary("NaN")}}</td>
-   <td>{{jsxref('Global_Objects/NaN','NaN')}} - не число</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Примеры">Примеры</h2>
-
-<p>Примеры ложных значений в JavaScript (которые приводятся к ложному в булевых контекстах и, таким образом, обходят блок if):</p>
-
-<pre class="brush: js">if (false)
-if (null)
-if (undefined)
-if (0)
-if (-0)
-if (0n)
-if (NaN)
-if ('')
-if ("")
-if (``)
-if (document.all)
-</pre>
-
-<h3 id="Логический_оператор_И">Логический оператор И, &amp;&amp;</h3>
-
-<p>Если первый объект ложный, он возвращает этот объект</p>
-
-<pre class="brush: js">let pet = false &amp;&amp; "dog";
-
-// ↪ false
-</pre>
-
-<div class="note">
-<p>В прошлом для обнаружения браузером использовался <code>document.all</code>, а <a href="http://www.whatwg.org/specs/web-apps/current-work/multipage/obsolete.html#dom-document-all">Спецификация HTML здесь определяет преднамеренное нарушение</a> стандарта ECMAScript для сохранения совместимости с устаревшим кодом. (<code>if (document.all) { // Internet Explorer code here(except IE11) }</code> or using <code>document.all</code> without checking its presence first: <code>document.all.foo</code>).</p>
-</div>
-
-<p>Иногда пишется <strong>falsy</strong>, хотя на английском языке обычно превращают слово в прилагательное с окончанием -y, любое окончание <em>e</em> отбрасывается(noise =&gt; noisy, ice =&gt; icy, shine =&gt; shiny)</p>
-
-<h2 id="Узнать_больше">Узнать больше</h2>
-
-<ul>
- <li>{{Glossary("Truthy")}}</li>
- <li>{{Glossary("Boolean")}}</li>
-</ul>
-
-<div>{{QuickLinksWithSubpages("/en-US/docs/Glossary")}}</div>
diff --git a/files/ru/glossary/falsy/index.md b/files/ru/glossary/falsy/index.md
new file mode 100644
index 0000000000..e315abb12e
--- /dev/null
+++ b/files/ru/glossary/falsy/index.md
@@ -0,0 +1,58 @@
+---
+title: Ложноподобное значение
+slug: Glossary/Falsy
+tags:
+  - CodingScripting
+  - Glossary
+  - JavaScript
+---
+**Ложноподобное** (**falsy**) значение — значение, которое становится `false` в {{Glossary("Boolean", "булевом")}} контексте.
+
+{{Glossary("JavaScript")}} использует {{Glossary("Type_Conversion", "преобразование типов")}}, чтобы привести значение к булевому типу, там, где это требуется (например, в {{Glossary("Conditional", "условных конструкциях")}} и {{Glossary("Loop", "циклах")}}.
+
+В следующей таблице приведен полный список ложноподобных значений JavaScript:
+
+| Значение                    | Описание                                                                                                                                                                                                                        |
+|-----------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `false`                     | Ключевое слово [`false`](/ru/docs/Web/JavaScript/Reference/Lexical_grammar#future_reserved_keywords_in_older_standards).                                                                                                        |
+| `0`                         | Ноль {{jsxref("Number")}} (к нему также относятся `0.0`, `0x0` и т.д.).                                                                                                                                                         |
+| `-0`                        | Отрицательный ноль типа {{jsxref("Number")}} (к нему также относятся `-0.0`, `-0x0` и т.д.).                                                                                                                                    |
+| `0n`                        | Ноль типа {{jsxref("BigInt")}} (также `0x0n`). Обратите внимание, что не может быть негативного нуля типа {{jsxref("BigInt")}} — отрицательный `0n` равняется `0n`.                                                                                         |
+| `""`, `''`, ` `` `          | Значение, содержащее пустую [строку](/ru/docs/Web/JavaScript/Reference/Global_Objects/String) .                                                                                                                                                 |
+| {{Glossary("null")}}        | [null](/ru/docs/Web/JavaScript/Reference/Global_Objects/null) — отсутствие какого-либо значения.                                                                                                                                       |
+| {{Glossary("undefined")}}   | [undefined](/ru/docs/Web/JavaScript/Reference/Global_Objects/undefined) — примитивное значение.                                                                                                                                  |
+| {{Glossary("NaN")}}         | [NaN](/ru/docs/Web/JavaScript/Reference/Global_Objects/NaN) — значение, не являющиеся числом.                                                                                                                                                     |
+| {{domxref("document.all")}} | Объекты считаются ложноподобными тогда и только тогда, когда у них есть внутренний слот [\[\[IsHTMLDDA\]\]](https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot). Этот слот есть только в объекте {{domxref("document.all")}}, и его задать через JavaScript. |
+
+## Примеры
+
+Примеры _ложноподобных_ значений в JavaScript (которые в булевых контекстах принудительно приводятся к false и таким образом _минуют_ блок `if`):
+
+```js
+if (false)
+if (null)
+if (undefined)
+if (0)
+if (-0)
+if (0n)
+if (NaN)
+if ("")
+```
+
+### Оператор логического И, &&
+
+Если первый операнд ложноподобен, то он будет возвращён в качестве результата:
+
+```js
+false && "dog"
+// ↪ false
+
+0 && "dog"
+// ↪ 0
+```
+
+## Смотрите также
+
+- {{Glossary("Truthy")}}
+- {{Glossary("Type_coercion")}}
+- {{Glossary("Boolean")}}
diff --git a/files/ru/glossary/truthy/index.html b/files/ru/glossary/truthy/index.html
deleted file mode 100644
index c1ecc2b86b..0000000000
--- a/files/ru/glossary/truthy/index.html
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: Truthy
-slug: Glossary/Truthy
-tags:
-  - Glossary
-  - JavaScript
-  - truthy
-  - Глоссарий
-translation_of: Glossary/Truthy
-original_slug: Глоссарий/Truthy
----
-<p>В {{Glossary("JavaScript")}}, <strong>истинное</strong> значение - это значение, которое считается <code>true</code>, когда встречается в контексте {{Glossary("Boolean")}}. Все значения истинные, если они не определены как {{Glossary("Falsy", "falsy")}} (кроме <code>false</code>, <code>0</code>, <code>-0</code>, <code>0n</code>, <code>""</code>, <code>null</code>, <code>undefined</code>, и <code>NaN</code>).</p>
-
-<p>{{Glossary("JavaScript")}} использует {{Glossary("Type_coercion", "приведение типов")}} в Boolean контекстах.</p>
-
-<p>Примеры истинных значений в JavaScript (которые будут приведены к true в булевых выражениях, и таким образом выполниться блок if):</p>
-
-<pre class="brush: js">if (true)
-if ({})
-if ([])
-if (42)
-if ("0")
-if (new Date())
-if (-42)
-if (12n)
-if (3.14)
-if (-3.14)
-if (Infinity)
-if (-Infinity)
-</pre>
-
-<h2 id="Смотрите_также">Смотрите также</h2>
-
-<ul>
- <li>{{Glossary("Falsy")}}</li>
- <li>{{Glossary("Type_Conversion", "Coercion")}}</li>
- <li>{{Glossary("Boolean")}}</li>
-</ul>
-
-<div>{{QuickLinksWithSubpages("/en-US/docs/Glossary")}}</div>
diff --git a/files/ru/glossary/truthy/index.md b/files/ru/glossary/truthy/index.md
new file mode 100644
index 0000000000..e4fbdf4ef0
--- /dev/null
+++ b/files/ru/glossary/truthy/index.md
@@ -0,0 +1,47 @@
+---
+title: Истинноподобное значение
+slug: Glossary/Truthy
+tags:
+  - CodingScripting
+  - Glossary
+  - JavaScript
+---
+В {{Glossary("JavaScript")}} **истинноподобное (truthy)** значение — это значение, рассматривающиеся как `true` в {{Glossary("Boolean", "булевом")}} контексте. К истинноподобным значениям относятся любые ("Falsy", "неложноподобные")}} значения (т.е. `false`, `0`, `-0`, `0n`, `""`, `null`, `undefined` и `NaN`).
+
+В булевых контекстах {{Glossary("JavaScript")}} использует механизм {{Glossary("Type_Coercion", "приведения типов")}}.
+
+Примеры _истинноподобных_ значений в JavaScript (которые будут принудительно приведены к `true` в булевых контекстах, выполняя таким образом содержимое блока `if`):
+
+```js
+if (true)
+if ({})
+if ([])
+if (42)
+if ("0")
+if ("false")
+if (new Date())
+if (-42)
+if (12n)
+if (3.14)
+if (-3.14)
+if (Infinity)
+if (-Infinity)
+```
+
+### Оператор логического И, &&
+
+Если первый операнд истинноподобен, то [оператор логического И](/en-US/docs/Web/JavaScript/Reference/Operators/Logical_AND) вернёт второй операнд:
+
+```js
+true && "dog"
+// возвращает "dog"
+
+[] && "dog"
+// возвращает "dog"
+```
+
+## Смотрите также
+
+- {{Glossary("Falsy")}}
+- {{Glossary("Type_Coercion", "Приведение типов")}}
+- {{Glossary("Boolean")}}
diff --git a/files/ru/glossary/type_coercion/index.html b/files/ru/glossary/type_coercion/index.html
deleted file mode 100644
index 74080fad6c..0000000000
--- a/files/ru/glossary/type_coercion/index.html
+++ /dev/null
@@ -1,45 +0,0 @@
----
-title: Type coercion
-slug: Glossary/Type_coercion
-tags:
-  - Beginner
-  - Glossary
-  - JavaScript
-  - Type coercion
-  - Начинающим
-  - приведение типа
-translation_of: Glossary/Type_coercion
-original_slug: Глоссарий/Type_coercion
----
-<p>Приведение типов (type coercion) - это автоматическое или неявное преобразование значений из одного типа данных в другой (например, строки в число). <em>{{Glossary('Type conversion', 'Преобразование типа')}}</em> похоже на <em>приведение типа</em>, потому что они оба преобразуют значения из одного типа данных в другой с одним ключевым различием — <em>приведение типа</em> является неявным, тогда как преобразование типа может быть неявным или явным.</p>
-
-<h2 id="Примеры">Примеры</h2>
-
-<pre class="brush: js">const value1 = '5';
-const value2 = 9;
-let sum = value1 + value2;
-
-console.log(sum);</pre>
-
-<p>В приведённом выше примере JavaScript <em>приводит</em> число <code>9</code> в строку, а затем объединяет два значения вместе, в результате получается строка <code>59</code>. JavaScript имел выбор между строкой или числом и решил использовать строку.</p>
-
-<p>Компилятор мог привести строку <code>5</code> к числу и вернуть сумму <code>14</code>, но он этого не сделал. Чтобы получить этот результат, вам нужно явно преобразовать строку <code>5</code> в число, используя метод {{jsxref("Global_Objects/Number", "Number()")}}:</p>
-
-<pre class="brush: js">sum = Number(value1) + value2;</pre>
-
-<section id="Quick_links">
-<ol>
- <li><a href="/ru/docs/Glossary">Глоссарий</a>
-
-  <ol>
-   <li>{{Glossary("Type")}}</li>
-   <li>{{Glossary("Type conversion")}}</li>
-  </ol>
- </li>
- <li>Статьи Википедии
-  <ol>
-   <li>{{Interwiki("wikipedia", "Type conversion")}}</li>
-  </ol>
- </li>
-</ol>
-</section>
diff --git a/files/ru/glossary/type_coercion/index.md b/files/ru/glossary/type_coercion/index.md
new file mode 100644
index 0000000000..80274474a3
--- /dev/null
+++ b/files/ru/glossary/type_coercion/index.md
@@ -0,0 +1,35 @@
+---
+title: Приведение типов
+slug: Glossary/Type_coercion
+tags:
+  - Coercion
+  - JavaScript
+  - Type coercion
+---
+Приведение типов (type coercion) — это автоматическое или неявное преобразование значений из одного типа данных в другой (например, строки в число). _{{Glossary("Type conversion")}}_ похоже на _приведение типа_, потому что они оба преобразуют значения из одного типа данных в другой с одним ключевым различием — _приведение типа_ выполняется неявно, тогда как преобразование типа может быть неявным _или_ явным.
+
+## Примеры
+
+```js
+const value1 = '5';
+const value2 = 9;
+let sum = value1 + value2;
+
+console.log(sum);
+```
+
+В приведённом выше примере JavaScript _приводит_ число `9` к строке, а затем объединяет два значения вместе, в результате чего получается строка `59`. У JavaScript был выбор между строкой и числом, и в данном случае он решил приведение значение к строке.
+
+В качестве альтернативного варианта, компилятор мог привести строку `5` к числу и вернуть сумму `14`. Чтобы получить подобный результат, нужно явным образом преобразовать строку `5` в число через метод {{jsxref("Global_Objects/Number", "Number()")}} :
+
+```js
+sum = Number(value1) + value2;
+```
+
+## Смотрите также
+
+- {{Interwiki("wikipedia", "Type conversion")}} (Википедия)
+- [Глоссарий](/ru/docs/Glossary)
+
+  - {{Glossary("Type")}}
+  - {{Glossary("Type conversion")}}