Update article.md

1-js/02-first-steps/07-type-conversions/article.md

@@ -1,102 +1,103 @@
-# Type Conversions
+# Konverzió típusok
 
-Most of the time, operators and functions automatically convert the values given to them to the right type.
+Legtöbbször operátorok és függvények automatikusan átalakítják az értéket a megfelelő típusra.
 
-For example, `alert` automatically converts any value to a string to show it. Mathematical operations convert values to numbers.
 
-There are also cases when we need to explicitly convert a value to the expected type.
+Mint például `alert` minden megadott értéket Stringnek alakít át, hogy megjelenítse. A matematikai műveletek az értékeket számokká alakítják.
 
-```smart header="Not talking about objects yet"
-In this chapter, we won't cover objects. For now we'll just be talking about primitives.
+Vannak esetek mikor nekünk kell kifejezetten átalakítani az értéket az elvárt típusra.
 
-Later, after we learn about objects, in the chapter <info:object-toprimitive> we'll see how objects fit in.
+```smart header="Objektumokról még nem is beszélve"
+Ebben a fejezeben nem  takarunk el objektumokat. Jelenleg csak a primitívekről beszélünk.
+
+Később, miután beszélünk az objektumokról, a fejezetben <info:object-toprimitive> megnézzük hogy illeszkednek.
 ```
 
-## String Conversion
+## String Konverziók
 
-String conversion happens when we need the string form of a value.
+String konverzió történik mikor nekünk szükséges van egy érték string formájára.
 
-For example, `alert(value)` does it to show the value.
+Mint például `alert(value)` megmutatja az értéket.
 
-We can also call the `String(value)` function to convert a value to a string:
+Ugyanúgy meghívhatjuk a `String(value)` függvényt, ahhoz hogy stringgé alakítsuk:
 
 ```js run
 let value = true;
 alert(typeof value); // boolean
 
 *!*
-value = String(value); // now value is a string "true"
+value = String(value); // most az érték string "true"
 alert(typeof value); // string
 */!*
 ```
 
-String conversion is mostly obvious. A `false` becomes `"false"`, `null` becomes `"null"`, etc.
+String konverzió legtöbbször egyértelmű. A `false` változik `"false"`-ra, `null` változik `"null"`-ra, stb.
 
-## Numeric Conversion
+## Szám Konverziók
 
-Numeric conversion happens in mathematical functions and expressions automatically.
+Szám konverzió történik a matematikai függvényekben és kifejezésekben automatikusan.
 
-For example, when division `/` is applied to non-numbers:
+Mint például amikor osztunk `/` nem számokra is vonatkozik:
 
 ```js run
-alert( "6" / "2" ); // 3, strings are converted to numbers
+alert( "6" / "2" ); // 3, stringek átalakítva számokká
 ```
 
-We can use the `Number(value)` function to explicitly convert a `value` to a number:
+Használhatjuk `Number(value)` függvényt, hogy átalakítsuk a `value` számmá:
 
 ```js run
 let str = "123";
 alert(typeof str); // string
 
-let num = Number(str); // becomes a number 123
+let num = Number(str); // átváltozik számmá 123
 
-alert(typeof num); // number
+alert(typeof num); // szám
 ```
 
-Explicit conversion is usually required when we read a value from a string-based source like a text form but expect a number to be entered.
+Explicit konverzió akkor szükséges mikor mi olvasunk egy értéekt a string-alapú forrásból, pl. egy szöveges űrlapból olvasunk ki egy értéket, de számot írtunk be.
 
-If the string is not a valid number, the result of such a conversion is `NaN`. For instance:
+Mikor a string nem valós szám, az eredmény átalakítás eredménye `NaN`. Mint például:
 
 ```js run
 let age = Number("an arbitrary string instead of a number");
 
-alert(age); // NaN, conversion failed
+alert(age); // NaN, átalakítási hiba
 ```
 
-Numeric conversion rules:
+Szám átalakítási szabály:
 
 | Value |  Becomes... |
 |-------|-------------|
 |`undefined`|`NaN`|
 |`null`|`0`|
 |<code>true&nbsp;and&nbsp;false</code> | `1` and `0` |
-| `string` | Whitespaces from the start and end are removed. If the remaining string is empty, the result is `0`. Otherwise, the number is "read" from the string. An error gives `NaN`. |
+| `string` | Szóközöket az elejéről és hátuljáról eltávolítjuk.Mikor a többi maradt string üres, az eredmény `0`. Különben a szám "olvasható" a stringből. A hiba pedig `NaN`-t ad vissza.
 
-Examples:
+Például:
 
 ```js run
 alert( Number("   123   ") ); // 123
