DEV Community: Dean

Learning Python Getting Key Of Max Value In Dictionary

Dean — Mon, 18 Jan 2021 00:00:00 +0000

Happy new year 2021! I want to kick off my new year blog entry with a beginner’s guide to my favourite language, Python.

We’ve all been there, learning a new language, there is always that little gem of a feature that is quite handy and makes the language enjoyable to write with. When I started learning Python, a lot of things changed for me with how I see programming, especially with all these things they call “pythonic”.

For today’s post, we’ll talk about getting the key with the max value in a dictionary. We’ll talk about basics all the way to using a 3rd party library to solve it.

Here’s what we’ll learn:

Basic Python Solution to Get Max
Using Standard Python Library
Using Numpy
Using Pandas

Tests

Programming would be easier if we had unit tests for our solution. If you’re following along, you can use the data below for unit tests.

import pytest

@pytest.mark.parametrize('data, expected, note', [
    ({
  'Andrew Wiggins': 17.8,
  'Eric Paschall': 11.7,
  'Stephen Curry': 28.4,
  'James Wiseman': 11.3,
  'Draymond Green': 4
  }, 'Stephen Curry', 'Stephen Curry is top avg scorer'),
    ({

  'Andrew Wiggins': 17.8,
  'Stephen Curry': 28.4,
  'Klay Thompson': 28.4,
  'Eric Paschall': 11.7,
  'James Wiseman': 11.3,
  'Draymond Green': 4
  }, 'Stephen Curry', 'Stephen Curry is top avg scorer as picked on insertion-order'),
  ({}, '', "No data, return empty string")
])
def test_top_scorer(data: dict, expected: str, note: str):
    assert top_scorer(data) == expected, note

** We’re using Python3.6+, thus dictionaries are now “insertion-ordered”. From GVR.

Basic Python Solution to Get Max

The max is straightforward enough, using a loop and recording the maximum value. Coming from a C-based language, and without knowledge of language features, this is how I possibly would write it:

def top_scorer(stats: dict) -> str:
  top_score_avg = 0
  top_scorer = ''

  for scorer in stats:
    if stats[scorer] > top_score_avg:
      top_score_avg = stats[scorer]
      top_scorer = scorer

  return top_scorer

Running our test:

collected 3 items
test_top_scorer.py::test_top_scorer[data0-Stephen Curry-Stephen Curry is top avg scorer] PASSED [33%]
test_top_scorer.py::test_top_scorer[data1-Stephen Curry-Stephen Curry is top avg scorer as picked on insertion-order] PASSED [66%]
test_top_scorer.py::test_top_scorer[data2--No data, return empty string] PASSED

Our code above works! But with how it is in the Python community, I always tend to ask myself, did I miss a language feature that would have made my code shorter and avoided reinventing the wheel?

In this case, there definitely is. We can use the max function to solve it.

Using Standard Python Library

When I started out with Python, using max on a dictionary often made me question how it will work as I knew that a dictionary is a set of key-value pairs.

In our case, we want to get the name of the player who has the “max” average score. Python’s max function accepts a key which can be used as criteria for getting the max value.

Let’s examine the max function.

max has a function signature:

 max(iterable, *[, key, default])

The dictionary input will be our iterable.

The key argument in max is a one-argument ordering function. In this case, we want the items ordered based on the top score.

The 3rd optional argument is what we’ll return if the iterable is empty. If we don’t supply a default, we’ll get a ValueError exception. Based on our unit test, it just means we set it to an empty string.

Before we make a key function for max, let’s step back first and rediscover the nature of Python dictionaries.

For example, if we want to get Stephen Curry’s average score, we access the dictionary as such:

>>> gsw_points_stat['Stephen Curry']
28.4
>>>

or alternatively:

>>> gsw_points_stat.get('Stephen Curry')
28.4
>>>

So, we could use either of these to supply our max function what it needs.

We can write:

def top_scorer(stats: dict) -> str:
  def ordering_fn(key: str) -> str:
    return stats[key]

  return max(stats, key=ordering_fn, default='')

Running our unit tests, and we still pass.

A different way of doing this is a lambda. A lambda is just an anonymous function.

We can write:

def top_scorer(stats: dict) -> str:
  return max(stats, key=lambda k: stats[k], default='')

