You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Copy file name to clipboardExpand all lines: 1-js/02-first-steps/05-types/article.md
+35-35Lines changed: 35 additions & 35 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -1,6 +1,6 @@
1
1
# Data types
2
2
3
-
A variable in JavaScript can contain any data. A variable can at one moment be a string and later receive a numeric value:
3
+
A variable in JavaScript can contain any data. A variable can at one moment be a string and at another be a number:
4
4
5
5
```js
6
6
// no error
@@ -10,7 +10,7 @@ message = 123456;
10
10
11
11
Programming languages that allow such things are called "dynamically typed", meaning that there are data types, but variables are not bound to any of them.
12
12
13
-
There are seven basic data types in JavaScript. Here we'll study the basics, and in the next chapters we'll talk about each of them in detail.
13
+
There are seven basic data types in JavaScript. Here, we'll cover them in general and in the next chapters we'll talk about each of them in detail.
14
14
15
15
## A number
16
16
@@ -19,11 +19,11 @@ let n = 123;
19
19
n =12.345;
20
20
```
21
21
22
-
The *number* type serves both for integer and floating point numbers.
22
+
The *number* type represents both integer and floating point numbers.
23
23
24
-
There are many operations for numbers, e.g. multiplication `*`, division `/`, addition `+`, subtraction `-` and so on.
24
+
There are many operations for numbers, e.g. multiplication `*`, division `/`, addition `+`, subtraction `-`, and so on.
25
25
26
-
Besides regular numbers, there are so-called "special numeric values" which also belong to that type: `Infinity`, `-Infinity` and `NaN`.
26
+
Besides regular numbers, there are so-called "special numeric values" which also belong to this data type: `Infinity`, `-Infinity` and `NaN`.
27
27
28
28
-`Infinity` represents the mathematical [Infinity](https://en.wikipedia.org/wiki/Infinity) ∞. It is a special value that's greater than any number.
29
29
@@ -33,7 +33,7 @@ Besides regular numbers, there are so-called "special numeric values" which also
33
33
alert( 1/0 ); // Infinity
34
34
```
35
35
36
-
Or just mention itin the code directly:
36
+
Or just reference it directly:
37
37
38
38
```js run
39
39
alert( Infinity ); // Infinity
@@ -44,27 +44,27 @@ Besides regular numbers, there are so-called "special numeric values" which also
44
44
alert( "not a number" / 2 ); // NaN, such division is erroneous
45
45
```
46
46
47
-
`NaN` is sticky. Any further operation on `NaN`would give`NaN`:
47
+
`NaN` is sticky. Any further operation on `NaN`returns`NaN`:
48
48
49
49
```js run
50
50
alert( "not a number" / 2 + 5 ); // NaN
51
51
```
52
52
53
-
So, if there's `NaN` somewhere in a mathematical expression, it propagates to the whole result.
53
+
So, if there's a `NaN` somewhere in a mathematical expression, it propagates to the whole result.
54
54
55
55
```smart header="Mathematical operations are safe"
56
-
Doing maths is safe in JavaScript. We can do anything: divide by zero, treat non-numeric strings as numbers, etc.
56
+
Doing maths is "safe" in JavaScript. We can do anything: divide by zero, treat non-numeric strings as numbers, etc.
57
57
58
-
The script will never stop with a fatal error ("die"). At worst we'll get `NaN` as the result.
58
+
The script will never stop with a fatal error ("die"). At worst, we'll get `NaN` as the result.
59
59
```
60
60
61
-
Special numeric values formally belong to the "number" type. Of course they are not numbers in a common sense of this word.
61
+
Special numeric values formally belong to the "number" type. Of course they are not numbers in the common sense of this word.
62
62
63
63
We'll see more about working with numbers in the chapter <info:number>.
64
64
65
65
## A string
66
66
67
-
A string in JavaScript must be quoted.
67
+
A string in JavaScript must be surrounded by quotes.
alert( `the result is *!*${1+2}*/!*` ); // the result is 3
93
93
```
94
94
95
-
The expression inside `${...}` is evaluated and the result becomes a part of the string. We can put anything there: a variable like `name` or an arithmetical expression like `1 + 2` or something more complex.
95
+
The expression inside `${...}` is evaluated and the result becomes a part of the string. We can put anything in there: a variable like `name` or an arithmetical expression like `1 + 2` or something more complex.
96
96
97
-
Please note that this can only be done in backticks. Other quotes do not allow such embedding!
97
+
Please note that this can only be done in backticks. Other quotes don't have this embedding functionality!
98
98
```js run
99
99
alert( "the result is ${1 + 2}" ); // the result is ${1 + 2} (double quotes do nothing)
100
100
```
@@ -128,31 +128,31 @@ let isGreater = 4 > 1;
128
128
alert( isGreater ); // true (the comparison result is "yes")
129
129
```
130
130
131
-
We'll cover booleans more deeply later in the chapter <info:logical-operators>.
131
+
We'll cover booleans more deeply in the chapter <info:logical-operators>.
132
132
133
133
## The "null" value
134
134
135
-
The special `null` value does not belong to any type of those described above.
135
+
The special `null` value does not belong to any of the types described above.
136
136
137
-
It forms a separate type of its own, which contains only the `null` value:
137
+
It forms a separate type of its own which contains only the `null` value:
138
138
139
139
```js
140
140
let age =null;
141
141
```
142
142
143
-
In JavaScript `null` is not a "reference to a non-existing object" or a "null pointer" like in some other languages.
143
+
In JavaScript,`null` is not a "reference to a non-existing object" or a "null pointer" like in some other languages.
144
144
145
-
It's just a special value which has the sense of "nothing", "empty" or "value unknown".
145
+
It's just a special value which represents "nothing", "empty" or "value unknown".
146
146
147
-
The code above states that the `age` is unknown or empty for some reason.
147
+
The code above states that `age` is unknown or empty for some reason.
148
148
149
149
## The "undefined" value
150
150
151
-
The special value `undefined` stands apart. It makes a type of its own, just like `null`.
151
+
The special value `undefined`also stands apart. It makes a type of its own, just like `null`.
152
152
153
153
The meaning of `undefined` is "value is not assigned".
154
154
155
-
If a variable is declared, but not assigned, then its value is exactly `undefined`:
155
+
If a variable is declared, but not assigned, then its value is `undefined`:
156
156
157
157
```js run
158
158
let x;
@@ -170,26 +170,26 @@ x = undefined;
170
170
alert(x); // "undefined"
171
171
```
172
172
173
-
...But it's not recommended to do that. Normally, we use `null` to write an "empty" or an "unknown" value into the variable, and `undefined`is only used for checks, to see if the variable is assigned or similar.
173
+
...But we don't recommend doing that. Normally, we use `null` to assign an "empty" or "unknown" value to a variable, and we use `undefined` for checks like seeing if a variable has been assigned.
174
174
175
175
## Objects and Symbols
176
176
177
177
The `object` type is special.
178
178
179
-
All other types are called "primitive", because their values can contain only a single thing (be it a string or a number or whatever). In contrast, objects are used to store collections of data and more complex entities. We'll deal with them later in the chapter <info:object> after we know enough about primitives.
179
+
All other types are called "primitive" because their values can contain only a single thing (be it a string or a number or whatever). In contrast, objects are used to store collections of data and more complex entities. We'll deal with them later in the chapter <info:object> after we learn more about primitives.
180
180
181
-
The `symbol` type is used to create unique identifiers for objects. We have to mention it here for completeness, but it's better to study them after objects.
181
+
The `symbol` type is used to create unique identifiers for objects. We have to mention it here for completeness, but it's better to study this type after objects.
182
182
183
183
## The typeof operator [#type-typeof]
184
184
185
-
The `typeof` operator returns the type of the argument. It's useful when we want to process values of different types differently, or just want to make a quick check.
185
+
The `typeof` operator returns the type of the argument. It's useful when we want to process values of different types differently or just want to do a quick check.
186
186
187
187
It supports two forms of syntax:
188
188
189
189
1. As an operator: `typeof x`.
190
-
2.Function style: `typeof(x)`.
190
+
2.As a function: `typeof(x)`.
191
191
192
-
In other words, it works both with parentheses or without them. The result is the same.
192
+
In other words, it works with parentheses or without them. The result is the same.
193
193
194
194
The call to `typeof x` returns a string with the type name:
The last three lines may need additional explanations:
220
+
The last three lines may need additional explanation:
221
221
222
-
1.`Math` is a built-in object that provides mathematical operations. We will learn it in the chapter <info:number>. Here it serves just as an example of an object.
223
-
2. The result of `typeof null` is `"object"`. That's wrong. It is an officially recognized error in `typeof`, kept for compatibility. Of course, `null` is not an object. It is a special value with a separate type of its own. So, again, that's an error in the language.
224
-
3. The result of `typeof alert` is `"function"`, because `alert` is a function of the language. We'll study functions in the next chapters, and we'll see that there's no special "function" type in the language. Functions belong to the object type. But `typeof` treats them differently. Formally, it's incorrect, but very convenient in practice.
222
+
1.`Math` is a built-in object that provides mathematical operations. We will learn it in the chapter <info:number>. Here, it serves just as an example of an object.
223
+
2. The result of `typeof null` is `"object"`. That's wrong. It is an officially recognized error in `typeof`, kept for compatibility. Of course, `null` is not an object. It is a special value with a separate type of its own. So, again, this is an error in the language.
224
+
3. The result of `typeof alert` is `"function"`, because `alert` is a function of the language. We'll study functions in the next chapters where we'll see that there's no special "function" type in JavaScript. Functions belong to the object type. But `typeof` treats them differently. Formally, it's incorrect, but very convenient in practice.
225
225
226
226
227
227
## Summary
@@ -236,10 +236,10 @@ There are 7 basic types in JavaScript.
236
236
-`object` for more complex data structures.
237
237
-`symbol` for unique identifiers.
238
238
239
-
The `typeof` operator allows us to see which type is stored in the variable.
239
+
The `typeof` operator allows us to see which type is stored in a variable.
240
240
241
241
- Two forms: `typeof x` or `typeof(x)`.
242
242
- Returns a string with the name of the type, like `"string"`.
243
-
- For `null` returns `"object"` -- that's an error in the language, it's not an object in fact.
243
+
- For `null` returns `"object"` -- this is an error in the language, it's not actually an object.
244
244
245
-
In the next chapters we'll concentrate on primitive values and once we're familiar with them, then we'll move on to objects.
245
+
In the next chapters, we'll concentrate on primitive values and once we're familiar with them, we'll move on to objects.
0 commit comments