Unit 1: Data & Objects

We've been using Arrays like a magical bag of holding. Put whatever you want in there, remove things, etc... But have you given any thought as to how they work or what we would do without them?

In other languages (C++, etc) the memory is a fixed size that the developer must allocate a specific size in advance. In JavaScript, Arrays have no set size - pushing to the array increases the size for us. Memory is allocated and deallocated for us by the "garbage collector" in the background. 

JavaScript's implementation of Arrays mimics an ADT called a doubly-linked list.

Hang in there - this lesson is a real doozy.

Recall

Recall when we made our own abstract data type for a Stack:

const stack = {

 contents: [],

 is_empty: function() {

   return (this.contents.length == 0)

 },

 push: function(content) {

   this.contents.push(content);

 },

 pop: function() {

   if (this.is_empty())

     return "The stack is empty";

   else

     return this.contents.pop();

 },

 peek: function() {

   if (this.is_empty())

     return "The stack is empty";

   else

     return this.contents[this.contents.length - 1];

 }

};

This allowed us to store and retrieve information in that custom data structure. But what if we needed to use more than one stack? In this style, we would need to copy and paste that exact code to make a const stack2 or something silly like that. Abstract data types as defined in lessons 1.1 and 1.2 cannot be copied. They are limited to one implementation per definition.

Classes

A class is a blueprint for a data structure that describes an object. Since it is a blueprint, we can make copies of it (called "instances"). As many copies as we need!

class Stack {

  // Other code goes here

}

We give the class name a capital first letter: Stack. This is a standard. Similar to String, Math, or Array.

We can give the Stack properties just like a house or your shirt have properties: colour, height, number of sleeves, etc. In code these are variables. To an object, they are descriptors or values: properties.

class Stack {

  name = "";

  contents = [];

  max_length = 255;

  // Etc...

}

Notice the lack of let, var, or const. More on this later, but essentially the let is implied.

New

Now that we have a blueprint for our object, we want to make an instance of one. This is called instantiation. We have already seen this when we ask JavaScript for a new array:

let arr = new Array(10); // get a new array of size 10

Guess what? Arrays are objects! By using the new keyword, we are asking JavaScript to create (or instantiate) an instance of an Array object - in this case of size 10. That means we can do it with our Stack!

class Stack {

 name = "";

 contents = [];

 max_length = 255;

}

// Create two instances of a stack, completely unrelated to each other

let my_stack = new Stack();

let another_stack = new Stack();

Working with Properties

How do we get access to the "name" property in the above examples? Or how do we change it?

Once an object is instantiated you can get or set the values of object propterties using the dot-notation we've seen with the String and Math objects:

let my_stack = new Stack();

my_stack.name = "Pretty little stack";

console.log(my_stack.name);       // 'Pretty little stack'

console.log(my_stack.max_length); // 255

Let's Practice

The diagram you see here is called a class diagram. More on that later but the basic pattern is:

property_name: data_type = optional_default_value

If no default value is required:

property_name: data_type