It still works and now, we’re down to one line. We’re not finished though. The key argument takes a unary function. With functions being first-class objects in Python, we can pass a function directly.

def top_scorer(stats: dict) -> str:
  return max(stats, key=stats.get, default='')

Using numpy

Numpy is a package for scientific computing in Python. It’s great and we can use it for this task too.

We can use argmax which is a function that returns the index of the max element of an array. argmax can actually support finding a max value row-wise or column-wise (which means we are using a jackhammer to drive a nail. This section is for learning).

so to get the max index of the top score in the list, we can:

max_index = np.argmax(data.values())

Note that if the dictionary is empty, argmax will return 0. So we’ll need to do a ternary operation.

From our data, this will return 0 as that is the index of the max value in the dictionary’s values. Knowing what our index is, we just need to get the list of keys.

Thus our final code:

import numpy as np

def top_scorer(stats: dict) -> str:
  return list(stats.keys())[np.argmax(list(stats.values()))] if stats else ''

Using pandas

Pandas is another python library for data analysis. It is used by the data science community and especially important for high performance when dealing with large amounts of data.

Our example isn’t much, but just for fun, we can use a pandas function to solve the problem too.

We can use the idxmax of a Series in pandas. A Series is a one-dimensional ndarray in pandas.

So our code would be:

import pandas as pd
def top_scorer(stats: dict) -> str:
    return pd.Series(stats).idxmax() if stats else ''

Discovering Typescript Operators

Dean — Thu, 03 Sep 2020 00:00:00 +0000

In this post, we'll talk about 3 operators we can use in Typescript. These operators are also available in Javascript.

Sample Problem

We want to extract and add up numbers in a string. If there are no numbers, then return 0.
For example, if we have the string:

"99 bottles of beer on the wall, take 1 down pass it around"

We want the function to return 100, where 99 and 1 are added together.

So in a map-reduce approach, this is my solution. (Also, as a first step, we had to split the string using space as a delimiter.).

export function sum(input: string): number {
  return input.split(' ')
              .map(word => Number(word) || 0)
              .reduce((total, current) => total + current, 0);
}

So to make sure our function is correct, we write a couple of tests:

  describe('Test sum of numbers', () => {
    it('should return 100 bottles of beer', () => {
      expect(sum('99 bottles of beer on the wall, take 1 down pass it around'))
        .to.be.equal(100);
    });

    it('should return 0 for no more bottles of beer', () => {
      expect(sum('No more bottles of beer on the wall, no more bottles of beer'))
        .to.be.equal(0);
    });
  });

  Test sum of numbers
    √ should return 100
    √ should return 0 for no more bottles of beer


  2 passing (9ms)

Unary Plus Operator

The Number function was my typical way to go in Typescript. But I discovered that we can also use the shorter unary plus operator.

With that, we modify our code so it is shorter:

export function sum(input: string): number {
  return input.split(' ')
              .map(word => +word || 0)
              .reduce((total, current) => total + current, 0);
}

Note that we've simply replaced Number(word) with just +word. It works just the same and still passes all the test.

Optional Chaining Operator

So what if the requirements change where the input string is now optional? We have to now deal with the input possibly being undefined. Let's say, we just return undefined if there is no input string.

With that, let's change our function:

export function sum(input?: string): number | undefined {
  if (!input) {
    return undefined;
  }
  return input.split(' ')
              .map(word => +word || 0)
              .reduce((total, current) => total + current, 0);
}

Note that we had to put in the if clause, otherwise we'll get:

error TS2532: Object is possibly 'undefined'.

Notice, we also had to add | undefined for the return type as we want our return to be either a number or undefined.

Adding a unit test for it, and we still pass:

  describe('Test sum of numbers', () => {
    it('should return 100 bottles of beer', () => {
      expect(sum('99 bottles of beer on the wall, take 1 down pass it around'))
        .to.be.equal(100);
    });

    it('should return 0 for no more bottles of beer', () => {
      expect(sum('No more bottles of beer on the wall, no more bottles of beer'))
        .to.be.equal(0);
    });

    it('should return undefined for no argument', () => {
      expect(sum()).to.be.undefined;
    });
  });

  Test sum of numbers
    √ should return 100 bottles of beer
    √ should return 0 for no more bottles of beer
    √ should return undefined for no argument


  3 passing (9ms)

