Skip to content

Commit 88f1c02

Browse files
iliakaniliakan
committed
merging all conflicts
2 parents 7b86629 + b85413d commit 88f1c02

File tree

229 files changed

+2396
-1172
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

229 files changed

+2396
-1172
lines changed

‎1-js/01-getting-started/1-intro/article.md

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,11 @@
44

55
## ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਕੀ ਹੈ?
66

7+
<<<<<<< HEAD
78
* ਜਾਵਾ ਸਕ੍ਰਿਪਟ * ਸ਼ੁਰੂਆਤ ਵਿੱਚ * "ਵੈੱਬ ਪੇਜਾਂ ਨੂੰ ਜੀਵੰਤ" * ਬਣਾਉਣ ਲਈ ਬਣਾਈ ਗਈ ਸੀ।
9+
=======
10+
*JavaScript* was initially created to "make web pages alive".
11+
>>>>>>> b85413d0bdd6f4f468fcadeacb4c4056e3671ce1
812
913
ਇਸ ਭਾਸ਼ਾ ਦੇ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ * ਸਕ੍ਰਿਪਟਾਂ * ਕਿਹਾ ਜਾਂਦਾ ਹੈ. ਉਹ ਇਕ ਵੈੱਬ ਪੇਜ ਦੇ HTML ਵਿਚ ਸਹੀ ਤਰ੍ਹਾਂ ਲਿਖੇ ਜਾ ਸਕਦੇ ਹਨ ਅਤੇ ਪੰਨੇ ਦੇ ਲੋਡ ਹੋਣ ਦੇ ਨਾਲ ਆਪਣੇ ਆਪ ਚਲ ਸਕਦੇ ਹਨ।
1014

‎1-js/02-first-steps/01-hello-world/1-hello-alert/index.html

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
<!DOCTYPE html>
2+
<html>
3+
4+
<body>
5+
6+
<script>
7+
alert( "I'm JavaScript!" );
8+
</script>
9+
10+
</body>
11+
12+
</html>

‎1-js/02-first-steps/01-hello-world/1-hello-alert/solution.md

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,2 @@
1+
2+
[html src="index.html"]

‎1-js/02-first-steps/01-hello-world/article.md

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -46,7 +46,7 @@ The `<script>` tag contains JavaScript code which is automatically executed when
4646
The `<script>` tag has a few attributes that are rarely used nowadays but can still be found in old code:
4747

4848
The `type` attribute: <code>&lt;script <u>type</u>=...&gt;</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.
5050

5151
The `language` attribute: <code>&lt;script <u>language</u>=...&gt;</code>
5252
: 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.
7878
We can give a full URL as well. For instance:
7979

8080
```html
81-
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.2.0/lodash.js"></script>
81+
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js"></script>
8282
```
8383

8484
To attach several scripts, use multiple tags:

‎1-js/02-first-steps/03-strict-mode/article.md

Lines changed: 18 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -19,8 +19,7 @@ For example:
1919
...
2020
```
2121

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.
2423

2524
````warn header="Ensure that \"use strict\" is at the top"
2625
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.
4746
4847
## Browser console
4948
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.
5150
5251
Sometimes, when `use strict` makes a difference, you'll get incorrect results.
5352
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:
5556
5657
```js
5758
'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
6162

6263
It works in most browsers, namely Firefox and Chrome.
6364

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:
6566

6667
```js
6768
(function() {
6869
'use strict';
6970

70-
// ...your code...
71+
// ...your code here...
7172
})()
7273
```
7374

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.
7582

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.**
7784

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.
7986

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.
8188

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.

‎1-js/02-first-steps/04-variables/article.md

Lines changed: 15 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -80,7 +80,6 @@ let user = 'John'
8080

8181
Technically, all these variants do the same thing. So, it's a matter of personal taste and aesthetics.
8282

83-
8483
````smart header="`var` instead of `let`"
8584
In older scripts, you may also find another keyword: `var` instead of `let`:
8685

