done with chapter 6

Author: jinnatul

README.md

@@ -42,3 +42,11 @@
   - [Section 5.2: How to get all enum values](/book_pages/chapter5/section5.2.md)
   - [Section 5.3: Extending enums without custom enum implementation](/book_pages/chapter5/section5.3.md)
   - [Section 5.4: Custom enum implementation: extends for enums](/book_pages/chapter5/section5.4.md)
+
+* Chapter 6: Functions
+
+  - [Section 6.1: Optional and Default Parameters](/book_pages/chapter6/section6.1.md)
+  - [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)
+  

book_pages/chapter6/section6.1.md

@@ -0,0 +1,34 @@
+# Section 6.1: Optional and Default Parameters
+
+### Optional Parameters
+
+In TypeScript, every parameter is assumed to be required by the function. You can add 
+a `?` at the end of a parameter name to set it as optional.
+
+For example, the lastName parameter of this function is optional:
+```ts
+function buildName(firstName: string, lastName?: string) {
+  // ...
+}
+```
+
+Optional parameters **must come after** all non-optional parameters:
+```ts
+function buildName(firstName?: string, lastName: string) // Invalid
+```
+
+### Default Parameters
+
+If the user passes undefined or doesn't specify an argument, the default value will be 
+assigned. These are called default-initialized parameters.
+For example, `"Smith" is the default value` for the lastName parameter.
+
+```ts
+function buildName(firstName: string, lastName = "Smith") {
+  // ...
+}
+
+buildName('foo', 'bar'); // firstName == 'foo', lastName == 'bar'
+buildName('foo'); // firstName == 'foo', lastName == 'Smith'
+buildName('foo', undefined); // firstName == 'foo', lastName == 'Smith'
+```

book_pages/chapter6/section6.2.md

@@ -0,0 +1,94 @@
+# Section 6.2: Function as a parameter
+
+### Suppose we want to receive a function as a parameter, we can do it like this:
+```ts
+function foo(otherFunc: Function): void {
+  ...
+}
+```
+
+### If we want to receive a constructor as a parameter:
+```ts
+function foo(constructorFunc: { new() }) {
+  new constructorFunc();
+}
+
+function foo(constructorWithParamsFunc: { new(num: number) }) {
+  new constructorWithParamsFunc(1);
+}
+```
+
+### Or to make it easier to read we can define an interface describing the constructor:
+```ts
+interface IConstructor {
+  new();
+}
+
+function foo(contructorFunc: IConstructor) {
+  new constructorFunc();
+}
+```
+### Or with parameters:
+```ts
+interface INumberConstructor {
+  new(num: number);
+}
+
+function foo(contructorFunc: INumberConstructor) {
+  new contructorFunc(1);
+}
+```
+
+### Even with generics:
+```ts
+interface ITConstructor<T, U> {
+  new(item: T): U;
+}
+
+function foo<T, U>(contructorFunc: ITConstructor<T, U>, item: T): U {
+  return new contructorFunc(item);
+}
+```
+
+### If we want to receive a simple function and not a constructor it's almost the same:
+```ts
+function foo(func: { (): void }) {
+  func();
+}
+
+function foo(constructorWithParamsFunc: { (num: number): void }) {
+  new constructorWithParamsFunc(1);
+}
+```
+### Or to make it easier to read we can define an interface describing the function:
+```ts
+interface IFunction {
+  (): void;
+}
+
+function foo(func: IFunction ) {
+  func();
+}
+```
+
+### Or with parameters:
+```ts
+interface INumberFunction {
+  (num: number): string;
+}
+
+function foo(func: INumberFunction ) {
+  func(1);
+}
+```
+
+### Even with generics:
+```ts
+interface ITFunc<T, U> {
+  (item: T): U;
+}
+
+function foo<T, U>(contructorFunc: ITFunc<T, U>, item: T): U {
+  return func(item);
+}
+```

book_pages/chapter6/section6.3.md

@@ -0,0 +1,24 @@
+# Section 6.3: Functions with Union Types
+
+### A TypeScript function can take in parameters of multiple, predefined types using union types.
+```ts
+function whatTime(hour:number|string, minute:number|string):string{
+  return hour+':'+minute;
+}
+
+whatTime(1,30) //'1:30'
+whatTime('1',30) //'1:30'
+whatTime(1,'30') //'1:30'
+whatTime('1','30') //'1:30'
+```
+
+TypeScript treats these parameters as a single type that is a union of the other types, so your function must be able to handle parameters of any type that is in the union.
+```ts
+function addTen(start:number|string):number{
+  if(typeof number === 'string'){
+    return parseInt(number)+10;
+  }else{
+    else return number+10;
+  }
+}
+```

book_pages/chapter6/section6.4.md

@@ -0,0 +1,18 @@
+# Section 6.4: Types of Functions
+
+### Named functions
+```ts
+function multiply(a, b) {
+  return a * b;
+}
+```
+
+### Anonymous functions
+```ts
+let multiply = function(a, b) { return a * b; };
+```
+
+### Lambda / arrow functions
+```ts
+let multiply = (a, b) => { return a * b; };
+```

myTs.ts

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