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/01-getting-started/1-intro/article.md
+4-3
Original file line number
Diff line number
Diff line change
@@ -4,7 +4,7 @@ Let's see what's so special about JavaScript, what we can achieve with it, and w
4
4
5
5
## What is JavaScript?
6
6
7
-
*JavaScript* was initially created to *"make web pages alive"*.
7
+
*JavaScript* was initially created to "make web pages alive".
8
8
9
9
The programs in this language are called *scripts*. They can be written right in a web page's HTML and run automatically as the page loads.
10
10
@@ -26,7 +26,7 @@ Different engines have different "codenames". For example:
26
26
27
27
-[V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) -- in Chrome and Opera.
28
28
-[SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey) -- in Firefox.
29
-
- ...There are other codenames like "Trident" and "Chakra" for different versions of IE, "ChakraCore" for Microsoft Edge, "Nitro" and "SquirrelFish" for Safari, etc.
29
+
- ...There are other codenames like "Chakra" for IE, "ChakraCore" for Microsoft Edge, "Nitro" and "SquirrelFish" for Safari, etc.
30
30
31
31
The terms above are good to remember because they are used in developer articles on the internet. We'll use them too. For instance, if "a feature X is supported by V8", then it probably works in Chrome and Opera.
32
32
@@ -63,7 +63,7 @@ JavaScript's abilities in the browser are limited for the sake of the user's saf
63
63
64
64
Examples of such restrictions include:
65
65
66
-
- JavaScript on a webpage may not read/write arbitrary files on the hard disk, copy them or execute programs. It has no direct access to OS system functions.
66
+
- JavaScript on a webpage may not read/write arbitrary files on the hard disk, copy them or execute programs. It has no direct access to OS functions.
67
67
68
68
Modern browsers allow it to work with files, but the access is limited and only provided if the user does certain actions, like "dropping" a file into a browser window or selecting it via an `<input>` tag.
69
69
@@ -110,6 +110,7 @@ Examples of such languages:
110
110
-[TypeScript](http://www.typescriptlang.org/) is concentrated on adding "strict data typing" to simplify the development and support of complex systems. It is developed by Microsoft.
111
111
-[Flow](http://flow.org/) also adds data typing, but in a different way. Developed by Facebook.
112
112
-[Dart](https://www.dartlang.org/) is a standalone language that has its own engine that runs in non-browser environments (like mobile apps), but also can be transpiled to JavaScript. Developed by Google.
113
+
-[Brython](https://brython.info/) is a Python transpiler to JavaScript that allow to write application in pure Python without JavaScript.
113
114
114
115
There are more. Of course, even if we use one of transpiled languages, we should also know JavaScript to really understand what we're doing.
Copy file name to clipboardExpand all lines: 1-js/02-first-steps/01-hello-world/article.md
+2-2
Original file line number
Diff line number
Diff line change
@@ -46,7 +46,7 @@ The `<script>` tag contains JavaScript code which is automatically executed when
46
46
The `<script>` tag has a few attributes that are rarely used nowadays but can still be found in old code:
47
47
48
48
The `type` attribute: <code><script <u>type</u>=...></code>
49
-
: The old HTML standard, HTML4, required a script to have a `type`. Usually it was `type="text/javascript"`. It's not required anymore. Also, the modern HTML standard totally changed the meaning of this attribute. Now, it can be used for JavaScript modules. But that's an advanced topic; we'll talk about modules in another part of the tutorial.
49
+
: The old HTML standard, HTML4, required a script to have a `type`. Usually it was `type="text/javascript"`. It's not required anymore. Also, the modern HTML standard totally changed the meaning of this attribute. Now, it can be used for JavaScript modules. But that's an advanced topic, we'll talk about modules in another part of the tutorial.
50
50
51
51
The `language` attribute: <code><script <u>language</u>=...></code>
52
52
: This attribute was meant to show the language of the script. This attribute no longer makes sense because JavaScript is the default language. There is no need to use it.
@@ -78,7 +78,7 @@ Here, `/path/to/script.js` is an absolute path to the script from the site root.
Copy file name to clipboardExpand all lines: 1-js/02-first-steps/02-structure/article.md
+2-2
Original file line number
Diff line number
Diff line change
@@ -94,7 +94,7 @@ But it should be two separate statements, not one. Such a merging in this case i
94
94
95
95
We recommend putting semicolons between statements even if they are separated by newlines. This rule is widely adopted by the community. Let's note once again -- *it is possible* to leave out semicolons most of the time. But it's safer -- especially for a beginner -- to use them.
96
96
97
-
## Comments
97
+
## Comments[#code-comments]
98
98
99
99
As time goes on, programs become more and more complex. It becomes necessary to add *comments* which describe what the code does and why.
100
100
@@ -136,7 +136,7 @@ alert('World');
136
136
```
137
137
138
138
```smart header="Use hotkeys!"
139
-
In most editors, a line of code can be commented out by pressing the `key:Ctrl+/` hotkey for a single-line comment and something like `key:Ctrl+Shift+/` -- for multiline comments (select a piece of code and press the hotkey). For Mac, try `key:Cmd` instead of `key:Ctrl`.
139
+
In most editors, a line of code can be commented out by pressing the `key:Ctrl+/` hotkey for a single-line comment and something like `key:Ctrl+Shift+/` -- for multiline comments (select a piece of code and press the hotkey). For Mac, try `key:Cmd` instead of `key:Ctrl` and `key:Option` instead of `key:Shift`.
140
140
```
141
141
142
142
````warn header="Nested comments are not supported!"
Copy file name to clipboardExpand all lines: 1-js/02-first-steps/03-strict-mode/article.md
+18-14
Original file line number
Diff line number
Diff line change
@@ -19,8 +19,7 @@ For example:
19
19
...
20
20
```
21
21
22
-
We will learn functions (a way to group commands) soon. Looking ahead, let's note that `"use strict"` can be put at the beginning of the function body instead of the whole script. Doing that enables strict mode in that function only. But usually, people use it for the whole script.
23
-
22
+
Quite soon we're going to learn functions (a way to group commands), so let's note in advance that `"use strict"` can be put at the beginning of a function. Doing that enables strict mode in that function only. But usually people use it for the whole script.
24
23
25
24
````warn header="Ensure that \"use strict\" is at the top"
26
25
Please make sure that `"use strict"` is at the top of your scripts, otherwise strict mode may not be enabled.
@@ -47,11 +46,13 @@ Once we enter strict mode, there's no going back.
47
46
48
47
## Browser console
49
48
50
-
For the future, when you use a browser console to test features, please note that it doesn't `use strict` by default.
49
+
When you use a [developer console](info:devtools) to run code, please note that it doesn't `use strict` by default.
51
50
52
51
Sometimes, when `use strict` makes a difference, you'll get incorrect results.
53
52
54
-
You can try to press `key:Shift+Enter` to input multiple lines, and put `use strict` on top, like this:
53
+
So, how to actually `use strict` in the console?
54
+
55
+
First, you can try to press `key:Shift+Enter` to input multiple lines, and put `use strict` on top, like this:
55
56
56
57
```js
57
58
'use strict'; <Shift+Enter for a newline>
@@ -61,25 +62,28 @@ You can try to press `key:Shift+Enter` to input multiple lines, and put `use str
61
62
62
63
It works in most browsers, namely Firefox and Chrome.
63
64
64
-
If it doesn't, the most reliable way to ensure `use strict` would be to input the code into console like this:
65
+
If it doesn't, e.g. in an old browser, there's an ugly, but reliable way to ensure `use strict`. Put it inside this kind of wrapper:
65
66
66
67
```js
67
68
(function() {
68
69
'use strict';
69
70
70
-
// ...your code...
71
+
// ...your code here...
71
72
})()
72
73
```
73
74
74
-
## Always "use strict"
75
+
## Should we "use strict"?
76
+
77
+
The question may sound obvious, but it's not so.
78
+
79
+
One could recommend to start scripts with `"use strict"`... But you know what's cool?
80
+
81
+
Modern JavaScript supports "classes" and "modules" - advanced language structures (we'll surely get to them), that enable `use strict` automatically. So we don't need to add the `"use strict"` directive, if we use them.
75
82
76
-
We have yet to cover the differences between strict mode and the "default" mode.
83
+
**So, for now `"use strict";` is a welcome guest at the top of your scripts. Later, when your code is all in classes and modules, you may omit it.**
77
84
78
-
In the next chapters, as we learn language features, we'll note the differences between the strict and default modes. Luckily, there aren't many and they actually make our lives better.
85
+
As of now, we've got to know about `use strict` in general.
79
86
80
-
For now, it's enough to know about it in general:
87
+
In the next chapters, as we learn language features, we'll see the differences between the strict and old modes. Luckily, there aren't many and they actually make our lives better.
81
88
82
-
1. The `"use strict"` directive switches the engine to the "modern" mode, changing the behavior of some built-in features. We'll see the details later in the tutorial.
83
-
2. Strict mode is enabled by placing `"use strict"` at the top of a script or function. Several language features, like "classes" and "modules", enable strict mode automatically.
84
-
3. Strict mode is supported by all modern browsers.
85
-
4. We recommended always starting scripts with `"use strict"`. All examples in this tutorial assume strict mode unless (very rarely) specified otherwise.
89
+
All examples in this tutorial assume strict mode unless (very rarely) specified otherwise.
````warn header="Declaring twice triggers an error"
138
+
A variable should be declared only once.
139
+
140
+
A repeated declaration of the same variable is an error:
141
+
142
+
```js run
143
+
let message = "This";
144
+
145
+
// repeated 'let' leads to an error
146
+
let message = "That"; // SyntaxError: 'message' has already been declared
147
+
```
148
+
So, we should declare a variable once and then refer to it without `let`.
149
+
````
150
+
138
151
```smart header="Functional languages"
139
152
It's interesting to note that there exist [functional](https://en.wikipedia.org/wiki/Functional_programming) programming languages, like [Scala](http://www.scala-lang.org/) or [Erlang](http://www.erlang.org/) that forbid changing variable values.
140
153
@@ -190,7 +203,7 @@ let имя = '...';
190
203
let 我 = '...';
191
204
```
192
205
193
-
Technically, there is no error here, such names are allowed, but there is an international tradition to use English in variable names. Even if we're writing a small script, it may have a long life ahead. People from other countries may need to read it some time.
206
+
Technically, there is no error here. Such names are allowed, but there is an international convention to use English in variable names. Even if we're writing a small script, it may have a long life ahead. People from other countries may need to read it some time.
Copy file name to clipboardExpand all lines: 1-js/02-first-steps/05-types/article.md
+31-24
Original file line number
Diff line number
Diff line change
@@ -1,16 +1,18 @@
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 at another be a number:
3
+
A value in JavaScript is always of a certain type. For example, a string or a number.
4
+
5
+
There are eight 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.
6
+
7
+
We can put any type in a variable. For example, a variable can at one moment be a string and then store a number:
4
8
5
9
```js
6
10
// no error
7
11
let message ="hello";
8
12
message =123456;
9
13
```
10
14
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
-
13
-
There are eight 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.
15
+
Programming languages that allow such things, such as JavaScript, are called "dynamically typed", meaning that there exist data types, but variables are not bound to any of them.
14
16
15
17
## Number
16
18
@@ -64,21 +66,23 @@ We'll see more about working with numbers in the chapter <info:number>.
64
66
65
67
## BigInt
66
68
67
-
In JavaScript, the "number" type cannot represent integer values larger than <code>2<sup>53</sup></code> (or less than <code>-2<sup>53</sup></code> for negatives), that's a technical limitation caused by their internal representation. That's about 16 decimal digits, so for most purposes the limitation isn't a problem, but sometimes we need really big numbers, e.g. for cryptography or microsecond-precision timestamps.
69
+
In JavaScript, the "number" type cannot represent integer values larger than <code>(2<sup>53</sup>-1)</code> (that's `9007199254740991`), or less than <code>-(2<sup>53</sup>-1)</code> for negatives. It's a technical limitation caused by their internal representation.
70
+
71
+
For most purposes that's quite enough, but sometimes we need really big numbers, e.g. for cryptography or microsecond-precision timestamps.
68
72
69
73
`BigInt` type was recently added to the language to represent integers of arbitrary length.
70
74
71
-
A `BigInt` is created by appending `n` to the end of an integer literal:
75
+
A `BigInt`value is created by appending `n` to the end of an integer:
As `BigInt` numbers are rarely needed, we devoted them a separate chapter <info:bigint>.
82
+
As `BigInt` numbers are rarely needed, we don't cover them here, but devoted them a separate chapter <info:bigint>. Read it when you need such big numbers.
79
83
80
-
```smart header="Compatability issues"
81
-
Right now `BigInt` is supported in Firefox and Chrome, but not in Safari/IE/Edge.
84
+
```smart header="Compatibility issues"
85
+
Right now `BigInt` is supported in Firefox/Chrome/Edge, but not in Safari/IE.
82
86
```
83
87
84
88
## String
@@ -123,7 +127,7 @@ We'll cover strings more thoroughly in the chapter <info:string>.
123
127
```smart header="There is no *character* type."
124
128
In some languages, there is a special "character" type for a single character. For example, in the C language and in Java it is called "char".
125
129
126
-
In JavaScript, there is no such type. There's only one type: `string`. A string may consist of only one character or many of them.
130
+
In JavaScript, there is no such type. There's only one type: `string`. A string may consist of zero characters (be empty), one character or many of them.
127
131
```
128
132
129
133
## Boolean (logical type)
@@ -163,7 +167,7 @@ In JavaScript, `null` is not a "reference to a non-existing object" or a "null p
163
167
164
168
It's just a special value which represents "nothing", "empty" or "value unknown".
165
169
166
-
The code above states that `age` is unknown or empty for some reason.
170
+
The code above states that `age` is unknown.
167
171
168
172
## The "undefined" value
169
173
@@ -174,30 +178,33 @@ The meaning of `undefined` is "value is not assigned".
174
178
If a variable is declared, but not assigned, then its value is `undefined`:
175
179
176
180
```js run
177
-
letx;
181
+
letage;
178
182
179
-
alert(x); // shows "undefined"
183
+
alert(age); // shows "undefined"
180
184
```
181
185
182
-
Technically, it is possible to assign `undefined` to any variable:
186
+
Technically, it is possible to explicitly assign `undefined` to a variable:
183
187
184
188
```js run
185
-
letx=123;
189
+
letage=100;
186
190
187
-
x =undefined;
191
+
// change the value to undefined
192
+
age =undefined;
188
193
189
-
alert(x); // "undefined"
194
+
alert(age); // "undefined"
190
195
```
191
196
192
-
...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.
197
+
...But we don't recommend doing that. Normally, one uses`null` to assign an "empty" or "unknown" value to a variable, while `undefined`is reserved as a default initial value for unassigned things.
193
198
194
199
## Objects and Symbols
195
200
196
201
The `object` type is special.
197
202
198
-
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.
203
+
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.
204
+
205
+
Being that important, objects deserve a special treatment. We'll deal with them later in the chapter <info:object>, after we learn more about primitives.
199
206
200
-
The `symbol` type is used to create unique identifiers for objects. We mention it here for completeness, but we'll study it after objects.
207
+
The `symbol` type is used to create unique identifiers for objects. We have to mention it here for the sake of completeness, but also postpone the details till we know objects.
The last three lines may need additional explanation:
242
249
243
250
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.
244
-
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.
245
-
3. The result of `typeof alert` is `"function"`, because `alert` is a function. We'll study functions in the next chapters where we'll also see that there's no special "function" type in JavaScript. Functions belong to the object type. But `typeof` treats them differently, returning `"function"`. That's not quite correct, but very convenient in practice.
251
+
2. The result of `typeof null` is `"object"`. That's an officially recognized error in `typeof` behavior, coming from the early days of JavaScript and kept for compatibility. Definitely, `null` is not an object. It is a special value with a separate type of its own.
252
+
3. The result of `typeof alert` is `"function"`, because `alert` is a function. We'll study functions in the next chapters where we'll also see that there's no special "function" type in JavaScript. Functions belong to the object type. But `typeof` treats them differently, returning `"function"`. That also comes from the early days of JavaScript. Technically, such behavior isn't correct, but can be convenient in practice.
246
253
247
254
## Summary
248
255
249
256
There are 8 basic data types in JavaScript.
250
257
251
-
-`number` for numbers of any kind: integer or floating-point, integers are limited by ±2<sup>53</sup>.
258
+
-`number` for numbers of any kind: integer or floating-point, integers are limited by <code>±(2<sup>53</sup>-1)</code>.
252
259
-`bigint` is for integer numbers of arbitrary length.
253
-
-`string` for strings. A string may have one or more characters, there's no separate single-character type.
260
+
-`string` for strings. A string may have zero or more characters, there's no separate single-character type.
254
261
-`boolean` for `true`/`false`.
255
262
-`null` for unknown values -- a standalone type that has a single value `null`.
256
263
-`undefined` for unassigned values -- a standalone type that has a single value `undefined`.
0 commit comments