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..d66cf9836 100644 --- a/1-js/02-first-steps/07-type-conversions/article.md +++ b/1-js/02-first-steps/07-type-conversions/article.md @@ -1,150 +1,151 @@ -# Type Conversions +# Type Conversies -Most of the time, operators and functions automatically convert the values given to them to the right type. +Gewoonlijk converteren operators en functies de aan hen gegeven waarden automatisch naar het juiste type. -For example, `alert` automatically converts any value to a string to show it. Mathematical operations convert values to numbers. +`alert` converteert bijvoorbeeld elke waarde automatisch naar een tekenreeks om het tonen. Wiskundige bewerkingen converteren waarden naar getallen. -There are also cases when we need to explicitly convert a value to the expected type. +Er zijn ook gevallen waarin we moeten een waarde uitdrukkelijk converteren naar het verwachte type. -```smart header="Not talking about objects yet" -In this chapter, we won't cover objects. For now we'll just be talking about primitives. +```smart header="Nog niet over objecten gesproken" +In dit hoofdstuk, we zullen niet bespreken objecten. Voor nu zullen we het alleen over primitieven hebben. -Later, after we learn about objects, in the chapter we'll see how objects fit in. +Later, nadat we hebben leren over objecten, zullen we in het hoofdstuk zien hoe objecten passen. ``` -## String Conversion +## Tekenreeks Conversie -String conversion happens when we need the string form of a value. +Tekenreeks conversie gebeurt wanneer we hebben de tekenreeksvorm van een waarde nodig. -For example, `alert(value)` does it to show the value. +`alert(value)` doet het bijvoorbeeld om de waarde te tonen. -We can also call the `String(value)` function to convert a value to a string: +We kunnen ook aan de `String(value)` (tekenreeks) functie roepen om een waarde naar een tekenreeks te converteren: ```js run let value = true; alert(typeof value); // boolean *!* -value = String(value); // now value is a string "true" +value = String(value); // nu is value een tekenreeks "true" alert(typeof value); // string */!* ``` -String conversion is mostly obvious. A `false` becomes `"false"`, `null` becomes `"null"`, etc. +Tekenreeks conversie is meestal duidelijk. Een `false` wordt `"false"`, `null` wordt `"null"`, ezv. -## Numeric Conversion +## Numerieke Conversie -Numeric conversion happens in mathematical functions and expressions automatically. +Numerieke conversie gebeurt automatisch in wiskundige functie en uitdrukkingen. -For example, when division `/` is applied to non-numbers: +Wanneer bijvoorbeeld verdeling `/` wordt toegepast op niet-getallen: ```js run -alert( "6" / "2" ); // 3, strings are converted to numbers +alert( "6" / "2" ); // 3, tekenreeksen worden geconverteerd naar getallen ``` -We can use the `Number(value)` function to explicitly convert a `value` to a number: +We kunnen de `Number(value)` (nummer) functie gebruiken om een `value` uitdrukkelijk naar een getal converteren: ```js run let str = "123"; alert(typeof str); // string -let num = Number(str); // becomes a number 123 +let num = Number(str); // wordt een getal 123 alert(typeof num); // number ``` -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. +Expliciete conversie is gewoonlijk vereist wanneer we een waarde uit een op tekenreeks gebaseerde bron zoals een tekstformulier lezen, maar wervachten dat er een getal wordt ingevoerd. -If the string is not a valid number, the result of such a conversion is `NaN`. For instance: +Als de tekenreeks geen geldig getal is, is het resultaat van een dergelijke conversie `NaN` (niet een getal). Bijvoorbeeld: ```js run -let age = Number("an arbitrary string instead of a number"); +let age = Number("een willekeurig tekenreeks in plaats van een getal"); -alert(age); // NaN, conversion failed +alert(age); // NaN, conversie mislukt ``` -Numeric conversion rules: +Numerieke conversie regels: -| 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`. | +| Waarde | Wordt... | +| ------ | -------- | +| `undefined` | `NaN` | +| `null` | `0` | +| true en false | `1` and `0` | +| `string` | Witruimte vanaf het begin en het einde worden verwijderd. Als de resterende tekenreeks leeg is, is het resultaat `0`. En anders is het getal "gelezen" uit de tekenreeks. Een fout geeft `NaN`. | -Examples: +Voorbeelden: ```js run alert( Number(" 123 ") ); // 123 -alert( Number("123z") ); // NaN (error reading a number at "z") +alert( Number("123z") ); // NaN (fout bij het lezen van een getal op "z") alert( Number(true) ); // 1 alert( Number(false) ); // 0 ``` -Please note that `null` and `undefined` behave differently here: `null` becomes zero while `undefined` becomes `NaN`. +Houd er rekening mee dat `null` en `undefined` gedragen hier anders: `null` wordt nul terwijl `undefined` `NaN` wordt. -Most mathematical operators also perform such conversion, we'll see that in the next chapter. +Meeste wiskundige operators uitvoeren ook een dergelijke conversie, dat zullen we zien in het volgende hoofdstuk. -## Boolean Conversion +## Booleaanse Conversie -Boolean conversion is the simplest one. +Booleanse conversie is de gemakkelijkste. -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)`. +Het gebeurt in logische bewerkingen (later zullen we conditietests en andere soortgelijke dingen ontmoeten), maar kan ook expliciet worden uitgevoerd met een oproep naar `Boolean(value)`. -The conversion rule: +De conversieregel: -- Values that are intuitively "empty", like `0`, an empty string, `null`, `undefined`, and `NaN`, become `false`. -- Other values become `true`. +- Waarden die intuïtief "leeg" zijn, zoals `0`, een lege tekenreeks, `null`, `undefined` en `NaN` worden `false`. +- Andere waarden worden `true`. -For instance: +Voorbeelden: ```js run alert( Boolean(1) ); // true alert( Boolean(0) ); // false -alert( Boolean("hello") ); // true +alert( Boolean("hallo") ); // 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="Let op: de tekenreeks met nul `\"0\"` is `true`" +Sommige talen (namelijk PHP) behandelen `"0"` als `false`. Maar in JavaScript is een niet-lege tekenreeks altijd `true`. ```js run alert( Boolean("0") ); // true -alert( Boolean(" ") ); // spaces, also true (any non-empty string is true) +alert( Boolean(" ") ); // spaties, ook true (elke niet-lege tekenreeks is true) ``` ```` -## Summary +## Overzicht -The three most widely used type conversions are to string, to number, and to boolean. +De drie meest gebruikte type conversies zijn naar tekenreeks, naar getaal en naar boolean. -**`String Conversion`** -- Occurs when we output something. Can be performed with `String(value)`. The conversion to string is usually obvious for primitive values. +**`Tekenreeks Conversie`** -- Gebeurt als we iets uitvoeren. Kan worden uitgevoerd met `String(value)` (tekenreeks). De conversie naar tekenreeks ligt meestal voor de hand voor primitieve waarden. -**`Numeric Conversion`** -- Occurs in math operations. Can be performed with `Number(value)`. +**`Numerieke Conversie`** -- Gebeurt in wiskundige bewerkingen. Kan worden uitgevored met `Number(value)` (getal). -The conversion follows the rules: +De conversie volgt de regels: -| 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`. | -**`Boolean Conversion`** -- Occurs in logical operations. Can be performed with `Boolean(value)`. +| Waarde | Wordt... | +| ------ | -------- | +| `undefined` | `NaN` | +| `null` | `0` | +| true / false | `1 / 0` | +| `string` | De tekenreeks wordt gelezen zoals het is, witruimten aan beide zijden worden genegeerd. Een lege tekenreeks wordt `0`. Een fout geeft `NaN`. | -Follows the rules: +**`Booleaanse Conversie`** -- Gebeurt in logische bewerkingen. Kan worden uitgevoerd met `Boolean(value)`. -| Value | Becomes... | -|-------|-------------| -|`0`, `null`, `undefined`, `NaN`, `""` |`false`| -|any other value| `true` | +Volgt de regels: +| Waarde | Wordt... | +| ------ | -------- | +| `0`, `null`, `undefined`, `NaN`, `""` | `false` | +| elke andere waarde | `true` | -Most of these rules are easy to understand and memorize. The notable exceptions where people usually make mistakes are: -- `undefined` is `NaN` as a number, not `0`. -- `"0"` and space-only strings like `" "` are true as a boolean. +De meeste van deze regels zijn gemakkelijk te begrijpen en te onthouden. De opmerkelijke uitzonderingen waar mensen gewoonlijk fouten maken zijn: -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. +- `undefined` is `NaN` als een getal, niet `0`. +- `"0"` en tekenreeksen met alleen spaties zoals `" "` zijn waar als een boolean. + +Objecten wordt hier niet behandeld. We komen er later op terug in het hoofdstuk dat uitsluitend aan objecten gewijd is, nadat we meer basisdingen over JavaScript hebben geleerd. pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy