We can create variables in C++ using the following syntax:

```
TYPE varName;
```

We declare the variable first with the data type, followed by the desired name. For example, if you want to store a person's age, you could do:

```
int age;
```

The left-hand side is the data type: an integer. The right-hand side is the variable name.

You can assign a value to a variable like so:

```
age = 35
```

Simply add the equal sign for the assignment operation, the value of the variable on the right-hand side. Note this is not a comparison.

You can declare your variable using other types, too. For instance, in the following examples we declare and define the values at the same time:

```
double circleArea = 3.123;

bool loading = true;

std::string name = "Roger";
```

A `double` is a floating point type that allows for the representation of numbers that have a fractional part.

A `bool` is a boolean type that has value that is either `true` or `false`.

A `string` is a sequence of characters. The `string` type belongs to the `std` namespace.

[Here is a program for you to play with](https://repl.it/@nbkhope/Cpp-Variables-Intro)

For more lessons on software development, visit NBK Tech World:

https://www.youtube.com/channel/UC3pR7vTMNPNmSk99YIBKUnw

See you there!


How to Create a Variable in the C++ Programming Language

A C++ program starts in the main function. That is where execution begins:

```
int main() {

}
```

In the construct above, the name of the function is `main`. The return type of the function is `int`, an integer. There are no parameters for the function, so there's nothing in between the parentheses. The body of the function is enclosed with curly braces. That is where we are going to write our code next.

We can write characters to standard output (i.e. the console) using the `cout`object. In order for us to use that object, we need to import a library called `iostream`. Let's see the code:


```
#include <iostream>

int main() {
    std::cout << "Hello World";    
}
```

Now, there are more things that we haven't covered.

To include the [external code that is already written for you](https://gcc.gnu.org/onlinedocs/gcc-4.6.2/libstdc++/api/a00911_source.html), we use the `#include`statement. In this situation, the standard library file name is within `< >`.

A sequence of characters in C++ is called a `string`. Strings appear under double quotes. In our example, we have the string `"Hello World"`. Note the quotes will not appear in the program output, only its contents.

The `cout` object is part of the `std` namespace, so we have to prefix it with `std::`.

The `<<` is an overloaded operator that is actually a function call to direct the string text on its right-hand side to the output on the left-hand side. Think of it as the sequence of characters that is to be directed to be displayed in the standard output. Note the direction of the `<<` operator arrow matters.

Before we can display the output of the program, we should add a line break after the hello message. Otherwise if you run the program in a terminal your command prompt will come up after the hello message instead of in a new line. We can use `std::endl`to add a new line break:

```
std::cout << "Hello World" << std::endl;    
```

The function `main`has a return type of `int`, an integer number. Even though our program is pretty simple and omitting the return value might still work, it is best we follow the principles and place the `return` statement at the end of the function:

```
#include <iostream>

int main() {
    std::cout << "Hello World" << std::endl;
    return 0;
}
```

The reason the return value is zero is because we expect the program to finish execution without any errors. Should the program have encountered any sort of error, the tradition is to use an error code that can be used to identify what kind of problem occurred. So if an integer other than 0 was returned in the program, it would have meant there was an error.

Now, bringing it all together, if you compile and run the program, you will get the following output:

```
Hello World
```

[You can try running the program on Repl.it here.](https://repl.it/@nbkhope/Cpp-First-Program)

To learn more about software development, visit NBK Tech World:

https://www.youtube.com/channel/UC3pR7vTMNPNmSk99YIBKUnw

See you there!


Writing your First Program in the C++ Programming Language

Interested in learning a lot more about GraphQL? Get a deep dive with [The Road to GraphQL](https://amzn.to/2TEfyKP). 

You can employ GraphQL in your Express server using a middleware. If you get a request that goes to the endpoint `POST /graphql`, it will pass through the GraphQL Express middleware and handle the response for you.

## Installing Packages

```
npm install express express-graphql graphql
```

The first package is for the Express server. You might already have that.

The second package is the Express GraphQL middleware.

The third package allows us to use GraphQL constructs in Nodejs.

## Setting Up

```
const express = require('express');
const graphqlHTTP = require('express-graphql');

const schema = require('./schema');

const app = express();
const PORT = 3000;

app.use('/graphql', graphqlHTTP({
  schema: schema
}));

app.listen(PORT, () => {
  console.log(`Server running at port ${PORT}`);
});
```

The **express-graphql** middleware requires an Express app. You apply the middleware using app.use(). The first argument is the endpoint where GraphQL will be listening. The code above uses the standard /graphql route. The second argument calls on the middleware with a schema property that can be defined in a separate file:

```
// schema.js
const {
  GraphQLObjectType,
  GraphQLSchema,
  GraphQLString,
} = require('graphql');

const RootQueryType = new GraphQLObjectType({
  name: 'RootQueryType',
  fields: {
    fruit: {
      type: GraphQLString,
      resolve() {
        return 'Banana';
      }
    }
  }
});

module.exports = new GraphQLSchema({
  query: RootQueryType
});
```

The GraphQL schema is defined using an object with the query property. That will be the entry point for the queries requested by the client. Under fields, you can specify different types of resources you can query. In the example, we add a field called "fruit" that corresponds to a resource for a fruit and will always return the string "Banana."

You will likely start off creating a new GraphQLObjectType. Then, you define the name and fields properties. For the name, you can call it after the resource type. Each field has a type and a resolve() method that tells GraphQL how to find that resource and return it to the client. There are different types depending on the data type you are using. For example: GraphQLInt, GraphQLList, GraphQLString, etc.

## Testing Queries with GraphiQL

![GraphiQL Running on Localhost 3000 graphql](https://nbktechworld.us-southeast-1.linodeobjects.com/static/images/9b11742c-fe84-4fe8-97a3-d760a2481cea.png)

It might be helpful, especially if you don't have a frontend to work with, to use the GraphiQL tool to test queries on the browser. To enable it, add the graphiql property when you apply the middleware:

```
app.use('/graphql', graphqlHTTP({
  schema: schema,
  graphiql: true
}));
```

With that, you can now access http://localhost:3000/graphql in your browser and it will open up a GraphiQL interface. You can try queries out there. For example, try the following:

```
query {
  fruit
}
```

You should expect the following response:

```
{
  "data": {
    "fruit": "Banana"
  }
}
```

## Creating a Custom Type

Having only one field is uninteresting and does not show the true power of GraphQL. Let us turn out fruit into an object with the following properties: id, name, description, isTasty, calories. You can isolate that FruitType in a different variable:

```
const {
  GraphQLBoolean,
  GraphQLID,
  GraphQLInt,
  GraphQLObjectType,
  GraphQLSchema,
  GraphQLString,
} = require('graphql');

const FruitType = new GraphQLObjectType({
  name: 'FruitType',
  fields: {
    id: {
      type: GraphQLID
    },
    name: {
      type: GraphQLString
    },
    description: {
      type: GraphQLString
    },
    isTasty: {
      type: GraphQLBoolean
    },
    calories: {
      type: GraphQLInt
    }
  }
});
```

You can create the new type using a new GraphQLObjectType. Then you define a name property. Then you define a list of fields the object will have. For each field, the property is the field name and the value an object with the type property. Notice how we used different kinds of GraphQL built-in types.

## Updating the Root Query

Once you defined your own FruitType, your RootQueryType then becomes like this:

```
const RootQueryType = new GraphQLObjectType({
  name: 'RootQueryType',
  fields: {
    fruit: {
      type: FruitType,
      resolve() {
        return {
          id: '507f1f77bcf86cd799439011',
          name: 'Banana',
          description: 'This fruit is delicious',
          isTasty: true,
          calories: 121
        };
      }
    }
  }
});
```

Notice how the type of fruit is no longer just a GraphQLString. It is now a FruitType, which happens to be a GraphQLObjectType.

The resolver method is also changed to reflect the new data structure for a Fruit. Typically, you would make a database call (e.g. via ORM) or an API call with an HTTP request in the resolve() method; then the data value for the specific resource would be returned. The resolve() method takes care to unwrap promises if you do provide them as the return value, so do not worry about doing that yourself.

One interesting thing to notice is the GraphQLID assumes the id property is a string, so be aware of that. You can check out the [documentation for all the different GraphQL types here](https://graphql.org/graphql-js/type).

## Trying a New Query

Now you can try the following query in GraphiQL in your browser:

```
query {
  fruit {
    id
    name
    description
    isTasty
    calories
  }
}
```

To which you will get the following response:

```
{
  "data": {
    "fruit": {
      "id": "507f1f77bcf86cd799439011",
      "name": "Banana",
      "description": "This fruit is delicious",
      "isTasty": true,
      "calories": 121
    }
  }
}
```

With GraphQL, you do not need to always get back all the fields from a resource. GraphQL allows you to ask only for the data you really need.

For example, the fruit object above does not have many fields, but a real world example would likely contains many, many fields.

Many times the client ends up not using all of the fields, so there is a lot of bandwidth waste. Users with a slow mobile connection would have to wait longer to download the larger set of data, only to end up using only part of it.

Other times, you end up not having enough data, so have to make additional requests to retrieve the missing parts.

GraphQL allows you to ask specifically for all the fields you are going to need to use in the client side. No more, no less. So you could just ask for the fruit id and name if you do not care about its description, nor if it is tasty, nor the calorie count:

```
query {
  fruit {
    id
    name
  }
}
```

## And GraphQL will give you just that:

```
{
  "data": {
    "fruit": {
      "id": "507f1f77bcf86cd799439011",
      "name": "Banana"
    }
  }
}
```

Isn't that wonderful? :)

Read [The Road to GraphQL](https://amzn.to/2TzoDoa) to deep dive into the world of GraphQL! 


Getting Started with GraphQL and Express

Want to learn more about JavaScript? Get the [Eloquent JavaScript](https://amzn.to/2BvDBEJ).

With the advent of ES6, two new keywords for the definition of variables have come forth: const and let. Now, whenever you need to define a variable, don't use var -- start off with const.

```
// The old way
var name = "Angela";

// The new way
const name = "Angela";
```

Once you assign the value of a const variable once, it can not be changed later. In case you are going to modify the variable's value again, you can use let. This is very common with, say, a for loop:

```
for (let i = 0; i < someArray.length; i++) {
  // do something
}
```

In the loop above, the index variable i will have to be changed at every iteration, so we cannot just use const.

Keep in mind things like an array can be added elements even though you use const:

```
const pets = [];

pets.push("cat");
pets.push("dog");

console.log(pets); // => ["cat", "dog"]
```

The above is totally fine using const because the array reference was assigned only once. Adding elements to the array does not change the location of that reference. However, reassigning pets to a totally new array would give you an error using const. In that case, you would need to use let:

```
const pets = [];
pets = ["hamster"]; // error: Assignment to constant variable

let pets = [];
pets = ["hamster"]; // fine because pets was declared with let
```

Another very interesting aspect of using let in a for loop is that the variable declared within the loop header will only be available to the instructions in the loop body. To illustrate that, consider the following example, using var:

```
for (var j = 0; j < 3; j++) {
  console.log(j);

}

console.log('-----'); // separator


console.log(j); // no problem here!
```

The code output will be the numbers 0, 1, 2; then the console.log will print 3. Note that the value of j was available even outside of the loop body that is between the curly braces for the for loop. Now, if you use let, things change:

```
for (let i = 0; i < 3; i++) {
  console.log(i);
}

console.log('-----'); // separator

console.log(i); // error: i is not defined
```

The output will be 0, 1, 2, and then an error will occur. That is because i is not defined outside the loop body. Using the let keyword, your variable will have local block scope, but not outside the area defined by the curly braces!

In conclusion, you should always start off declaring your variables with const. Then, if you later need to modify its value more than once, you can easily change the keyword const to let and everything will be fine! Also watch out for the scope rules regarding the new ES6 keywords, since they have block-level scope and will not be available anywhere outside the block. :)

For further reference, see:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let

Learn more about JavaScript with the [Eloquent JavaScript](https://amzn.to/2BvDBEJ).


JavaScript: Stop Using var with ES6

**Need a reference text for the Ruby programming language? [Get the Well-Grounded Rubyist](https://amzn.to/2BwAtZg).**

RSpec has become a popular choice as a testing framework for Ruby. Let us learn how to make unit tests and use a test-driven development approach to implement a program to calculate the factorial of a number.

# Factorial Review

The factorial of a number is defined as the number repeatedly multiplied by itself MINUS one until we reach the base case of 1:

```
4! = 4 * 3 * 2 * 1 = 24
```

In essence, you can define it recursively as such: the factorial of n is always that number times the factorial of (n - 1).

```
4! = 4 * 3! = 4 * 3 * 2! = 4 * 3 * 2 * 1! = 4 * 3 * 2 * 1 = 24
```

The base cases are:

```
1! = 1
0! = 1
```

# Test-Driven Development

In this approach of development, we FIRST write TESTS; then, we write some code to make the tests PASS. We repeat that approach repeatedly until the development process has been complete. In summary:

1) Write tests
2) Run the tests
3) Make first test pass
4) Run the tests
5) Make second test pass
...
AND SO ON until all the tests have succeeded.

# Getting Started

Create a file to hold the definition for our factorial method and call it factorial.rb:

```
touch factorial.rb
```

Now, create a folder called spec/ to hold all the unit tests:

```
mkdir spec
```

RSpec will look for tests in that directory, so it is important you follow this naming convention.

All the unit tests should be named with a suffix _spec.rb, so let us create the following test file:

```
touch spec/factorial_spec.rb
```

# Writing Our First Test

We will be writing the tests inside the spec file. Let us get started and type the following into factorial_rspec.rb:

```
require_relative '../factorial'

describe "Factorial" do
  it "computes the factorial of 0" do
    expect(factorial(0)).to eq 1
  end
end
```

We need the first line to import the contents of the factorial.rb file one level up in the tree hierarchy. You need not add the .rb extension when you do that.

Next, we use a **describe** construct to define the block of tests for the factorial method. You typically create a describe for each method that you have. In our case, we will only be writing one method (factorial), so one describe block will suffice.

Inside the describe block, you add many unit tests using an "it" statement. These are the actual constructs that perform the tests. You will have many of these for each unit test.

When doing test-driven development, you can start off testing for the most essential elements: in the this case, we have a base case for the factorial, which is `factorial(0)` being equal to 1. You use the expect method to take a look at the return value of the method that was called as its argument. It will expect that to equal the integer 1.

Keep in mind that although RSpec reads a lot like English, there is no magic here: all those constructs are just Ruby methods. In our case, describe is just a method that takes on a string argument and is being passed a Ruby block (that contains the it statements). The same is true for it: it is just a method and takes a string argument and also accepts a Ruby block.

Do a web search on "RSpec Cheatsheet" or just look a [this one](https://www.anchor.com.au/wp-content/uploads/rspec_cheatsheet_attributed.pdf) to see all the cool things you can do with RSpec.

# Running the Tests

You can run the tests from the same directory as factorial.rb using the rspec command:

```
rspec
```

RSpec will look for files in the spec/ folder and will run them. Make sure to run the rspec command one level up from the spec directory in the filesystem tree!

You will get an output similar to the following:

```
$ rspec
F

Failures:

  1) Factorial computes the factorial of 0
     Failure/Error: expect(factorial(0)).to eq 1

     NoMethodError:
       undefined method `factorial' for #<RSpec::ExampleGroups::Factorial:0x007ff503b68398>
     # ./spec/factorial_spec.rb:5:in `block (2 levels) in <top (required)>'

Finished in 0.00064 seconds (files took 0.13099 seconds to load)
1 example, 1 failure

Failed examples:

rspec ./spec/factorial_spec.rb:4 # Factorial computes the factorial of 0
```

So the test failed because we have not defined the factorial method. Let's go ahead and do that inside factorial.rb:

```
def factorial
end
```

If you run the tests again, you will get:

```
$ rspec
F

Failures:

  1) Factorial computes the factorial of 0
     Failure/Error: expect(factorial(0)).to eq 1

     ArgumentError:
       wrong number of arguments (1 for 0)
     # ./factorial.rb:16:in `factorial'
     # ./spec/factorial_spec.rb:5:in `block (2 levels) in <top (required)>'

Finished in 0.00093 seconds (files took 0.18702 seconds to load)
1 example, 1 failure

Failed examples:

rspec ./spec/factorial_spec.rb:4 # Factorial computes the factorial of 0
```

Now, there is an ArgumentError: we passed in one argument, but the method definition does not take any parameters. Let us fix that in factorial.rb:

```
def factorial(n)
end
```

Run the tests again:

```
$ rspec
F

Failures:

  1) Factorial computes the factorial of 0
     Failure/Error: expect(factorial(0)).to eq 1

       expected: 1
            got: nil

       (compared using ==)
     # ./spec/factorial_spec.rb:5:in `block (2 levels) in <top (required)>'

Finished in 0.05403 seconds (files took 0.1312 seconds to load)
1 example, 1 failure

Failed examples:

rspec ./spec/factorial_spec.rb:4 # Factorial computes the factorial of 0
```

Now, we got nil instead of 1 for the factorialof 0 because our method is not defined with anything in particular. Let us fix the problem by simply returning 1 from the method:

```
def factorial(n)
  1
end
```

Run the tests:

```
$ rspec
.

Finished in 0.0014 seconds (files took 0.18038 seconds to load)
1 example, 0 failures
```

Great! We finally got the test to pass. Now, we can write more tests and keep on going in the same fashion: make a test, run the tests, fix the problem, run the test again and see the test pass.

# Formatting RSpec Output

You might want to format the RSpec output to display colors and more detailed information about the tests (for example, which tests actually passed). To do that, create a .rspec file in the same directory as factorial.rb:

```
touch .rspec
```

Add the following contents to the file:

```
--color
--format documentation
```

Now RSpec is going to show us a more detailed output with colors :)

# Writing More Tests

Let us go back to writing tests. Write another test, now for the factorial of 1:

```
describe "Factorial" do
  it "computes the factorial of 0" do
    expect(factorial(0)).to eq 1
  end
  it "computes the factorial of 1" do
    expect(factorial(1)).to eq 1
  end
end
```

If you run the tests, you will see you are still passing them. Now, write another test:

```
it "computes the factorial of 2" do
  expect(factorial(2)).to eq 2
end
```

Run the tests again:

```
$ rspec

Factorial
  computes the factorial of 0
  computes the factorial of 1
  computes the factorial of 2 (FAILED - 1)

Failures:

  1) Factorial computes the factorial of 2
     Failure/Error: expect(factorial(2)).to eq 2

       expected: 2
            got: 1

       (compared using ==)
     # ./spec/factorial_spec.rb:11:in `block (2 levels) in <top (required)>'

Finished in 0.02178 seconds (files took 0.13048 seconds to load)
3 examples, 1 failure

Failed examples:

rspec ./spec/factorial_spec.rb:10 # Factorial computes the factorial of 2
```

Now it is your job to go to the definition of the factorial method and add some code to make the next test pass. You keep on doing that and eventually you will get to write the correct method definition. You could keep tweaking the code on and on, but as soon as you reach, say, a test that checks the factorial of 4, you can just starting writing the factorial method for real.

Here is the code for more tests:

```
require_relative '../factorial'

describe "Factorial" do
  it "computes the factorial of 0" do
    expect(factorial(0)).to eq 1
  end
  it "computes the factorial of 1" do
    expect(factorial(1)).to eq 1
  end
  it "computes the factorial of 2" do
    expect(factorial(2)).to eq 2
  end
  it "computes the factorial of 3" do
    expect(factorial(3)).to eq 6
  end
  it "computes the factorial of 4" do
    expect(factorial(4)).to eq 24
  end
  it "computes the factorial of 5" do
    expect(factorial(5)).to eq 120
  end
  it "computes the factorial of 6" do
    expect(factorial(6)).to eq 720
  end
  it "computes the factorial of 7" do
    expect(factorial(7)).to eq 5040
  end
end
```

RSec Output:



Make sure to start with the first test that is failing and fix that one. Then, proceed to the next one, and so on. Here is the completed factorial method:

```
# Given an integer greater than or equal to zero
def factorial(n)
  return 1 if n <= 1

  product = 1
  index = n

  while index > 1
    product *= index
    index -= 1
  end

  product
end
```

In the example definition above, we return 1 for n less than or equal to 1 to take care of the base cases (0! = 1 and 1! = 1). Assume the given input is greater than or equal to zero. Then, to keep track of the continously multiplication by the number minus one, a product variable is used. The index variable is set to the given number at first and will decrease by one in every iteration. The method finally returns product, which holds the factorial of the given input, at the end.

# All Tests Pass :)

```
$ rspec

Factorial
  computes the factorial of 0
  computes the factorial of 1
  computes the factorial of 2
  computes the factorial of 3
  computes the factorial of 4
  computes the factorial of 5
  computes the factorial of 6
  computes the factorial of 7

Finished in 0.00362 seconds (files took 0.13484 seconds to load)
8 examples, 0 failures
```

# Conclusion

Unit testing has never been easier with RSpec for Ruby. It reads much like English and provides a nice framework to perform test-driven development. With the use of describe blocks and it blocks, you can get started writing your first tests. Make sure to write the tests first before actually implementing your code. Don't forget! :)

**Looking for a reference text for Ruby? [Get the Well-Grounded Rubyist](https://amzn.to/2BwAtZg).**



Intro to RSpec and Test-Driven Development

**Need a reference text for the Ruby programming language? [Get the Well-Grounded Rubyist](https://amzn.to/2BwAtZg).**

An important data structure in Ruby is the hash. Hashes is a data structure of key-value pairs. In other programming languages, it might be called a dictionary or an associative array. If you know JavaScript, Ruby hashes are very similar to Objects. Let us take a look at the most basic aspects of Ruby hashes.

## Creating a Hash

You can create a hash using literal notation, with curly braces:

```
hash = {}
```

The above is very similar to creating empty arrays, except for hashes you have to use curly braces.

## Populating the Hash

To populate the hash, you can use bracket notation. Let us say we want to keep track of a todo list and use the key as the day of the week and the value as what we need to do. Populate the hash for Monday as so:

```
todo = {}
todo[:monday] = "clean the dishes"
```

Verify the contents of the hash:

```
=> {:monday=>"clean the dishes"}
```

A hash is a data structure of key-value pairs, so in the code above, we are associating the key `:monday` with the value "clean the dishes." One thing to notice is that we are using a symbol as the key. You could have used a string as the key, but it is common to use symbols as the key to Ruby hashes. Generally, using symbols will speed things up, as ultimately a string key will eventually (and internally) be converted to a symbol anyway.

Let us add one more todo to the hash:

```
todo[:wednesday] = "karate practice"
```

Now, the contents of the hash are:

```
=> {:monday=>"clean the dishes", :wednesday=>"karate practice"}
```

Hashes are represented using curly braces, with each key-value pair separated by a comma. The mapping between a key and a value is represented using the rocket or arrow symbol `=>`.

In general, you could have the key or value as any kind of object, not just a string or a symbol. For instance, you could use an integer as the key, but this would seem much like an array. You could also use, say, an array as the value to a certain key. That is perfectly fine in Ruby.

## Accessing Nonexistent Key-Value Pairs

Now, what happens if you try to access a key for which the key-value pair does not exist?

```
=> {:monday=>"clean the dishes", :wednesday=>"karate practice"}

todo[:friday]
=> nil
```

The answer is nil. If you try to access a key for which there is not value associated with it, you will get nil. This behavior, however, can be changed if you create a new hash using new and then give it an argument for the default value. For instance:

```
todo = Hash.new
=> {}
todo[:tuesday]
=> nil
```

The above creates a new hash using Hash.new instead of using just {}. That results in the same outcome. When you try to refer to a key that points to no value, you get nil. Now, if you give new a default value:

```
todo = Hash.new("DOES NOT EXIST")
=> {}
todo[:tuesday]
=> "DOES NOT EXIST"

todo
=> {}
```

In the case above, whenever you try to access some key that does not have an associated value, you will get the string "DOES NOT EXIST", because you told Hash.new that that would be the default value in that situation. Mind, however, that the actual hash is still empty even though you got back "DOES NOT EXIST."

## Creating a Hash with Initial Key-Value Pairs

So far we had to create a hash from scratch and add key-value pairs one by one. You could also have defined a hash with initial key-value pairs like so:

```
todo = { :monday => "clean the dishes", :wednesday => "karate practice" }
```

You can access the value to which a key points to using bracket notation and passing the key as the parameter:

```
todo[:monday]
=> "clean the dishes"

todo[:wednesday]
=> "karate practice"
```

## Alternative Notation

There is an alternative notation to write hashes. If you are familiar with JavaScript, this will look just like writing JavaScript objects. Given the following definition:

```
todo = { :monday => "clean the dishes", :wednesday => "karate practice" }
```

Remove the arrow => and move the colon from the left-hand side of the symbol name to its right-hand side:

```
todo = { monday: "clean the dishes", wednesday: "karate practice" }
```

One thing to keep in mind is that you can only use that notation if the key is a symbol. Also, internally, hashes are still represented using the => notation:

```
todo
=> {:monday=>"clean the dishes", :wednesday=>"karate practice"}
```

## Hash Size and Searching the Hash for Existence of Key/Values

You can find out how many key-value pairs there are in the hash using the size method:

```
todo
=> {:monday=>"clean the dishes", :wednesday=>"karate practice"}

todo.size
=> 2
```

Two useful methods to determine the existence of a certain key or certain value are: has_key? and has_value?

Here is an example:

```
todo.has_key? :monday
=> true

todo.has_key? :tuesday
=> false
```

Because we have :monday as one of the keys in the todo hash, we get true. However, the hash does not have the key :tuesday, so we get false for that.

Similarly, you can check whether some value is present in the hash:

```
todo.has_value? "wash the car"
=> false

todo.has_value? "clean the dishes"
=> true
```

There are many other useful methods that you can find in the Ruby documentation. So check it out! 

## Hashes as the Last Argument to Methods

Say we have a method like so:

```
def greeting(name, hash)
  puts "Hello, #{name} !"
end

greeting("James", {})
```

Output:

```
Hello, James !
```

The method will simply say Hello followed by whatever name you give as the first argument. For the second argument, I just passed in an empty hash. Let us work with that hash next:

```
def greeting(name, hash)
  puts "Hello, #{name} !"
  puts "It seems that you have to #{hash[:monday]} on Monday"
end

greeting("James", { :monday => "wash the car" })
```

Output:

```
Hello, James !
It seems that you have to wash the car on Monday
```

So we passed a hash as an argument to greeting. That method then took the value in the hash whose key is :monday and used it to display a message about what the person needs to do.

Now that you understand what the method does, let us get to the point: if the last argument to a method call is a hash, you can omit the curly braces:

```
greeting("James", :monday => "wash the car")
```

You will see that a lot. Furthermore, you can also use the alternative notation:

```
greeting("James", monday: "wash the car")
```

To me, that looks a lot better. But you have to watch out for what it really means! That is just a hash in disguise. Keep in mind that because the hash is the last argument to the method call, you can omit the curly braces. And then you can also use the alternative notation, because the key is a symbol. It does not matter how many key-value pairs the hash has, the following would be totally okay too:

```
greeting("James", monday: "wash the car", tuesday: "do the laundry")
```

## Fetch versus Bracket Notation to Retrieve a Value

Given the example:

```
todo
=> {:monday=>"clean the dishes", :wednesday=>"karate practice"}
```

You already know that to access a hash's value, you have to give the key within the square brackets:

```
todo[:monday]
=> "clean the dishes"
```

You can achieve the same outcome using the fetch method:

```
todo.fetch(:monday)
=> "clean the dishes"
```

But is there any difference at all? Consider the case where the key does not exist (i.e. no such key-value pair exists in the hash)

```
todo[:friday]
=> nil

todo.fetch(:friday)
KeyError: key not found: :friday
 from (irb):63:in `fetch'
 from (irb):63
 from /usr/bin/irb:12:in `<main>'
```

While using bracket notation returns nil for a key that does not map to any value, using the fetch method will actually raise an exception! Let us go back to our example with the greeting method:

```
def greeting(name, hash)
  puts "Hello, #{name} !"
  puts "It seems that you have to #{hash[:friday]} on Monday"
  p hash[:friday]
end

greeting("James", { :monday => "wash the car" })
```

I changed the hash key in the greeting method to :friday (which does not have an associated value) and added a p statement to check the value of hash[:friday]. The output is:

```
Hello, James !
It seems that you have to  on Monday
nil
```

Now, if we use fetch instead:

```
def greeting(name, hash)
  puts "Hello, #{name} !"
  puts "It seems that you have to #{hash.fetch(:friday)} on Monday"
  p hash[:friday]
end

greeting("James", { :monday => "wash the car" })
```

Output:

```
Hello, James !
KeyError: key not found: :friday
 from (irb):80:in `fetch'
 from (irb):80:in `greeting'
 from (irb):84
 from /usr/bin/irb:12:in `<main>'
```

When we used bracket notation, the program kept executing and whenever we tried to access an unexistent key, we just got nil and things were just fine. But when we used fetch, it raised a KeyError exception and halted program execution right away. That is the difference between fetch and [] notation: the former raises an exception while the latter only returns nil. If you use fetch, make sure to rescue the exception and do something about it; otherwise, your program will come to a halt and stop. With bracket notation, the program will still keep going, even though having nil in certain places might have undesired effects in what you are trying to do. So handle the nil as well! :)

## Conclusion

Ruby hashes are an important data structure that allows you to store data in key-value pairs. Make sure to understand them well, play with irb and make your own hashes. Try doing crazy things with it. Give it different kinds of keys and values and see what you get. Try accessing something that does not exist. Have fun! :)

