Skip to content

Update article.md #173

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 1 commit into
base: master
Choose a base branch
from
Open
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
97 changes: 49 additions & 48 deletions 1-js/02-first-steps/07-type-conversions/article.md
Original file line number Diff line number Diff line change
@@ -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
Expand All @@ -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.