translation of primitive-methods

Author: romaldowoho

1-js/05-data-types/01-primitives-methods/1-string-new-property/solution.md

@@ -1,31 +1,30 @@
-
-Try running it:
+Попробуйте запустить код:
 
 ```js run
-let str = "Hello";
+let str = "Привет";
 
 str.test = 5; // (*)
 
-alert(str.test); 
+alert(str.test);
 ```
 
-There may be two kinds of result:
-1. `undefined`
-2. An error.
+Здесь может быть два результата:
 
-Why? Let's replay what's happening at line `(*)`:
+1. `undefined`
+2. Ошибка
 
-1. When a property of `str` is accessed, a "wrapper object" is created.
-2. The operation with the property is carried out on it. So, the object gets the `test` property.
-3. The operation finishes and the "wrapper object" disappears.
+Почему? Давайте посмотрим что происходит на линии `(*)`:
 
-So, on the last line, `str` has no trace of the property. A new wrapper object for every object operation on a string.
+1. В момент обращения к свойству `str` создается "объект-обертка".
+2. Операция со свойством выполняется на объекте. Таким образом, объект получает свойство `test`.
+3. Операция заканчивается и "объект-обертка" удаляется.
 
-Some browsers though may decide to further limit the programmer and disallow to assign properties to primitives at all. That's why in practice we can also see errors at line `(*)`. It's a little bit farther from the specification though.
+Выходит, на последней линии `str` больше не имеет свойства `test`. При каждой объектной операции со строкой создается новый "объект-обертка".
 
-**This example clearly shows that primitives are not objects.**
+Некоторые браузеры могут решить еще более ограничить возможности пользователя и запретить присваивание свойств примитивным типам. Поэтому, на практике мы можем встречать ошибки на линии `(*)`. Хотя, это далековато от правил языка.
 
-They just can not store data. 
+**Данный пример наглядно показывает, что примитивы не являются объектами.**
 
-All property/method operations are performed with the help of temporary objects.
+Они просто не могут хранить данные.
 
+Все операции со свойствами/методами выполняются с помощью временных объектов.

1-js/05-data-types/01-primitives-methods/1-string-new-property/task.md

@@ -1,18 +1,17 @@
-importance: 5
+важность: 5
 
 ---
 
-# Can I add a string property?
+# Могу ли я добавить свойство Строки?
 
-
-Consider the following code:
+Взгляните на следующий код:
 
 ```js
-let str = "Hello";
+let str = "Привет";
 
 str.test = 5;
 
 alert(str.test);
 ```
 
-How do you think, will it work? What will be shown?
+Как вы думаете, это сработает? Что выведется на экран?

1-js/05-data-types/01-primitives-methods/article.md

@@ -1,130 +1,131 @@
-# Methods of primitives
+# Методы с примитивными типами данных
 
-JavaScript allows us to work with primitives (strings, numbers, etc.) as if they were objects.
+Javascript позволяет нам работать с примитивными типами данных (далее: примитивы) (строки, числа, и т.д) так, как если бы они были объектами.
 
-They also provide methods to call as such. We will study those soon, but first we'll see how it works because, of course, primitives are not objects (and here we will make it even clearer).
+Также, примитивы имеют методы объектов. Их мы изучим позже, но сначала мы разберем как это все работает, потому что, конечно, примитивы - не объекты (и здесь мы разберем это поподробнее).
 
-Let's look at the key distinctions between primitives and objects.
+Давайте взглянем на ключевые различия между примитивами и объектами.
 
-A primitive
+Примитив
 
-- Is a value of a primitive type.
-- There are 6 primitive types: `string`, `number`, `boolean`, `symbol`, `null` and `undefined`.
+- Это значение «примитивного» типа.
+- Есть 6 примитивных типов: `string`, `number`, `boolean`, `symbol`, `null` и `undefined`.
 
-An object
+Объект
 
-- Is capable of storing multiple values as properties.
-- Can be created with `{}`, for instance: `{name: "John", age: 30}`. There are other kinds of objects in JavaScript; functions, for example, are objects.
+- Может хранить множество значений как свойства.
+- Объявляется при помощи фигурных скобок `{}`, например: `{name: "Рома", age: 30}`. В JavaScript есть и другие виды объектов; например, функции тоже являются объектами.
 