**Looking for a reference text for Ruby? Get the [Well-Grounded Rubyist](https://amzn.to/2BwAtZg).**


Ruby Hashes

### ### Need a reference text for the Ruby programming language? [Get the Well-Grounded Rubyist]().

You can use arrays to group similar data into a single entity, instead of having to create multiple variables just to separate that same kind of data. Ruby makes it really convenient for you to work with arrays: you can use bracket notation to access and set elements and use stack/queue-like methods to manipulate its data (i.e. push, pop, unshift, shift). Furthermore, you can easily go through an array and use that data in some form using iterators like each, map, select, and reject.

Creating an Array

You can either create an empty array or start it off with a few elements. To start off from scratch, you can use the [] empty array:
```
animals = []
```
Then, you would populate the array with elements using the operations we will learn later.

Otherwise, you can just initialize it with some elements:

```
animals = ["dog", "cat", "bear", "horse", "eagle"]
```

Arrays are denoted within brackets and have to be comma-separated. The array above is an array of strings and has 5 elements. Although we used strings above, you could use just about any data type because Ruby allows for arrays to have a mix of different types. For example, the following would be okay too:

```
array = [12, "dog", 3, "cat", 4.65, 0, "eagle"]
```

The above is an array of mixed data types -- it has integers, floats, and strings.

Accessing Elements

Coming back to our animals example, we can access each element using bracket notation:

```
animals = ["dog", "cat", "bear", "horse", "eagle"]

animals[0] is the first element of the array ("dog")
animals[4] is the last element of the array ("eagle")
```

To access elements in an array, you start counting from zero: so the first element will be at position 0 and the last element will be at position given by the size of the array MINUS one. In the case above, we have a 5-element array, so the position of the last element is 5 - 1, which is 4.

You can determine the size of the array in Ruby using the length or size method:

```
animals.size 
animals.length
```

They both return the same thing and will give you the number of elements in the array.

Modifying Array At the End

You can add new elements to the end of the array using the push method:

```
animals = ["dog", "cat", "bear", "horse", "eagle"]

animals.push("pigeon")

=> ["dog", "cat", "bear", "horse", "eagle", "pigeon"]
```

Note how the new element "pigeon" was added to the end of the array. This is like a stack for those of you familiar with basic data structures.

To remove an element from the end of the array, you can use pop:

```
animals = ["dog", "cat", "bear", "horse", "eagle"]

animals.pop
=> "eagle"

=> ["dog", "cat", "bear", "horse"]
```

Ruby gives you the popped element as the return value from the pop method, you can do something with that. The element is removed from the end of the array, though.

Modifying the Array At the Beginning

There are two other methods that allow you to add/remove elements from the beginning of the array instead of at the end: they are unshift and shift.

You can use unshift to add an element to the beginning of an array:

```
animals = ["dog", "cat", "bear", "horse", "eagle"]

animals.unshift("dinosaur")

=> ["dinosaur", "dog", "cat", "bear", "horse", "eagle"]
```

The new element has been added to the front of the array. This is like a queue for those of you familiar with basic data structures.

If you want to remove an element from the beginning of the array, use shift:

```
animals = ["dog", "cat", "bear", "horse", "eagle"]

animals.shift
=> "dog"

animals
=> ["cat", "bear", "horse", "eagle"]
```

When you do a shift operation, the element at the beginning of the array is removed and then returned to you so you can do something with it.

Modifying Specific Elements

You can use bracket notation to modify specific elements of an array at a certain index. For example, given the array of animals, you could replace the second element, "cat", with something else:

```
animals = ["dog", "cat", "bear", "horse", "eagle"]
animals[1] = "turtle"
animals
=> ["dog", "turtle", "bear", "horse", "eagle"]
```

Notice how the second element (whose index is 1) was replaced by "turtle."

Iterating Over Array

You can go through each element in the array using the each iterator. It is part of the Enumerable module. You can find many useful things there, so check it out. Anyway, here is an example:

```
animals = ["dog", "turtle", "bear", "horse", "eagle"]

animals.each { |animal| puts animal }
```

The above will go through each element in the array of animals and display its value (each on its own line). The each iterator accepts a block (denoted within braces) whose block parameter variable will take in each array element, one at a time, starting from the first one up to the last one, and then do something with it. In this case, I am using the puts statement to display each element's value.

Output:

```
dog
turtle
bear
horse
eagle
```

Other useful iterators are map, select, and reject. I invite you to look them up in the Ruby documentation. Now, let us see how to iterate over an array using a plain while loop:

```
animals = ["dog", "turtle", "bear", "horse", "eagle"]

index = 0

while index < animals.length
  puts animals[index]
  index += 1
end
```

The above uses the index variable to keep track of the location in the array. It starts off at 0 because the first element of the array is at position 0. Then, the loop condition is that the index is less than the number of elements in the array. Remember the last element is always the array size MINUS one. Inside the loop, you just display the value of the element at position index in the animals array. At the end of the loop, just before the end keyword, make sure to have the increment for index, so we do not end up with an infinite loop. The output of the above construct will be:

```
dog
turtle
bear
horse
eagle
```

Conclusion

Ruby makes it really nice and intuitive to work with arrays. You can think of them as stacks or queues, too. You can easily create, access, and modify its elements using Ruby's built-in methods. Furthermore, the Enumerable module has some interesting methods and iterators that allow you to extract certain pieces of information from Arrays. Don't forget to check that out as well! :) Thank you for reading and have fun! 

