<section id="description">
  <p>В циклах не обязательно счетчики увеличивать именно на <code>1</code>. Изменив наше <code>final-expression</code>,
    мы можем считать четными числами, то есть увеличивая значение сразу на <code>2</code>. Мы начнем с
    <code>i = 0</code> и будем выполнять цикл до тех пор, пока истинно условие <code>i &#x3C; 10</code> . Мы будем
    увеличивать <code>i</code> на 2 каждый цикл с <code>i += 2</code> с помощью оператора <a href="https://freecode.academy/learn/exercises/56533eb9ac21ba0edf2244af" target="_blank">+=</a> .
  <pre class="language-js"><code>const ourArray = [];

for (let i = 0; i < 10; i += 2) { 
  ourArray.push(i); 
}</code> </pre>

  В результате <code>ourArray</code> будет содержать <code>[0,2,4,6,8]</code>.</p>
</section>

Iterate Odd Numbers With a For Loop

<section id="description">
  <p>Цикл <code>for</code> также может использоваться для уменьшения значения счетчика. Ведь на самом деле нет жесткой
    привязки к тому, что условие должно быть с каким-либо счетчиком. В циклах мы можем выполнять любую логику и
    проверять любые условия.
  </p>

  <p>
    Для того, чтобы выполнить обратный отсчет значения нашей переменной, нам нужно изменить нашу
    <code>initialization</code>, чтобы задать большее число, которое будет на каждой итерации уменьшаться в
    <code>final-expression</code>. А смысл <code>condition</code> останется прежним - проверять условие на истинность.
  </p>
  <p>
    Мы начнем с <code>i = 10</code> и будем выполнять цикл до тех пор, пока условие <code>i > 0</code> истинно. Мы будем
    уменьшать <code>i</code> на 2 при каждой итерации, используя оператор <a
      href="https://freecode.academy/learn/exercises/56533eb9ac21ba0edf2244b0" target="_blank">-=</a>.
  <pre class="language-js"><code>const ourArray = [];

for (let i = 10; i > 0; i -= 2) {
  ourArray.push(i);
}</code></pre>

  В результате <code>ourArray</code> будет содержать <code>[10,8,6,4,2]</code> .
  </p>
</section>

Count Backwards With a For Loop

<section id="description">
<p>В JavaScript вы можете сохранить значение в переменной с оператором <dfn>присваивания</dfn> . <pre class="language-js"><code>myVariable = 5;</code></pre>Это присваивает значение  <code>5</code> переменной <code>myVariable</code> . Назначение всегда идет справа налево. Все, что находится справа от оператора <code>=</code> разрешается до того, как значение присваивается переменной слева от оператора. <pre class="language-js"><code>myVar = 5; 
myNum = myVar; </code></pre> 

Здесь переменной <code>myVar</code> присваивается значение <code>5</code> и затем переменной <code>myNum</code> присваивается значение переменной <code>myVar</code>. А так как переменная <code>myVar</code> содержала значение <code>5</code>, то и переменная <code>myNum</code> тоже получила значение <code>5</code>.</p></section>

Storing Values with the Assignment Operator

<section id="description">
<p>Хорошей практикой является объявление переменной вместе с инициализацией её начальным значением. Код <pre class="language-js"><code>var myVar = 0;</code></pre> создает новую переменную <code>myVar</code> и присваивает ей начальное значение <code>0</code> .</p></section>

Initializing Variables with the Assignment Operator

<section id="description">
  <p>Когда объявляются переменные JavaScript, они имеют начальное значение <code>undefined</code> . Если вы выполняете
    математическую операцию с <code>undefined</code> переменной, ваш результат будет <code>NaN</code> что означает
    <dfn>«Not a Number»</dfn> . Если вы конкатенируете строку с <code>undefined</code> переменной, вы получите буквенную
    <dfn>строку</dfn> <code>"undefined"</code> .</p>
</section>

Understanding Uninitialized Variables

<section id="description">
<p>В JavaScript все переменные и имена функций чувствительны к регистру. Это означает, что имеет значение заглавные вы буквы используете или строчные. <code>MYVAR</code> - это не то же самое, что <code>MyVar</code> и <code>myvar</code> (потому что регистр букв не совпадает). Возможно иметь несколько разных переменных с одним и тем же именем, но с другим регистром. Настоятельно рекомендуется, чтобы для ясности вы <em>не</em> использовали эту функцию языка. 
<h4> Лучшая практика </h4> 
Введите имена переменных в JavaScript в <dfn>camelCase</dfn> (так называемый "верблюжий регистр"). В <dfn>camelCase</dfn> имена переменных с несколькими словами имеют первое слово в нижнем регистре, а первая буква каждого последующего слова заглавная. <strong>Примеры:</strong> <pre class="language-js"><code>var someVariable;
var anotherVariableName;
var thisVariableNameIsSoLong; </code></pre></p>
</section>

Understanding Case Sensitivity in Variables

<section id="description">
<p>Вы можете легко <dfn>увеличить</dfn> значение перменной с помощью оператора <code>++</code>. <pre class="language-js"><code>i++;</code></pre> 
Это выражение эквивалентно выражению <code>i = i + 1;</code>

</p>

<p> <strong>Заметка</strong>: Вся строка становится <code>i++;</code> , устраняя необходимость использования оператора присваивания. Важно понять, что данная операция не просто возвращает новое значение, но и меняет значение самой переменной.
</p>


<p>
<strong>Важная информация</strong>: Два знака ++ можно ставить не только после переменной, но и перед переменной. Разница в том, что в первом случае переменная меняется, но возвращается ее старое значение, а во втором случае возвращается сразу новое значение. Вот пример, чтобы было понятней.
<pre class="language-js">
  <code>// Создаем переменную со значением 1
  var a = 1;
  a++; // Значение 1
  a === 2; // true Здесь уже значение 2, так как это уже следующая операция

  // Создаем переменную со значением 1
  var b = 1;
  ++b; // Значение 2
  b === 2; // Здесь в любом случае уже измененная переменная
</code></pre>
</p>

<p>
Все это немного запутанно, но очень важно понимать. Это будет иметь значение в момент сравнивания. Пример:

<pre class="language-js">
  <code>// Создаем переменную со значением 1
  var a = 1;
  a++ === 2; // false, так как хоть значение переменной и изменилось, в ответ мы получили ее старое значение

  // Создаем переменную со значением 1
  var b = 1;
  ++b === 2; // true, потому что здесь мы сразу получили новое значение.
</code></pre>

</p>
</section>

Increment a Number with JavaScript

<section id="description">
<p>Вы можете легко <dfn>уменьшать</dfn> или уменьшить переменную на один с <code>--</code> оператором. <code>i--;</code> эквивалентно <code>i = i - 1;</code> <strong>Заметка</strong> <br> Вся строка становится <code>i--;</code>, устраняя необходимость использования знака равенства.</p></section>

Decrement a Number with JavaScript

<section id="description">
<p>Оператор <dfn>остатка</dfn> <code>%</code> дает остаток от деления двух чисел. <strong>пример</strong> <pre class="language-js"><code>5%2 === 1; // Потому что 
Math.floor(5/2) === 2; // Частное
2 * 2 === 4;
5 - 4 === 1; // Остаток </code> </pre><strong>Применение</strong> <br> В математике число может быть проверено как четное или нечетное, проверяя остаток от деления числа на <code>2</code> . <pre class="language-js"><code>17%2 === 1; // (17 - нечетное)
48%2 === 0; // (48 четное) </code></pre> <strong>Заметка</strong> <br> Оператор <dfn>остатка</dfn> иногда некорректно называют оператором «модуль». Он очень похож на модуль, но не работает должным образом с отрицательными числами.</p></section>

Finding a Remainder in JavaScript

<section id="description">
<p>В программировании обычно используются назначения для изменения значения переменной. Помните, что при выполнении операции присвоения (то есть когда применяется знак <code>=</code>), вычисления выполняются справа налево. То есть сначала справа от знака равно все высчитывается, и только потом этот результат присваивается переменной слева от знака равно. Поэтому мы можем сказать, что выражение <code>myVar = myVar + 5;</code> добавит <code>5</code> к значению переменной <code>myVar</code> (то есть сначала справа от знака равно будет высчитана сумма значений myVar и 5, а потом полученное значение будет присвоено переменной myVar, по сути, перетерев ее старое значение). Поскольку это такая общая схема, существуют операторы, которые выполняют как математические операцию, так и назначение за один шаг. Одним из таких операторов является оператор <code>+=</code>. <pre class="language-js"><code>var myVar = 1;
myVar += 5;
console.log(MyVar); // Выведет 6 </code></pre></p>
</section>

Compound Assignment With Augmented Addition

<section id="description">
<p>Как и оператор <code>+=</code> , <code>-=</code> вычитает число из переменной. <pre class="language-js"><code>myVar = myVar - 5;</code></pre> вычитает <code>5</code> из <code>myVar</code>. Это можно переписать как: <pre class="language-js"><code>myVar -= 5;</code></pre></p>
</section>

Compound Assignment With Augmented Subtraction

<section id="description">
<p>Оператор <code>*=</code> умножает переменную на число. <pre class="language-js"><code>myVar = myVar * 5;</code></pre> умножит <code>myVar</code> на <code>5</code> . Это можно переписать как: <pre class="language-js"><code>myVar *= 5;</code></pre></p>
</section>

Compound Assignment With Augmented Multiplication

<section id="description">
<p>Оператор <code>/=</code> делит переменную на другое число. <pre class="language-js"><code>myVar = myVar / 5;</code> </pre><code>myVar</code> на <code>5</code> . Это можно переписать как: <pre class="language-js"><code>myVar /= 5;</code></pre></p>
</section>

Compound Assignment With Augmented Division

<section id="description">
<p>Алгоритм преобразования от Цельсия в Фаренгейт - это температура в градусах Цельсия <code>9/5</code> и плюс <code>32</code> . Вам дается переменная <code>celsius</code> представляющая температуру в градусах Цельсия. Используйте переменную <code>fahrenheit</code> уже определена, и назначьте ей температуру Фаренгейта, эквивалентную заданной температуре Цельсия. Используйте вышеупомянутый алгоритм, чтобы помочь преобразовать температуру Цельсия в Фаренгейт. Не беспокойтесь слишком много о функциях и заявлениях о возврате, поскольку они будут рассмотрены в будущих задачах. Пока что используйте только те операторы, которые вы уже узнали.</p></section>

Convert Celsius to Fahrenheit

<section id="description">
<p>Значения <dfn>строк</dfn> в JavaScript могут быть записаны с одинарными или двойными кавычками, если вы начинаете и заканчиваете одним и тем же типом кавычек. В отличие от некоторых других языков программирования одиночные и двойные кавычки работают одинаково в JavaScript. <pre class="language-js"><code>const doubleQuoteStr = "Это строка";
const singleQuoteStr = 'Это также строка'; </code></pre> Причина, по которой вы, возможно, захотите использовать один тип кавычек вместе с другими, - это если вы хотите использовать оба в строке.<pre class="language-js"><code> const conversation = 'Finn exclaims to Jake, "Algebraic!"';</code></pre> Однако это становится проблемой, если вам нужно использовать внешние кавычки внутри строки. Помните, что строка должна иметь одинаковые кавычки в начале и в конце. Но если у вас есть такая же кавычка где-то посередине, строка закончится раньше и выкинет ошибку. <pre class="language-js"><code>const goodStr = 'Jake asks Finn, "Hey, let\'s go on an adventure?"';
const badStr = 'Finn responds, "Let's go!"'; // Выдает ошибку </code></pre> В <dfn>goodStr</dfn> выше вы можете безопасно использовать обе кавычки, используя обратную косую черту <code>\</code> в качестве escape-символа (экранирующего символа). 
</p>
<p>
<strong>Заметка</strong> <br> Обратную косую черту <code>\</code> не следует путать с прямой косой чертой <code>/</code>. Они не делают то же самое.</p></section>

Quoting Strings with Single Quotes

<section id="description">
<p>Когда вы определяете строку, вы должны начинать и заканчивать строку кавычками. Что происходит, когда вам нужна двойная  <code>"</code> или одиночная <code>'</code> кавычка внутри вашей строки? В JavaScript вы можете <dfn>экранировать</dfn> кавычку, помещая <dfn>обратную косую черту</dfn> ( <code>\</code> ) перед ней. <pre class="language-js"><code>var sampleStr = "Alan said, \"Peter is learning JavaScript\".";</code></pre> Это сигнализирует JavaScript, что следующая кавычка не является концом строки, а просто часть строки. Поэтому, если вы попробуете вывести это в консоли, вы получите: <code>Alan said, "Peter is learning JavaScript".</code></p>
</section>

Escaping Literal Quotes in Strings

<section id="description">
<p>Кавычки не являются единственными символами, которые могут быть <dfn>экранированы</dfn> внутри строки. Существует две причины использования экранирующих символов: во-первых, чтобы вы могли использовать символы, которые вы в противном случае не могли бы вывести, например, backspace. Во-вторых, вы можете представить несколько кавычек в строке без неправильного толкования JavaScript, что вы имеете в виду. Мы узнали об этом в предыдущей задаче. <table class="table table-striped"><thead><tr><th> Код </th><th> Вывод </th></tr></thead><tbody><tr><td> <code>\'</code> </td> <td> одиночная цитата </td></tr><tr><td> <code>\"</code> </td> <td> двойная цитата </td></tr><tr><td> <code>\\</code> </td> <td> обратный слэш </td></tr><tr><td> <code>\n</code> </td> <td> новая линия </td></tr><tr><td> <code>\r</code> </td> <td> возврат каретки </td></tr><tr><td> <code>\t</code> </td> <td> табуляция </td></tr><tr><td> <code>\b</code> </td> <td> возврат на одну позицию (backspace) </td></tr><tr><td> <code>\f</code> </td> <td> форма </td></tr></tbody></table> <em>Обратите внимание, что обратная косая черта должна быть экранирована, чтобы отображать ее как обратную косую черту.</em></p>
</section>

Escape Sequences in Strings

<section id="description">
<p>В JavaScript, когда оператор <code>+</code> используется со строкой, он называется оператором <dfn>конкатенации</dfn> и выполняет функцию объединения строк. Вы можете создать новую строку из других строк путем <dfn>конкатенации</dfn> их вместе. <strong>Пример</strong> <pre class="language-js"><code> "Меня зовут Алан," + " я конкатенирую". </code></pre> <strong>Заметка</strong> <br> Следите за пробелами. Конкатенация не добавляет пробелов между конкатенированными строками, поэтому вам нужно будет добавить их самостоятельно внутри кавычек.</p></section>

Concatenating Strings with Plus Operator

<section id="description">
<p>Мы также можем использовать оператор <code>+=</code> для <dfn>конкатенации</dfn> строки в конец существующей строковой переменной. Это может быть очень полезно для разбиения длинной строки на несколько строк. <strong>Заметка</strong> <br> Следите за пробелами. Конкатенация не добавляет пробелов между конкатенированными строками, поэтому вам нужно будет добавить их самостоятельно.</p></section>

Concatenating Strings with the Plus Equals Operator

<section id="description">
<p>Иногда вам нужно будет создать строку в стиле <a href="https://en.wikipedia.org/wiki/Mad_Libs" target="_blank">Mad Libs</a>. Используя оператор конкатенации ( <code>+</code> ), вы можете вставить одну или несколько переменных в строку, которую вы формируете.</p></section>

Constructing Strings with Variables

<section id="description">
<p>В JavaScript значения строк <dfn>неизменяемы</dfn>, а это значит, что они не могут быть изменены после создания. Например, следующий код: <pre class="language-js"><code>var myStr = "Bob";
myStr[0] = "J"; </code></pre> не может изменить значение <code>myStr</code> на «Job», потому что содержимое <code>myStr</code> не может быть изменено. Обратите внимание, что это <em>не</em> означает, что значение переменной <code>myStr</code> нельзя изменить. Нельзя изменить именно отдельные символы строки. Но можно изменить в целом значение переменной <code>myStr</code>, если присвоить ей новое значение, например: <pre class="language-js"><code>var myStr = "Bob";
myStr = "Job"; </code></pre></p>
</section>

Understand String Immutability

<section id="description">
<p>Теперь мы будем использовать наши знания объектов типа <code>String</code> для создания словесной игры <a href="https://en.wikipedia.org/wiki/Mad_Libs" target="_blank">Mad Libs</a>, которую мы назовем «Word Blanks». Вы создадите (возможно, юмористическое) предложение стиля «Заполнить пробелы. В игре «Mad Libs» вам предоставляются предложения с некоторыми пропущенными словами, такими как существительные, глаголы, прилагательные и наречия. Затем вы заполняете недостающие части словами по вашему выбору так, чтобы законченное предложение имело смысл. 
Рассмотрите это предложение: <code>It was really ____, and we ____ ourselves ____</code>. 
В этом предложении есть три недостающих фрагмента: прилагательное, наречие и глагол, и мы можем добавить слова по нашему выбору, чтобы завершить его. Затем мы можем назначить заполненное предложение переменной следующим образом: <pre class="language-js"><code>const sentence = "It was really " + "hot" + ", and we " + "laughed" + " ourselves " + "silly" + ".";</code></pre></p>
</section>

Word Blanks

<section id="description">
<p>Создайте список покупок в переменной <code>myList</code>. Список должен быть многомерным массивом, содержащим несколько подмассивов. Первый элемент в каждом подмассиве должен содержать строку с именем элемента. Второй элемент должен быть числом, представляющим количество, например <code>["Chocolate Bar", 15]</code> В списке должно быть не менее 5 подмассивов.</p></section>

Shopping List

<section id="description">
<p><dfn>Параметры</dfn> (или аргументы) - это переменные, которые действуют как заполнители для значений, которые должны быть введены в функцию при ее вызове. Когда функция определена, она обычно определяется вместе с одним или несколькими параметрами. Фактические значения, которые вводятся (или <dfn>«переданы»</dfn> ) в функцию при ее вызове, называются <dfn>аргументами</dfn> . Вот функция с двумя аргументами <code>param1</code> и <code>param2</code> : <pre class="language-js"><code>function testFun(param1, param2) {
  console.log(param1, param2);
}</code> </pre>
Затем мы можем вызвать функцию <code>testFun</code> с передачей в нее аргументов: <pre class="language-js"><code>testFun("Hello", "World");</code></pre>
Мы передали два аргумента: <code>"Hello"</code> и <code>"World"</code>. Внутри функции <code>param1</code> будет равен "Hello", а <code>param2</code> будет равен "World". Обратите внимание, что вы можете снова вызвать <code>testFun</code> с другими аргументами, и параметры будут принимать значение новых аргументов.</p></section>

Passing Values to Functions with Arguments

<section id="description">
<p>В JavaScript <dfn>область видимости</dfn> относится к видимости переменных. Переменные, определенные вне функционального блока, имеют <dfn>глобальную</dfn> область. Это означает, что их можно увидеть везде в вашем JavaScript-коде. Переменные, которые используются без ключевого слова <code>var</code>, автоматически создаются в глобальной области видимости. Это может привести к непредвиденным последствиям в другом месте вашего кода или при повторном запуске функции. Вы всегда должны объявлять переменные с помощью <code>var</code>, <code>let</code> или <code>const</code> в зависимости от ситуации.</p></section>

Global Scope and Functions

<section id="description">
<p>Переменные, объявленные внутри функции, а также параметры функции имеют <dfn>локальную</dfn> область видимости. Это означает, что они видны только внутри этой функции. Вот функция <code>myTest</code> с локальной переменной <code>loc</code> . <pre class="language-js"><code>function myTest () {
  var loc = "foo";
  console.log(loc);
}
myTest (); // logs "foo"
console.log(loc); // Error: loc не определен </code></pre> 

<code>loc</code> не определяется вне функции.</p></section>

Local Scope and Functions

<section id="description">
<p>Можно иметь как <dfn>локальные</dfn>, так и <dfn>глобальные</dfn> переменные с тем же именем. Когда вы это делаете, <code>локальная</code> переменная имеет приоритет над <code>глобальной</code> переменной. В этом примере: <pre class="language-js"><code>var someVar = "Hat";

function myFun() {
  var someVar = "Head";
  return someVar;
}

myFun(); // Head
</code></pre> функция <code>myFun</code> вернет <code>"Head"</code> потому что присутствует локальная версия переменной.</p></section>

Global vs. Local Scope in Functions

<section id="description">
<p>Мы можем передавать значения в функцию с <dfn>аргументами</dfn> . Вы можете использовать оператор <code>return</code> чтобы вернуть результат выполнения функции. <strong>Пример</strong> <pre class="language-js"><code>function plusThree(num) {
  return num + 3;
}
var answer = plusThree(5); // 8 </code></pre> 

<code>plusThree</code> принимает <dfn>аргумент</dfn>  <code>num</code> и возвращает значение, равное <code>num + 3</code>.</p></section>

Return a Value from a Function with Return

<section id="description">
<p>Если вы вспомните из нашего обсуждения <a href="https://freecode.academy/learn/exercises/56533eb9ac21ba0edf2244a8" target="_blank">Сохранение значений с помощью оператора назначения</a>, все, что находится справа от знака равенства, будет выполнено до присвоения значения. Это означает, что мы можем взять возвращаемое значение функции и присвоить ее переменной. Предположим, что мы предварительно определили функцию <code>sum</code>, которая суммирует два числа и возвращает их значение. <pre class="language-js"><code>ourSum = sum(5, 12);</code></pre> 

