We already know that it is possible to explicitly declare the type of an element in our application by using optional type annotations:

function greetNamed(name: string): string {
    return 'Hi! ${name}';
}

In the previous function, we specified the type of parameter name (string) and its return type (string). Sometimes, we will need to specify the types of the function, as opposed to specifying the types of its components (arguments or returned value). Let's look at an example:

let greetUnnamed: (name: string) => string;

greetUnnamed = function(name: string): string {
 return 'Hi! ${name}';
};

In the preceding example, we have declared the greetUnnamed variable and its type. The greetUnnamed type is a function type that takes a string variable called name as its only parameter and returns a string after being invoked. After declaring the...

In this section, we are going to learn how to work with function parameters in multiple scenarios, including optional parameters, default parameters, and rest parameters.

Trailing commas are commas that are used after the final argument of a function. Using a comma after the last parameter of a function can be useful because it is very common to forget a comma when we modify an existing function by adding additional parameters.

For example, the following function only takes one parameter and doesn't use trailing commas:

function greetWithoutTralingCommas(
    name: string
): string {
    return 'Hi! ${name}';
}

Some time after the initial implementation...

Low-level languages, such as C, have low-level memory management features. In programming languages with a higher level of abstraction, such as TypeScript, values are allocated when variables are created, and automatically cleared from memory when they are no longer used. The process that cleans the memory is known as garbage collection and is performed by the JavaScript runtime garbage collector.

The garbage collector does a great job, but it is a mistake to assume that it will always prevent us from facing a memory leak. The garbage collector will clear a variable from the memory whenever the variable is out of scope. It is important to understand how the TypeScript scope works in order for us to understand the life cycle of variables.

Some programming languages use the structure of the program source code to determine what variables we are referring...

An immediately-invoked function expression (IIFE) is a design pattern that produces a lexical scope using function scoping. IIFE can be used to avoid variable hoisting from within blocks or to prevent us from polluting the global scope, for example:

let bar = 0; // global

(function() {
    let foo: number = 0; // In scope of this function
    bar = 1; // Access global scope
    console.log(bar); // 1
    console.log(foo); // 0
})();

console.log(bar); // 1
console.log(foo); // Error

In the preceding example, we have wrapped the declaration of a variable (foo) with an IIFE. The foo variable is scoped to the IIFE function and is not available in the global scope, which explains the error when trying to access it on the last line.

The bar variable is global. Therefore, it can be accessed from within and from outside the IIFE function.

We can also pass a variable...

In TypeScript, we can use template strings such as the following:

let name = "remo";
let surname = "jansen";
let html = '<h1>${name} ${surname}</h1>';

We can use a template string to create a special kind of function known as a tag function.

We can use a tag function to extend or modify the standard behavior of template strings. When we apply a tag function to a template string, the template string becomes a tagged template.

We are going to implement a tag function named htmlEscape. To use a tag function, we must use the name of the function, followed by a template string:

let html = htmlEscape '<h1>${name} ${surname}</h1>';

A tag template must return a string and take the following arguments:

• A TemplateStringsArray, which contains all the static literals in the template string (...

In this chapter, we have learned a lot about functions. We have learned about different kinds of functions, such as named and anonymous function, and function declarations and function expressions. We also learned how to declare different types of function signatures as well as how to work with function arguments in multiple scenarios.

In the next chapter, we are going to learn about asynchronous programming techniques. We will learn why functions play a very fundamental role in the TypeScript and JavaScript asynchronous programming model.