done with chapter 7

Author: jinnatul

README.md

@@ -49,4 +49,14 @@
   - [Section 6.2: Function as a parameter](/book_pages/chapter6/section6.2.md)
   - [Section 6.3: Functions with Union Types](/book_pages/chapter6/section6.3.md)
   - [Section 6.4: Types of Functions](/book_pages/chapter6/section6.4.md)
+  
+* Chapter 7: Classes
+
+  - [Section 7.1: Abstract Classes](/book_pages/chapter7/section7.1.md)
+  - [Section 7.2: Simple class](/book_pages/chapter7/section7.2.md)
+  - [Section 7.3: Basic Inheritance](/book_pages/chapter7/section7.3.md)
+  - [Section 7.4: Constructors](/book_pages/chapter7/section7.4.md)
+  - [Section 7.5: Accessors](/book_pages/chapter7/section7.5.md)
+  - [Section 7.6: Transpilation](/book_pages/chapter7/section7.6.md)
+  - [Section 7.7: Monkey patch a function into an existing class](/book_pages/chapter7/section7.7.md)
 

book_pages/chapter7/section7.1.md

@@ -0,0 +1,36 @@
+# Section 7.1: Abstract Classes
+
+```ts
+abstract class Machine {
+  constructor(public manufacturer: string) {
+
+  }
+
+  // An abstract class can define methods of its own, or...
+  summary(): string {
+    return `${this.manufacturer} makes this machine.`;
+  }
+
+  // Require inheriting classes to implement methods
+  abstract moreInfo(): string;
+}
+
+class Car extends Machine {
+  constructor(manufacturer: string, public position: number, protected speed: number) {
+    super(manufacturer);
+  }
+
+  move() {
+    this.position += this.speed;
+  }
+
+  moreInfo() {
+    return `This is a car located at ${this.position} and going ${this.speed}mph!`;
+  }
+}
+
+let myCar = new Car("Konda", 30, 70);
+myCar.move(); // position is now 80
+console.log(myCar.summary()); // prints "Konda makes this machine."
+console.log(myCar.moreInfo()); // prints "This is a car located at 80 and going 70mph!"
+```

book_pages/chapter7/section7.2.md

@@ -0,0 +1,16 @@
+# Section 7.2: Simple class
+
+```ts
+class Car {
+  public position: number = 50;
+  private speed: number = 42;
+
+  move() {
+    this.position += this.speed;
+  }
+}
+
+var car = new Car(); // create an instance of Car
+car.move(); // call a method
+console.log(car.position); // access a public property
+```

book_pages/chapter7/section7.3.md

@@ -0,0 +1,26 @@
+# Section 7.3: Basic Inheritance
+
+```ts
+class Car {
+  public position: number = 25;
+  protected speed: number = 42;
+
+  move() {
+    this.position += this.speed;
+    console.log(this.position);
+  }
+}
+  
+class SelfDrivingCar extends Car {
+  move() {
+    //super.move();
+    console.log('Hi Morol');
+  }
+}
+
+let myCar = new Car();
+myCar.move(); // 67
+
+myCar = new SelfDrivingCar();
+myCar.move(); // Hi Morol
+```

book_pages/chapter7/section7.4.md

@@ -0,0 +1,61 @@
+# Section 7.4: Constructors
+
+```ts
+class Car {
+  public position: number;
+  protected speed: number;
+  constructor(position: number, speed: number) {
+    this.position = position;
+    this.speed = speed;
+  }
+  move() {
+    this.position += this.speed;
+    return this.position;
+  }
+}
+
+let myCar = new Car(30, 56);
+console.log(myCar.move()); // 86
+```
+
+```ts
+class Car {
+  constructor(public position: number, protected speed: number) {}
+  move() {
+    this.position += this.speed;
+  }
+}
+```
+
+```ts
+var Car = (function () {
+  function Car(position, speed) {
+    this.position = position;
+    this.speed = speed;
+  }
+
+  Car.prototype.move = function () {
+    this.position += this.speed;
+  };
+
+  return Car;
+}());
+
+let myCar = new Car(23, 32);
+console.log(myCar); // Car { position: 23, speed: 32 }
+```
+
+Constructors of derived classes have to call the base class constructor with **super()** .
+```ts
+class SelfDrivingCar extends Car {
+  constructor(startAutoPilot: boolean) {
+    super(0, 42);
+    if (startAutoPilot) {
+      this.move();
+    }
+  }
+}
+
+let car = new SelfDrivingCar(true);
+console.log(car.position); // access the public property position
+```

book_pages/chapter7/section7.5.md

@@ -0,0 +1,26 @@
+# Section 7.5: Accessors
+
+```ts
+class Car {
+  public position: number = 0;
+  private _speed: number = 42;
+  private _MAX_SPEED = 100
+
+  move() {
+    this.position += this._speed;
+  }
+
+  get speed(): number {
+    return this._speed;
+  }
+
+  set speed(value: number) {
+    this._speed = Math.max(value, this._MAX_SPEED);
+  }
+}
+
+let car = new Car();
+console.log(car.speed); // 42
+car.speed = 120;
+console.log(car.speed); // 120
+```

book_pages/chapter7/section7.6.md

@@ -0,0 +1,58 @@
+# Section 7.6: Transpilation
+
+### TypeScript source
+```ts
+class SomeClass {
+  public static SomeStaticValue: string = "hello";
+  public someMemberValue: number = 15;
+  private somePrivateValue: boolean = false;
+
+  constructor () {
+    SomeClass.SomeStaticValue = SomeClass.getGoodbye();
+    this.someMemberValue = this.getFortyTwo();
+    this.somePrivateValue = this.getTrue();
+  }
+
+  public static getGoodbye(): string {
+    return "goodbye!";
+  }
+
+  public getFortyTwo(): number {
+    return 42;
+  }
+
+  private getTrue(): boolean {
+    return true;
+  }
+}
+```
+
+### JavaScript source
+
+```js
+var SomeClass = (function () {
+  function SomeClass() {
+    this.someMemberValue = 15;
+    this.somePrivateValue = false;
+    SomeClass.SomeStaticValue = SomeClass.getGoodbye();
+    this.someMemberValue = this.getFortyTwo();
+    this.somePrivateValue = this.getTrue();
+  }
+
+  SomeClass.getGoodbye = function () {
+    return "goodbye!";
+  };
+
+  SomeClass.prototype.getFortyTwo = function () {
+    return 42;
+  };
+
+  SomeClass.prototype.getTrue = function () {
+    return true;
+  };
+
+  return SomeClass;
+}());
+
+SomeClass.SomeStaticValue = "hello";
+```

book_pages/chapter7/section7.7.md

@@ -0,0 +1,25 @@
+# Section 7.7: Monkey patch a function into an existing class
+
+Sometimes it's useful to be able to extend a class with new functions. For example 
+let's suppose that a string should be converted to a camel case string. So we need to 
+tell TypeScript, that String contains a function called toCamelCase , which returns a 
+string .
+```ts
+interface String {
+  toCamelCase(): string;
+}
+```
+
+### Now we can patch this function into the String implementation.
+```ts
+String.prototype.toCamelCase = function() : string {
+  return this.replace(/[^a-z ]/ig, '')
+    .replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, (match: any, index: number) => {
+      return + match === 0 ? "" : match[index === 0 ? 'toLowerCase' : 'toUpperCase']();
+    });
+}
+```
+If this extension of String is loaded, it's usable like this:
+```ts
+"This is an example".toCamelCase(); // => "thisIsAnExample"
+```

myTs.ts

@@ -1 +1 @@
-console.log('Welcome to TypeScript Professionals');
+console.log('Welcome to TypeScript Professionals');