Feb 21, 2020 · Feb 22, 2020 · Feb 22, 2020 · Feb 23, 2020 · Feb 23, 2020 · Feb 23, 2020
diff --git a/1-js/09-classes/01-class/article.md b/1-js/09-classes/01-class/article.md
Original file line number	Diff line number	Diff line change
Expand Up		@@ -127,7 +127,7 @@ Sometimes people say that `class` is a "syntactic sugar" (syntax that is designe
		function User(name) {
		this.name = name;
		}
	// any function prototype has constructor property by default,
	// a function prototype has "constructor" property by default,
		// so we don't need to create it

		// 2. Add the method to prototype
Expand All		@@ -146,7 +146,7 @@ Still, there are important differences.

		1. First, a function created by `class` is labelled by a special internal property `[[FunctionKind]]:"classConstructor"`. So it's not entirely the same as creating it manually.

	And unlike a regular function, a class constructor must be called with `new`:
	The language checks for that property in a variety of places. For example, unlike a regular function, it must be called with `new`:

		```js run
		class User {
Expand All		@@ -166,6 +166,7 @@ Still, there are important differences.

		alert(User); // class User { ... }
		```
	There are other differences, we'll see them soon.

		2. Class methods are non-enumerable.
		A class definition sets `enumerable` flag to `false` for all methods in the `"prototype"`.
Expand Down Expand Up		@@ -209,7 +210,6 @@ new User().sayHi(); // works, shows MyClass definition
		alert(MyClass); // error, MyClass name isn't visible outside of the class
		```


		We can even make classes dynamically "on-demand", like this:

		```js run
Expand All		@@ -229,7 +229,7 @@ new User().sayHi(); // Hello
		```


	## Getters/setters, other shorthands
	## Getters/setters

		Just like literal objects, classes may include getters/setters, computed properties etc.

Expand Down Expand Up		@@ -267,22 +267,11 @@ alert(user.name); // John
		user = new User(""); // Name is too short.
		```

	The class declaration creates getters and setters in `User.prototype`, like this:
	Technically, such class declaration works by creating getters and setters in `User.prototype`.

	```js
	Object.defineProperties(User.prototype, {
	name: {
	get() {
	return this._name
	},
	set(name) {
	// ...
	}
	}
	});
	```
	## Computed names [...]

	Here's an example with a computed property name in brackets `[...]`:
	Here's an example with a computed method name using brackets `[...]`:

		```js run
		class User {
Expand All		@@ -298,13 +287,15 @@ class User {
		new User().sayHi();
		```

	Such features are easy to remember, as they resemble that of literal objects.

		## Class fields

		```warn header="Old browsers may need a polyfill"
		Class fields are a recent addition to the language.
		```

	Previously, classes only had methods.
	Previously, our classes only had methods.

		"Class fields" is a syntax that allows to add any properties.

Expand All		@@ -313,23 +304,45 @@ For instance, let's add `name` property to `class User`:
		```js run
		class User {
		!
	name = "Anonymous";
	name = "John";
		/!

		sayHi() {
		alert(`Hello, ${this.name}!`);
		}
		}

	new User().sayHi();
	new User().sayHi(); // Hello, John!
	```

	So, we just write "<property name> = <value>" in the declaration, and that's it.

	The important difference of class fields is that they are set on individual objects, not `User.prototype`:

	alert(User.prototype.sayHi); // placed in User.prototype
	alert(User.prototype.name); // undefined, not placed in User.prototype
	```js run
	class User {
	!
	name = "John";
	/!
	}

	let user = new User();
	alert(user.name); // John
	alert(User.prototype.name); // undefined
		```

	The important thing about class fields is that they are set on individual objects, not `User.prototype`.
	Technically, they are processed after the constructor has done it's job, and we can use for them complex expressions and function calls:

	```js run
	class User {
	!
	name = prompt("Name, please?", "John");
	/!
	}

	Technically, they are processed after the constructor has done it's job.
	let user = new User();
	alert(user.name); // John
	```

		### Making bound methods with class fields

Expand Down