Looking for a reference text for Ruby? Get the [Well-Grounded Rubyist](https://amzn.to/2BwAtZg).


Ruby Arrays

Need a reference text for the Ruby programming language? Get the [Well-Grounded Rubyist](https://amzn.to/2BwAtZg).

This article will briefly go over Strings in Ruby.

First, let us talk about a few String methods. You can see all the methods available to a string if you call the "methods" method:

```
"Some String".methods
=> [:<=>, :==, :===, :eql?, :hash, :casecmp, :+, :*, :%, :[], :[]=, 
:insert, :length, :size, :bytesize, :empty?, :=~, :match, :succ, 
:succ!, :next, :next!, :upto, :index, :rindex, :replace, :clear, 
:chr, :getbyte, :setbyte, :byteslice, :scrub, :scrub!, :freeze, 
:to_i, :to_f, :to_s, :to_str, :inspect, :dump, :upcase, :downcase, 
:capitalize, :swapcase, :upcase!, :downcase!, :capitalize!, :swapcase!, 
:hex, :oct, :split, :lines, :bytes, :chars, :codepoints, :reverse, 
:reverse!, :concat, :<<, :prepend, :crypt, :intern, :to_sym, :ord, 
:include?, :start_with?, :end_with?, :scan, :ljust, :rjust, :center, 
(output omitted)
:public_send, :respond_to?, :extend, :display, :method, :public_method, 
:singleton_method, :define_singleton_method, :object_id, :to_enum, 
:enum_for, :equal?, :!, :!=, :instance_eval, :instance_exec, :__send__, 
:__id__]
```

There are many methods you could use, but here we will just talk about a few.

To start off, if you want to change the case of a string, you can either make it upper case or lower case with the following methods:

```
"Hello".upcase
"World".downcase
```

Output:

```
=> "HELLO"
=> "world"
```

There is a method that capitalizes the first character in the string and makes everything else lowercase:

```
"How ARe You dOIng toDAY?".capitalize

=> "How are you doing today?"
```

You can get rid of trailing spaces (either from the left or from the right) using the lstrip/rstrip method:

```
"   , And then ".lstrip

=> ", And then "

"   , And then ".rstrip

=> "   , And then"
```

Now, if you had those strings in a variable and you called all those methods, the original string would not change. That is, you would get a copy of the original string that was transformed according to the method you called. If you really want to change the original string, you would have to use the exclamation point, like this:

```
my_word = "Hello"
# Uppercases my_word permanently
my_word.upcase!
puts my_word
```

Output:

```
=> "HELLO"
```

Compare the use of no exclamation with one actually present:

```
sentence = "I climbed a tree."
another_sentence = sentence.upcase

puts "Original sentence: #{sentence}"
puts "Another sentence: #{another_sentence}"

sentence.upcase!
puts "Now sentence is: #{sentence}"
```

Output:

```
Original sentence: I climbed a tree.
Another sentence: I CLIMBED A TREE.
Now sentence is: I CLIMBED A TREE.
```

So in the code above we define a string variable and then create another string variable that takes the uppercase version of that original variable. Upon printing both of those variables, you see that the original is still unchanged while the second one has all its letters uppercase.

The code above uses **string interpolation** to display the value of a string variable. If you don't know about this, it is simple: within a double-quoted string, use #{} and place the variable name inside to actually display its value when you use puts. That is, puts "Something bla bla **#{some_variable}** will be displayed"

Now, moving on. The second part of the code calls the upcase method with a bang, !. Now, the actual variable will be modified. Whatever is stored in sentence will be turned into uppercase permanently. When you call puts to display the value of sentence, you see it is indeed a string with all characters uppercase.

Let us now talk about other more advanced methods. Before that, know that you can access any character in the string using standard array access notation:

```
my_string = "Somewhere over the rainbow"
# Displays the fourth character in the string (counts from 0)
puts my_string[3]
```

Output:

```
=> e
```
A useful method to search for a substring is the `include?` method.

```
"Welcome to my world".include? "world"
=> true

"Welcome to my world".include? "to"
=> true

"Welcome to my world".include? "earth"
=> false
```

So the method returns either true, if the sequence of characters was found in the string, or false, if the sequence of characters was not found.

The include? method can also take just a single character, if you use either "x", 'x', or ?x, where x is any character.

```
"Hello".include? 'e'
=> true

# Does it include the character e? (same as above)
"Hello".include? ?e
=> true
```

Now, another useful method is the sub method. You can substitute characters in a string with something else.

```
"I went to the gym today.".sub 'gym', 'theater'
```

Output (irb):

```
irb(main):023:0> "I went to the gym today.".sub 'gym', 'theater'
=> "I went to the theater today."
```

So the method sub substitutes a given string with a new string. Note that it does not change the original string, but makes a copy. If you want to actually change the original string (when working with variables), use the exclamation point:

```
sentence = "I ate pasta yesterday."
another_sentence = sentence.sub 'pasta', 'cake'

puts sentence
puts another_sentence

# Modify "sentence" variable permanently
sentence.sub! 'pasta', 'cake'
puts sentence
```

Output:
```
I ate pasta yesterday.
I ate cake yesterday.
I ate cake yesterday.
```
Note that the sub method substitutes only once. That is, the first match it finds will be the only one changed:

```
irb(main):002:0> sentence = "I love to eat a lot of pasta pasta much pasta"
=> "I love to eat a lot of pasta pasta much pasta"
irb(main):003:0> sentence
=> "I love to eat a lot of pasta pasta much pasta"
irb(main):004:0> sentence.sub 'pasta', 'pizza'
=> "I love to eat a lot of pizza pasta much pasta"
irb(main):005:0> sentence
=> "I love to eat a lot of pasta pasta much pasta"
```

That is all for this article. We talked about how you can modify strings using upcase, downcase, capitalize, as well as how to modify the original array using the exclamation (!) point. Then we looked at how to find matches in a string using include? and how to substitute matches with the sub method. There are many methods out there, so you could use the method "methods" to find out which methods are available to each class object.

Looking for a reference text for Ruby? Get the [Well-Grounded Rubyist](https://amzn.to/2BwAtZg).


Ruby Basic String Methods

Need a reference text for the Ruby programming language? Get the [Well-Grounded Rubyist](https://amzn.to/2BwAtZg).

Reading data from a file as well as writing data to a file has been made easy with Ruby. This article will cover how to read from a file and how to write to a file using Ruby's File class.

Let us jump right into it: to read each line from a file, use a block for the foreach() method of the File class.

```
File.foreach('somefile.txt') do |line|
  puts line
end
```

Each line will contain a \n newline character, so if you would like to chop it off, use 

```
line.chomp
```

Assuming somefile.txt contains the following contents:

```
This is a sample file
With some contents within
This is the last line :)
```

The output of the Ruby script would be:

```
$ ruby basic_file_io.rb 
This is a sample file
With some contents within
This is the last line :)
```

So you iterate through each line of the file and do something with that line. Specify the filename as the method parameter and then do a block with a parameter that will be used to hold each line, |line|.

There is one problem with the above construct: what if the file did not exist? Then surely you will get a problem:

```
basic_file_io.rb:1:in `foreach': No such file or directory - doesnt_exist.txt (Errno::ENOENT)
```

I tried to open a file called "doest_exist.txt" to read, but it did not exist, so I got an error.

To get around that error, you can either: handle the exception, or first check if the file exists before trying to do anything with it.

The following code illustrates how to handle exceptions:

```
begin
  File.foreach('doesnt_exist.txt') do |line|
    puts line
  end

rescue Exception => e
  puts "Oh no, something went terribly wrong!"
  puts e.message
  puts "Maybe we can do something about that problem here . . ."
end
```

Output:

```
$ ruby basic_file_io.rb 
Oh no, something went terribly wrong!
No such file or directory - doesnt_exist.txt
Maybe we can do something about that problem here . . .
```

As you can see, you could have done something about the problem using the exception construct. You start off by saying "begin" then put everything you are attempting to do right afterward. Then, you make a "rescue" section with an object to hold the data for the exception; I used the name "e" above. Within the rescue section, you can determine how the program should behave in case some problem happens. Using e.message, you can also see the description of the problem. Finally, don't forget to finish everything with an "end."

Another way to handle problems when trying to read a file is using the "exist?" method. If you don't want to use exceptions, then you can try this out:

```
if File.exist? 'sample.txt'
  File.foreach('sample.txt') do |line|
    puts line.chomp
  end
else
  puts "I am sorry, but the file does not exist."
end
```

Assuming sample.txt does not exist, the output is:

```
I am sorry, but the file does not exist.
```

Now, let us see how to write to a file. In a similar fashion, we use the File class and call the open() method with a block that will do something to the file:

```
File.open('newfile.txt', 'w') do |file|
  file.puts "Hello everyone!"
  file.puts "This will be a brand new file!"
  file.puts "Just one more last line"
end
```

The above will open the file "newfile.txt" for "write." That is, a new file will be created and IF there is already a file named "newfile.txt," it will be completely wiped out and OVERWRITTEN. So be careful with the "w" mode. :) Moving on, you just use the |file| parameter to add things to the file. Just call file.puts with whatever string you want to add to the file contents. Because "puts" adds a newline character, each of those sentences written in the code above will be in their own line. When you take a look at the file, you get this:

```
$ cat newfile.txt
Hello everyone!
This will be a brand new file!
Just one more last line
```

Pretty cool, isn't it? Now, there are other modes that let you append to files, etc. I will leave it to you to Google it and find out about them if you don't already know. Here is a big hint: http://stackoverflow.com/questions/3682359/what-are-the-ruby-file-open-modes-and-options

And to conclude everything, just an important note: files are automatically *closed* at the end of each block, so there is no need to call a method to close the file, like in other programming languages such as C++ and PHP. 

In summary, Ruby lets you handle file I/O with the File class. You can iterate over a file to read each line using the File.foreach() method. There might be cases in which the file will not exist, so you can handle issues with an exception (begin-rescue-end construct). There is also the option to use the File.exist? method to check whether a file exists. Writing to files can be done using the File.open() method in combination with a block with instructions to add something to the file. You can use the puts method on the block parameter to add some content to the file.

Looking for a reference text for Ruby? Get the [Well-Grounded Rubyist](https://amzn.to/2BwAtZg).


Basic File I/O in Ruby

Interested in learning the C++ programming language? Try doing it with [One Hour a Day](https://amzn.to/2DJKsw1).

The switch statement is similar to the if statement in a way that it determines what the program should do depending on certain conditions. It can also be used to control the flow of program. But the way it is built follows a different approach and, unlike the if statement, the switch statement allows for multiple cases or tests to yield the same outcome.

```
switch (myVariable)
{
    case myFirstCaseValue:
        // do these statements
        break;

    case mySecondCaseValue:
        // do these statements
        break;

    // and so on ...

    case myLastCaseValue:
        // do these statements
        break;

    default:
        // do these statements if no cases were matched (i.e. default behavior)
}
```

The way the switch traditionally works is like this: you give it an integer expression within the parenthesis (usually a variable). Then the program starts checking for each case that matches that particular case value with the value that was given to the switch statement. If the value of the case matches (that is, is equal to) the same value as the given integer expression in the parenthesis, then it will execute those statements under the case and will ONLY stop when it finds a break statement. The presence of the break is crucial for your switch statement to stop and yield proper behavior, so do not forget to include a break after listing all the statements that should be executed for each case.

Some programming languages other than C++ allow for the expression under switch (expression) to be something other than an integer value. PHP, for instance, allows the use of strings as the argument for the switch statement. With that, your cases can be string values instead of just integer values.

```
int myIntegerVariable;

myIntegerVariable = 3;

switch (myIntegerVariable)
{
case 1:
  cout << "Action #1" << endl;
  break;

case 2:
  cout << "Action #2" << endl;
  break;

case 3:
  cout << "Action #3" << endl;
  break;

default:
  cout << "Default Action" << endl;

}
```

Output:

```
Action #3
```

First we declare an integer value. Then we assign the value 3 to the integer variable. Next, the switch takes the integer value as its expression and then starts going through the cases. First, it checks the first case: does myIntegerVariable hold the value 1? No, because myIntegerVariable holds the integer 3. It then skips to the next case: does myIntegerVariable hold the value 2? No. Then, the next case: does myIntegerVariable hold the value 3? Yes. Because the values matched, the statements under "case 3:" are executed: it simply displays a message, "Action #3." The program will continue executing statements as long as there is no break statement, so we have to make sure there is a break so the switch statement is terminated and the program goes on to do other stuff.

Had we made the integer variable in the above example hold a case that is not 1, 2, nor 3, then it would default to the default case, which appears at the end, right before the closing brace. In a way, that is like the "else" of an if statement, when all the conditions have failed to be true.

Keep in the mind that the expression given to the switch statement, in C++, has to be an integer, and that the values for the "case X" have to be constant values (no variables allowed!). However, programming languages like PHP allow for the use of strings for the switch expression and cases.

As an example, the following would not work in C++:

```
string myGreeting;

myGreeting = "Hello";

switch (myGreeting)
{
case "Morning":
  cout << "Good morning to you, too!" << endl;
  break;

case "Hello":
  cout << "Hello, dolly!" << endl;
  break;

case "Night:":
  cout << "See you" << endl;
  break;

default:
  cout << "Good night!!" << endl;

}
```

Output (the compiler produces an error as output):

```
switch_statement.cpp: In function ‘int main()’:
switch_statement.cpp:87:21: error: switch quantity not an integer
   switch (myGreeting)
```

But the above construct would surely work in PHP because it allows strings to be used as the switch expression and case, unlike C++, which only allows integers to be used:

```
<?php

$myGreeting = "Hello";

switch ($myGreeting) {

  case "Morning":
    echo "Good morning to you, too!";
    break;

  case "Hello":
    echo "Hello, dolly!";
    break;

  case "Night":
    echo "Good night!!";
    break;

  default:
    echo "What's up?";

}

?>
```

Output:

```
Hello, dolly!
```

Switch expressions are typically given an enumeration ("enum") because it makes it easier to understand each case. An enum is like a label given to an integer. It looks like text, but is just a mask behind an actual integer number. For instance, you could make a list of enums that would give represent the integer values 0, 1, 2, 3 like this, using C++:

```
enum
{
    MY_FIRST_ENUM,
    MY_SECOND_ENUM,
    MY_THIRD_ENUM,
    MY_FOURTH_ENUM
};
```

With the above, you could use any of the enum items in place of a variable name or value. That would just mask the value behind the scenes. Had we used MY_THIRD_ENUM, we would be actually referring to the value 2 (you start counting from 0 if you use the above enumeration).

Imagine we have a game in which we are checking input from the user. Assume the user presses a key in the keyboard to move the character in the game. It would be either the up, down, left, or right arrows -- there are four cases. So we could make a switch statement to take care of that. But suppose we do not want to explicitly use integers for each case part. Instead, we could use an enum to mask those numbers and make us better understand the code we are writing:

```
// An enumeration for the keyboard keys
// Each gets associated with an integer value, starting from 0 going to 1, 2, 3, etc.
enum
{
    KEY_UP,
    KEY_DOWN,
    KEY_LEFT,
    KEY_RIGHT
}

// Assume we got the integer value associated with
// the key press inside userKeyPress
switch (userKeyPress)
{
    case KEY_UP:
        // move up
        break;

    case KEY_DOWN;
        // move down
        break;

    case KEY_LEFT:
        // move left
        break;

    case KEY_RIGHT:
        // move right
        break;
}
```

The above code would translate to exactly the code below. Which one is better to understand? I think the above code is much more intuitive.

```
// Assume we got the integer value associated with
// the key press inside userKeyPress:
// 0 means up key was pressed
// 1 means up key was pressed
// 2 means up key was pressed
// 3 means up key was pressed

switch (userKeyPress)
{
    case 0:
        // move up
        break;

    case 1;
        // move down
        break;

    case 2:
        // move left
        break;

    case 3:
        // move right
        break;
}
```

To conclude this article, let us touch upon making multiple cases yield the same outcome. Remember that we had the break statement for every case ending? What if we take that out and stack cases on top of each other, all leading to the same statements? That will do exactly what you would expect: If any of those cases matched, then it would execute those very statements!

Take a look at the code below. Imagine you took some test or a class and you got your grade inside a variable called myGrade. The example below uses a character to check each case. But wait, how come a character can be used if C++ only accepts integer as the expression/case for a switch? Well, that is because a character is actually an integer value. A character is just a mask for an integer value. For instance, the character 'A' can be a representation for the value 65. So the example below will work.

```
char myGrade = 'C';

switch (myGrade)
{
    case 'A':
        cout << "Excellent!" << endl;
        break;

    case 'B':
        cout << "Great!" << endl;
        break;

    case 'C':
    case 'D':
        cout << "Okay..." << endl;
        break;

    case 'F':
        cout << "You totally failed!" << endl;
        break;

    default:
        cout << "Invalid grade." << endl;
}
```

Output:

```
Okay...
```

The example checks for your grade and goes through each case. Observe we stacked case 'C' and 'D' on top of each other. That is because we want to display the same message if you got either grade C or D. So two cases are yielding the same outcome -- the same message. You can stack as many cases as you want. The secret to this is that once a case is matched, the program keeps executing statements as long as there is no break. Had the case been 'C' in the above example, then it would match there and everything below "case 'C':" would get executed up to the point where a break command was found, signaling the switch operation to terminate. That is, it will walk over to case 'D' and execute the cout with the message "Okay..." even though that case did not match.

Learning the C++ programming language? How about doing it with [One Hour a Day](https://amzn.to/2DJKsw1).


The Switch Statement (Case)

Interested in learning the C++ programming language? Try doing it with [One Hour a Day](https://amzn.to/2DJKsw1).

Using arrays lets you assemble multiple data into a single entity. Using a primitive data type variable like an int or a double only allows you to store a single value. But when you make that variable an array, then you can store more than one value in one single variable entity.

This article will only consider static arrays -- that is, their size is already pre-determined and cannot be changed once the array has been declared. If you are looking for arrays that can change their size after declaration, those are called dynamic arrays.

In C++, arrays are declared with the following syntax:

```
data_type arrayName[arraySize];

data_type arrayName[arraySize] = { firstVal, secVal, ..., lastVal };
```

First, you have to say the type of you data you will be using. That could be any primitive data type such as char, int, float, double or more complex data types such as objects.

After that, give the array a name and tell its size (or length) within the brackets. The size has to be a constant, something that has already been pre-determined. Additionally, you may also want to initialize the array with given values. You do that enclosing each value in a comma-separated-list, within braces (you have to match the number of items with the array size). If you initialize the array right away, you can omit the arraySize and make the compiler guess the size from the number of items in the list. Note that the values have to be all of the same data type because you are declaring an array of a specific type.

As a concrete example:

```
// Declares an array of integers with 8 elements
int myIntegerArray[8];

// Declares and initializes an array of doubles with 6 elements
double myDoubleArray[6] = { 2.43, 1.24, 1.7, 1.234, 1.9, 3.0 };

// Declares and initializes an array of characters with 3 elements
// (array size guessed from number of items in the comma-separated list)
char myCharArray[] = { 'a', 'b', 'c' };
```

Note the above array of integers was not initialized, so there is not any meaning value assigned to each element yet.

To go through the items of each array, you usually do a for loop:

```
for (int i = 0; i < arraySize; i++)
{
    // goes through each array element
}
```

The loop starts at the first element -- which is always element "0" because array elements are counted from 0 and not one. The last array element is always the array size minus one, so we use just the greater-than operator; the loop stops after "i" becomes the same value as the array size.

As a concrete example:

```
// Goes through the array of integers (that has size 8) and
// sets each element to current value of i multiplied by 2
for (int i = 0; i < 8; i++)
{
    myIntegerArray[i] = i * 2;

    // Displays the current element value that was just assigned above
    cout << myIntegerArray[i] << endl;
}
```

Output:

```
0
2
4
6
8
10
12
14
```

One thing to keep a watch on is that in C++, you might find yourself accidentaly trying to find an element that is out of bounds in an array. Say your array has 8 elements. The last element has index [7] because you start counting elements from [0]. So the last element would be referred to myArray[7] in this case. But what if you tried to access myArray[8]? Well, this element does not really exist -- you are going out of bounds! It is like you have gone into someone else's property. Your C++ compiler might not complain about that. It will just assume that you are a good person and have not tresspassed into anyone else's property. Watch for this, especially when you do a "for" loop. Always make sure the loop condition uses the right comparison operator (typically you would use <, but you could also use <=) to prevent you from accessing elements beyond the array size.

Let us now look at another example using the last two previously declared arrays:

```
// Store the array size in an integer variable
int myDoubleArraySize = 6;

for (int i = 0; i < myDoubleArraySize; i++)
{
    cout << "myDoubleArray[" << i << "] has value " << myDoubleArray[i] << endl;
}
```

Output:

```
myDoubleArray[0] has value 2.43
myDoubleArray[1] has value 1.24
myDoubleArray[2] has value 1.7
myDoubleArray[3] has value 1.234
myDoubleArray[4] has value 1.9
myDoubleArray[5] has value 3
```

The above just goes through each element in the array of doubles and displays the corresponding value.

```
// Store the array size in an integer variable
int myCharArraySize = 3;

for (int i = 0; i <= (myCharArraySize - 1); i++)
{
    cout << myCharArray[i] << endl;
}
```

Output:

```
a
b
c
```

The above goes through each of the three elements in the array of chars. Note how my loop condition is different from the previously used less-than only operator. Here, instead of using i < arraySize, I am using i <= arraySize MINUS 1. That is exactly the same thing as checking for "i" less than the array size. I placed parenthesis between the expression just for emphasis. The loop ends when we reach arraySize minus 1, which is exactly the last element in the array.

Arrays are great when you have large amounts of data and you want to keep them organized and encapsulated into a single variable entity. When you work with arrays, always start counting from 0; the last array element is located at the size of array minus one. Arrays work well with loops because you can handle data conveniently by just using a single statement to take care of each and all of the array elements. Typically, you would use a for loop to go through the elements of an array, either for assignment or just to display their value.

Learning the C++ programming language? How about doing it with [One Hour a Day](https://amzn.to/2DJKsw1).


C++ Arrays

Interested in learning the C++ programming language? Try doing it with [One Hour a Day.](https://amzn.to/2DJKsw1)

When you need to perform repeated actions, over and over again, making a programming loop is often the preferred approach. The while and for loops are the most common types of loops. This article will consider the traditional "for" loop, the one derived from the C programming language. Other kinds of for loops are also available, depending on the programming language, and allow you to more conveniently loop over data types such as arrays and objects.

The syntax for the for loop is as follows:

```
for (initializer; condition; increment/decrement)
{
    // do these statements as long as condition holds true
}
```

The construct above is often the same for many programming languages. Some programming languages allow you to omit the parenthesis, others need you to place a colon (:) at the end of the first line, and so on. This article will consider the for loop using the C/C++ syntax.

The way the for loop works is it first initializes a certain variable (or variables). Then, it checks the condition to see if it is true. If the condition is true, the statements within the braces are executed. After that, the loop goes on to increment or decrement the loop control variable (which is often the one you had just initialized in the initializer list). Then, it checks for the condition to see if it still holds true. If so, then it goes on to run the statements again. Then it increments or decrements the loop control variable. Then it checks the condition again. This pattern repeats until the condition becomes false, whereupon the loop terminates and the program continues to do whatever it needs to do next.

Let us take a look a concrete example:

```
for (int i = 1; i <= 10; i++)
{
    cout << i << endl;
}
```

The above outputs the following:

```
1
2
3
4
5
6
7
8
9
10
```

Going the for loop above, first an integer variable named "i" is declared and then initialized with value 1. Then, the condition part is checked. Is 1 <= 10? Yes, it is true, so it executes the statements within the braces. In this case, it only outputs the value of the variable "i." After executing the cout statement, the variable "i" gets incremented: i++, going from value 1 to value 2. After that increment operation, the loop condition is once again checked. If the condition holds true, which it is (2 <= 10), then it goes on to execute the loop statements again. Then i gets incremented, and becomes 3. The condition is again checked (3 <= 10), holds true because the comparison yields a true value. The statements are once again executed, the loop control variable "i" is incremented, the condition is checked. This pattern repeats over and over until the loop condition becomes false, whereupon the loop terminates. In this case, that will be when i becomes 11. So in the end, the loop produces an output that counts from 1 to 10.

For loops are often used to go through the elements of an array:

```
// An array of integers with 8 elements
int myArray[8] = { 2, 3, 6, 3, 21, 14, 17, 1 };

// To hold the size of the array (i.e. number of elements)
int arraySize = 8;

for (int i = 0; i < arraySize; i++)
{
    cout << myArray[i] << endl;
}
```

The above outputs all the elements of the array, each in a new line. Note that for arrays, you start counting from 0 and the last element is always the size (or length) of the array minus one. Thus the for loop construct usually follows the format above.

Output:

```
2
3
6
3
21
14
17
1
```

In general, the for loop is used when you know specifically how many times to iterate. In the above example, the length of the array was known and it was expected the loop would repeat 8 times. When you do not really know how many times you are going to iterate or you would like some more flexibility and freedom in your loop, you would use a while loop.

Interested in learning the C++ programming language? Try doing it with [One Hour a Day](https://amzn.to/2DJKsw1).


The For Loop

**Interested in learning the C++ programming language? Try doing it with [One Hour a Day](https://amzn.to/2DJKsw1).**

Doing repetitive tasks can be accomplished with a programming loop. This article will cover the while and do-while loops. They appear in many different programming languages and often follow the same construct.

Let us first consider the while loop. When you need to keep on repeating the sames tasks, you can put those tasks within a while loop and it will execute as long as some condition is true:

```
while (condition)
{
    // do these statements as long as the condition is true
}
```

In the while loop, first the condition is checked. The condition is anything that yields a Boolean value (either true or false). If the condition in the while loop is true, then the statements within the braces are executed. Otherwise, the loop terminates.

To determine when the loop terminates, a loop-control variable is often used. For example, it could be a variable that keeps a count. As long as the count matches a certain criteria, then the loop would keep on running. As soon as that condition no longer holds, then the while loop terminates.

Consider the following while construct in C++:

```
// Declares an integer variable and assigns it the value 1
int n = 1;

while (n <= 10)
{
    cout << "The value of n is " << n << endl;

    // This line is important as it makes sure the loop is not infinite
    n++;
}
```

The above code will produce the following output:

```
The value of n is 1
The value of n is 2
The value of n is 3
The value of n is 4
The value of n is 5
The value of n is 6
The value of n is 7
The value of n is 8
The value of n is 9
The value of n is 10
```

Going through the code, a variable n is declared and assigned the value 1. Then comes the while loop: first the condition is checked -- is 1 less than or equal to 10? Yes, it is. Since the condition is true, the statements within the braces are executed: the current value of n is displayed and then the value of n gets incremented. The increment part is very important. If we did not have that line, then the loop would going on infinitely. Infinite loops are to be avoided at all costs because they never end! The program above makes sure the loop ends by adjusting the variable n accordingly in every loop iteration. The condition -- that n is less than 10 -- will eventually become false and thus the loop will terminate.

Let us a now consider the do-while loop:

```
do
{
    // do these statements (at least once)
} while (condition);
```

The do-while loop works just like the while loop, but the statements within the braces get executed at least once. That is, when the program reaches the do-while, it starts executing the block statements right away without check the condition! Then, after executing the statements within the braces for the first time, it checks for the condition within the while parenthesis. If that condition is true, the loop statements get executed again. This pattern will keep on repeating as long as the condition is true. When the condition finally becomes false, then the loop terminates and the program goes on to do other stuff.

Consider this program in C++:

```
int m = 2;

do
{
    cout << "The value of m is " << m << endl;
    m++;

} while (m < 2);
```

First, a variable is declared and defined with the integer value 2.

The program hits the do-while construct and starts executing the statements right away: it displays the value of m, which is 2. Then, it increments m (i.e. increases its value by 1). The variable m now holds the value 3. The condition in the while parenthesis is then checked (for the first time) and evaluates to false because 3 < 2 is not true. The loop then terminates right away.

Output:

```
The value of m is 2
```

So the do-while loop executes the statements at least once, even if the condition within the while parenthesis is false right from the beginning.

In general, while loops are often used when you do not exactly know how many repetitions you have to make in order to accomplish a task. Loops that you know exactly how many times to iterate are often implemented using a for loop.

Learning the C++ programming language? How about doing it with [One Hour a Day](https://amzn.to/2DJKsw1).


The While and Do-While Loops

Starting out with programming? Be sure to check out [The Self-Taught Programmer](https://amzn.to/2TMTYUG).

The if statement is used to control the flow of a program. It allows you to determine where to go when you hit an "intersection" in a program. The construct below works on multiple programming languages and follows almost the same syntax (especially in C-based languages).

```
if (condition)
{
    // do these statements
}
```

The way the if statement works is like this: first, it checks the conditions within parenthesis. That has to be something that yields a Boolean value (either true or false). If the condition within the parenthesis is true, then the statements within the braces are executed. Otherwise, nothing is done.

Now, if you want something to happen in case the if condition fails, then that is when the "else" clause comes in handy:

```
if (condition)
{
    // do these statements
}
else
{
    // otherwise, do these statements
}
```

In this case, if the condition is false, then the statements in the else-block get executed. In essence, when all if conditions fail, the else statements get executed.

If you wanted to check for more than one specific condition, you can use an else-if construct:

```
if (condition)
{
    // do these statements
}
else if (another condition)
{
    // do these other statements
}
else
{
    // otherwise, do these statements
}
```

Adding an else-if statement will allow for another condition check. That is, if the condition in the very first if statement is false, then the condition of the next else-if statement will be checked. If that condition is true, then the statements in the else-if block get executed. Otherwise, it will proceed to check the next condition (if there is any other else-if). When all the conditions fail, the else statements get executed.

Thus, with the if-elseif-else construct, you can determine multiple paths for your program to take. You can have as many conditions to check as you want. Just add more else-if statements like this:

```
if (condition)
{
    // do these statements
}
else if (another condition)
{
    // do these other statements
}
else if (yet another condition)
{
    // do these other statements
}
else if (and yet another condition)
{
    // do these other statements
}
else
{
    // otherwise, if all the above conditions fail, do these statements
}
```

Keep in mind that only one path may be chosen. If the very first if-condition is true, then those statements within the braces get executed AND nothing else. All the other else-ifs and the else get skipped. If the very first if-condition is false, then the condition for the next else-if statement is checked. If the else-if-condition is true, then the statements within that else-if block get executed AND nothing else. If that condition is false, then it will keep on checking for other else-if conditions. If all the else-if conditions fail (that is, yield false), then the statements within the else-block get executed. That is it. You will only reach the else part when all of the previous conditions have failed and there is no other way to go. In a way, the "else" tells your program where to go or what to do in the last resort.

Here is an example of an complete if statement construct, in C++:

```
// Checks whether a number is between 1 and 100
// If the number is less than 1, it says "too small"
// If the number is greater than 100, it says "too big"

if (number < 1)
{
    cout << "Your number is too small." << endl;
}
else if (number > 100)
{
    cout << "Your number is too big." << endl;
}
else
{
    // Number is between 1 and 100
    cout << "You are in the right range!" << endl;
}
```

First it checks if the number is less than 1. If that is the case, then it is certainly out of range. Otherwise, the number is greater than or equal to 1. For the second condition, it checks whether the number is greater than 100. If that is true, then the number is out of range. Once the two conditions have been checked and they both fail, then there is no other choice, but to conclude that the number has to be between 1 and 100. In that case, there is not even a need to check for any condition; just using an else clause will do.

In conclusion, the if statement is used to control the flow of a program. It lets your program makes choices on what path to take based on the given conditions. Multiple choices are not allowed in an if statement. Only one path may be chosen.

Want a more in-depth look into computer programming? Check out [The Self-Taught Programmer](https://amzn.to/2TMTYUG).


Articles