Advertisement
shopnilSS

Inheritance with prototype and class

Sep 2nd, 2021
97
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. //part 1
  2. //create an object
  3. // const user = {}
  4. // user.name = "shopnil"
  5. // user.age = 25
  6. // user.intro = function () {
  7. //     console.log(`I am ${user.name} I am ${user.age} years old`);
  8. // }
  9. // // console.log(user);
  10. // user.intro()
  11.  
  12. //part 2
  13. //create a constructor function object
  14. // function User (name, age) {
  15. //     const user = {}
  16. //     user.name = name
  17. //     user.age = age
  18. //     user.intro = function () {
  19. //         console.log(`I am ${user.name} I am ${user.age} years old`);
  20. //     }
  21. //     return user
  22. // }
  23. // const shopnil = User("shopnil", 25)
  24. // shopnil.intro()
  25.  
  26. //part 3
  27. //create a constructor function object
  28. // const userMethod = {
  29. //     intro (user) {
  30. //         console.log(`I am ${user.name} I am ${user.age} years old`);
  31. //     }
  32. // }
  33. // function User (name, age) {
  34. //     const user = {}
  35. //     user.name = name
  36. //     user.age = age
  37. //     user.intro = userMethod.intro.bind(user, user)
  38. //     return user
  39. // }
  40. // const shopnil = User("shopnil", 25)
  41. // const sidrat = User("sidrat", 18)
  42. // // console.log(shopnil);
  43. // shopnil.intro()
  44. // console.dir(shopnil)
  45. // console.dir(sidrat)
  46.  
  47.  
  48. //part 4
  49. //create a constructor function but the method store as a prototype
  50. // const userMethod = {
  51. //     intro (user) {
  52. //         console.log(`I am ${user.name} I am ${user.age} years old`);
  53. //     }
  54. // }
  55. // function User (name, age) {
  56. //     const user = Object.create(userMethod)
  57. //     user.name = name
  58. //     user.age = age
  59. //     return user
  60. // }
  61. // const shopnil = User("shopnil", 25)
  62. // const sidrat = User("sidrat", 18)
  63. // // console.log(shopnil);
  64. // shopnil.intro(shopnil)
  65. // console.dir(shopnil)
  66. // console.dir(sidrat)
  67.  
  68. //part 5
  69. //store the outer method function into function's prototype method or property
  70. // function User (name, age) {
  71. //     const user = Object.create(User.prototype )
  72. //     user.name = name
  73. //     user.age = age
  74. //     return user
  75. // }
  76. // User.prototype = {
  77. //      intro (user) {
  78. //         console.log(`I am ${user.name} I am ${user.age} years old`);
  79. //     }
  80. // }
  81. // const shopnil = User("shopnil", 25)
  82. // const sidrat = User("sidrat", 18)
  83. // // console.log(shopnil);
  84. // shopnil.intro(shopnil)
  85. // console.dir(shopnil)
  86. // console.dir(sidrat)
  87.  
  88. //part 6
  89. //create a constructor function but the method store as a prototype
  90. // const userMethod = {
  91. //     intro (user) {
  92. //         console.log(`I am ${user.name} I am ${user.age} years old`);
  93. //     }
  94. // }
  95. // function User (name, age) {
  96. //     const user = Object.create(userMethod)
  97. //     user.name = name
  98. //     user.age = age
  99. //     return user
  100. // }
  101. // const shopnil = User("shopnil", 25)
  102. // const sidrat = User("sidrat", 18)
  103. // // console.log(shopnil);
  104. // shopnil.intro(shopnil)
  105. // console.dir(shopnil)
  106. // console.dir(sidrat)
  107.  
  108. //part 5
  109. // store the outer method function into function's prototype method or property   and create the contractor function with new keyword
  110. // function User (name, age) {
  111. //     // const user = Object.create(User.prototype )
  112. //     this.name = name
  113. //     this.age = age
  114. //     // return user
  115. // }
  116. // User.prototype = {
  117. //      intro (user) {
  118. //         console.log(`I am ${user.name} I am ${user.age} years old`);
  119. //     }
  120. // }
  121. // const shopnil = new User("shopnil", 25)
  122. // const sidrat = new User("sidrat", 18)
  123. // // console.log(shopnil);
  124. // shopnil.intro(shopnil)
  125. // console.dir(shopnil)
  126. // // console.dir(sidrat)
  127.  
  128.  
  129. //part 6
  130. //make a contractor function with method with the help of prototype in vanila java script way
  131. // function User (name, age) {
  132. //     this.name = name
  133. //     this.age = age
  134. // }
  135. // User.prototype = {
  136. //      intro (user) {
  137. //         console.log(`I am ${user.name} I am ${user.age} years old`);
  138. //     }
  139. // }
  140. // const shopnil = new User("shopnil", 25)
  141. // const sidrat = new User("sidrat", 18)
  142. // shopnil.intro(shopnil)
  143. // console.dir(User)
  144.  
  145. //make a contractor  with method with the help of new es6 class syntax way
  146. // class User {
  147. //     constructor (name, age) {
  148. //         this.name = name
  149. //         this.age = age
  150. //     }
  151. //     intro (user) {
  152. //         console.log(`I am ${user.name} I am ${user.age} years old`);
  153. //     }
  154. // }
  155. // const shopnil = new User("shopnil", 25)
  156. // const sidrat = new User("sidrat", 18)
  157. // shopnil.intro(shopnil)
  158. // console.dir(shopnil)
  159. //Create a class constructor with method from the scratch part 1 - part 6
  160.  
  161. //Start the inheritance part with vanila js way first
  162. // Part 7
  163. //create the inheritance with vanila javascript way
  164.  
  165. //Parent
  166. // function Parent (name, age) {
  167. //     this.name = name
  168. //     this.age = age
  169. // }
  170. // Parent.prototype = {
  171. //     intro: function(){
  172. //         console.log(`Hello I am ${this.name} I am ${this.age} years old`);
  173. //     }
  174. // }
  175.  
  176. // //Child one
  177. // function Child (name, age, birthDate) {
  178. //     Parent.call(this, name, age)
  179. //     this.birthDate = birthDate
  180. // }
  181. // Child.prototype = Object.create(Parent.prototype)
  182. // Child.prototype.constructor = Child
  183. // Child.prototype.hello = function () {
  184. //         console.log(`hello`);
  185. //     }
  186.  
  187. // //Grand Child
  188. // function GrandChild (name, age, birthDate) {
  189. //     Child.call(this, name, age, birthDate)
  190. // }
  191. // GrandChild.prototype = Object.create(Child.prototype)
  192. // GrandChild.prototype.constructor = GrandChild
  193. // const childThree = new GrandChild("sidrat", 14, "1999-05-20")
  194. // childThree.intro()
  195.  
  196.  
  197.  
  198. // Part 8
  199. //Create the inheritance with  class
  200. class Parent {
  201.     constructor (name, age) {
  202.         this.name = name
  203.         this.age = age
  204.     }
  205.     intro(){
  206.         console.log(`Hello I am ${this.name} I am ${this.age} years old`);
  207.     }
  208.  
  209. }
  210.  
  211. //Child
  212. class Child extends Parent {
  213.     constructor (name, age, birthDate) {
  214.         super (name, age)
  215.         this.birthDate = birthDate
  216.     }
  217.     hello () {
  218.         console.log(`hello`);
  219.     }
  220. }
  221. const childOne = new Child ("ridon", 23, "1999-05-25")
  222. console.log(childOne);
  223.  
  224. //GrandChild
  225. class GrandChild extends Child {
  226.     constructor (name, age, birthDate) {
  227.         super (name, age, birthDate)
  228.     }
  229. }
  230. const grandChildOne = new GrandChild ("sakib", 23, "1999-05-25")
  231. console.log(grandChildOne);
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement