diff --git a/1-js/02-first-steps/07-type-conversions/article.md b/1-js/02-first-steps/07-type-conversions/article.md index cf97b3307..5af0d07b5 100644 --- a/1-js/02-first-steps/07-type-conversions/article.md +++ b/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 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 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`| |true and false | `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,8 +107,8 @@ 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 @@ -115,26 +116,26 @@ 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`| |true / false | `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... | |-------|-------------| @@ -142,9 +143,9 @@ Follows the rules: |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 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 fejezetben beszélünk róla, amely kizárólag az objektumoknak van szentelve, miután további alapvető dolgokat tanultunk a JavaScriptről.