Forem: Laura Berge

Ruby Modules

Laura Berge — Tue, 04 Aug 2020 03:05:39 +0000

When we write classes in Ruby, we may find that we end up using a lot of code just for methods. In Ruby, we can use modules to abstract out any methods our class needs access to. (If you're unfamiliar with Ruby classes, you can check out a blog I wrote on classes and instances in Ruby here). We declare modules in a similar way to classes. For example, we're going to use a class of Dog that is going to need access to many methods.

class Dog
    attr_accessor :name

    def initialize(name)
        @name = name
    end
end

Instance Methods in Modules

Now that we have our class, we're going to create a module to store methods our individual dogs may need access to.

module DogInstanceMethods
    def speak
       puts "Woof!"
    end

    def growl
        puts "Grrrr..."
    end

    def sit
        puts "*sits*"
    end

    def walk?(energy)
        if energy
            true
        else
            false
        end
    end
end

In order to include DogInstanceMethods in our Dog class, we need to use the 'include' keyword.

# make sure to include the filename with the module at the top such as:
# require_relative DogInstanceMethods.rb

class Dog
    include DogInstanceMethods
end

jitta = Dog.new("Jitta")
jitta.speak #=> "Woof!"

Class Methods in Modules

Now this works great for instance methods, but what about class-level methods? When declared inside a class, we use self to tell our program we're operating on Dog as a class. However, self in the module is the module DogInstanceMethods itself. So in order to include class methods, we use the same format as above except we use extend instead of include.

module DogClassMethods
    def species
        puts "Canis Lupus"
    end

    def fun_fact
        puts "Dogs have unique nose prints like humans have fingerprints."
    end
end


class Dog
    extend DogClassMethods
end

Dog.fun_fact #=> "Dogs have unique nose prints like humans have fingerprints."

Nesting Modules

Let's put our class and instance methods under the same roof in order to keep the code organized. We can nest them within a larger module called DogMethods and refer to them using 'OuterModule::InnerModule'.

module DogMethods
    module InstanceMethods
        def speak
            puts "Woof!"
        end
    end

    module ClassMethods
        def species
            puts "Canis Lupus"
        end
    end
end

class Dog
    include DogMethods::InstanceMethods
    extend DogMethods::ClassMethods

    attr_accessor :name

    def initialize(name)
        @name = name
    end
end

jitta = Dog.new("Jitta")
jitta.speak #=> "Woof!"
Dog.species #=> "Canis Lupus"

Questions

Feel free to leave any questions or comments about modules in Ruby. Happy coding!

Rescue Your Ruby Program: Intro to Error Handling

Laura Berge — Tue, 28 Jul 2020 02:09:45 +0000

In Ruby, any time our code throws an error, our program will break. Now, this is often a good feature because errors tell us what our bug is and where in the code it's located. However, sometimes we have some code that may throw an error, such as getting user input that isn't what we expected. Let's say we have a calculator program and a user tries to divide a number by 0.

loop do
    print "Please enter a base number:"
    x = gets
    print "Please enter a divisor:"
    y = gets
    puts x.to_i * y.to_i
end

The code above will throw a ZeroDivisionError if y is equal to zero or a non-number string. (Strings converted to integers in ruby evaluate to 0). However, we don't want our program to break when the user inputs 0. Instead, we want to let them know that dividing a number by 0 is impossible in math. So, we need to find a way to display a message to the user and keep our program going. We can accomplish this using a rescue in Ruby.

Rescue in Ruby

begin
    # code to execute that may throw an error
rescue
    # code that is executed if the above code throws an error
end

In our case, we could write the code like:

loop do
    print "Please enter a base number:"
    x = gets
    print "Please enter a divisor:"
    y = gets
    puts y
    begin
        puts x.to_i / y.to_i
    rescue
        puts "Sorry, the divisor you entered is invalid. Please enter a non-zero number for the divisor."
    end
end

If the user enters an invalid divisor, the error message is shown and the program continues to run. Now we can even be more specific if we know what errors we're expecting.

Passing Arguments to Rescue

Rescue by default handles any StandardError, but we can a specific error as an argument. If we pass in an error like TypeError, that rescue block will only execute if the error thrown is a TypeError.

loop do
    print "Please enter a base number:"
    x = gets
    print "Please enter a divisor:"
    y = gets
    puts y
    begin
        puts x.to_i / y.to_i
    rescue ZeroDivisionError
        puts "Sorry, the divisor you entered is invalid. Please enter a non-zero number for the divisor."
    end
end

In this way, we can handle multiple errors differently in the same statement.

begin
    # the code in question
rescue ZeroDivisionError
    # execute code specific to this error
rescue TypeError
    # so on
rescue ArgumentError
    # and so forth
end

We can also operate on the error thrown as a variable.

begin
    # the code in question
rescue => error
    puts "A #{error.class} was thrown: #{error.message}"
end

Else and Ensure

In our begin-end block, we can also use else and ensure statements. The else block will run if no exception is thrown, and the ensure block will always run.

begin
    # code in question
rescue
    puts "Oops we have an error..."
else
    puts "No errors here"
ensure
    puts "I will always run - error or not!"
end

Raising Errors

Now that we know a bit about how to rescue our errors, what if we actually want to raise a custom error of our own? We can do this using raise in Ruby.

raise StandardError.new("custom error message")

If you have a program that needs a new type of error, you can also create one using class inheritance.

class MyCustomError < StandardError
end

if true
    raise MyCustomError("my custom error message")
end

Questions

Feel free to let me know in the comments:

Have you used begin/end blocks in your code before?
Have you ever created a custom error for a program or application?
What is the error message you dread the most?
What is your favorite error message?
Other comments/questions?

Ruby: Glass half nil?

Laura Berge — Mon, 20 Jul 2020 23:50:30 +0000

When getting started with Ruby, it's common to see the following error:

NoMethodError (undefined method `method_name_here' for nil:NilClass)

To a beginner, this may be intimidating, but don't fret. All this means is that whatever variable we're trying to call the given method on (method_name_here in this case) is actually equivalent to nil. There's a good chance we assigned that variable equal to an item that simply does not exist.

I had this happen during the first project I made in Ruby. I was scraping a lot of data from tables on a Spanish vocabulary website. When I iterated over the data and tried printing it to the console, I got the NoMethodError. I had to hunt down why one or more of the vocabulary words were coming up as nil. It turned out that a couple of the table cells in the website were blank. Knowing what the error meant was crucial to solving this bug efficiently. In order to understand this error, we need to know more about what nil actually means.

What is Nil?

Last week, I wrote a blog about how Ruby is a purely object-oriented language, and I mentioned that nil itself is an object. The nil object refers to nothing or a lack of value. In other languages such as JavaScript, we use the term null. When we create a variable, we can set it equal to nil if we don't want to assign a value right away.

answer = nil
count = 0

# some code that finds our answer and stops looking when found
until answer do
    count += 1
    if count == 5
        answer = count
    end
end

p answer #=> 5

The above code runs the until statement until 'answer' has been assigned the value of the count variable. That is because when answer = nil, the truthiness of 'answer' is false. We could assign answer equal to false and get the same result. However, nil is more specific in that when an item returns nil, we know that it has a lack of value, or that we actually didn't return anything at all.

Nil is an object and has a class

If we navigate to the terminal and use IRB, we can look at nil and NilClass more in-depth. The first thing to know is that nil is an object and has a unique object id. This object id will always be the same - either 4 or 8 depending on your system. Nil also has a class of NilClass. NilClass has only one instance - nil. This is the same for true and false in Ruby. TrueClass has one instance called 'true' and FalseClass has a single instance called 'false'. NilClass has both class and instance methods available. Feel free to explore some of these, but we do not need to know them all and probably won't ever use most of them.

irb(main):001:0> nil.object_id
=> 8
irb(main):002:0> nil.class
=> NilClass
irb(main):003:0> NilClass.methods
=> [:allocate, :superclass, :<=>, :<=, :>=, :==, :===, :included_modules, :include?, :name, :ancestors, :attr, :attr_reader, :attr_writer, :attr_accessor, :instance_methods, :public_instance_methods, :protected_instance_methods, :private_instance_methods, :constants, :const_get, :const_set, :const_defined?, :class_variables, :remove_class_variable, :class_variable_get, :class_variable_set, :class_variable_defined?, :freeze, :inspect, :private_constant, :public_constant, :const_missing, :deprecate_constant, :include, :singleton_class?, :prepend, :module_exec, :module_eval, :class_eval, :remove_method, :<, :>, :undef_method, :class_exec, :method_defined?, :alias_method, :to_s, :private_class_method, :public_method_defined?, :private_method_defined?, :protected_method_defined?, :public_class_method, :autoload?, :instance_method, :public_instance_method, :define_method, :autoload, :instance_variable_defined?, :remove_instance_variable, :instance_of?, :kind_of?, :is_a?, :tap, :instance_variable_get, :instance_variable_set, :protected_methods, :instance_variables, :private_methods, :method, :public_method, :public_send, :singleton_method, :define_singleton_method, :extend, :to_enum, :enum_for, :=~, :!~, :eql?, :respond_to?, :object_id, :send, :display, :class, :nil?, :hash, :dup, :singleton_class, :clone, :then, :itself, :yield_self, :untaint, :taint, :tainted?, :trust, :untrust, :untrusted?, :singleton_methods, :frozen?, :methods, :public_methods, :equal?, :!, :instance_exec, :!=, :instance_eval, :__id__, :__send__]
irb(main):004:0> nil.methods
=> [:&, :rationalize, :inspect, :to_a, :to_s, :===, :to_f, :to_i, :=~, :to_h, :nil?, :to_r, :to_c, :|, :^, :instance_variable_defined?, :remove_instance_variable, :instance_of?, :kind_of?, :is_a?, :tap, :instance_variable_get, :instance_variable_set, :protected_methods, :instance_variables, :private_methods, :method, :public_method, :public_send, :singleton_method, :define_singleton_method, :extend, :to_enum, :enum_for, :<=>, :!~, :eql?, :respond_to?, :freeze, :object_id, :send, :display, :class, :hash, :dup, :singleton_class, :clone, :then, :itself, :yield_self, :untaint, :taint, :tainted?, :trust, :untrust, :untrusted?, :singleton_methods, :frozen?, :methods, :public_methods, :equal?, :!, :==, :instance_exec, :!=, :instance_eval, :__id__, :__send__]
irb(main):005:0>

Let's explore a couple of these methods:

irb(main):005:0> nil.to_i
=> 0
irb(main):006:0> nil.to_a
=> []
irb(main):007:0> nil.to_s
=> ""
irb(main):008:0> nil.nil?
=> true
irb(main):009:0> NilClass.nil?
=> false

Nil can be converted to an integer of 0, an empty array, or an empty string. However, these values are not the same as nil nor are they even evaluated as falsy.

irb(main):010:0> 0.nil?
=> false
irb(main):011:0> [].nil?
=> false
irb(main):012:0> "".nil?
=> false
irb(main):013:0> !!0
=> true
irb(main):014:0> !![]
=> true
irb(main):015:0> !!""
=> true
irb(main):016:0> !!nil
=> false

Encountering Nil

So when might we get the value of nil if we don't explicitly assign it?

Let's say we have a hash that represents our shopping list. We have to visit multiple stores to get all our items and each store has one or more items that we need.

shopping_list = {
    :cub_foods => ["olive oil", "flour", "rice", "cereal", "soup"],
    :walgreens => ["tylenol", "toothpaste", "claritin"],
    :farmers_market => ["veggies", "fruit", "honey"],
    :target => ["pasta", "plates"]
}

Now, let's say we forgot to add the pet store to our list. We're at PetSmart and check our list:

shopping_list[:pet_store]
#=> nil

We get back nil since that key currently does not exist in our shopping_list hash. So let's add some values.

shopping_list[:pet_store] = ["dog food"]

shopping_list[:pet_store][0]
#=> "dog food"

shopping_list[:pet_store][1]
#=> nil

shopping_list[:pet_store][3] = "new toy"

shopping_list[:pet_store]
#=> ["dog food", nil, nil, "new toy"]

So we can see that nil is simply returned when a value doesn't exist.

Questions

Let me know in the comments below if you have any lingering questions, comments, or even complaints about nil. Happy coding!

Classes and Instances in Ruby

Laura Berge — Mon, 13 Jul 2020 21:40:07 +0000

When I was first learning Ruby, one of the concepts many of my classmates struggled with was object orientation. Ruby is a pure object-oriented language which means that everything in Ruby is an object. Even the term 'nil' that Ruby uses to represent nothing/null is an object. Objects in programming can include multiple variables and methods. For example, whenever we create a string in ruby, we are actually creating an object that is an instance of the class String.

string_instance = "table"
string_instance.chars.sort.join #=> "abelt"

We have access to the chars method because it is an instance method of the String class. The chars method creates an instance of Array from our string so that we can access the method sort which is an instance method of the class Array. The instance method join is also from the class of Array which then creates an instance of String again. If you're having trouble following, don't worry, this will make a lot more sense when we discuss how classes and instances are created.

When we want to represent something, we can create our own classes to do so. The class itself is an object and the instances of that class are also objects. Now, what is a class?

Classes in Ruby

When we define a class in Ruby, we're really creating a category with which we can create new objects. For example, let's say we have an application where we want to store users. We can create a class called User.

class User
    # code relating to the user class goes here
end

Now that we created a class, we can create new users using this class.

molly = User.new()

p molly #=> #<User:0x00007f8c738acbc0>

Now Molly is an instance of our User class. However, we can't do much with Molly since our USer class doesn't have any extra functionality. So, let's give all our users a name.

class User
    def initialize(name)
        @name = name
    end
end

molly = User.new("Molly")

molly #=> #<User:0x00007fdafab1e428 @name="Molly">

molly.name #=> NoMethodError (undefined method `name' for #<User:0x00007fdafab1e428 @name="Molly">)

When we create a class in Ruby, we can include the initialize method. This method takes the number of arguments we give and is called when we create a new instance. When we call the .new() method, initialize will be called. Ruby will check that we've provided the proper number of arguments and will throw an argument error now if we try to call User.new() without a name passed in.

We are assigned the instance variable name to the name passed into the new function. By using the '@' symbol before a variable, we are saying that variable is an instance variable in our class. An instance variable is one that is stored under an instance of our class (such as molly) rather than the class itself. I'll include more on this later so don't worry if you're confused.

However, we can also see that trying to access Molly's name directly doesn't work. This is because we don't have a 'getter' method.

Setters and Getters

In order to read the name value of our User instances, we need to create a getter method.

class User
    def initialize(name)
        @name = name
    end

    # getter method
    def readName
        @name
    end
end

molly = User.new("Molly")
molly.readName #=> "Molly"

Our getter method just returns the name property. I used 'readName' as the function name to illustrate that we can call it whatever we want. However, since we actually want to call molly.name, we can also write:

class User
    def initialize(name)
        @name = name
    end

    # getter method
    def name
        @name
    end
end

molly = User.new("Molly")
molly.name #=> "Molly"

Setter methods allow us to 'set' or write variables.

class User
    def initialize(name)
        @name = name
    end

    # getter method
    def name
        @name
    end

    # setter
    def catch_phrase=(catch_phrase)
        @catch_phrase = catch_phrase
    end

    # getter
    def catch_phrase
        @catch_phrase
    end
end

tony = User.new("Tony Montana")

tony.catch_phrase #=> nil

tony.catch_phrase = "Say hello to my little friend!"

tony.catch_phrase #=> "Say hello to my little friend!"

In order to define a setter method, we declare a method with an equals operator. When we call tony.catch_phrase =, we are actually using shorthand for:

tony.catch_phrase=("Say hello to my little friend!")

Attr Writers, Reader, and Accessors

Coding every variable we want to be able to set and get for each instance could be incredibly code-intensive. The code would also be very repetitive. Luckily, Ruby has a macro we can use to define setters and getters!

class User
    attr_reader :name, :catch_phrase
    attr_writer :catch_phrase

    def initialize(name)
        @name = name
    end
end

The code above is the exact same as before, the attr_reader writes the 'getter' methods and the attr_writer writes the 'setter' methods. If we have a variable using both the reader and writer, we can use attr_accessor to write both methods for us.

class User
    attr_reader :name
    attr_accessor :catch_phrase

    def initialize(name)
        @name = name
    end
end

tony = User.new("Tony Montana")

tony.catch_phrase #=> nil

tony.catch_phrase = "Say hello to my little friend!"

tony.catch_phrase #=> "Say hello to my little friend!"

tony #=> #<User:0x00007fc5d2949a40
 @catch_phrase="Say hello to my little friend!",
 @name="Tony Montana">

Other Instance Methods

Our instance methods don't need to be limited to setters and getters. We can create other methods as well. To illustrate this, let's look at dogs and cats as an example.

class Dog
    attr_accessor :name

    def initialize(name)
        @name = name
    end

    def speak
        "WOOF!"
    end
end

class Cat
    attr_accessor :name

    def initialize(name)
        @name = name
    end

    def speak
        "Meeeoooww."
    end
end

chewy = Dog.new("Chewy")
lucy = Dog.new("Lucy")
mittens = Cat.new("Mittens")
gretchen = Cat.new("Gretchen")

chewy.speak #=> "WOOF!"
lucy.speak #=> "WOOF!"
mittens.speak #=> "Meeeoooww."
gretchen.speak #=> "Meeeoooww."

Inheritance

Let's take our animal classes and expand on them. We are going to create a model for a vet office. For this, we're going to have a class of Pet, Dog, Cat, and SmallAnimal.

class Pet
end

class Dog < Pet
    attr_accessor :name

    def initialize(name)
        @name = name
    end
end

class Cat < Pet
    attr_accessor :name

    def initialize(name)
        @name = name
    end
end

class SmallAnimal < Pet
    attr_accessor :name

    def initialize(name)
        @name = name
    end
end

Now, we know all our animal instances are examples of the Pet class, so we can have SmallAnimal, Dog, and Cat inherit from Pet. What this allows us to do is create methods in our Pet class that are relevant to all animals. For example, we can set up an appointment reminder method that returns a string with a reminder and that pet's name.

class Pet
    def appointment_reminder
        "Time to make an appointment for #{@name}"
    end
end

Now whenever we create a new instance of Dog, SmallAnimal, or Cat, we can access this appointment_reminder method.

spot = Dog.new("Spot")

spot.appointment_reminder #=> "Time to make an appointment for Spot"

Class Methods

Let's say our vet office needed to be able to access a list of all Pets that have been created. We want this list specific to the type of pet. We can use a class method in order to achieve this.

class Dog
    attr_accessor :name

    @@all = []

    def initialize(name)
        @name = name
        @@all << self
    end

    def self.all
        @@all
    end
end

Dog.new("Spot")
Dog.new("Lucy")
Dog.new("Jitta")
Dog.new("Sully")
Dog.new("Chewy")

Dog.all #=> [#<Dog:0x00007fe584171f58 @name="Spot">,
 #<Dog:0x00007fe5841a3e40 @name="Lucy">,
 #<Dog:0x00007fe584299ac0 @name="Jitta">,
 #<Dog:0x00007fe58430be40 @name="Sully">,
 #<Dog:0x00007fe58435aec8 @name="Chewy">]

Dog.all[0] #=> #<Dog:0x00007fe584171f58 @name="Spot">
Dog.all[3] #=> #<Dog:0x00007fe58430be40 @name="Sully">

Using '@@' signifies a class variable.

First, we declare a class variable equal to an empty array.

Then, each time a new Dog is created, we push that Dog instance into our @@all array. Self in Ruby refers to whatever we are currently calling a method on. When we call the initialize method, it is on the new instance of Dog we created.

spot = Dog.new('Spot')
# => calls this: spot.initialize('Spot')

Therefore, 'self' in the initialize method represents spot in this case. Spot is pushed into the @@all class variable.

Finally, we declare a getter method so that we can access this class variable. We use self to declare a class variable because, within this scope, self represents the class Dog. So, def 'self.all' means 'Dog.all'.

class Dog
    def self.all
    end

    # technically can also be written
    def Dog.all
    end
end

Final Thoughts

Let me know:

What are you confused about with object orientation?
Are there concepts about classes in Ruby that I didn't go over that could use some clarification?
What is your favorite part about OOP (object-oriented programming)?
As always, any corrections or critiques?

Happy coding!

Learn Ruby through Testing: Ruby Koans

Laura Berge — Tue, 07 Jul 2020 00:18:43 +0000

One of the best ways (in my opinion) to begin learning to program is through test-driven development. If you're just getting started learning ruby, want to explore more of the fundamental concepts, or learn more about how tests are written in Ruby, there is a great tool available called the Ruby Koans.

Koan is a word used by Zen Buddhist monks to describe questions, paradoxes, stories, etc. that are to be meditated on and further their Zen practice. The Ruby Koans were created by Jim Weirich who was very influential to the Ruby language community as he developed multiple tools including Rake. The purpose of the Ruby Koans is to introduce users to the Ruby language through test code. Because testing is so important to sustainable and scalable development, learning foundational concepts using test code is a great way for beginners to learn.

Getting Started

In order to get started, we need to make sure we have Ruby installed and the version is at least 1.8. To check which version is installed, in the terminal we can run:

ruby -v

I have ruby 2.6.4 installed so we are good to go. Check out the documentation here if you need to install or upgrade Ruby.

Clone the Git Repo

The GitHub repo has all the code needed to run the koans. Simply navigate in the terminal into the directory that we want the koans project to be and run:

git clone https://github.com/edgecase/ruby_koans

Then open up the directory in a code editor. (I use Visual Studio Code.)

Generate the Koans

The koans are not generated by default so before we explore the directory we need to run:

rake gen

If at any point we wish to restart and regenerate the koans, just run:

rake regen

Quick note: You may notice the src directory follows the same structure as the koans directory. That folder does contain the koans but with the answers filled in. You are welcome to reference these answers if you are stuck, but I recommend following the tests first.

Fix the Tests

In order to start our journey, we need to run the first test. The command rake will execute our test code.

rake

The test output says:

Please meditate on the following code:
  /Users/laura/Desktop/dev/ruby_koans/koans/about_asserts.rb:10:in `test_assert_truth'

So we can navigate to the file in the koans folder titled 'about_asserts' and see that the first method is called test_assert_truth.

The code says false and there is a note to change it to true. Let's delete false and replace it with true. Now let's run rake again, and we've passed our first test!

Keep going through all the tests and you might achieve enlightenment. More likely, you'll at least have a better understanding of Ruby and how to test your code.

Note on Length

The koans usually take 5 or so hours. I completed them in a span of 6 hours with a few breaks between, but I would recommend spreading it out into smaller chunks throughout a few days, week, or even month. There is a lot of information in each answer so make sure you're learning why a line of code passes the test before moving on to the problem. Passing the tests is not as important as learning what they teach. But most of all, have fun coding!

Exploring the Console

Laura Berge — Mon, 29 Jun 2020 22:28:28 +0000

While learning JavaScript, one of the most important tools available is the in-browser console. While many beginners quickly learn how to use console.log("Hello World!") to print to the console, there are so many other useful methods available in the console object! In order to see this more clearly, we can navigate to the browser's dev tools and into the console. If we type console and hit enter, we should see a JS object with tons of methods inside.

In this list, we can see the log method. However, that's only one of many methods listed out. So, let's dive a bit into these methods!

We have:

assert: ƒ assert()
clear: ƒ clear()
context: ƒ context()
count: ƒ count()
countReset: ƒ countReset()
debug: ƒ debug()
dir: ƒ dir()
dirxml: ƒ dirxml()
error: ƒ error()
group: ƒ group()
groupCollapsed: ƒ groupCollapsed()
groupEnd: ƒ groupEnd()
info: ƒ info()
log: ƒ log()
profile: ƒ profile()
profileEnd: ƒ profileEnd()
table: ƒ table()
time: ƒ time()
timeEnd: ƒ timeEnd()
timeLog: ƒ timeLog()
timeStamp: ƒ timeStamp()
trace: ƒ trace()
warn: ƒ warn()

assert

Assert is a method that we can pass a conditional into. If that conditional is false, then the console will give an error message saying that the assertion failed. If the conditional is true, the console won't print anything.

If we type console.assert(2 > 1), this will evaluate to true so nothing will be printed.

If we type console.assert(2 < 1), this will evaluate to false so a red error message will be printed stating "Assertion failed".

clear

Clear is also a pretty commonly used method. The clear function takes no arguments and will 'clear' the console. Any variables or functions that have been declared will remain. If we declare let newVariable = 10, then call console.clear(), then console.log(newVariable), 10 will still be printed to the console. Clear just helps to remove any busy messages, errors, or previous code while we're trying to debug in the console.

context

As far as I'm aware, console.context() just prints out the functions available in the console object again. I.e. it prints out the context of the console object itself.

count

I personally am a big fan of the count method, even though I haven't used it in actual practice. The count method accepts an argument and prints out how many times that argument has been counted. If no arguments are passed, the method will count that as default.

So if we call console.count(), 'default: 1' will be printed. If we call console.count() again, this time 'default: 2' will be printed.

However, if we then call console.count('Hello World'), 'Hello World: 1' will be printed. Each time we continue calling count with that specific argument, the print out will add 1 to the count under that item. We can use count with different arguments and it will keep track of each of these separately.

countReset

The countReset method just resets the count for a given argument. Calling console.countReset() will reset our count for the default, but to reset the 'Hello World' count, we need to call console.countReset('Hello World').

debug

Using console.debug() is very similar to using a console.log() except that the message is only printed if the console is set up to display the debug output.

dir

I use this method a lot because it allows you to take a more in-depth look at and object and its child objects. There are times when I've found console.log is sufficient in allowing me to what is available in a given object, but console.dir is often needed for more complex objects. In order to best illustrate the difference, try using both to log the document object -

console.log(document)
console.dir(document)

The console.dir should include all the methods available to the document object whereas log often just outputs the HTML code of the document.

dirxml

The dirxml is very similar to the dir method except that it shows the tree of nodes associated with a given XML or HTML object/element. For example, if there is a div element with a number of child elements, we can console.dirxml(thatDiv) and receive an interactive print out of all the child elements of that div.

console.dirxml(document.querySelector('head'))
console.dirxml(document.querySelector('body'))

error

This method just prints out a red error message to the console with a message that is passed in as an argument.

console.error('oops something went wrong')

group

console.group() can be a very handy way to organize any logs, error messages, etc. that we're doing in the console. By calling console.group(), we group any following calls into the group we're using. Groups can have multiple tiers. To end a group we use console.groupEnd(). I genuinely think the best way to understand this one is to navigate to the browser and see how it outputs messages visually.

console.log('I am not in any grouping')
console.group('outer group')
console.log('I am in the outer group')
console.group('inner group')
console.log('I am in an inner group inside the outer group')
console.groupEnd()
console.log('I am also in the outer group')
console.groupEnd()
console.log('I am also not in any group')

As we see in the code above, console.group does accept an optional parameter that can be used to name or label the group.

groupCollapsed

This method works just like console.group() except that the messages inside the group are collapsed by default and need to be expanded to examine. This can be very helpful if we have a lot of code printing in the console and we don't want to see it all at once.

console.log('I am not in any grouping')
console.groupCollapsed('outer group')
console.log('I am in the outer group')
console.groupCollapsed('inner group')
console.log('I am in an inner group inside the outer group')
console.groupEnd()
console.log('I am also in the outer group')
console.groupEnd()
console.log('I am also not in any group')

groupEnd

See the group method.

info

This method again is very similar to console.log(). It will print out a passed in object or string. Its purpose is to show information based on what's passed in whereas a log is meant to log an item. Most of the time they are completely interchangeable.

log

Again, log just prints out the passed in argument(s) to the console. It does accept multiple arguments as does the info method.

profile

I'm not going to explore this method since it's not standard and has compatibility issues, but feel free to explore the documentation on console.profile().

profileEnd

I'm also not going to explore this method since it's not standard and has compatibility issues, but feel free to explore the documentation on console.profileEnd().

table

This method is also a favorite of mine. Whenever we have data that could be better visualized in a table format, we can use console.table(). If we console.table(anObject), a table with one column of the keys will be printed along with the next column being the corresponding values. This one is also a very visual method so I encourage you to play around with it in dev tools.

let me = {
  name: 'Laura',
  favoriteLanguage: 'JavaScript',
  height: '5\'10"',
  zodiac: 'Aries'
}

console.table(me)

time

The console.time() method is used to start a timer that will be printed out when timeEnd is called. This can be very useful when seeing how long a given algorithm takes.

timeEnd

When console.timeEnd() is called after console.time(), the timer is stopped and the number of milliseconds taken is printed to the console.

timeLog

This method does the same as timeEnd without stopping the timer. Calling console.timeLog() prints out the current ms the timer is at.

timeStamp

I'm also not going to explore this method since timeStamp not standard and has compatibility issues, but feel free to explore the documentation on console.timeStamp().

trace

This method points prints out the path to how we got to the line we're currently on. For example, if we have several nested functions and console.trace() is inside the most inner function, when we call the outer function, console.trace will print out all the functions tracing back from the innermost to the outermost function.

function outer(){
  middle()
}

function middle(){
  inner()
}

function inner(){
  console.trace()
}

outer()

// printed to our console in this order will be:
// inner
// middle
// outer

warn

The warn method is just like console.error(), except it's meant to display a warning rather than an error. Instead of the message showing up in red with an x icon, warnings are yellow with ! warning signs.

console.warn('Warning: your browser version will no longer be compatible with our site by January 1, 2021. Please consider updating to the newest version.')

Intro to Recursion

Laura Berge — Mon, 22 Jun 2020 22:45:33 +0000

As a boot camp graduate looking for my first programming job, I have been spending a lot of time self-teaching CS concepts that come up in coding interviews. The term recursion continuously came up while I was researching how to prepare for technical interviews. A quick lookup of the word online defines recursion as:

"a computer programming technique involving the use of a procedure, subroutine, function, or algorithm that calls itself one or more times until a specified condition is met at which time the rest of each repetition is processed from the last one called to the first"

“recursion,” Merriam-Webster.com Dictionary, Accessed 6/22/2020.

Despite having been an English major, reading this definition left me still confused. From the definition, I know that a recursive algorithm calls itself until a given condition is met. However, I still couldn't visualize what a recursive solution would actually look like. So I decided the best way for me to learn a new programming term is to code. I looked up what problems are best solved through recursion and found one dealing with strings.

The problem

Print out all permutations of a given string.

In order to start thinking of an algorithm solution, I mapped out the solution manually.

I found what I was doing taking a given letter and tacking on different options until all options were exhausted. In this case, I take the word train and pin the letter t to the beginning and focus on rearranging "rain". In order to do so, I pin 'r' in place. Then 'a'. Then 'i'. Finally 'n'. Once I've exhausted all options, I backtrack to 'r' and choose 'i' first instead of 'a' this time. I continue to repeat this backtracking process until all possibilities beginning with the letter 't' are exhausted moving on to 'rtain'.

Turning the manual solution into an algorithm

In order to automate this process, I used my explanation of the manual process to work it into variables and functions. Here is my code as I began working through the problem:

function permutate(string){
    // I'm thinking I'm going to need to iterate over my characters and pin them to the beginning of a string
    for (let i = 0; i < string.length; i++) {
        // pin at beginning string[i]
        let prefix = string.charAt(i)

        let suffix = string.substring(0, i) + string.substring(i + 1, string.length)
        // now I need to find all permutations of the suffix and print them with the prefix tacked on
        for (let i = 0; i < suffix.length; i++) {
            // pin on a new character to prefix and then continue finding permutations of the suffix until it is empty and the prefix contains 5 characters
        }
    }
}

I realized I wanted to separate out the beginning of the word from the end which is why I used the terms prefix and suffix. The prefix holds the letters chosen while the suffix holds the remaining possibilities. Looking back at my diagram, it was clear that the process I was performing manually had a lot of repetition. I used the same logic to rearrange letters at each step of my pyramid. I continually tacked on a new character until none were left, then backtracked to when a new possibility existed.

With that logic in mind, I thought about how I could generalize a function so that I could reuse it to continuously tack on options until none remain. One the suffix is empty, the prefix should contain 5 characters which will be one of the permutations. Then, I would need to backtrack to the last time there was more than one option.

// to start, I would need an empty 'prefix'
let prefix = ""
let suffix = "train"

// I'll also begin storing my results in an array
let results = []

// As I use my function, I expect each call to add one character to the prefix while removing that character from the suffix
permutate("", "train", [])
//=>
prefix = "t"
suffix = "rain"
results = []

permutate("t", "rain", [])
//=>
prefix = "tr"
suffix = "ain"
results = []

permutate("tr", "ain", [])
//=>
prefix = "tra"
suffix = "in"
results = []

permutate("tra", "in", [])
//=>
prefix = "trai"
suffix = "n"
results = []

permutate("trai", "n", [])
//=>
prefix = "train"
suffix = ""
results = ["train"]

// then I would need to backtrack

permutate("tra", "in", ["train"])
//=>
prefix = "tran"
suffix = "i"
results = ["train"]

permutate("tran", "i", ["train"])
//=>
prefix = "trani"
suffix = ""
results = ["train", "trani"]

// and so on...

In order to implement this recursive function, I'm using a results array that I can continuously pass to the function as well as the prefix and suffix parameters. The first item my recursive function will need to check is whether a permutation has been found or not - i.e. whether the suffix no longer contains any characters.

function recursivelyPermutate(prefix, suffix, results){
    if (suffix.length === 0) {
        results.push(prefix)
    }
}

If the suffix still contains characters, I want to iterate over those characters tack each one onto the prefix while removing it from the suffix.

function recursivelyPermutate(prefix, suffix, results){
    if (suffix.length === 0) {
        results.push(prefix)
    } else {
        for (let i = 0; i < suffix.length; i++){
            prefix = prefix + suffix.charAt(i)
            suffix = suffix.slice(0, i) + suffix.slice(i + 1, suffix.length)
        }
    }
}

Now that the prefix and suffix have changed to include each option in the suffix, I can call recursivelyPermutate again with the updated substrings. The function will automatically stop calling once all options have been used thanks to the conditional.

function recursivelyPermutate(prefix, suffix, results){
    if (suffix.length === 0) {
        results.push(prefix)
    } else {
        for (let i = 0; i < suffix.length; i++){
            recursivelyPermutate(prefix + suffix.charAt(i), suffix.slice(0, i) + suffix.slice(i + 1, suffix.length), results)
        }
    }
}

Now I have a function that accepts three parameters and changes the results array passed in to store all the possible permutations. However, what I really want is to be able to call permutate("train") and have all the permutations printed to the console. To do so, I just need to add one more function that calls the recursive function the first time.

function recursivelyPermutate(prefix, suffix, results){
    if (suffix.length === 0) {
        results.push(prefix)
    } else {
        for (let i = 0; i < suffix.length; i++){
            recursivelyPermutate(prefix + suffix.charAt(i), suffix.slice(0, i) + suffix.slice(i + 1, suffix.length), results)
        }
    }
}

function permutate(string){
    results = []
    recursivelyPermutate("", string, results)
    results.forEach(permutation => {
        console.log(permutation)
      })
}

Finally, since I don't really need access to the recursive function outside of the scope of my permutate function, I'm going to place that function inside my permutate function. That way I don't have to pass the results in as a parameter since the variable will be within scope.

function permutate(string){
    results = []

    function recursivelyPermutate(prefix, suffix){
        if (suffix.length === 0) {
            results.push(prefix)
        } else {
            for (let i = 0; i < suffix.length; i++){
                recursivelyPermutate(prefix + suffix.charAt(i), suffix.slice(0, i) + suffix.slice(i + 1, suffix.length))
            }
        }
    }

    recursivelyPermutate("", string)
    results.forEach(permutation => {
        console.log(permutation)
    })
}

permutate('train')

And at last, I have finally written my first recursive solution to a problem.

Discuss

I hope this helped begin to explain what a recursive solution is, what it looks like, and how to approach a code challenge that could make use of recursion.

In the comments below, I'd love to know:

Have you used recursion in a project or interview? If yes, how so?
What do you like/dislike about recursion?
What methods for solving code challenges do you enjoy the most?

Automating a Mac using AppleScript

Laura Berge — Mon, 15 Jun 2020 18:47:35 +0000

While in the process of creating a wallpaper automation project using python, I found the easiest way to change the wallpaper on my MacBook was using AppleScript. The command I found was:

# the %s is the path to an image file stored locally
command = """/usr/bin/osascript<<END
    tell application "Finder"
        set desktop picture to POSIX file "%s"
    end tell
    END"""

Digging into this code, the beginning path directs to the osascript file which allows us to run AppleScript and other OSA language scripts. Then the code is fairly self-explanatory: I tell the application Finder to set the desktop wallpaper to a file saved on our computer. I then end the tell and and the script.

Given how easy the script was to read and understand, my curiosity of AppleScript was piqued. So I decided to learn some basic commands and keywords in AppleScript to make automation on my Mac easier in the future.

AppleScript Editor

To begin playing around with AppleScript, the Mac has an application under Applications/Utilities called Script Editor. Open that up and you should see the following:

If there is already a script written in the main body, just open a new window using ⌘N or File>New. Once the body is blank, we're ready to start scripting.

Once we have a script written, we can compile the code using the hammer icon (saving the file also compiles the code) and press the play button to run the script.

Hello World!

AppleScript has the command 'say' that will audibly say the string we type after. Try it out by typing say and whatever string in quotations you want your computer to say, compiling the code, and pressing play. Your Mac should have the default voice speak whatever you typed in quotes.

Apple has another way of saying "Hello World" with it's recognizable muted 'beep' sound. Try trying the word beep on a new line and running the script.

Popup 'OK' or 'Cancel' Options

We can also use the 'display dialog' command to open up an option menu for the user to select OK or Cancel.

When the code is run, a window will pop up. Try running the code twice so you can see the difference in output depending on the selection. There are many use cases where you may want to receive confirmation before completing a task, and this command makes that process a snap.

Variables

We can also create and assign variables in AppleScript. The syntax looks like:

set myName to "Laura"

After setting this variable, I can add it to strings using the & operator. In the following script, I use the say command so my computer says "Welcome back, Laura" as well as printing it out to the results on line 3 (note that we don't use print or any other keyword).

Interacting with Applications

In the script I used to change wallpaper, I interacted with an application - Finder. We can use AppleScript to interact with any scriptable applications on a Mac. Here is a link to all the key codes AppleScript uses that make interacting with applications easier as well as notes on using the command 'keystroke' instead. Using these key codes, we can go to specific websites, input information, click on items, search for info, etc. Basically anything we can do manually using our keyboards we can do through AppleScript.

In order to open an application, the command 'activate' is used.

tell application "iTunes" to activate
activate application "Spotify"

Both of the commands above are a valid way to open an application and/or bring it to the front. To run commands through an application, we use the command 'tell.'

tell application "Finder"
    set desktop picture to POSIX file "%s"
end tell

To change desktop wallpaper on a Mac, we tell Finder to set the desktop picture to a image file at a given path. We then end the tell. We can run multiple commands within the tell block. Different scritable applications accept different commands.

In order to know what applications are scriptable and what commands we can use, all we need to do is open the dictionary included in the Script Editor.

I have Spotify downloaded and it's included in the dictionary, so I will use that as an example. There are a lot of commands that listed in the dictionary, but I'm going to use play track and pause. Using play track instead of just play, I can specify a specific song or album using unique Spotify URIs. these can be found by right clicking on a song or album, navigating to share, and then copy Spotify URI. I will also be utilizing delay which telling AppleScript to wait a given number of seconds before executing the next line.

activate application "Spotify"
tell application "Spotify"
    play track "spotify:track:4OBZT9EnhYIV17t4pGw7ig"
    delay 60
    play track "spotify:track:3898C4AbdbptwYet6547e5"
end tell

After 60 seconds, Best Part by H.E.R is paused. Then we tell Spotify to play "The Girl from Ipanema" by João Gilberto and Astrud Gilberto.

Note that we don't actually need to pause the previous song to switch. That line is only there to show another command in Spotify.

If you have any favorite uses of AppleScript, let me know in the comments! I've just begun exploring the documentation and am excited to continue deepening my AppleScript knowledge.

If you're curious about what can be done using Google Chrome, here is a fun video about using AppleScript to automate following users on Instagram through a Chrome browzer. Disclaimer, I don't recommend botting on Instagram and neither does the video.

JS Array Methods: Filter, Map, Reduce, and Sort

Laura Berge — Mon, 08 Jun 2020 18:58:57 +0000

When working with arrays in JavaScript, there are a number of methods at our disposal. I always think the best way to learn is to explore, so if you're unfamiliar or a beginner when it comes to array methods, be sure to type Array.prototype into the console in dev tools. A whole list of methods should print out beginning with contact and ending at values. Here are the docs with some more explanation of all the different methods. I'm just going to be explaining filter, map, reduce, and sort, but be sure to play around with any other methods you aren't familiar with.

For the following examples I am going to be using these arrays:

const numbers = [5, 2, -1, 3, 0, 2, 4, 2]
const alpha = ['d', 'w', 'a', 'v', 'y', 't', 'r', 'c', 'k']
const names = ['Zach', 'Laura', 'Matt', 'Jessica', 'Hannah']

Array.prototype.filter()

The filter function creates a new array from an existing array but removes any values that don't fit the passed in conditional. I'll first show this by taking any number below 1 out of the numbers array:

const positiveNumbers = numbers.filter(n => {
  return n > 0
})

// positiveNumbers = [5, 2, 3, 2, 4, 2]
// const numbers = [5, 2, -1, 3, 0, 2, 4, 2]

The 'n' in the numbers.filter() function just represents an individual value in the array as is is iterated over. So the function starts by passing in the first value (5) and returning true or false depending on whether 5 > 0. If true, 5 will be added to the new array. If false, it won't be included in the positiveNumbersArray. The function is non-descructive, so the numbers array remains the same.

Let's say we have a study group of all the people in the names array except for Matt. We can create a new array and filter him out.

const studyGroup = names.filter(name => {
  return name !== 'Matt'
})

// studyGroup = ['Zach', 'Laura', 'Jessica', 'Hannah']

Array.prototype.map()

The map function creates a new array using an existing array and operating over every value. For example:

const doubledNumbers = numbers.map(n => {
  return n * 2
})

// doubledNumbers = [10, 4, -2, 6, 0, 4, 8, 4]
// numbers = [5, 2, -1, 3, 0, 2, 4, 2]

In the above code, we define a new variable 'doubledNumbers'. The map function iterates over the numbers array, multiplying each value by two and adding them to a new array. The numbers array is left unchanged.

Let's say we want to take our array of names and create another array with welcome messages.

const welcomeMessages = names.map(name => {
  return `Welcome, ${name}!`
})

// welcomeMessages = ['Welcome, Zach!', 'Welcome, Laura!', 'Welcome, Matt!', 'Welcome, Jessica!', 'Welcome, Hannah!']

The names array is still unchanged, but now we have an array of all our welcome messages without having to hard-code a message for each name.

Array.prototype.reduce()

The reduce method is a bit more complex. The method is for tracking an array and reducing it to a single value. It also expects a function like filter and map, but can also take an initial value. For example:

// array.reduce(callbackFunction, initialValue)

const total = numbers.reduce((total, n) => {
  return total + n
}, 5)
// evaluates to 22

const total = numbers.reduce((total, n) => {
  return total - n
}, 0)
// evaluates to -17

const total = numbers.reduce((total, n) => {
  return total - n
})
// evaluates to -7

As seen in the last example, the reduce function doesn't require the initial value to be passed in. If no initial value is passed, it will start from the first value of the array. In the first example, 5 is passed in so the function's work as it iterates over the array looks like:

initialValue = 5
numbers = [5, 2, -1, 3, 0, 2, 4, 2]
5 + 5 = 10
10 + 2 = 12
12 + -1 = 11
11 + 3 = 14
14 + 0 = 14
14 + 2 = 16
16 + 4 = 20
20 + 2 = 22
return 22

The total starts at the initialValue passed in or the start of the array, then alters it as it iterates through the rest of the array, returning the final total when finished.

Array.prototype.sort()

The sort method is the one I had the hardest time understanding when I fist started learning how to code. I'll start by looking at the method without passing any arguments in.

const alphabetized = alpha.sort()

// alphabetized = ["a", "c", "d", "k", "r", "t", "v", "w", "y"]
// alpha = ["a", "c", "d", "k", "r", "t", "v", "w", "y"]

numbers.sort()

// numbers = [-1, 0, 2, 2, 2, 3, 4, 5]

Sort called without any arguments will sort from least to greatest ('a' < 'z' = true, 'Z' < 'a'). However, it will only compare the first character by default unless the first character is the same. Like 219 will be sorted before 3 since 2 < 3. 218 will be sorted before 22 since 2 = 2 so the second character will be evaluated. Sort basically sorts numbers alphabetically by default. The other important thing to note is that sort is destructive and changes the existing array rather than creating a new array.

However, the sort function does accept a function as an argument. Sort expects either a negative, 0, or a positive to be returned depending on how the two array values compare. Another way to write the default sort function is:

numbers.sort((a, b) => {
  if (a < b) {
    return -1
  } else if (a > b) {
    return 1
  } else {
    return 0
  }
})
// [-1, 0, 2, 2, 2, 3, 4, 5]

// To get reverse order, we switch the 1 and -1:

numbers.sort((a, b) => {
  if (a < b) {
    return 1
  } else if (a > b) {
    return -1
  } else {
    return 0
  }
})
// [5, 4, 3, 2, 2, 2, 0, -1]

However, since we're working with numbers, we don't need to manually return -1 or 1. Instead we can just write:

// from least to greatest
numbers.sort((a, b) => {
  return a - b
})

// from greatest to least
numbers.sort((a, b) => {
  return b - a
})

If a positive number is returned, the function will sort the next value before the previous value. If a negative number is returned, then the previous value will be sorted before the next. If a 0 is returned, there will be no change in order. I'll give another more example using an array of objects.

const family = [{
    role: 'mom',
    name: 'Ms. Smith',
    age: 45
  }, {
    role: 'dad',
    name: 'Mr. Smith',
    age: 45
  }, {
    role: 'sister',
    name: 'Hannah',
    age: 2
  }, {
    role: 'brother',
    name: 'Zach',
    age: 9
  }, {
    role: 'brother',
    name: 'Matt',
    age: 7
  }]

// we need to sort the family by ascending age
family.sort((a, b) => {
  return a.age - b.age
})

Now our family array is sorted by youngest to oldest.

Quick Note:

Feel free to drop a comment for any clarifications or corrections! ♥

Using LocalStorage to Persist Data

Laura Berge — Fri, 29 May 2020 01:15:34 +0000

Making an app that requires persisting some simple but non-sensitive data? Do you want to cache some data to help your app run faster when a user returns? Using web storage can make that extremely simple if the data being stored doesn't need security.

There are two types of web storage objects:

localStorage (no specified expiration and will persist after the window closes)
sessionStorage (cleared when the browser window is closed)

I will only be diving into localStorage for this blog. More info on how web storage data is stored as well as browser compatibility.

Note on Security

While web storage can be very convenient, never store sensitive user information using web storage. No data protection measures are in place for localStorage. Keep in mind that localStorage is compatible with most browsers, but not all, so make sure your app doesn’t rely on localStorage to run. Here is another blog post going more in-depth about why and when using localStorage can be dangerous.

What is localStorage exactly?

The localStorage is just a JS object. If you open up dev tools and type localStorage into the console, you should get back a JS object. If the length is greater than 0, there is information stored there by the page you are currently on. When I looked at localStorage for dev.to, there is actually a ‘current_user’ key that has a lot of my info saved under it like id, username, profile_image, etc. You can visit any webpage you like and see if and how that page uses localStorage.

The localStorage object has a few methods we can make use of:

localStorage.clear()
localStorage.setItem(key, value)
localStoage.getItem(key)
localStorage.removeItem(key)
localStorage.key(index)

Note: sessionStorage has the exact same methods.

.clear()

To start playing around with localStorage in the browser, we can start with a clean slate by running localStorage.clear().

This removes all items saved to localStorage at this domain.

.setItem()

Now let's add an key-value pair to localStorage:

In this example, we are going to be storing a simple grocery list.

.getItem()

Let's see if our data is saved properly by using the getItem method.

Our data was saved, but the array was converted to a string in a way we didn't intend. To fix this, we can use JSON.stringify() and JSON.parse() in order to convert our array into a string for localStorage and back to an array once we retrieve it.

.removeItem()

To remove our key-value pair, we just need to use the removeItem method.

.key()

The only other method available to us it localStorage.key(index). This method returns the key of an item when passed an index. This could be useful if you had to loop through the data you stored in localStorage and pass in an index.

Play Around!

Since localStorage is easy to access in dev tools, I would highly recommend going to some of your favorite sites and seeing if/how they use localStorage and sessionStorage. This may help you get ideas on when you might use it and get insight into the security of different websites.

FullCalendar with React

Laura Berge — Tue, 28 Jan 2020 22:29:36 +0000

So I finally finished my final project for Flatiron School! I am beyond proud of how far I've come, but I am still yearning to learn more -- especially about CSS and UX/UI design. For the final project, we had to build an application with a React/Redux frontend with a Rails API backend. I've got to say, the React section has by far been the most fun for me. To challenge myself, I decided to learn how to implement FullCalendar into my petcare scheduling application.

Why FullCalendar

I knew I wanted a calendar on my application and did not want to waste time building it out myself. A lot of the curriculum tells us not to reinvent the wheel if we don't have a good reason to. So I turned to research and found that FullCalendar was a very popular JS calendar with many features. I liked how easy it was to load events in as well as edit them. After a few hours of reading through the docs and looking up videos, I decided to give it a go.

Importing FullCalendar into React

To get started, I needed to install FullCalendar via the command line.

npm install --save @fullcalendar/react @fullcalendar/core @fullcalendar/daygrid @fullcalendar/interaction

Then, I had to import FullCalendar along with the usually imports into my component.

import React, { Component } from 'react'
import FullCalendar from '@fullcalendar/react'
import dayGridPlugin from '@fullcalendar/daygrid'
import interactionPlugin from '@fullcalendar/interaction'

export default class Schedule extends Component {
  // declare any necessary functions such as handleDateClick, etc.

  render() {
    return <FullCalendar 
                    defaultView="dayGridMonth" 
                    plugins={[dayGridPlugin, interactionPlugin]}
                    editable={true}
                    eventDrop={this.handleEventDrop}
                    eventClick={this.handleEventClick}
                    events={this.formatEvents()}
                />
  }
}

Note: The Interaction Plugin isn't necessary but makes interacting with events (i.e. editing and deleting) possible. React allows you to use all the usual FullCalendar features, these are just the ones I chose to keep it simple my first time around. Feel free to go wild with all the possible features!

FullCalendar React Docs

Getting Events on the Calendar

FullCalendar uses the events prop to determine what to render to the calendar. The event prop expects an array of event objects with keys of title, start, and an optional end. It also has a key of extendedProps which it sends and props with keys it doesn't expect to. In order to easily access my event information when clicking on an event (the eventClick prop), I put any info I needed under the extendedProps key.

// ex. events={[{title: 'Appointment', start: '02-10-2020'}, {title: "", start: "03-05-2020"}]}

// events={this.formatEvents()}

formatEvents() {
  return this.props.appointments.map(appointment => {
            const {title, end, start} = appointment

            let startTime = new Date(start)
            let endTime = new Date(end)

            return {
              title, 
              start: startTime,
              end: endTime, 
              extendedProps: {...appointment}
            }
        })
}

Editting Events

With eventClick and eventDrop, the user can easily edit an event. I used eventClick to open up a form for a user to view and edit any information about that appointment. In eventDrop, when the user drags an appointment to a different day, the appointment can be edited to start on that date.

handleEventClick= ({event}) => {
    // openAppointment is a function I wrote to open a form to edit that appointment
    this.props.openAppointment(event.extendedProps)
}

handleEventDrop = (info) => {
        if(window.confirm("Are you sure you want to change the event date?")){
            console.log('change confirmed')

            // updateAppointment is another custom method
            this.props.updateAppointment({...info.event.extendedProps, start: info.event.start, end: info.event.end})

        } else {
            console.log('change aborted')
        }
   }

These FullCalendar methods made updating and persisting data very easy. I'm planning on playing around with FullCalendar more to learn more about the numerous features and how it works in vanilla JS.

If you have a favorite feature of FullCalendar that I haven't used, or if you have another calendar that you use in your applications, feel free to let me know! :)

Diving into React: The Final Module of Flatiron School

Laura Berge — Sun, 29 Dec 2019 21:21:09 +0000

I'm in my fifth month of Flatiron's coding boot camp, and the time has simultaneously flown by while feeling like years. In the fifth and final module of Flatiron, I am learning React and Redux. Since React has felt very different from anything we've done so far, I figured now would be the perfect time to blog about some beginner concepts--components and props.

Programmers love the separation of concerns, and - based on my current understanding - React does an excellent job of making separation very easy.

Components

React has a class called Component which is used to declare and components built into your application. Any components made are technically classes that inherit from the Component class. Components are used to separate aspects of our application that will need to be appended to the DOM.

class Welcome extends React.Component {
  render() {
    return (
      <div>
        Hello World!
      </div>
    )
  }
}

To render that component to the DOM, the component is added in the App class using JSX (a tag language that is basically a combination of JS and XML to render HTML):

class App extends React.Component {
  render() {
    return (
      <div>
        <Welcome />
      </div>
    )
  }
}

This would append the 'Hello World' div to the ReactDOM in our application. Components become more dynamic by adding properties or 'props'.

Props

Let's say we wanted the welcome message in our application to be customized by name. We can do this by adding a 'name' prop to our Welcome component.

class Welcome extends React.Component {
  render() {
    return (
      <div>
        Hello {this.props.name}!
      </div>
    )
  }
}

Then when we call our component in our App class we can pass in a name prop to our welcome message.

class App extends React.Component {
  render() {
    return (
      <div>
        <Welcome name="Laura" />
        <Welcome name="John" />
        <Welcome name="Audrey" />
        <Welcome name="Charlie" />
      </div>
    )
  }
}

This would append 4 customized welcome messages to our ReactDOM. As the code stands now, the App class is still hardcoded, but this can be easily altered by iterating over an object containing the name data.

Default Props

If we also wanted to pass in a default name in case none was given, React has a 'defaultProps' method that makes this easy and very readable. After declaring our Welcome component, we can declare the default props we want to include.

class Welcome extends React.Component {
  render() {
    ...
  }
}

Welcome.defaultProps = {
  name: "stranger"
}

Et voilà, that is my simple intro to React components and props. So far I have been enjoying learning React. I love when code is very readable and clean, and that seems to be deeply ingrained in React. The concepts seem pretty logical and self-explanatory - but of course, I am just beginning to scratch the surface. I'm excited to dig deeper (next I'm learning about forms and events) and begin building some React apps.

React docs: https://reactjs.org/docs/getting-started.html

Happy new year to all!

My goal in 2020 is to continue building and learning. I'd like to dive into Swift (and maybe Kotlin) once I feel my understanding is deep enough in Ruby on Rails, JS/HTML/CSS, React, and Redux.