-One of the best things about objects is that we can store a function as one of its properties.
+Одна из лучших особенностей объектов это то, что мы можем хранить метод как одно из свойств объекта.
 
 ```js run
-let john = {
-  name: "John",
+let roma = {
+  name: "Рома",
   sayHi: function() {
-    alert("Hi buddy!");
+    alert("Привет, дружище!");
   }
 };
 
-john.sayHi(); // Hi buddy!
+roma.sayHi(); // Привет, дружище!
 ```
 
-So here we've made an object `john` with the method `sayHi`.
+Здесь мы создали объект `roma` с методом `sayHi`.
 
-Many built-in objects already exist, such as those that work with dates, errors, HTML elements, etc. They have different properties and methods.
+Существует множество встроенных объектов. Например, те, которые работают с датами, ошибками, HTML элементами, и т.д. Они имеют различные свойства и методы.
 
-But, these features come with a cost!
+Однако, у этих особенностей есть определенная цена!
 
-Objects are "heavier" than primitives. They require additional resources to support the internal machinery. But as properties and methods are very useful in programming, JavaScript engines try to optimize them to reduce the additional burden.
+Объекты «тяжелее» примитивов. Они нуждаются в дополнительных ресурсах для поддержания внутренней структуры. Но, так как свойства и методы очень полезны в программировании, движки JavaScript оптимизируют их для уменьшения дополнительной нагрузки.
 
-## A primitive as an object
+## Примитив как объект
 
-Here's the paradox faced by the creator of JavaScript:
+Вот парадокс, с которым столкнулся создатель JavaScript:
 
-- There are many things one would want to do with a primitive like a string or a number. It would be great to access them as methods.
-- Primitives must be as fast and lightweight as possible.
+- Есть много вещей, которые хотелось бы сделать с примитивами как string или number. Было бы замечательно если бы мы могли вызывать эти «вещи» так же, как методы.
+- Примитивы должны быть как можно легкими и быстрыми.
 
-The solution looks a little bit awkward, but here it is:
+Вот решение, хотя выглядит оно немного неуклюже:
 
-1. Primitives are still primitive. A single value, as desired.
-2. The language allows access to methods and properties of strings, numbers, booleans and symbols.
-3. When this happens, a special "object wrapper" is created that provides the extra functionality, and then is destroyed.
+1. Примитивы остаются примитивами. Одно значение, как и хотелось.
+2. Язык позволяет иметь доступ к методам и свойствам strings, numbers, booleans и symbols.
+3. При этом, создается специальный "объект-обертка", который предоставляет дополнительную функциональность, а после, удаляется.
 
-The "object wrappers" are different for each primitive type and are called: `String`, `Number`, `Boolean` and `Symbol`. Thus, they provide different sets of methods.
+Каждый примитив имеет свой собственный "объект-обертку", которые называются: `String`, `Number`, `Boolean` и `Symbol`. Таким образом,они имеют разный набор методов.
 
-For instance, there exists a method [str.toUpperCase()](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase) that returns a capitalized string.
+К примеру, существует метод [str.toUpperCase()](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase), который возвращает cтроку в верхнем регистре.
 
-Here's how it works:
+Вот как он работает:
 
 ```js run
-let str = "Hello";
+let str = "Привет";
 
-alert( str.toUpperCase() ); // HELLO
+alert(str.toUpperCase()); // ПРИВЕТ
 ```
 
-Simple, right? Here's what actually happens in `str.toUpperCase()`:
+Легко, правда? Вот, что на самом деле происходит в `str.toUpperCase()`:
 
-1. The string `str` is a primitive. So in the moment of accessing its property, a special object is created that knows the value of the string, and has useful methods, like `toUpperCase()`.
-2. That method runs and returns a new string (shown by `alert`).
-3. The special object is destroyed, leaving the primitive `str` alone.
+1. Строка `str` - примитив. В момент обращения к его свойству, создается специальный объект, который знает значение строки и имеет такие полезные методы, как `toUpperCase()`.
+2. Этот метод запускается и возвращает новую строку (показывается в `alert`).
+3. Специальный объект удаляется, оставляя только примитив `str`.
 