@@ -135,6 +134,20 @@ alert(hello); // Hello world!
135134
alert(message); // Hello world!
136135
```
137136
137+
````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+
138151
```smart header="Functional languages"
139152
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.
140153
@@ -190,7 +203,7 @@ let имя = '...';
190203
let 我 = '...';
191204
```
192205
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.
194207
````
195208

196209
````warn header="Reserved names"

‎1-js/02-first-steps/05-types/article.md

Lines changed: 28 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -1,16 +1,18 @@
11
# Data types
22

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:
48

59
```js
610
// no error
711
let message = "hello";
812
message = 123456;
913
```
1014

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.
1416

1517
## Number
1618

@@ -64,21 +66,23 @@ We'll see more about working with numbers in the chapter <info:number>.
6466

6567
## BigInt
6668

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.
6872

6973
`BigInt` type was recently added to the language to represent integers of arbitrary length.
7074

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:
7276

7377
```js
7478
// the "n" at the end means it's a BigInt
7579
const bigInt = 1234567890123456789012345678901234567890n;
7680
```
7781

78-
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.
7983

8084
```smart header="Compatability issues"
81-
Right now `BigInt` is supported in Firefox and Chrome, but not in Safari/IE/Edge.
85+
Right now `BigInt` is supported in Firefox/Chrome/Edge, but not in Safari/IE.
8286
```
8387

8488
## String
@@ -163,7 +167,7 @@ In JavaScript, `null` is not a "reference to a non-existing object" or a "null p
163167

164168
It's just a special value which represents "nothing", "empty" or "value unknown".
165169

166-
The code above states that `age` is unknown or empty for some reason.
170+
The code above states that `age` is unknown.
167171

168172
## The "undefined" value
169173

@@ -174,30 +178,33 @@ The meaning of `undefined` is "value is not assigned".
174178
If a variable is declared, but not assigned, then its value is `undefined`:
175179

176180
```js run
177-
let x;
181+
let age;
178182

179-
alert(x); // shows "undefined"
183+
alert(age); // shows "undefined"
180184
```
181185

182-
Technically, it is possible to assign `undefined` to any variable:
186+
Technically, it is possible to explicitly assign `undefined` to a variable:
183187

184188
```js run
185-
let x = 123;
189+
let age = 100;
186190

187-
x = undefined;
191+
// change the value to undefined
192+
age = undefined;
188193

189-
alert(x); // "undefined"
194+
alert(age); // "undefined"
190195
```
191196

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.
193198

194199
## Objects and Symbols
195200

196201
The `object` type is special.
197202

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.
199206

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.
201208

202209
## The typeof operator [#type-typeof]
203210

@@ -241,16 +248,16 @@ typeof alert // "function" (3)
241248
The last three lines may need additional explanation:
242249

243250
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.
246253

247254
## Summary
248255

249256
There are 8 basic data types in JavaScript.
250257

251258
- `number` for numbers of any kind: integer or floating-point, integers are limited by ±2<sup>53</sup>.
252259
- `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.
254261
- `boolean` for `true`/`false`.
255262
- `null` for unknown values -- a standalone type that has a single value `null`.
256263
- `undefined` for unassigned values -- a standalone type that has a single value `undefined`.

‎1-js/02-first-steps/09-alert-prompt-confirm/1-simple-page/solution.md renamed to ‎1-js/02-first-steps/06-alert-prompt-confirm/1-simple-page/solution.md

File renamed without changes.

‎1-js/02-first-steps/09-alert-prompt-confirm/1-simple-page/task.md renamed to ‎1-js/02-first-steps/06-alert-prompt-confirm/1-simple-page/task.md

File renamed without changes.

‎1-js/02-first-steps/09-alert-prompt-confirm/article.md renamed to ‎1-js/02-first-steps/06-alert-prompt-confirm/article.md

Lines changed: 8 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -1,26 +1,18 @@
11
# Interaction: alert, prompt, confirm
22

3-
In this part of the tutorial we cover JavaScript language "as is", without environment-specific tweaks.
4-
5-
But we'll still be using the browser as our demo environment, so we should know at least a few of its user-interface functions. In this chapter, we'll get familiar with the browser functions `alert`, `prompt` and `confirm`.
3+
As we'll be using the browser as our demo environment, let's see a couple of functions to interact with the user: `alert`, `prompt` and `confirm`.
64

75
## alert
86

9-
Syntax:
10-
11-
```js
12-
alert(message);
13-
```
14-
15-
This shows a message and pauses script execution until the user presses "OK".
7+
This one we've seen already. It shows a message and waits for the user to press "OK".
168

179
For example:
1810

1911
```js run
2012
alert("Hello");
2113
```
2214

23-
The mini-window with the message is called a *modal window*. The word "modal" means that the visitor can't interact with the rest of the page, press other buttons, etc. until they have dealt with the window. In this case -- until they press "OK".
15+
The mini-window with the message is called a *modal window*. The word "modal" means that the visitor can't interact with the rest of the page, press other buttons, etc, until they have dealt with the window. In this case -- until they press "OK".
2416

2517
## prompt
2618

@@ -38,7 +30,11 @@ It shows a modal window with a text message, an input field for the visitor, and
3830
`default`
3931
: An optional second parameter, the initial value for the input field.
4032