При вызове функция <code>sum</code> вернет значение <code>17</code> и это значение мы можем присвоить переменной <code>ourSum</code>.</p></section>

Assignment with a Returned Value

<section id="description">
<p>Когда оператор <code>return</code> достигнут, выполнение текущей функции прекращается, и управление возвращается в вызывающее местоположение. <strong>Пример</strong> 
<pre class="language-js"><code>function myFun() {
  console.log("Hello");
  return "World";
  console.log("byebye")
}
myFun();</code></pre> 

При вызове функции <code>myFun</code> в консоль будет выведено "Hello", а вот "byebye" никогда не будет выполнено, потому что оператор return возвращает результат выполнение функции и дальнейшее выполнение кода функции прерывается. То есть до строки <code>console.log("byebye")</code> выполнение кода просто никогда не дойдет.</p></section>

Return Early Pattern for Functions

<section id="description">
<p>В информатике <dfn>очередь</dfn> представляет собой абстрактную <dfn>структуру данных, в</dfn> которой элементы хранятся в определенном порядке. Новые элементы могут быть добавлены в конец <code>очереди</code>, а старые элементы извлекаются из начала <code>очереди</code>.</p></section>

Stand in Line

<section id="description">
<p>Есть два способа доступа к свойствам объекта: dot notation (через точку <code>.</code>) and bracket notation (через квадратные скобки <code>[]</code>, как в случае с массивами).</p>

<p>Точку вы используете тогда, когда заранее знаете имя свойства, к которому хотите обратиться.</p>

<p>Вот пример того, как обратиться к свойству объекта, используя точку:</p><p><pre><code class="language-js">var myObj = {
  prop1: "val1",
  prop2: "val2"
};
var prop1val = myObj.prop1; // val1
var prop2val = myObj.prop2; // val2
</code></pre></p>
</section>

Accessing Object Properties with Dot Notation

<section id="description">
  <p>Второй способ доступа к свойствам объекта - это скобочная нотация ( <code>[]</code> ). Если свойство объекта, к
    которому вы пытаетесь получить доступ, имеет пробел в своем имени, вам нужно будет использовать нотацию в виде
    скобок. Тем не менее, вы все равно можете использовать точечную нотацию для доступа к свойствам без пробелов.</p>
  <p>Ниже приведен пример использования скобок для чтения свойства объекта:
  <pre class="language-js"><code>const myObj = {
"Space Name": "Kirk",
"More Space": "Spock",
"NoSpace": "USS Enterprise"
};

myObj["Space Name"];
myObj['More Space'];
myObj["NoSpace"];</code></pre>
  Обратите внимание, что имена свойств с пробелами в них должны быть в кавычках (одинарных или двойных).</p>
</section>

Accessing Object Properties with Bracket Notation

<section id="description">
<p>Еще одно использование скобочной нотации для объектов - это доступ к свойству, которое хранится как значение переменной. Это может быть очень полезно для итерации через свойства объекта или при доступе к поисковой таблице. Ниже приведен пример использования переменной для доступа к свойству: <pre class="language-js"><code>const dogs = {
  Fido: "Mutt",
  Hunter: "Doberman",
  Snoopie: "Beagle"
};

const myDog = "Hunter";
const myBreed = dogs[myDog];
console.log(myBreed);</code> </pre>

Другой способ использования этой концепции - это формирование имени свойства динамически во время выполнения программы. Пример: <pre class="language-js"><code>const someObj = {
  propName: "John"
};

function propPrefix(str) {
  const s = "prop";
  return s + str;
}

const someProp = propPrefix("Name"); // return "propName"
console.log(someObj[someProp]);</code> </pre>

</p>

<p>
Или вот так:
<pre class="language-js"><code>const someObj = {
  propName: "John"
};
const someProp = "prop" + "Name"; // return "propName"
console.log(someObj[someProp]);</code> </pre>

Обратите внимание, что мы <em>не</em> используем кавычки вокруг имени переменной при ее использовании для доступа к свойству (что делало бы переменную не переменной, а простой строкой), потому что мы используем <em>значение</em> переменной, а не <em>имя</em>.</p></section>

Accessing Object Properties with Variables

<section id="description">
  <p>Объекты можно рассматривать как хранилище ключей / значений, например как словарь. Если у вас есть табличные
    данные, вы можете использовать для «поиска» объект, а не оператор <code>switch</code> или цепочки
    <code>if/else</code>. Это наиболее полезно, когда вы знаете, что ваши входные данные ограничены определенным
    диапазоном. Вот пример простого обратного алфавитного поиска:
  <pre class="language-js"><code>const alpha = {
  1:"Z",
  2:"Y",
  3:"X",
  4:"W",
  // ...
  24:"C",
  25:"B",
  26:"A"
};

alpha[2]; // Y
alpha[24]; // C

const value = 2;
alpha[value]; // Y</code></pre>
  </p>
</section>

Using Objects for Lookups

<section id="description">
  <p>Иногда вы можете хотеть хранить данные в гибкой <dfn>структуре данных</dfn>. Объект JavaScript - это один из
    способов обработки гибких данных. Они допускают произвольные комбинации <dfn>строк</dfn> , <dfn>чисел</dfn>,
    <dfn>булевых</dfn> , <dfn>массивов</dfn>, <dfn>функций</dfn> и <dfn>объектов</dfn>. Вот пример сложной структуры
    данных:
  <pre class="language-js"><code>const ourMusic = [
  {
    "artist": "Daft Punk",
    "title": "Homework",
    "release_year": 1997,
    "formats": [
      "CD",
      "Cassette",
      "LP"
    ],
    "gold": true
  }
];</code></pre>
  Это массив, содержащий один объект внутри. Объект имеет различные фрагменты <dfn>метаданных</dfn> об альбоме. Он
  также имеет вложенный массив <code>formats</code> . Если вы хотите добавить больше записей альбомов, вы можете
  сделать это, добавив записи в массив верхнего уровня. Объекты хранят данные в свойстве, которое имеет формат ключа.
  В приведенном выше примере <code>"artist": "Daft Punk"</code> - это свойство, которое имеет ключ
  <code>artist</code> и значение <code>Daft Punk</code> . <a href="http://www.json.org/" target="_blank">JavaScript Object Notation</a> или <code>JSON</code> - это специальный формат данных, разработанный для хранения объектов, массивов, чисел, строк, булевых и null-значений.
  <pre class="language-js"><code>{
  "artist": "Daft Punk",
  "title": "Homework",
  "release_year": 1997,
  "formats": [
    "CD",
    "Cassette",
    "LP"
  ],
  "gold": true
}</code></pre> <strong>Заметка</strong> <br> Каждый элемент массива должен быть разделен знаком запятой.
  </p>
</section>

Manipulating Complex Objects

<section id="description">
  <p>Доступ к вложенным объектам можно получить, объединяя несколько элементов в точечной или блочной нотации. Вот
    многоуровневый объект:
  <pre class="language-js"><code>const ourStorage = {
  "desk": {
  "drawer": "stapler"
  },
  "cabinet": {
  "top drawer": {
  "folder1": "a file",
  "folder2": "secrets"
  },
  "bottom drawer": "soda"
  }
  };
  
  ourStorage.cabinet["top drawer"].folder2;
  ourStorage.desk.drawer;</code></pre>
  </p>

  <p>
    <code>ourStorage.cabinet["top drawer"].folder2</code> вернет строковое значение <code>secrets</code>, а <code>ourStorage.desk.drawer</code> вернет строковое <code>stapler</code>.
  </p>
  <p>Как вы наверняка заметили, через каждую точечную или скобочную нотацию мы как бы "проваливаемся" вглубь объекта, проходя через нужные нам свойства объекта (проходя и другие вложенные в него свойства-объекты).</p>
</section>

Accessing Nested Objects

<section id="description">
  <p>Как мы видели в предыдущих примерах, объекты могут содержать как вложенные объекты, так и вложенные массивы.
    Подобно доступу к вложенным объектам, нотация матричного массива может быть использована для доступа к вложенным
    массивам. Ниже приведен пример доступа к вложенному массиву:
  <pre class="language-js"><code>const ourPets = [
  {
    animalType: "cat",
    names: [
      "Meowzer",
      "Fluffy",
      "Kit-Cat"
    ]
  },
  {
    animalType: "dog",
    names: [
      "Spot",
      "Bowser",
      "Frankie"
    ]
  }
];

ourPets[0].names[1]; // Fluffy
ourPets[1].names[0]; // Spot</code></pre>
  </p>
</section>

Accessing Nested Arrays

<section id="description">
  <p>Вам предоставляется объект JSON, представляющий часть вашей коллекции музыкальных альбомов. Каждый альбом имеет
    несколько свойств и уникальный идентификационный номер в качестве ключа. Не все альбомы имеют полную информацию.
    </p>
</section>

Record Collection

<section id="description">
<p>В JavaScript есть много <dfn>операторов сравнения</dfn>. Все эти операторы возвращают логическое значение <code>true</code> или <code>false</code>. Основным оператором равенства является оператор <code>==</code> . Оператор равенства сравнивает два значения и возвращает <code>true</code> если они эквивалентны или <code>false</code> если они не эквивалентны. Обратите внимание, что равенство отличается от присваивания ( <code>=</code> ), которое присваивает значение справа от оператора переменной в левой части. <pre class="language-js"><code>function equalityTest(myVal) {
  if (myVal == 10) {
    return "Equal";
  }
  return "Not Equal";
}</code></pre> 

Если <code>myVal</code> равно <code>10</code>, оператор равенства возвращает <code>true</code> , поэтому код в фигурных скобках будет выполняться, и функция вернет <code>"Equal"</code>. В противном случае функция вернет <code>"Not Equal"</code>. Чтобы JavaScript мог сравнивать значения разных <code>типов данных</code> (например, <code>Number</code> и <code>String</code> ), он должен преобразовывать один тип в другой. Это называется «Типовое принуждение». Однако, как только это произойдет, он может сравнить их следующим образом: <pre class="language-js"><code>1 == 1 // true
1 == 2 // false
1 == '1' // true
"3" == 3 // true 
</code></pre></p>
</section>

Comparison with the Equality Operator

<section id="description">
<p>Строгое равенство ( <code>===</code> ) является аналогом оператора равенства ( <code>==</code> ). Однако, в отличие от оператора равенства, который пытается преобразовать оба значения в общий тип, строгий оператор равенства не выполняет преобразование типа. Если сравниваемые значения имеют разные типы, они считаются неравными, а оператор строгого равенства возвращает false. <strong>Примеры</strong> <pre class="language-js"><code>3 === 3 // true
3 === '3' // false </code> </pre>
Во втором примере <code>3</code> является типом <code>Number</code> (число), а <code>'3'</code> - <code>String</code> (строка).</p></section>