-So primitives can provide methods, but they still remain lightweight.
+Получается, что примитивы могут предоставлять методы, и в то же время оставаться «лёгкими».
 
-The JavaScript engine highly optimizes this process. It may even skip the creation of the extra object at all. But it must still adhere to the specification and behave as if it creates one.
+Движок JavaScript очень оптимизирует этот процесс. Он даже может пропустить создание специального объекта. Однако, он все же должен придерживаться спецификаций и работать так, как будто он его создает.
 
-A number has methods of its own, for instance, [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) rounds the number to the given precision:
+Число имеет собственный набор методов. Например, [toFixed(n)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed) округляет число до n знаков после запятой.
 
 ```js run
 let n = 1.23456;
 
-alert( n.toFixed(2) ); // 1.23
+alert(n.toFixed(2)); // 1.23
 ```
 
-We'll see more specific methods in chapters <info:number> and <info:string>.
+Более подробно с различными свойствами и методами мы познакомимся в главах <info:number> и <info:string>.
 
+``warn header="Конструкторы `String/Number/Boolean` предназначены только для внутреннего пользования"
+Некоторые языки, такие как Java позволяют создание "объектов-оберток" для примитивов при помощи такого синтаксиса как `new Number(1)` или `new Boolean(false)`.
 
-````warn header="Constructors `String/Number/Boolean` are for internal use only"
-Some languages like Java allow us to create "wrapper objects" for primitives explicitly using a syntax like `new Number(1)` or `new Boolean(false)`.
+В JavaScript, это тоже возможно по историческим причинам, но очень **не рекомендуется**. В некоторых местах последствия могут быть катастрофическими.
 
-In JavaScript, that's also possible for historical reasons, but highly **unrecommended**. Things will go crazy in several places.
-
-For instance:
+Например:
 
 ```js run
-alert( typeof 1 ); // "number"
+alert(typeof 1); // "число"
 
-alert( typeof new Number(1) ); // "object"!
+alert(typeof new Number(1)); // "объект"!
 ```
 
-And because what follows, `zero`, is an object, the alert will show up:
+И так как `zero` - это объект, модальное окно выведется на экран.
 
 ```js run
 let zero = new Number(0);
 
-if (zero) { // zero is true, because it's an object
-  alert( "zero is truthy?!?" );
+if (zero) {
+  // zero возвращает "true", так как является объектом
+  alert("zero имеет «истинное» значение?!?");
 }
 ```
 
-On the other hand, using the same functions `String/Number/Boolean` without `new` is a totally sane and useful thing. They convert a value to the corresponding type: to a string, a number, or a boolean (primitive).
+С другой стороны, использование функций `String/Number/Boolean` без оператора `new` является вполне разумной и полезной вещью. Они превращают значение в соответствующий примитивный тип: в строку, в число, в булевой тип.
+
+К примеру, следующее вполне легально:
 
-For example, this is entirely valid:
 ```js
-let num = Number("123"); // convert a string to number
+let num = Number("123"); // превращает строку в число
 ```
-````
 
+`````
 
-````warn header="null/undefined have no methods"
-The special primitives `null` and `undefined` are exceptions. They have no corresponding "wrapper objects" and provide no methods. In a sense, they are "the most primitive".
 
-An attempt to access a property of such value would give the error:
+````warn header="null/undefined не имеют методов"
+Особенные примитивы `null` and `undefined` являются исключениями. У них нет соответствующих "объектов-оберток" и они не имеют никаких методов. В некотором смысле, они "самые примитивные".
 
+Попытка доступа к свойствам такого значения возвратит ошибку:
 ```js run
-alert(null.test); // error
-````
+alert(null.test); // ошибка
+`````
 
-## Summary
+## Итого
 
-- Primitives except `null` and `undefined` provide many helpful methods. We will study those in the upcoming chapters.
-- Formally, these methods work via temporary objects, but JavaScript engines are well tuned to optimize that internally, so they are not expensive to call.
+- Все примитивы кроме `null` и `undefined` предоставляют множество полезных методов. Мы познакомимся с ними поближе в следующих главах.
+- Формально, эти методы работают с помощью временных объектов, но движки JavaScript очень хорошо оптимизируют этот процесс внутренне, так что их вызов не требует много ресурсов.