mongodb indexing

Author: rohan-paul

Javascript/Prototypal-Inheritence/Inheritence-OOP-Class-vs-Prototypes-Example-BEST-1.md renamed to Javascript/Prototypal-Inheritence/Inheritence-OOP-Class-vs-Prototypes-Example-BEST.md

@@ -59,6 +59,8 @@ function Dog (name, energy, breed) {
 }
 
 Dog.prototype = Object.create(Animal.prototype)
+// In the above I could have also used the below format
+// Dog.prototype = new Animal()
 
 Dog.prototype.bark = function () {
   console.log('Woof Woof!')
@@ -97,5 +99,14 @@ We call `super()` inside of a subclass' constructor method in order to call the
 
 Child class will have access to all parent class methods.
 
+Seperate Note - An important difference between function declarations and class declarations is that function declarations are hoisted and class declarations are not. You first need to declare your class and then access it, otherwise code like the following will throw a ReferenceError:
 
+```
+const p = new Rectangle(); // ReferenceError
+
+class Rectangle {}
+```
 
+#### Further Reading
+- 1. [https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes)
+- 2. [https://tylermcginnis.com/javascript-inheritance-and-the-prototype-chain/](https://tylermcginnis.com/javascript-inheritance-and-the-prototype-chain/)

Javascript/Prototypal-Inheritence/Inheritence-OOP-Class-vs-Prototypes-BEST.md renamed to Javascript/Prototypal-Inheritence/Inheritence-OOP-Class-vs-Prototypes-Theory.md

@@ -1,30 +1,32 @@
 var Person = function(name) {
-	this.name = name;
+  this.name = name;
 };
 
 Person.prototype.hello = function() {
-	console.log(`Hello ${this.name} You are part of this PersonProto`);
+  console.log(`Hello ${this.name} You are part of this PersonProto`);
 };
 
 // To define a derived class first , A) Create a new class and call the constructor of the base class explicitly with the `Class.call`. At least one parameter must be passed to that: the current object wih the `this` keyword
 
 var Worker = function(name, job) {
-	Person.call(this, name);
-	this.job = job;
+  Person.call(this, name);
+  this.job = job;
 };
 // B) Create the prototype of the derived class, based on the base class. To do that, *hard* copy the prototype of the base class. There's two ways to do this, the commented out line below could also have been used.
 
 // Worker.prototype = Object.create(Person.prototype);
 
 Worker.prototype = new Person();
+// In the above I could have also used the below format
+// Worker.prototype = Object.create(Person.prototype)
 
 // C)(Re)set the `constructor` property to refer to the new class instead of the (copied) base class.
 
 Worker.prototype.constructor = Worker;
 
 // Overwrite inherited functions or create new ones if you want.
 Worker.prototype.hello = function() {
-	console.log(`Hello ${this.name} You are part of this WorkerProto`);
+  console.log(`Hello ${this.name} You are part of this WorkerProto`);
 };
 
 var p1Proto = new Person("Jack");

Javascript/Prototypal-Inheritence/Prototype-Example-1.js

@@ -0,0 +1,62 @@
+An index in MongoDB is a special data structure that holds the data of few fields of documents on which the index is created. Indexes improve the speed of search operations in database because instead of searching the whole document, the search is performed on the indexes that holds only few fields. On the other hand, having too many indexes can hamper the performance of insert, update and delete operations because of the additional write and additional data space used by indexes.
+
+How to create index in MongoDB
+Syntax:
+
+`db.collection_name.createIndex({field_name: 1 or -1})`
+
+The value 1 is for ascending order and -1 is for descending order.
+
+For example, I have a collection studentdata. The documents inside this collection have following fields:
+student_name, student_id and student_age
+
+Lets say I want to create the index on student_name field in ascending order:
+
+`db.studentdata.createIndex({student_name: 1})`
+
+Output:
+
+```
+{
+        "createdCollectionAutomatically" : false,
+        "numIndexesBefore" : 1,
+        "numIndexesAfter" : 2,
+        "ok" : 1
+}
+```
+
+#### Finding the indexes in a collection
+
+We can use **getIndexes**() method to find all the indexes created on a collection. The syntax for this method is:
+
+db.collection_name.getIndexes()
+So to get the indexes of studentdata collection, the command would be:
+
+```
+db.studentdata.getIndexes()
+[
+        {
+                "v" : 2,
+                "key" : {
+                        "_id" : 1
+                },
+                "name" : "_id_",
+                "ns" : "test.studentdata"
+        },
+        {
+                "v" : 2,
+                "key" : {
+                        "student_name" : 1
+                },
+                "name" : "student_name_1",
+                "ns" : "test.studentdata"
+        }
+]
+
+```
+
+The output shows that we have two indexes in this collection. The default index created on _id and the index that we have created on student_name field.
+
+#### Default _id Index
+
+This is the default index which will be created by MongoDB when you create a new collection. If you don’t specify any value for this field, then _id will be primary key by default for your collection so that a user can’t insert two documents with same _id field values. You can’t remove this index from the _id field.

MongoDB/indexing-in-mongo.md

@@ -1,6 +1,6 @@
 To put it simply, a higher-order component is a function, that takes a component and returns a new component. I like to think of them as parameterized components. Many times I find myself creating several components with very similar logic, with only 1 or 2 changes. Once I find a use case like this, it’s very simple to abstract the shared logic, and put the logic that changes into parameters.
 
-You can read more about HOCs here, in the official React docs. Since components are just functions and HOCs are just functions that return other functions, we can use functional concepts to chain them using utilities methods such as compose, which is provided by many libraries (it's included in Redux!).
+Since components are just functions and HOCs are just functions that return other functions, we can use functional concepts to chain them using utilities methods such as compose, which is provided by many libraries (it's included in Redux!).
 
 So HOCs are to tackle the situation when I have to share the same functionality across multiple components.