41-
The visitor may type something in the prompt input field and press OK. Or they can cancel the input by pressing Cancel or hitting the `key:Esc` key.
33+
```smart header="The square brackets in syntax `[...]`"
34+
The square brackets around `default` in the syntax above denote that the parameter as optional, not required.
35+
```
36+
37+
The visitor can type something in the prompt input field and press OK. Then we get that text in the `result`. Or they can cancel the input by pressing Cancel or hitting the `key:Esc` key, then we get `null` as the `result`.
4238
4339
The call to `prompt` returns the text from the input field or `null` if the input was canceled.
4440

‎1-js/02-first-steps/06-type-conversions/article.md renamed to ‎1-js/02-first-steps/07-type-conversions/article.md

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,9 @@ For example, `alert` automatically converts any value to a string to show it. Ma
77
There are also cases when we need to explicitly convert a value to the expected type.
88

99
```smart header="Not talking about objects yet"
10-
In this chapter, we won't cover objects. Instead, we'll study primitives first. Later, after we learn about objects, we'll see how object conversion works in the chapter <info:object-toprimitive>.
10+
In this chapter, we won't cover objects. For now we'll just be talking about primitives.
11+
12+
Later, after we learn about objects, in the chapter <info:object-toprimitive> we'll see how objects fit in.
1113
```
1214

1315
## String Conversion

‎1-js/02-first-steps/07-operators/1-increment-order/solution.md renamed to ‎1-js/02-first-steps/08-operators/1-increment-order/solution.md

File renamed without changes.

‎1-js/02-first-steps/07-operators/1-increment-order/task.md renamed to ‎1-js/02-first-steps/08-operators/1-increment-order/task.md

File renamed without changes.

‎1-js/02-first-steps/07-operators/2-assignment-result/solution.md renamed to ‎1-js/02-first-steps/08-operators/2-assignment-result/solution.md

File renamed without changes.

‎1-js/02-first-steps/07-operators/2-assignment-result/task.md renamed to ‎1-js/02-first-steps/08-operators/2-assignment-result/task.md

File renamed without changes.

‎1-js/02-first-steps/07-operators/3-primitive-conversions-questions/solution.md renamed to ‎1-js/02-first-steps/08-operators/3-primitive-conversions-questions/solution.md

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -10,8 +10,8 @@ true + false = 1
1010
"4" - 2 = 2
1111
"4px" - 2 = NaN
1212
7 / 0 = Infinity
13-
" -9 " + 5 = " -9 5" // (3)
14-
" -9 " - 5 = -14 // (4)
13+
" -9 " + 5 = " -9 5" // (3)
14+
" -9 " - 5 = -14 // (4)
1515
null + 1 = 1 // (5)
1616
undefined + 1 = NaN // (6)
1717
" \t \n" - 2 = -2 // (7)

‎1-js/02-first-steps/07-operators/3-primitive-conversions-questions/task.md renamed to ‎1-js/02-first-steps/08-operators/3-primitive-conversions-questions/task.md

File renamed without changes.

‎1-js/02-first-steps/08-operators/4-fix-prompt/solution.md

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
The reason is that prompt returns user input as a string.
2+
3+
So variables have values `"1"` and `"2"` respectively.
4+
5+
```js run
6+
let a = "1"; // prompt("First number?", 1);
7+
let b = "2"; // prompt("Second number?", 2);
8+
9+
alert(a + b); // 12
10+
```
11+
12+
What we should to is to convert strings to numbers before `+`. For example, using `Number()` or prepending them with `+`.
13+
14+
For example, right before `prompt`:
15+
16+
```js run
17+
let a = +prompt("First number?", 1);
18+
let b = +prompt("Second number?", 2);
19+
20+
alert(a + b); // 3
21+
```
22+
23+
Or in the `alert`:
24+
25+
```js run
26+
let a = prompt("First number?", 1);
27+
let b = prompt("Second number?", 2);
28+
29+
alert(+a + +b); // 3
30+
```
31+
32+
Using both unary and binary `+` in the latest code. Looks funny, doesn't it?

‎1-js/02-first-steps/08-operators/4-fix-prompt/task.md

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
importance: 5
2+
3+
---
4+
5+
# Fix the addition
6+
7+
Here's a code that asks the user for two numbers and shows their sum.
8+
9+
It works incorrectly. The output in the example below is `12` (for default prompt values).
10+
11+
Why? Fix it. The result should be `3`.
12+
13+
```js run
14+
let a = prompt("First number?", 1);
15+
let b = prompt("Second number?", 2);
16+
17+
alert(a + b); // 12
18+
```

0 commit comments

Comments
 (0)