C# 7.0 – Pattern Matching in Switch

C# 7.0 adds lots of new features to bring code simplification and performance. Pattern matching is one of the interesting features of C# 7.0.  Pattern Matching simplifies code that is conditional on the shape of data.

Pattern matching means we can switch based on the type of data to execute one or more statements.

For example, In previous times if we want to match more than one case in switch we used to do like the following

case 11:
case 12:
case 13:
    Console.Write("greater 10");
    break;

Using C# 7.0 pattern matching, we can set the range of input values in the switch cases using when. We can switch based on any type, can use pattern matching case clauses.

Let’s see an example of pattern matching,

switch (experience)
{
     case var exp when (experience > 0 & experience < 4):
         Console.Write("Junior stage with {0} years of experience level", exp);
         break;

      case var exp when (experience > 10):
         Console.Write("Super senior stage with {0} years of experience level", exp);
         break;

     case var exp when (new List<int>() { 4, 5, 6, 7 }).Contains(experience):
         Console.Write("Mid level stage with {0} years of experience level", exp);
         break;

     default:
         Console.Write("code hits the default case");
         break;
}

In the above code, the first case checks the experience greater than 0 and less than 4 using pattern matching. we can check more than condition using & which is similar to the way we use in if/for loops.

In the second case, we are matching only one conditional case in switch clause.

In the third case, we are checking whether the experience value is available in the list of int values we have. At final the default case works as always, and get executes at last if no other case clauses get hits.

In this pattern matching switch cases, the order of clauses is determining which pattern needs to be validated first.

The exp variable will have the value of experience variable on the successful pass of pattern matching.

I have used VS Code for executing this code and committed the source in this repo. Have a look 🙂

Happy coding 🙂

map() – JavaScript Functional Programming

What is functional programming?

Functional programming is a programming paradigm, the process of building components using pure functions and avoiding shared state, mutable data and side-effects.

In simple, functional programming is doing our tasks with functions, avoiding side effects by using pure functions.

For example, Without iterating the list using user defined loops; we can iterate the list using the functions like map(), reduce(), and filter()

Let’s see about map() function in this post.

I have started exploring about functional programming in recent times. The topic looks very interesting and helping me to optimize my own codes. After using functional programming, my code looks pretty good and maintainable.

For example, If I need to iterate a list and extract some data previously I use some for loops to do the task like following:

var players = [
 { name: 'Dhoni', nickname: 'Super Cool Captain' },
 { name: 'Raina', nickname: 'Furious fielder' },
 { name: 'Ashwin', nickname: 'Spin Master' }
];

var namelistusingloop = [];

for (var i = 0; i < players.length; i++) {
 namelistusingloop.push(players[i].name);
}

Later I found that using map function, we can simplify our function even more.

map() will take the callback function as follows.

var namelistusingmap = players.map(function (player) {
 return player.name;
});

In the above part, the map() will iterate the list based on its length. We don’t have to initialize & iterate list as we did in the for loop.

Now the code looks simple and effective. All the short code doesn’t mean effective unless it reduces the development time & maintenance period.

We can even simplify the code with map() using arrow functions.

var namelistwitharrow = players.map((player) => player.name);

In short, arrow function is used to simplify our callback function. To know more about arrow functions click here to visit the earlier post in this space.

Now the code looks even cooler and smart

var namelistusingmap = players.map(function (player) {
 return player.name;
});

var namelistwitharrow = players.map((player) => player.name);

Lets put all code together to compare to take quick look,

var players = [
 { name: 'Dhoni', nickname: 'Super Cool Captain' },
 { name: 'Raina', nickname: 'Furious fielder' },
 { name: 'Ashwin', nickname: 'Spin Master' }
];

// using loops
var namelistusingloop = [];

for (var i = 0; i < players.length; i++) {  namelistusingloop.push(players[i].name); } // using map function var namelistusingmap = players.map(function (player) {  return player.name; }); // using map function and arrow function var namelistwitharrow = players.map((player) => player.name);

console.log(namelistusingloop);
console.log(namelistusingmap);
console.log(namelistwitharrow);


Output

["Dhoni", "Raina", "Ashwin"]
["Dhoni", "Raina", "Ashwin"]
["Dhoni", "Raina", "Ashwin"]

Now it’s up to us to decide which module we have to use in our code – the code using the pure function or using the loops.

Let’s explore more about functional programming in upcoming posts.

Happy coding!