-alert( Number("123z") );      // NaN (error reading a number at "z")
+alert( Number("123z") );      // NaN (számként nem tudja beolvasni a "z"-t)
 alert( Number(true) );        // 1
 alert( Number(false) );       // 0
 ```
 
-Please note that `null` and `undefined` behave differently here: `null` becomes zero while `undefined` becomes `NaN`.
+Kérjük, vedd figyelembe, hogy a `null` és `undefined` másképp viselkedik: `null` átalakul nullává, miközben az `undefined` átalakul `NaN` értékké.
 
-Most mathematical operators also perform such conversion, we'll see that in the next chapter.
+A legtöbb matematikai operátor is végez ilyen átalakítást, amit a következő fejezetben megnézünk.
 
-## Boolean Conversion
+## Boolean Konverziók
 
 Boolean conversion is the simplest one.
 
 It happens in logical operations (later we'll meet condition tests and other similar things) but can also be performed explicitly with a call to `Boolean(value)`.
 
-The conversion rule:
+A konverzió szabály:
 
-- Values that are intuitively "empty", like `0`, an empty string, `null`, `undefined`, and `NaN`, become `false`.
-- Other values become `true`.
+- Értékek intuitív módon "empty" értékűek, mint a `0`, egy üres string, `null`, `undefined`, és `NaN`, átalakul `false` értékké.
+- Más értékek pedig `true` értékűek.
 
-For instance:
+Mint például:
 
 ```js run
 alert( Boolean(1) ); // true
@@ -106,45 +107,45 @@ alert( Boolean("hello") ); // true
 alert( Boolean("") ); // false
 ```
 
-````warn header="Please note: the string with zero `\"0\"` is `true`"
-Some languages (namely PHP) treat `"0"` as `false`. But in JavaScript, a non-empty string is always `true`.
+````warn header="Vedd figyelembe: a string 0-val `\"0\"` az `true`"
+Néhány nyelvek (pl. PHP) a `"0"` az `false`. De JavaScriptben a nem üres string az mindig `true`.
 
 ```js run
 alert( Boolean("0") ); // true
 alert( Boolean(" ") ); // spaces, also true (any non-empty string is true)
 ```
 ````
 
-## Summary
+## Összegzés
 
-The three most widely used type conversions are to string, to number, and to boolean.
+A három legszélesebb körben használt típuskonverzió a stringre, számra és boolean értékre.
 
-**`String Conversion`** -- Occurs when we output something. Can be performed with `String(value)`. The conversion to string is usually obvious for primitive values.
+**`String Konverziók`** -- Akkor fordul elő, ha valamit kiadunk. A `String(value)` paraméterrel hajtható végre. A stringre átalakítás általában nyilvánvaló primitív értékek esetén.
 
-**`Numeric Conversion`** -- Occurs in math operations. Can be performed with `Number(value)`.
+**`Szám Konverziók`** -- A matematikai műveletekben fordul elő. A `Number(value)` paraméterrel hajtható végre.
 
-The conversion follows the rules:
+A konverziók az alábbi szabályt használják:
 
 | Value |  Becomes... |
 |-------|-------------|
 |`undefined`|`NaN`|
 |`null`|`0`|
 |<code>true&nbsp;/&nbsp;false</code> | `1 / 0` |
-| `string` | The string is read "as is", whitespaces from both sides are ignored. An empty string becomes `0`. An error gives `NaN`. |
+| `string` | A string "as is" mindkét oldalon figyelmen kívül hagyja a szóközöket. Egy üres string visszaadja a `0` értéket. Egy hiba pedig `NaN` értéket. |
 
-**`Boolean Conversion`** -- Occurs in logical operations. Can be performed with `Boolean(value)`.
+**`Boolean Konverziók`** -- Logikai műveletekben fordul elő. A `Boolean(value)` paraméterrel hajtható végre.
 
-Follows the rules:
+Kövesd a szabályt:
 
 | Value |  Becomes... |
 |-------|-------------|
 |`0`, `null`, `undefined`, `NaN`, `""` |`false`|
 |any other value| `true` |
 
 
-Most of these rules are easy to understand and memorize. The notable exceptions where people usually make mistakes are:
+A szabályok többsége könnyen érthető és megjegyezhető. A figyelemre méltó kivételek, ahol az emberek általában hibáznak, a következők:
 
-- `undefined` is `NaN` as a number, not `0`.
-- `"0"` and space-only strings like `"   "` are true as a boolean.
+- `undefined` az `NaN` mint szám, nem `0`.
+- A `"0"` és a csak a szóközt használok stringek pl. `"   "` logikai értékként igazak.
 
-Objects aren't covered here. We'll return to them later in the chapter <info:object-toprimitive> that is devoted exclusively to objects after we learn more basic things about JavaScript.
+Az objektumokat nem érintettük a fejezetben. Később a <info:object-toprimitive> fejezetben beszélünk róla, amely kizárólag az objektumoknak van szentelve, miután további alapvető dolgokat tanultunk a JavaScriptről.