Comparison with the Strict Equality Operator

<section id="description">
<p>Оператор неравенства ( <code>!=</code> ) Является противоположным оператору равенства. Это означает «Не равно» и возвращает <code>false</code> когда равенство вернет <code>true</code> и <em>наоборот</em> . Как и оператор равенства, оператор неравенства будет преобразовывать типы данных значений при сравнении. <strong>Примеры</strong> <pre class="language-js"><code>1 != 2 // true
1 != "1" // false
1 != '1' // false
1 != true // false
0 != false // false </code></pre></p>
</section>

Comparison with the Inequality Operator

<section id="description">
<p>Оператор строгого неравенства ( <code>!==</code> ) является логической противоположностью оператора строгого равенства. Это означает «строго не равно» и возвращает <code>false</code> когда строгое равенство вернет <code>true</code> и <em>наоборот</em> . Строгое неравенство не будет преобразовывать типы данных. <strong>Примеры</strong> <pre class="language-js"><code>3 !== 3 // false
3 !== '3' // true
4 !== 3 // true </code></pre></p>
</section>

Comparison with the Strict Inequality Operator

<section id="description">
<p>Оператор "Больше чем" ( <code>></code> ), сравнивает значения двух чисел. Если число слева больше числа справа, оно возвращает <code>true</code>. В противном случае возвращается <code>false</code>. Как и оператор равенства, оператор "Больше чем", преобразует типы данных при сравнении. <strong>Примеры</strong> <pre class="language-js"><code>5 > 3 // true
7 > '3' // true
2 > 3 // false
'1' > 9 // false </code></pre></p>
</section>

Comparison with the Greater Than Operator

<section id="description">
<p>При использовании оператора <code>Больше либо равно</code> ( <code>>=</code> ) сравниваются значения двух чисел. Если число слева больше или равно числу справа, возвращается <code>true</code>. В противном случае возвращается <code>false</code>. Подобно оператору равенства, оператор <code>Больше либо равно</code> будет преобразовывать типы данных при сравнении. <strong>Примеры</strong> <pre class="language-js"><code>6 >= 6 // true
7 >= '3' // true
2 >= 3 // false
'7' >= 9 // false </code></pre></p>
</section>

Comparison with the Greater Than Or Equal To Operator