And now comes the optional chaining operator. We can get rid of the if clause we added earlier by using the optional chaining operator. This will make it cleaner.

export function sum(input?: string): number | undefined {
  return input?.split(' ')
              .map(word => +word || 0)
              .reduce((total, current) => total + current, 0);

}

Optional chaining lets us write code that immediately stops running if we encounter null or undefined.

Nullish Coalescing

So now, a new requirement came in! Instead of returning undefined, we must return zero instead if there is no argument. To accomodate the new requirement, we've now changed our code to:

export function sum(input?: string): number {
  if (input) {
    return input.split(' ')
              .map(word => +word || 0)
              .reduce((total, current) => total + current, 0)
  }

  return 0;

This is where the nullish coalescing operator comes very handy. The nullish coalescing operator lets us fallback to a default value if the left side of it is null or undefined.

With this operator, our code will be:

export function sum(input?: string): number {

  return input?.split(' ')
              .map(word => +word || 0)
              .reduce((total, current) => total + current, 0)
              ?? 0;
}

And we write a few more tests to make sure we are behaving correctly:

  describe('Test sum of numbers', () => {
    it('should return 100 bottles of beer', () => {
      expect(sum('99 bottles of beer on the wall, take 1 down pass it around'))
        .to.be.equal(100);
    });

    it('should return 0 for no more bottles of beer', () => {
      expect(sum('No more bottles of beer on the wall, no more bottles of beer'))
        .to.be.equal(0);
    });

    it('should return 0 for no argument', () => {
      expect(sum()).to.be.equal(0);
    });

    it('should return 0 for empty string', () => {
      expect(sum('')).to.be.equal(0);
    });

    it('should return 0 for undefined', () => {
      expect(sum(undefined)).to.be.equal(0);
    });

  });

  Test sum of numbers
    √ should return 100 bottles of beer
    √ should return 0 for no more bottles of beer
    √ should return 0 for no argument
    √ should return 0 for empty string
    √ should return 0 for undefined


  5 passing (11ms)

Cool! All our tests passed!

And that's it for this post. Thanks for reading!

Using Python To Compute Start To End Dates

Dean — Thu, 23 Jul 2020 00:00:00 +0000

Tax time is upon us in Australia, and due to covid19, this tax time is a bit different as we have to compute for our working from home costs (for some of us who don't normally work from home).

In Australia, the tax office introduced a 'shortcut method' to compute for deductions. See here for more details.

The shortcut method is simply claiming a deduction of 80 cents for each hour worked from home. We know how many hours we work in a day, but how do we compute the total number of days excluding the holidays and weekends without manually counting the days on a calendar?

We will try to answer that question in this blog post.

1. Installation for required packages

We will use Python (I used 3.8.4 at the time of writing this entry) to compute for the number of days. Let's install our required packages via pip.

> pip install numpy
> pip install pandas
> pip install holidays

2. Let's get coding

First, let's import all our packages:

import pandas as pd
import numpy as np
import holidays

So we'll need to supply our start and end dates as strings and convert them to datetime using pandas to_datetime.

For example, if I worked from home from March 18 to June 30, I supply March 18 to July 1. We have to add +1 day as this is required by numpy's busday_count function. We'll talk more about that in the later part.

Let's also call the .date() at the end to exclude the time from datetime.

start = pd.to_datetime('18/03/2020', format='%d/%m/%Y').date()
end = pd.to_datetime('01/07/2020', format='%d/%m/%Y').date()

Using the holidays package, we can easily pick up the holidays in any country it supports. I live in Australia, so we use that.

Below is what holidays.Australia contains.

>>> print(*holidays.Australia(years=2020).items(), sep="\n")
(datetime.date(2020, 1, 1), "New Year's Day")
(datetime.date(2020, 1, 26), 'Australia Day')
(datetime.date(2020, 1, 27), 'Australia Day (Observed)')
(datetime.date(2020, 4, 10), 'Good Friday')
(datetime.date(2020, 4, 13), 'Easter Monday')
(datetime.date(2020, 4, 25), 'Anzac Day')
(datetime.date(2020, 12, 25), 'Christmas Day')
(datetime.date(2020, 12, 26), 'Boxing Day')
(datetime.date(2020, 12, 28), 'Boxing Day (Observed)')

This is default to ACT.

States can have different holidays. The Queen's Birthday holiday on June 8th isn't on the list by default as it is not the same in NSW.

So let's add that in by providing a prov argument NSW.

# First, create our holidays lookup
nsw_holidays = [*holidays.Australia(years=2020, prov='NSW')]

# Note, add any holiday or absences manually if any
# sick_leave = pd.to_datetime('29/06/2020', format='%d/%m/%Y').date()
# nsw_holidays[sick_leave] = "Colds"

Now that we're all setup, let's call the busday_count function in numpy.

The busday_count function will count the number of days between 2 dates, excluding the end date.

According to numpy's documentation, this is the function signature:

numpy.busday_count(begindates,
                   enddates,
                   weekmask='1111100',
                   holidays=[],
                   busdaycal=None,
                   out=None)

Note that the weekmask is a boolean representation of what days to count in a week. This is a monday to sunday representation. So the 2 zeros at the end means we exclude saturdays and sundays which is what we really want.

Now that we have nsw_holidays, we need to assign this to the holidays parameter. Note that nsw_holidays is a dictionary, so we unpack the keys only.

We will keep busdaycal and out as None.

So now, we count our wfh days.

wfh_day_count = np.busday_count(start, end, holidays=[*nsw_holidays.keys()])

wfh_day_count is the total number of days you've worked from home from March 18 to June 30.

Here's the whole source code:

import pandas as pd
import numpy as np
import holidays

start = pd.to_datetime('18/03/2020', format='%d/%m/%Y').date()
end = pd.to_datetime('01/07/2020', format='%d/%m/%Y').date()

nsw_holidays = holidays.Australia(years=2020, prov='NSW')

print(*nsw_holidays.items(), sep='\n')

wfh_day_count = np.busday_count(start, end, holidays=[*nsw_holidays.keys()])

print(f'Total WFH Days {wfh_day_count}')

And that's it. I hope this helps anyone looking for a quick way to compute.

Discovering Typescript Enums

Dean — Mon, 25 May 2020 00:00:00 +0000

Coming from an OOP, C-based language (C++, C#), enums are essentials when it comes to making magical specific numbers into human-readable names. With Typescript, enums are similar, but have differences from other languages.

1. Enums Under The Hood

As we already know, Typescript code is compiled into Javascript. An enum declaration is no different.

If we had a Typescript enum below:

enum Fruit
{
    Apple,
    Mango,
    Banana,
    Total
}

it gets compiled to:

var Fruit;
(function (Fruit) {
    Fruit[Fruit["Apple"] = 0] = "Apple";
    Fruit[Fruit["Mango"] = 1] = "Mango";
    Fruit[Fruit["Banana"] = 2] = "Banana";
    Fruit[Fruit["Total"] = 3] = "Total";
})(Fruit || (Fruit = {}));

That Javascript code looks very interesting. The compiled Javascript is a mapping of strings to numbers and numbers to strings.

In terms of Javascript, the map Fruit, used like:

Fruit["Apple"] = 0;

above will mean, that Fruit.Apple or Fruit["Apple"] will return 0.

What is interesting in this code, is the reverse mapping part.

The Fruit["Apple"] = 0 bit in:

Fruit[Fruit["Apple"] = 0] = "Apple";

is equivalent to Fruit[0] = "Apple";, thus, we can access the enum as Fruit[0], and this returns a string if we use numerical indices to access the enum.

This is really great as it means we can access the enum via index or loop through it. In C#, we can create an array from the enum in order for the enum to be accessed by index.

// C# Code to access an enum via index, or loop through it.
var fruits = (Fruit[])Enum.GetValues(typeof(Fruit));

So, if we print out Apple in Fruit:

console.log(`An apple's numeric value is ${Fruit.Apple}`);
console.log(`An apple's numeric value is ${Fruit["Apple"]}`);
console.log(`An apple's string value is ${Fruit[0]}`);

Our output would be:

An apple's numeric value is 0
An apple's numeric value is 0
An apple's string value is Apple

2. Const Enums

Typescript also has const enums, which differs in how it compiles into Javascript. If we had the const enum below:

const enum ConstFruit
{
    Apple,
    Mango,
    Banana
}

console.log(`An apple's numeric value is ${ConstFruit.Apple}`);
console.log(`An mango's numeric value is ${ConstFruit["Mango"]}`);
console.log(`An banana's numeric value is ${ConstFruit["Banana"]}`);

It gets compiled to:

console.log("An apple's numeric value is " + 0 /* Apple */);
console.log("A mango's numeric value is " + 1 /* "Mango" */);
console.log("A banana's numeric value is " + 2 /* "Banana" */);

Notice the values are just inlined with comments beside them.There is no lookup table generated.

So if we do ConstFruit[0], we get an error:

"A const enum member can only be accessed using a string literal."

As expected, because the lookup table doesn’t exist, we are getting an error.

3. Ambient Enums

Ambient enums are useful for when the enum type already exists elsewhere. This could be another library, perhaps an old Javascript one. An ambient enum is declared like:

declare enum AmbientFruit
{
    Apple,
    Mango,
    Banana
}
console.log(`An apple's numeric value is ${AmbientFruit.Apple}`);

Its compiled Javascript looks like:

console.log("An apple's numeric value is " + AmbientFruit.Apple);

Ambient enums don’t emit a lookup object. Looking at the value of AmbientFruit.Apple as Javascript code, it appears like it is telling the compiler that “I have this type somewhere, and you can go ahead and compile it”. If the type doesn’t really exist, then we get a runtime error.

4. Preserve Const Enum Flag

As discussed in item 2, const enums don’t emit a lookup object. However, when compiling with --preserveConstEnums, the compiler will emit a lookup object. However, the values are still inlined.

So when we have:

const enum ConstFruit
{
    Apple,
    Mango,
    Banana
}

console.log(`An apple's numeric value is ${ConstFruit.Apple}`);
console.log(`A mango's numeric value is ${ConstFruit["Mango"]}`);

the compiled Javascript is:

var ConstFruit;
(function (ConstFruit) {
    ConstFruit[ConstFruit["Apple"] = 0] = "Apple";
    ConstFruit[ConstFruit["Mango"] = 1] = "Mango";
    ConstFruit[ConstFruit["Banana"] = 2] = "Banana";
})(ConstFruit || (ConstFruit = {}));
console.log("An apple's numeric value is " + 0 /* Apple */);
console.log("A mango's numeric value is " + 1 /* "Mango" */);

Note that this flag doesn’t affect ambient enums.

5. String Enums

Lastly, in Typescript 2.4, string enums were introduced.

We declare string enums:

enum FruitStrings
{
    APPLE = "Apple",
    MANGO = "Mango",
    BANANA = "Banana"
}
console.log(`An apple's ${typeof(FruitStrings.APPLE)} value is "${FruitStrings.APPLE}"`);

The compiled Javascript will look like:

var FruitStrings;
(function (FruitStrings) {
    FruitStrings["APPLE"] = "Apple";
    FruitStrings["MANGO"] = "Mango";
    FruitStrings["BANANA"] = "Banana";
})(FruitStrings || (FruitStrings = {}));
console.log("An apple's " + typeof (FruitStrings.APPLE) + " value is \"" + FruitStrings.APPLE + "\"");

Notice that the numerical value is gone. It also doesn’t have a reverse lookup. So

let t = FruitStrings["Apple"];

will produce an error:

Property 'Apple' does not exist on type 'typeof FruitStrings'. Did you mean 'APPLE'?

And that’s it for enums. It looks great to have reverse lookups. They look pretty handy.

Discovering Typescript Part 2

Dean — Sat, 16 May 2020 00:00:00 +0000

This is part 2 of 2 about my Typescript discoveries. If you haven’t read part 1, you can read it here.

So this entry will be about classes. Object oriented languages have a lot of similarities and Typescript is no different.

Here’s a list of what I’ll cover in this blog post:

Constructors and Implicit Properties
Class and Method Access
Object Literals
Prototypal Inheritance
Interfaces

Constructors and Implicit Properties

Coming from C# or other C-based OOP languages, we get so used to having constructors having the same name as the class name. In Typescript, it’s different.

Our constructor would look like this:

class Book {
    public salesRank: number;
    public title: string;
    private isbn: string;

    constructor(salesRank: number, title: string, isbn: string) {
        this.salesRank = salesRank;
        this.title = title;
        this.isbn = isbn;
    }

    description() {
        return `${this.title} ISBN: ${this.isbn} Rank# ${this.salesRank}`
    }
}

Alternatively, this would look cleaner if we use implicit properties. In that way, we observe the DRY principle. However, this is really a matter of personal preference.

class Book {
    constructor(
        public salesRank: number,
        public title: string,
        private isbn: string
    )
    {}

    description() {
        return `${this.title} ISBN: ${this.isbn} Rank# ${this.salesRank}`
    }
}

Class And Method Access

Coming from a C# background, default(unspecified) access in classes that are not nested within other classes/structs are always internal. In Typescript, classes have public access by default.

class Patient {

    constructor(
        public firstName: string,
        public lastName: string,
        public email: string,
        private age: number
    )
    {}

    greet() {
        console.log(`Hello ${this.firstName}`);
        console.log(`Year Born: ${this.yearBorn()}`);
    }

    private yearBorn() : number {
        let date: Date = new Date();
        return date.getFullYear() - this.age;
    }
}

The greet function above is public, and accessible:

var patientA = new Patient("Joe", "Black", "joe_black@awesomeemail.com", 24);
patientA.greet();
>>> Hello Joe
Year Born: 1996

If we try to access yearBorn() outside its scope, we get an error:

patientA.yearBorn();
>>> error TS2341: Property 'yearBorn' is private and only accessible within class 'Patient'.

Object Literals

There are cases in Javascript where we just want something short and simple. Essentially, an object without any intent of creating any prototypal inheritance.

Object literals to the rescue! Actually, object literals are already in Javascript, but nice to know we have it here in Typescript.

const rectangle = {
    height: 20,
    width : 40,
    area: function() { return this.width * this.height; }
}

Prototypal Inheritance

Being an object oriented language, inheritance also exists in Typescript.

Here’s how:

class OutPatient extends Patient {
    constructor(
        fn: string, ln: string, email: string, age: number
    ) {
        super(fn, ln, email, age);
    }

    greet() {
        super.greet();
        console.log(`Welcome to outpatient services, ${this.firstName}. Please pick a number.`);
    }
}

To derive from a base class, we simply use the extends keyword. If the base class has a constructor, we can construct the base class by using the super keyword, and we’re all set.

Overriding methods are straightforward. If we need to call a method from the parent class, we just use the super keyword.

Interfaces

Any object oriented language wouldn’t be complete without interfaces. As OOP coders, we always have that principle of writing to abstractions rather than concrete implementations (or dependency inversion if you prefer the ‘D’ in SOLID principles).

So with that, here’s what our Typescript interface looks like:

 interface Product {
    name: string;
    sku: string;
    id: number;
    discount(): number;
}

So the above code tells us that name, sku and id are properties and that discount is a method.

Writing against this interface, this would be:

class Chair implements Product {
    constructor(
        public name: string,
        public sku: string,
        public id: number
    ) {

    }

    discount() : number {
        return 0.25;
    }
}

Discovering Typescript Part 1

Dean — Sat, 09 May 2020 00:00:00 +0000

Today, I decided to learn Typescript, and here are 6 items I learned. These are not meant to be a comprehensive coverage of the language.

1. Variables and Functions

Being a transpiler for Javascript, it is expected to be closer to how Javascript does its function.
Typescript functions look like this:

function add(addend1: number, addend2:number) : number {
    return addend1 + addend2;
}

The function add takes 2 numbers and returns their sum. Typescript treats both floats and integers as numbers. So a float works too for this function.

console.log(`Sum of numbers ${add(434,344)}`);
console.log(`Sum of floating point numbers ${add(43.4, 23.4)}`);

>>> Sum of numbers 778
>>> Sum of floating point numbers 66.8

The : number bit is the return type of the function.

2. String Interpolation or Formatted String Literals

Other languages like C#6's string interpolation and Python 3.6's formatted string literals make it quite convenient to create formatted strings.

Check out below on how other languages do it:

int x = 4;
int y = 5;
Console.WriteLine($"The sum of {x} and {y} is {x+y}");
>>> The sum of 4 and 5 is 9

Python

x,y = 4,5
print(f"The sum of {x} and {y} is {x+y}")
>>> The sum of 4 and 5 is 9

We can do something similar in typescript/javascript, except it is per variable. This is called "template literals".

This works using backticks and wrapping each variable with ${}.

console.log(`The sum of ${a} and ${b} is ${a+b}`);
>>> The sum of 2 and 5 is 7

3. For Loops

This one caught me by surprise when I tried passing the contents of a number list into a function.

Suppose, I have a function that contains a switch like below:

function giveMe(what:number) {
    switch(what) {
        case 1:
            console.log("you gave me 1");
            break;
        case 2:
            console.log("you gave me 2");
            break;
        default:
            console.log("you gave me more!");
    }
}

then I supply numbers from a list:

let nums = [1,2,3];

for(var n of nums) {
    giveMe(n);
}

Note the of in the loop above. This can be surprising for C# and Python developers who get so used to using the preposition in in loops like:

foreach(var number in numbers) {
    GiveMe(number);
}

Python

for number in numbers:
    give_me(number)

Doing something similar in Typescript like below:

for(var n in nums) {
    giveMe(n);
}

Will give you a type error: Argument of type 'string' is not assignable to parameter of type 'number'. This is because in is meant to iterate over object properties, and thus has a type string.

4. Parameters

Like C# and Python, Typescript has optional and default parameters.

Typescript has it as such for optional parameters:

function increase(num: number, inc?:number) : number {
    if (inc != undefined) {
        return num + inc;
    }

    return num + 1;
}

console.log(increase(10));
console.log(increase(10,2));
>>> 11
>>> 12

inc?: number is an optional parameter.

For default parameters, it goes like:

function increase(num: number, inc:number = 1) : number {
    return num + inc;
}

console.log(increase(10));
console.log(increase(10,2));
>>> 11
>>> 12

With C#, there is a params keyword that can be useful for taking a variable number of arguments.

public static int GetTotal(params int[] addends) {
    return addends.Sum();
}

GetTotal(1,2,3,4,5);
>>> 15

In Python, its equivalent for taking a variable number of arguments:
Python

def get_total(*addends):
    return sum(addends)

get_total(1,2,3,4,5)
>>> 15

Similarly, this can be achieved in Typescript using the spread operator:

function getTotal(...addends:number[]) : number {
    let total = 0;
    for (var n of addends) {
        total += n;
    }
    // Or if you like using Javascript's functional operations
    // n.reduce(function(total, cv) {
    //    return total += cv;
    //}, 0);

    return total;
}

getTotal(1,2,3,4,5);
>>> 15

These are called rest parameters in Typescript.

5. Function Overloading

Typescript also supports function overloading. It is somewhat very unique in my opinion, when comparing it to other object oriented languages.

Python, being a dynamic language does not have a concept of function overloading (we do have multiple dispatch in Python, but let's not go there).

So, let's take as an example, C#:

public static int Add(int a, int b) {
    return a + b;
}

public static int Add(int a, int b, int c) {
        return a + b + c;
}

However, with typescript, it works differently. We have to do it by writing a method declaration for each overload first, then implement the method.

So we make this for each overload like:

function add(a: number, b: number) : number;
function add(a: number, b: number, c: number) : number;

Then we implement the method/function:

function add(a: number, b: number, c?: number) : number {
    let total = a + b;

    if (c != undefined) {
        total += c;
    }
    return total;
}

console.log(add(1,2,3));
console.log(add(1,2));

In some cases, we may end up checking the type of the argument. As an example, if we had a method that had different types:

function identification(id: string) : string;
function identification(id: number): string;

function identification(value: (string | number)): string {
    switch(typeof value) {
        case "string":
            return `My id is ${value}`;
        case "number":
            return `My id is XX-${value}`;
    }
}

console.log(identification("XX-123"));
console.log(identification(123));
// >>> My id is XX-123
// >>> My id is XX-123

6. Arrow Functions

Arrow functions in typescript are very similar to C#.

let greetFn = (name:string) => console.log(`Hello ${name}`);
greetFn("Bob");

As a side note, I was quite surprised that there is a subtle difference when using arrow operators in Javascript ES6. Below is legal in ES6:

let greetFn = name => console.log(`Hello ${name}`);
greetFn("Bob");

So with this, I thought I could do:

// Note without parenthesis around name:string
let greetFn = name:string => console.log(`Hello ${name}`);
greetFn("Bob");

This however leads to an error, so I had to put back the parenthesis.

And that is it! Stay tuned for part 2, where I will share a few things I learned about classes in Typescript.