<section id="description">
<p>Оператор <code>Меньше чем</code> ( <code>&#x3C;</code> ) сравнивает значения двух чисел. Если число слева меньше числа справа, оно возвращает <code>true</code>. В противном случае возвращается <code>false</code>. Как и оператор равенства, оператор <dfn>Меньше, чем</dfn> преобразует типы данных при сравнении. <strong>Примеры</strong> <pre class="language-js"><code> 2 &#x3C; 5 // true
'3' &#x3C; 7 // true
5 &#x3C; 5 // false
3 &#x3C; 2 // false
'8' &#x3C; 4 // false </code></pre></p>
</section>

Comparison with the Less Than Operator

<section id="description">
<p>Оператор <code>Меньше либо равно</code> ( <code>&#x3C;=</code> ) сравнивает значения двух чисел. Если число слева меньше или равно числу справа, выражение возвращает <code>true</code>. В противном случае возвращает <code>false</code>. Так же как и оператор равенства, <code>Меньше либо равно</code> преобразует типы данных. <strong>Примеры</strong> <pre class="language-js"><code>4 &#x3C;= 5 // true
'7' &#x3C;= 7 // true
5 &#x3C;= 5 // true
3 &#x3C;= 2 // false
'8' &#x3C;= 4 // false </code></pre></p>
</section>

Comparison with the Less Than Or Equal To Operator

<section id="description">
<p>Иногда вам нужно проверять несколько условий одновременно. Логический оператор <code>И</code> ( <code>&#x26;&#x26;</code> ) возвращают <code>true</code> тогда и только тогда, когда <dfn>операнды</dfn> слева и справа от него являются истинными. Тот же эффект может быть достигнут путем вложения выражения <code>if</code> внутри другого <code>if</code> 

<pre class="language-js"><code>if (num > 5) {
  if (num < 10) { 
    return "Yes" ; 
  } 
} 
// else
return "No" ;</code></pre>
 будет возвращаться true только тогда, когда <code>num</code> больше <code>5</code> и меньше <code>10</code>. Та же логика может быть записана как: <pre class="language-js"><code>if (num > 5 && num < 10) { 
  return "Yes"; 
} 
// else
return "No";</code></pre></p>
</section>

Comparisons with the Logical And Operator

<section id="description">
<p>Логический оператор <code>Или</code> ( <code>||</code> ) возвращает <code>true</code> если любой из <dfn>операндов</dfn> равен <code>true</code>. В противном случае возвращается <code>false</code> . Логический оператор <code>Или</code> состоит из двух символов вертикальной черты ( <code>||</code> ). Обычно это можно найти рядом с клавишами Backspace и Enter. Нижеприведенный пример должен выглядеть знакомым с предыдущих уроков: <pre class="language-js"><code>if (num > 10) {
  return "No";
}
if (num < 5) { 
  return "No"; 
} 
// else
return "Yes";</code></pre> 
вернет "Yes" только в том случае, если значение <code>num</code> находится между <code>5</code> и <code>10</code> (включая 5 и 10). Та же логика может быть записана как: <pre class="language-js"><code>if (num > 10 || num < 5) { 
  return "No"; 
} return "Yes";</code></pre></p>
</section>

Comparisons with the Logical Or Operator

<section id="description">
<p>Когда условие для оператора <code>if</code> истинно, выполняется блок кода после него. Как насчет того, когда это условие ложно? Обычно ничего не происходило. С помощью инструкции <code>else</code> может выполняться альтернативный блок кода. <pre class="language-js"><code>if (num > 10) {
  return "Bigger than 10";
} else {
  return "10 or Less";
}</code></pre></p>
</section>

Introducing Else Statements

<section id="description">
<p>Если у вас есть несколько условий, которые необходимо учесть последовательно и в зависимости от результата предыдущих проверок, вы можете связать несколько инструкций <code>if</code> с помощью инструкции <code>else if</code> . <pre class="language-js"><code>if (num > 15) {
  return "Bigger than 15";
} 
else if (num < 5) { 
  return "Smaller than 5"; 
} 
else { 
  return "Between 5 and 15"; 
}</code></pre></p>
</section>

Introducing Else If Statements

<section id="description">
<p>Несколько условий <code>else if</code> могут быть объединены вместе для сложной логики. Пример 
<pre class="language-js"><code>if (condition1) {
  statement1
} else if (condition2) {
  statement2
} else if (condition3) {
  statement3
} 
// . . .
else {
  statementN
}</code></pre>
</p>
</section>

Chaining If Else Statements

<section id="description">
<p>Если у вас есть много вариантов на выбор, используйте оператор <code>switch</code>. Оператор <code>switch</code> проверяет значение и может иметь множество операторов <code>case</code>, которые определяют различные возможные значения. Условия выполняются из первого совпадающего значения <code>case</code> до тех пор, пока не будет обнаружен оператор <code>break</code> (хотя он и не обязателен и может вовсе отсутствовать). 
Пример:
<pre class="language-js"><code>switch(lowercaseLetter) {
  case "a":
    console.log("A");
    break;
  case "b":
    console.log("B");
    break;
}</code></pre> 

Условия <code>case</code> проверяются со строгим равенством ( <code>===</code>). Оператор <code>break</code> указывает JavaScript, что следует прекратить все дальнейшие проверки. Если <code>break</code> отсутствует, будет выполнен следующий оператор.</p></section>

Selecting from Many Options with Switch Statements

<section id="description">
<p>В операторе <code>switch</code> может быть нецелесообразно указывать все возможные значения в качестве операторов <code>case</code> (их может быть просто очень много). Вместо этого вы можете добавить оператор <code>default</code>, который будет выполняться, если не найдено совпадающих операторов <code>case</code>. Думайте об этом как о финальном <code>else</code> утверждении в конструкциях <code>if/else</code>. Оператор <code>default</code> должен быть последним условием. Пример <pre class="language-js"><code>switch (num) {
  case value1:
    statement1;
    break;
  case value2:
    statement2;
    break;
    // ...
  default:
    defaultStatement;
    break; // Здесь break не обязателен, но пользовательские средства проверки кода могут ругаться на его отсутствие
}</code></pre></p>
</section>

Adding a Default Option in Switch Statements

<section id="description">
<p>Если в конструкции <code>switch</code> оператор <code>break</code> не указан в операторе <code>case</code>, следующий(ие) оператор(ы) <code>case</code> выполняются до тех пор, пока не будет обнаружен <code>break</code> или конец конструкции <code>switch</code>. Если у вас несколько вхождений с одним и тем же выходом, вы можете представить их в инструкции <code>switch</code> следующим образом: <pre class="language-js"><code>let result = "";
switch(val) {
  case 1:
  case 2:
  case 3:
    result = "1, 2, or 3";
    break;
  case 4:
    result = "4 alone";
}</code> </pre>
Случаи для 1, 2 и 3 будут давать одинаковый результат.</p></section>

Multiple Identical Options in Switch Statements

<section id="description">
<p>Если у вас есть много вариантов на выбор, оператор <code>switch</code> может быть проще писать, чем множество условий <code>if</code> / <code>else if</code>. Например: <pre class="language-js"><code>if (val === 1) {
  answer = "a";
} else if (val === 2) {
  answer = "b";
} else {
  answer = "c";
}</code></pre> <br />
можно заменить на: <pre class="language-js"><code>switch(val) {
  case 1:
    answer = "a";
    break;
  case 2:
    answer = "b";
    break;
  default:
    answer = "c";
}</code></pre></p>
</section>

Replacing If Else Chains with Switch

<section id="description">
  <p>Если у вас многомерный массив, вы можете использовать ту же логику циклов <code>for</code>, чтобы перечислить
    массив и все дочерние массивы второго уровня этого массива.

    Вот пример:
  <pre class="language-js"><code>const arr = [
  [1, 2], 
  [3, 4], 
  [5, 6]
];

for (let i = 0; i < arr.length; i++) { 
  for (let j=0; j < arr[i].length; j++) { 
    console.log(arr[i][j]); 
  } 
}</code></pre>
  Это выводит каждый подэлемент в <code>arr</code> по одному за раз.
  </p>
  <p>
    Обратите внимание, что для внутреннего цикла мы проверяем <code>.length</code> элемента <code>arr[i]</code> , так как
    <code>arr[i]</code> сам является массивом.</p>
</section>

Nesting For Loops

<section id="description">
<p>Одним из простейших и наиболее широко известных <dfn>шифров</dfn> является <code>Caesar cipher</code> , также известный как <code>shift cipher</code> . В <code>shift cipher</code> значения букв сдвигаются на некоторую установленную величину. Обычным современным использованием является шифр <a href="https://en.wikipedia.org/wiki/ROT13" target="_blank">ROT13</a> , где значения букв сдвигаются на 13 мест. Таким образом, «A» ↔ 'N', 'B' ↔ 'O' и т. Д. Напишите функцию, которая берет строку с кодировкой <a href="https://en.wikipedia.org/wiki/ROT13" target="_blank">ROT13 в</a> качестве входных данных и возвращает декодированную строку. Все буквы будут заглавными. Не трансформируйте неалфавитный символ (т.е. пробелы, знаки препинания), но передайте их. Не забудьте использовать <a href="https://www.freecodecamp.org/forum/t/how-to-get-help-when-you-are-stuck-coding/19514" target="_blank">Read-Search-Ask,</a> если вы застряли. Попробуйте подключить программу. Напишите свой собственный код.</p></section>

Caesars Cipher

<section id="description">
<p>Так же, как мы можем построить строку из нескольких строк из строковых <dfn>литералов</dfn>, мы также можем добавить переменные в строку, используя оператор plus equals ( <code>+=</code> ).</p></section>

Appending Variables to Strings

<section id="description">
<p>Один из способов думать о <dfn>многомерном</dfn> массиве - это <em>массив массивов</em> . Когда вы используете скобки для доступа к вашему массиву, первый набор скобок ссылается на записи в массиве внешнего (первого уровня), а каждая дополнительная пара скобок ссылается на следующий уровень записей внутри массива. <strong>Пример</strong> <pre class="language-js"><code>var arr = [
  [1,2,3],
  [4,5,6],
  [7,8,9],
  [[10,11,12], 13, 14]
]; 
arr[3]; // равно [[10,11,12], 13, 14]
arr[3][0]; // равно [10,11,12]
arr[3][0][1]; // равно 11</code></pre> </p></section>

Access Multi-Dimensional Arrays With Indexes

<section id="description">
  <p>В игре Blackjack в казино игрок может получить преимущество над домом, отслеживая относительное количество высоких
    и низких карт, оставшихся в колоде. Это называется <a href="https://en.wikipedia.org/wiki/Card_counting"
      target="_blank">подсчет карт</a> . Наличие более высоких карт, оставшихся в колоде, способствует игроку. Каждой
    карте присваивается значение в соответствии с приведенной ниже таблицей. Когда счет положителен, игрок должен делать
    ставки на высокий уровень. Когда счетчик равен нулю или отрицателен, игрок должен делать ставки на низком уровне.
  <table class="table table-striped">
    <thead>
      <tr>
        <th> Изменить счет </th>
        <th> Карты </th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td> +1 </td>
        <td> 2, 3, 4, 5, 6 </td>
      </tr>
      <tr>
        <td> 0 </td>
        <td> 7, 8, 9 </td>
      </tr>
      <tr>
        <td> -1 </td>
        <td> 10, 'J', 'Q', 'K', 'A' </td>
      </tr>
    </tbody>
  </table> 
  </p>
</section>

Counting Cards

<section id="description">
  <p>В игре в <a href="https://en.wikipedia.org/wiki/Golf" target="_blank">гольф</a> каждая лунка имеет <code>par</code>
    (номинал), означающее среднее число <code>strokes</code> (ударов), выполнить которые предположительно необходимо
    игроку, чтобы выиграть игру. В зависимости от того, насколько выше или ниже <code>par</code> количества
    <code>strokes</code> игрока, результату присваивается то или иное прозвище.</p>
</section>

Golf Code

<section id="description">
<p>Общей задачей в JavaScript является итерация содержимого массива. Один из способов сделать это - цикл <code>for</code> . Этот код выводит каждый элемент массива <code>arr</code> на консоль: 
<pre class="language-js"><code>const arr = [10, 9, 8, 7, 6];

for (let i = 0; i < arr.length; i++) { 
  console.log(arr[i]); 
}</code></pre>

 Помните, что массивы имеют нулевую нумерацию индексов, что означает, что последний индекс массива равен длине массива минус 1. 
 </p><p>
Наше <dfn>условие</dfn> для этого цикла равно <code>i &#x3C; arr.length</code>. Выполнение цикла завершится тогда, когда <code>i</code> будет равно длине массива минус 1.</p></section>

Iterate Through an Array with a For Loop

<section id="description">
<p>Вы можете вспомнить из <a href="https://freecode.academy/learn/exercises/56533eb9ac21ba0edf2244d0" target="_blank">сравнения с Оператором равенства,</a> что все операторы сравнения возвращают логическое <code>true</code> или <code>false</code>. Иногда люди используют оператор <code>if/else</code> для сравнения, например: <pre class="language-js"><code>function isEqual(a, b) {
  if (a === b) {
    return true;
  } else {
    return false;
  }
}</code> </pre>

Но есть лучший способ сделать это. Поскольку <code>===</code> возвращает <code>true</code> или <code>false</code>, мы можем просто вернуть результат сравнения: <pre class="language-js"><code>function isEqual(a, b) {
  return a === b; // true or false
}</code></pre></p>
</section>

Returning Boolean Values from Functions

<section id="description">
  <p>Иногда полезно проверить, существует ли свойство данного объекта или нет. Мы можем использовать метод объектов
    <code>.hasOwnProperty(propname)</code> для определения того, имеет ли этот объект указанное имя свойства.
    <code>.hasOwnProperty()</code> возвращает <code>true</code> или <code>false</code> если свойство найдено или нет.
    <strong>Пример</strong>
  <pre class="language-js"><code>const myObj = {
  top: "hat",
  bottom: "pants"
};

myObj.hasOwnProperty("top"); // true
myObj.hasOwnProperty("middle"); // false</code></pre>
  </p>
</section>

Testing Objects for Properties

<section id="description">
  <p>У нас есть набор объектов, представляющих собой список контактов. Напишите функцию <code>lookUpProfile</code>
    которая принимает аргументы <code>name</code> и <code>prop</code>.

  <ol>
    <li>Функция должна проверять, соответствует ли <code>name</code> свойству <code>firstName</code> данного контакта и
      данное
      свойство
      <code>prop</code> является свойством этого объекта контакта.
    </li>
    <li>Если оба эти условия истинны, верните значение этого свойства.</li>
    <li>Если
      <code>name</code> не соответствует контактам, тогда верните <code>No such contact</code>
    </li>
    <li>Если <code>prop</code> не
      соответствует каким-либо действительным свойствам объекта контакта, найденного для соответствия <code>name</code>
      тогда
      верните <code>No such property</code></li>
  </ol>

  </p>

  <p>
    <b>Подсказка</b>: Вам будет полезно вспомнить метод <a
      href="https://freecode.academy/learn/exercises/567af2437cbaa8c51670a16c"
      target="_blank">Object.prototype.hasOwnProperty()</a>
  </p>
  <p>
    <b>Подсказка 2</b>: Вам так же может пригодиться метод <a
      href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Array/find"
      target="_blank">Array.prototype.find()</a> для поиска элементов массива по условию.
  </p>
</section>

Profile Lookup

<section id="description">
<p>Порядок конструкций <code>if</code> и <code>else if</code> имеет значение. Функция выполняется сверху вниз, поэтому вы должны быть внимательными с тем, какой код прописан в какой последовательности. Возьмем эти две функции в качестве примера. Вот первый: <pre class="language-js"><code>function foo(x) {
  if (x < 1) { 
    return "Less than one"; 
  } 
  else if (x < 2) { 
    return "Less than two"; 
  } 
  else {
    return "Greater than or equal to two"; 
  } 
}</code></pre> 
А второй второй пример, в котором просто изменен порядок условий: 
<pre class="language-js"><code>function bar(x) {
  if (x < 2) { 
    return "Less than two"; 
  } 
  else if (x < 1) { 
    return "Less than one"; 
  } 
  else {
    return "Greater than or equal to two"; 
  } 
}</code></pre> 
Хотя эти две функции выглядят почти одинаковыми, мы можем получить разные результаты. 
<pre class="language-js"><code>foo(0) // "Less than one"
bar(0) // "Less than two" </code></pre>
</p>

</section>

Logical Order in If Else Statements

<section id="description">
<p>Мы можем получить доступ к данным внутри массивов с помощью <code>индекстов</code> . Индексы массивов пишутся в квадратных скобках точно так же, как и в строках (как это мы делали в недавних уроках). Разница только в том, что в строках через индексы мы получали символы этих строк, а в массивах мы получаем элементы этих массивов (элементы могут быть любых типов, в том числе и другими массивами).

Подобно строкам, массивы используют индексирование с <dfn>нулевым</dfn> индексом, поэтому первым элементом в массиве является элемент с индексом <code>0</code> . <strong>Пример</strong> <pre class="language-js"><code>var array = [50,60,70];
array[0]; // равно 50
var data = array[1]; // равно 60 </code></pre> 

<strong>Заметка</strong> <br> Между именем массива и квадратными скобками не должно быть пробелов, например <code>array[0]</code>. Хотя JavaScript способен корректно обрабатывать, это может смутить других программистов, читающих ваш код.</p></section>

Access Array Data with Indexes

<section id="description">
<p>Простым способом добавления данных в конец массива является метод <code>Array.prototype.push()</code>. <a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Array/push" target="_blank">Array.prototype.push()</a> принимает один или несколько <dfn>параметров</dfn> и добавляет их в конец массива. <pre class="language-js"><code>var arr = [1,2,3];
arr.push(4); // arr теперь [1,2,3,4]</code></pre></p>

<p>
  <b>Примечание: </b> Метод <code>.push()</code> является мутирующим, то есть изменяющим саму переменную. То есть для того, чтобы сама переменная-массив изменилась, не надо ей переназначать полученный результат. Сам по себе вызов метода <code>.push()</code> уже меняет переменную. При этом в результате метод возвращает не текущую переменную, а новую длину массива (количество элементов в нем). Для лучшего понимания посмотрите измененный пример: 
</p>

<pre class="language-js"><code>var arr = [1,2,3];
arr.length === 3;   // Было 3 элемента
const length = arr.push(4); // arr теперь [1,2,3,4]
arr.length === length; // Длина массива теперь 4 и равна значению переменной length </code></pre>

<p>
  <b>Внимание!</b> В примере мы написали arr.push(), а в описании выше писали Array.prototype.push(). Здесь мы сталкиваемся с принципами <a href="https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D1%82%D0%BE%D1%82%D0%B8%D0%BF%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5" target="_blank">Объектно-Прототипного программирования</a>. Суть в том, что в JavaScript обозначено <a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Data_structures" target="_blank">9 основных типов данных</a>. Один из этих типов: <a href="https://developer.mozilla.org/ru/docs/Glossary/Object">Object</a> (Объект). <a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Array" target="_blank">Array</a> (Массив) в свою очередь тоже есть суть Object (Объект) и является встроенным объектом самого языка JavaScript (Хотя правильней будет сказать самого движка). Так вот, прототипы объектов могут иметь свои наборы готовых методов (функций). И все конечные инстансы, созданные на основе таких объектов, получают тот же самый набор методов. Более того, при изменении прототипов исходных объектов, конечные инстансы так же получают измененный набор методов. Методами функции называются тогда, когда они принадлежат каким-либо объектам (являются свойствами объектов). Вот и метод <code>Array.prototype.push()</code> - это не самостоятельная функция <code>push()</code>, а именно метод массива. То есть если у вас переменная будет не инстанс массива, а число или строка, то у такой переменной не будет метода push(). 
</p>
<p>
  <b>Подсказка: </b> познакомьтесь и с другими методами объекта <a href="https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Array" target="_blank">Array</a> в документации MDN.
</p>
</section>

Manipulate Arrays With push()

<section id="description">
<p>Другой способ изменить данные в массиве - использовать метод <code>Array.prototype.pop()</code>. <code>.pop()</code> используется для того, чтобы "выдернуть" последний элемент массива. Мы можем сохранить это значение "выдернутого" элемента, присвоив его переменной. Другими словами, <code>.pop()</code> удаляет последний элемент из массива и возвращает этот элемент. Любой тип записи можно "выдернуть" из массива - числа, строки, даже вложенные массивы. <pre class="language-js"><code>var threeArr = [1, 4, 6];
var oneDown = threeArr.pop();
console.log(oneDown); // Returns 6 
console.log(threeArr); // Returns [1, 4]</code></pre>  </p>
</section>

Manipulate Arrays With pop()

<section id="description">
<p><code>.pop()</code> всегда удаляет последний элемент массива. Что делать, если вы хотите удалить первый? Вот где применяется <code>.shift()</code> . Он работает так же, как <code>.pop()</code>, за исключением того, что он удаляет первый элемент, а не последнего.</p></section>

Manipulate Arrays With shift()

<section id="description">
<p>Метод <code>.unshift()</code> работает точно так же, как <code>.push()</code>, но вместо добавления элемента в конце массива <code>.unshift()</code> добавляет элемент в начале массива.</p></section>

Manipulate Arrays With unshift()

<section id="description">
<p>В JavaScript мы можем разделить наш код на многократно используемые блоки, называемые <dfn>функциями</dfn> . Вот пример функции: <pre class="language-js"><code>function functionName() {
  console.log ("Hello World");
} </code></pre> Вы можете вызвать или <dfn>выполнить</dfn> эту функцию, используя ее имя, за которой следуют скобки, например: <pre class="language-js"><code>functionName();</code></pre>
Каждый раз, когда функция вызывается, выполняется прописанный в ней код (внутри фигурных скобок). В нашем случае функция <code>functionName</code> выводит сообщение <code>"Hello World"</code> на консоль dev.</p></section>

Write Reusable JavaScript with Functions

<section id="description"><p>Ранее  вы уже слышали термин <code>Object</code> (Объект). Объекты похожи на <code>массивы</code>, за исключением того, что вместо использования индексов для доступа и изменения их данных, вы получаете доступ к данным в объектах через так называемые <code>свойства</code>. По большому счету структуру объекта можно описать как <code>Ключ</code>-<code>Значение</code>. То есть чтобы получить из <code>объекта</code> значение определенного <code>свойства</code>, надо использовать <code>ключ</code> этого свойства (или по-другому <code>имя</code>).

</p>
<p>

Объекты полезны для хранения данных структурированным способом и могут представлять объекты реального мира, такие как <code>cat</code> (кошка). </p>
<p>
Вот пример объекта cat: <pre class="language-js"><code>const cat = {
  "name": "Whiskers",
  "legs": 4,
  "tails": 1,
  "enemies": ["Water", "Dogs"]
};</code> </pre>
</p>
<p>

В этом примере все имена свойств являются строками, к примеру <code>"name"</code> , <code>"legs"</code> и <code>"tails"</code>. Однако вы также можете использовать и числа в качестве имен свойства. Тем не менее, все имена свойств в объектах автоматически приводятся к типу <code>строка</code>. 

Вы даже можете опустить кавычки для строковых имен свойств (если эти имена не содержат пробелов и других спецсимволов), а именно: <pre class="language-js"><code>const anotherObject = {
  make: "Ford",
  5: "five",
  "model": "focus"
};</code></pre> </p></section>

Build JavaScript Objects

<section id="description">
  <p>После того, как вы создали объект JavaScript, вы можете обновить его свойства в любое время, точно так же, как если
    бы вы обновили любую другую переменную. Вы можете использовать <a
      href="https://freecode.academy/learn/exercises/56533eb9ac21ba0edf2244c8" target="_blank">точечную</a> или <a
      href="https://freecode.academy/learn/exercises/56533eb9ac21ba0edf2244c9" target="_blank">скобочную</a> нотацию для
    доступа к объектам. Например, давайте посмотрим на объект <code>ourDog</code> :
  <pre class="language-js"><code>const ourDog = {
  "name": "Camper",
  "legs": 4,
  "tails": 1,
  "friends": ["everything!"]
  };</code></pre>

  Поскольку это очень счастливая собака, давайте сменим его имя на <code>Happy Camper</code>. Вот как мы обновляем
  свойство этого объекта:
  <pre class="language-js"><code>ourDog.name = "Happy Camper";</code></pre> или
  <pre class="language-js"><code>ourDog["name"] = "Happy Camper";</code></pre>
  Теперь, когда мы получим значение свойства <code>ourDog.name</code>, вместо исходного значения "Camper", мы получим
  его новое имя "Happy Camper".</p>
</section>

Updating Object Properties

<section id="description">
  <p>Вы можете добавлять новые свойства к существующим объектам JavaScript так же, как вы их модифицировали. Вот как мы
    добавим свойство <code>bark</code> в объект <code>ourDog</code>:
  <pre class="language-js"><code>ourDog.bark = "bow-wow";</code></pre> или
  <pre class="language-js"><code>ourDog["bark"] = "bow-wow";</code></pre> 
  Теперь, когда мы вызовем <code>ourDog.bark</code>, мы получим значение записанного свойства - <code>"bow-wow"</code>.</p>
</section>

Add New Properties to a JavaScript Object

<section id="description">
  <p>Мы также можем удалить свойства из объекта, используя оператор delete. <br />
    <b>Пример</b>
  <pre class="language-js"><code>delete ourDog.bark;</code></pre>
  </p>

  <p>Давайте еще раз посмотрим как изменился этот объект после удаления свойства. <br />
  <b>Было</b>
  <pre class="language-js"><code>const ourDog = {
    "name": "Camper",
    "legs": 4,
    "tails": 1,
    "friends": ["everything!"],
    "bark": "bow-wow"
  };
  
  delete ourDog.bark;</code></pre>

  <br />
  <b>Стало</b>
  <pre class="language-js"><code>{
    "name": "Camper",
    "legs": 4,
    "tails": 1,
    "friends": ["everything!"]
  }</code></pre>
  </p>
</section>

Delete Properties from a JavaScript Object

<section id="description">
<p>Вам даны два массива и индекс. Используйте метод массива <code>slice</code> и <code>splice</code> для копирования каждого элемента первого массива во второй массив по порядку. Начните вставлять элементы в индекс <code>n</code> второго массива. Верните результирующий массив. Входные массивы должны оставаться неизменными после запуска функции. Не забудьте использовать <a href="https://www.freecodecamp.org/forum/t/how-to-get-help-when-you-are-stuck-coding/19514" target="_blank">Read-Search-Ask,</a> если вы застряли. Напишите свой собственный код.</p></section>

Slice and Splice

<section id="description">
<p>Длина массива, как и типы данных, которые она может содержать, не является фиксированной. Массивы могут быть определены с длиной любого количества элементов, и элементы могут быть добавлены или удалены с течением времени; другими словами, массивы являются <dfn>изменяемыми</dfn> . В этой задаче мы рассмотрим два метода, с помощью которых мы можем программным образом модифицировать массив: <code>Array.push()</code> и <code>Array.unshift()</code> . Оба метода принимают один или несколько элементов в качестве параметров и добавляют эти элементы в массив, на который вызывается метод; метод <code>push()</code> добавляет элементы в конец массива, а <code>unshift()</code> добавляет элементы в начало. Рассмотрим следующее: <blockquote> пусть двадцать Три = 'XXIII'; <br> let romanNumerals = ['XXI', 'XXII']; <br><br> romanNumerals.unshift ('XIX', 'XX'); <br> // теперь равно ['XIX', 'XX', 'XXI', 'XXII'] <br><br> romanNumerals.push (twentyThree); <br> // теперь равно ['XIX', 'XX', 'XXI', 'XXII', 'XXIII'] Обратите внимание, что мы также можем передавать переменные, что позволяет нам еще большую гибкость в динамическом изменении данных нашего массива. </blockquote></p>
</section>

Add Items to an Array with push() and unshift()

<section id="description">
<p>Оба <code>unshift()</code> <code>push()</code> и <code>unshift()</code> имеют соответствующие методы, которые являются почти функциональными противоположностями: <code>pop()</code> и <code>shift()</code> . Как вы уже догадались, вместо добавления <code>pop()</code> <em>удаляет</em> элемент из конца массива, а <code>shift()</code> удаляет элемент с самого начала. Ключевое различие между <code>pop()</code> и <code>shift()</code> и их кузенами <code>push()</code> и <code>unshift()</code> заключается в том, что ни один из методов не принимает параметры, и каждый из них позволяет только массиву изменять один элемент за раз. Давайте взглянем: <blockquote> let greetings = ['whats up?', 'hello', 'see ya!']; <br><br> greetings.pop (); <br> // теперь равно ['whats up?', 'hello'] <br><br> greetings.shift (); <br> // теперь равно ['hello'] </blockquote> Мы также можем вернуть значение удаляемого элемента любым из следующих способов: <blockquote> let popped = greetings.pop (); <br> // возвращает 'hello' <br> // приветствия теперь равны [] </blockquote></p>
</section>

Remove Items from an Array with pop() and shift()

<section id="description">
<p>Итак, мы научились удалять элементы с начала и конца массивов с помощью <code>shift()</code> и <code>pop()</code> , но что, если мы хотим удалить элемент из где-то посередине? Или удалить сразу несколько элементов? Ну, вот где <code>splice()</code> приходит. <code>splice()</code> позволяет нам сделать это: <strong>удалить любое количество последовательных элементов</strong> из любого места в массиве. <code>splice()</code> может принимать до 3 параметров, но на данный момент мы сосредоточимся только на первом 2. Первые два параметра <code>splice()</code> представляют собой целые числа, которые представляют индексы или позиции массива, который является <code>splice()</code> призвал. И помните, массивы <em>нуль-индексируются</em> , поэтому, чтобы указать первый элемент массива, мы будем использовать <code>0</code> . Первый параметр <code>splice()</code> представляет собой индекс в массиве, из которого начинается удаление элементов, а второй параметр указывает количество удаляемых элементов. Например: <blockquote> пусть array = ['today', 'was', 'not', 'so', 'great']; <br><br> array.splice (2, 2); <br> // удалить 2 элемента, начиная с 3-го элемента <br> // массив теперь равен ['today', 'was', 'great'] </blockquote> <code>splice()</code> не только изменяет массив, на который он вызывается, но также возвращает новый массив, содержащий значение удаленных элементов: <blockquote> пусть array = ['I', 'am', 'feeling', 'really', 'happy']; <br><br> пусть newArray = array.splice (3, 2); <br> // newArray равно ['really', 'happy'] </blockquote></p>
</section>

Remove Items Using splice()

<section id="description">
<p>Помните, что в последнем вызове мы упоминали, что <code>splice()</code> может принимать до трех параметров? Ну, мы можем сделать еще один шаг с помощью <code>splice()</code> - в дополнение к удалению элементов, мы можем использовать этот третий параметр, который представляет один или несколько элементов, чтобы <em>добавить</em> их также. Это может быть невероятно полезно для быстрого переключения элемента или набора элементов для другого. Например, предположим, что вы храните цветовую схему для набора элементов DOM в массиве и хотите динамически изменять цвет на основе некоторых действий: <blockquote> function colorChange (arr, index, newColor) { <br> arr.splice (индекс, 1, newColor); <br> return arr; <br> } <br><br> let colorScheme = ['# 878787', '# a08794', '# bb7e8c', '# c9b6be', '# d1becf']; <br><br> colorScheme = colorChange (colorScheme, 2, '# 332327'); <br> // мы удалили '# bb7e8c' и добавили '# 332327' на свое место <br> // colorScheme теперь равно ['# 878787', '# a08794', '# 332327', '# c9b6be', '# d1becf'] </blockquote> Эта функция принимает массив шестнадцатеричных значений, индекс, с которого нужно удалить элемент, и новый цвет для замены удаленного элемента. Возвращаемое значение представляет собой массив, содержащий новую измененную цветовую схему! Хотя этот пример немного упрощен, мы можем видеть, что значение, использующее <code>splice()</code> может иметь максимальный потенциал.</p></section>

Add Items Using splice()

<section id="description">
<p>Следующий метод, который мы рассмотрим, - <code>slice()</code> . <code>slice()</code> , вместо того, чтобы модифицировать массив, копировать или <em>извлекать</em> заданное количество элементов в новый массив, оставляя массив вызываемым без изменений. <code>slice()</code> принимает только 2 параметра - первый - это индекс, с которого нужно начинать извлечение, а второй - это индекс, в котором останавливается извлечение (извлечение произойдет до, но не включает элемент в этот индекс). Учти это: <blockquote> пусть weatherConditions = ['rain', 'snow', 'sleet', 'hail', 'clear']; <br><br> let todaysWeather = weatherConditions.slice (1, 3); <br> // todaysWeather равно ['snow', 'sleet']; <br> // weatherConditions по-прежнему равно ['rain', 'snow', 'sleet', 'hail', 'clear'] <br></blockquote> Фактически, мы создали новый массив, извлекая элементы из существующего массива.</p></section>

Copy Array Items Using slice()

<section id="description">
<p>Хотя <code>slice()</code> позволяет нам выбирать, какие элементы массива копировать, среди нескольких других полезных задач, новый <dfn>оператор с расширением</dfn> ES6 позволяет нам легко скопировать <em>все</em> элементы массива в порядке, с простым и хорошо читаемым синтаксисом. Синтаксис распространения просто выглядит так: <code>...</code> На практике мы можем использовать оператор спредов для копирования массива следующим образом: <blockquote> let thisArray = [true, true, undefined, false, null]; <br> let thatArray = [... thisArray]; <br> // thisArray равно [true, true, undefined, false, null] <br> // thisArray остается неизменным и идентичен этому массиву </blockquote></p>
</section>

Copy an Array with the Spread Operator

<section id="description">
<p>Так как массивы могут быть изменены, или <em>мутировали,</em> в любое время, нет никакой гарантии , о том, где определенная часть данных будет находиться на данном массиве, или если этот элемент даже до сих пор существует. К счастью, JavaScript предоставляет нам еще один встроенный метод, <code>indexOf()</code> , который позволяет нам быстро и легко проверить наличие элемента в массиве. <code>indexOf()</code> принимает элемент как параметр, а при вызове возвращает позицию или индекс этого элемента или <code>-1</code> если элемент не существует в массиве. Например: <blockquote> пусть плоды = ['яблоки, груши, апельсины, персики, груши; <br><br> fruit.indexOf ('date') // возвращает -1 <br> fruit.indexOf ('апельсины') // возвращает 2 <br> fruit.indexOf ('pears') // возвращает 1, первый индекс, в котором существует элемент </blockquote></p>
</section>

Check For The Presence of an Element With indexOf()

<section id="description">
<p>Иногда при работе с массивами очень удобно выполнять итерацию по каждому элементу, чтобы найти один или несколько элементов, которые могут нам понадобиться, или манипулировать массивом на основе того, какие элементы данных соответствуют определенному набору критериев. JavaScript предлагает несколько встроенных методов, каждый из которых перебирает несколько массивов несколькими разными способами для достижения разных результатов (например, each <code>every()</code> , <code>forEach()</code> , <code>map()</code> и т. Д.), Однако наиболее гибкий метод и предлагает нам наибольшую величина управления является простым <code>for</code> петли. Рассмотрим следующее: <blockquote> функция largeThanTen (arr) { <br> пусть newArr = []; <br> для (пусть i = 0; i &#x3C;arr.length; i ++) { <br> если (arr [i]> 10) { <br> newArr.push (обр [я]); <br> } <br> } <br> return newArr; <br> } <br><br> moreThanTen ([2, 12, 8, 14, 80, 0, 1]); <br> // возвращает [12, 14, 80] </blockquote> Используя цикл <code>for</code> , эта функция выполняет итерации по каждому элементу массива и обращается к нему, и подвергает его простому тесту, который мы создали. Таким образом, мы легко и программно определили, какие элементы данных больше <code>10</code> , и возвратил новый массив, содержащий эти элементы.</p></section>

Iterate Through All an Array's Items Using For Loops

<section id="description">
  <p>Потрясающие! Вы только что узнали тонну о массивах! Это был довольно высокий уровень обзора, и есть еще много
    возможностей узнать о работе с массивами, многое из которых вы увидите в последующих разделах. Но прежде чем перейти
    к просмотру <dfn>объектов</dfn> , давайте взглянем еще раз и посмотрим, как массивы могут стать немного более
    сложными, чем то, что мы видели в предыдущих задачах. Одна из самых мощных функций при рассмотрении массивов как
    структур данных состоит в том, что массивы могут содержать или даже полностью состоять из других массивов. Мы видели
    массивы, которые содержат массивы в предыдущих задачах, но довольно простые. Однако массивы могут содержать
    бесконечную глубину массивов, которые могут содержать другие массивы, каждый со своими произвольными уровнями
    глубины и т. Д. Таким образом, массив может очень быстро стать очень сложной структурой данных, известной как
    <dfn>многомерный</dfn> или вложенный массив. Рассмотрим следующий пример:
  <pre class="language-js"><code>let nestedArray = [ // top, or first level - the outer most array
  ['deep'], // an array within an array, 2 levels of depth
  [
    ['deeper'], ['deeper'] // 2 arrays nested 3 levels deep
  ],
  [
    [
      ['deepest'], ['deepest'] // 2 arrays nested 4 levels deep
    ],
    [
      [
        ['deepest-est?'] // an array nested 5 levels deep
      ]
    ]
  ]
]; 
console.log (nestedArray [2] [1] [0] [0] [0]);
// logs: самый глубокий? </code></pre> И теперь,
  когда мы знаем, где эта часть данных, мы можем ее сбросить, если нам нужно: <pre class="language-js"><code>nestedArray[2][1][0][0][0] = 'deeper still';
console.log(nestedArray[2][1][0][0][0]);
// now logs: deeper still</code></pre>
  </p>
</section>

Create complex multi-dimensional arrays

<section id="description">
<p>Другим огромным преимуществом оператора <dfn>спреда</dfn> является возможность объединения массивов или вставки всех элементов одного массива в другой при любом индексе. С более традиционными синтаксисами мы можем конкатенировать массивы, но это позволяет нам объединять массивы в конце одного и в начале другого. Синтаксис Spread делает следующую операцию чрезвычайно простой: <blockquote> пусть thisArray = ['sage', 'rosemary', 'parsley', 'thyme']; <br><br> let thatArray = ['basil', 'cilantro', ... thisArray, 'coriander']; <br> // thisArray теперь равен ['basil', 'cilantro', 'sage', 'rosemary', 'parsley', 'thyme', 'coriander'] </blockquote> Используя синтаксис распространения, мы только что выполнили операцию, которая была бы более сложной и более сложной, если бы мы использовали традиционные методы.</p></section>

Combine Arrays with the Spread Operator

<section id="description">
<p>В большинстве своих объектов объекты представляют собой только коллекции <dfn>пар ключ-значение</dfn> , или, другими словами, части данных, сопоставленные с уникальными идентификаторами, которые мы называем <dfn>свойствами</dfn> или <dfn>ключами</dfn> . Давайте рассмотрим очень простой пример: <blockquote> пусть FCC_User = { <br> имя пользователя: 'awesome_coder', <br> последователи: 572, <br> баллы: 1741, <br> completedProjects: 15 <br> }; </blockquote> Вышеприведенный код определяет объект с именем <code>FCC_User</code> который имеет четыре <dfn>свойства</dfn> , каждый из которых соответствует определенному значению. Если бы мы хотели узнать количество <code>followers</code> <code>FCC_User</code> , мы можем получить доступ к этому свойству, написав: <blockquote> let userData = FCC_User.followers; <br> // userData равно 572 </blockquote> Это называется <dfn>точечной нотации</dfn> . Кроме того, мы также можем получить доступ к свойству с помощью скобок, например: <blockquote> let userData = FCC_User ['followers'] <br> // userData равно 572 </blockquote> Обратите внимание, что с <dfn>обозначением в скобках</dfn> мы заключили <code>followers</code> в кавычки. Это связано с тем, что скобки фактически позволяют нам передавать переменную in, которая будет оцениваться как имя свойства (подсказка: помните об этом позже!). Если бы мы передали <code>followers</code> без кавычек, движок JavaScript попытался бы оценить его как переменную, и <code>ReferenceError: followers is not defined</code> был бы указан идентификатор <code>ReferenceError: followers is not defined</code> .</p></section>

Add Key-Value Pairs to JavaScript Objects

<section id="description">
<p>Теперь давайте посмотрим на несколько более сложный объект. Свойства объекта могут быть вложены в произвольную глубину, а их значениями могут быть любые типы данных, поддерживаемые JavaScript, включая массивы и даже другие объекты. Рассмотрим следующее: <blockquote> let inestedObject = { <br> id: 28802695164, <br> дата: «31 декабря 2016 года», <br> данные: { <br> totalUsers: 99, <br> онлайн: 80, <br> onlineStatus: { <br> активен: 67, <br> 13 гостей <br> } <br> } <br> }; </blockquote> <code>nestedObject</code> имеет три уникальных ключа: <code>id</code> , значение которого - число, <code>date</code> , значение которого является строкой, и <code>data</code> , значение которых является объектом, у которого есть еще один объект, вложенный в него. Хотя структуры могут быстро стать сложными, мы все равно можем использовать одни и те же обозначения для доступа к необходимой нам информации.</p></section>

Modify an Object Nested Within an Object

<section id="description">
<p>В первом вызове объекта мы упоминали использование нотации в виде скобок как способ доступа к значениям свойств с использованием оценки переменной. Например, представьте, что наш <code>foods</code> объект используется в программе для кассового аппарата супермаркета. У нас есть функция , которая устанавливает <code>selectedFood</code> и мы хотим , чтобы проверить наши <code>foods</code> объекта на наличие этой пищи. Это может выглядеть так: <blockquote> let selectedFood = getCurrentFood (scannedItem); <br> пусть инвентарь = продукты питания [selectedFood]; </blockquote> Этот код будет оценивать значение, хранящееся в переменной <code>selectedFood</code> и возвращать значение этого ключа в файле <code>foods</code> или <code>undefined</code> если оно отсутствует. Обозначение скобок очень полезно, поскольку иногда свойства объекта неизвестны до выполнения, или нам нужно получить доступ к ним более динамичным способом.</p></section>

Access Property Names with Bracket Notation

<section id="description">
<p>Теперь вы знаете, какие объекты и их основные функции и преимущества. Короче говоря, это хранилища с ключевыми значениями, которые обеспечивают гибкий, интуитивно понятный способ структурирования данных <strong><em>и</em></strong> обеспечивают очень быстрое время поиска. Во всех остальных задачах мы опишем несколько общих операций, которые вы можете выполнять на объектах, чтобы вы могли комфортно применять эти полезные структуры данных в своих программах. В более ранних задачах мы добавили и модифицировали пары ключ-значение объекта. Здесь мы увидим, как мы можем <em>удалить</em> пару ключ-значение из объекта. Давайте вернемся к примеру нашего <code>foods</code> последний раз. Если мы хотим удалить ключ <code>apples</code> , мы можем удалить его, используя ключевое слово <code>delete</code> : <blockquote> удалять пищу. </blockquote></p>
</section>

Use the delete Keyword to Remove Object Properties

<section id="description">
<p>Теперь мы можем добавлять, изменять и удалять ключи из объектов. Но что, если мы просто хотим узнать, обладает ли объект конкретным свойством? JavaScript предоставляет нам два разных способа сделать это. Один использует <code>hasOwnProperty()</code> метод , а другой использует <code>in</code> ключевом слове. Если у нас есть объектные <code>users</code> с собственностью <code>Alan</code> , мы можем проверить его наличие одним из следующих способов: <blockquote> users.hasOwnProperty ( 'Алан'); <br> «Алан» у пользователей; <br> // оба возвращают true </blockquote></p>
</section>

Check if an Object has a Property

<section id="description">
<p>Иногда вам может потребоваться повторить все ключи внутри объекта. Для этого требуется конкретный синтаксис в JavaScript, называемый выражением <dfn>for for ... in</dfn> . Для объекта наших <code>users</code> это может выглядеть так: <blockquote> для (разрешить пользователям пользователей) { <br> console.log (пользователь); <br> }; <br><br> // logs: <br> Алан <br> Джефф <br> Сара <br> Райан </blockquote> В этом заявлении мы определили <code>user</code> переменной, и, как вы можете видеть, эта переменная была сброшена во время каждой итерации каждому из ключей объекта, когда оператор зациклился на объекте, в результате чего каждое имя пользователя печаталось на консоль. <strong>ЗАМЕТКА:</strong> <br> Объекты не поддерживают упорядочение хранимых ключей, например массивов; таким образом, позиция клавиш на объекте или относительный порядок, в котором он появляется, не имеет значения при ссылке или доступе к этому ключу.</p></section>

Iterate Through the Keys of an Object with a for...in Statement

<section id="description">
<p>Мы также можем сгенерировать массив, содержащий все ключи, хранящиеся в объекте, с использованием <code>Object.keys()</code> и передачи объекта в качестве аргумента. Это вернет массив со строками, представляющими каждое свойство объекта. Опять же, не будет никакого конкретного порядка для записей в массиве.</p></section>

Generate an Array of All Object Keys with Object.keys()

<section id="description">
<p>Теперь вы видели все основные операции для объектов JavaScript. Вы можете добавлять, изменять и удалять пары ключ-значение, проверять наличие ключей и перебирать все ключи в объекте. По мере продолжения изучения JavaScript вы увидите еще более универсальные приложения объектов. Кроме того, дополнительные уроки Advanced Data Structures далее в учебной программе также охватывают объекты ES6 <dfn>Map</dfn> и <dfn>Set</dfn> , оба из которых похожи на обычные объекты, но предоставляют некоторые дополнительные функции. Теперь, когда вы изучили основы массивов и объектов, вы полностью готовы приступить к решению более сложных проблем с помощью JavaScript!</p></section>

Modify an Array Stored in an Object

<section id="description">
<p>Ниже приведен пример простейшей реализации структуры данных массива. Это известно как <dfn>одномерный массив</dfn> , что означает, что он имеет только один уровень, или что он не имеет других массивов, вложенных в него. Обратите внимание, что он содержит <dfn>булевы</dfn> , <dfn>строки</dfn> и <dfn>числа</dfn> , среди прочих допустимых типов данных JavaScript: <blockquote> let simpleArray = ['one', 2, 'three', true, false, undefined, null]; <br> console.log (simpleArray.length); <br> // журналы 7 </blockquote> У всех массивов есть свойство length, которое, как показано выше, может быть очень легко доступно с помощью синтаксиса <code>Array.length</code> . Более сложную реализацию массива можно увидеть ниже. Это известно как <dfn>многомерный массив</dfn> или массив, содержащий другие массивы. Обратите внимание, что этот массив также содержит <dfn>объекты</dfn> JavaScript, которые мы рассмотрим очень внимательно в следующем разделе, но пока все, что вам нужно знать, это то, что массивы также способны хранить сложные объекты. <blockquote> пусть complexArray = [ <br> [ <br> { <br> один: 1, <br> два: 2 <br> }, <br> { <br> три: 3, <br> четыре: 4 <br> } <br> ], <br> [ <br> { <br> a: "a", <br> b: "b" <br> }, <br> { <br> c: "c", <br> d: "d" <br> } <br> ] <br> ]; </blockquote></p>
</section>

Use an Array to Store a Collection of Data

<section id="description">
  <p>В предыдущем вызове использовался один <code>тернарный оператор</code>. Вы также можете использовать сразу
    несколько таких операторов, чтобы проверить наличие нескольких условий. Следующая функция использует if, else if и
    else для проверки нескольких условий:
  <pre class="language-js"><code>function findGreaterOrEqual(a, b) {
  if (a === b) {
    return "a and b are equal";
  }
  else if (a > b) {
    return "a is greater";
  }
  else {
    return "b is greater";
  }
}</code></pre>Вышеупомянутая функция может быть переписана с использованием нескольких
  <code>тернарных операторв</code>:
  <pre class="language-js"><code>function findGreaterOrEqual(a, b) {
  return (a === b) ? "a and b are equal" 
    : (a > b) ? "a is greater" 
      : "b is greater";
}</code></pre>
  </p>
</section>

Use Multiple Conditional (Ternary) Operators

<section id="description">
<p>Функция <code>parseInt()</code> анализирует строку и возвращает целое число. Она принимает второй аргумент <code>radix</code> (разрядность), который определяет базу номера в строке. <code>radix</code> может быть целым числом от 2 до 36. Вызов функции выглядит так: <code>parseInt(string, radix);</code> И вот пример: <pre class="language-js"><code>var a = parseInt("11", 2);</code></pre> В переменной radix указано, что «11» находится в двоичной системе или базе 2. Этот пример преобразует строку «11» в целое число 3.</p></section>

Use the parseInt Function with a Radix

<section id="description">
<p>Функция <code>parseInt()</code> анализирует строку и возвращает целое число в случае успеха. Вот пример: <pre class="language-js"><code>var a = parseInt("007");</code></pre> 
Вышеупомянутая функция преобразует строку "007" в целое число 7. 
Если первый символ в строке не может быть преобразован в число, то функция возвращает <code>NaN</code>.</p>
<p>Так же следует отметить, что переданная строка не обязательно должна содержать только числа. Главное условие - число должно быть первым символом. Если условие соблюдено, что функция parseInt() попытается распознать все возможные числа, пока не встретит конец строки или иной не числовой символ. <b>Пример</b>

<pre class="language-js"><code>parseInt("") // NaN
parseInt("str777") // NaN
parseInt("777.str") // 777
parseInt("777.111.str") // 777
</code></pre>
</p>
</section>

Use the parseInt Function

<section id="description">
  <p><dfn>Условный оператор</dfn>, также называемый <dfn>тернарным оператором</dfn>, может использоваться как однострочное выражение <code>if-else</code>. Синтаксис: <code>condition ? statement-if-true : statement-if-false;</code>
    Следующая функция использует инструкцию <code>if-else</code> для проверки условия:
  <pre class="language-js"><code>function findGreater(a, b) {
  if(a > b) {
    return "a is greater";
  }
  else {
    return "b is greater or equal";
  }
}</code></pre> 
Это можно переписать с помощью <code>тернарного оператора</code> : <pre class="language-js"><code>function findGreater(a, b) {
  return a > b ? "a is greater" : "b is greater or equal";
}</code></pre>
  </p>
</section>