Consider this `addTwoNumbers` function:

```typescript
export const addTwoNumbers = (a, b) => {
  return a + b;
};
```

This function takes in `a` and `b` and adds them together.

It looks like perfectly valid JavaScript.

Running `npm run exercise 01` in the terminal, we can see that our tests pass.

But even though it looks valid and tests pass, TypeScript isn't happy.

The terminal displays the following errors along with the line of code where they happen:

```typescript
Parameter 'a' implicitly has an 'any' type.
Parameter 'b' implicitly has an 'any' type.
```

## Challenge

Read through [our explainer on implicit any's](/concepts/parameter-x-implicitly-has-an-any-type) and see if you can find how to fix these TypeScript errors.

First thing’s first: dealing with the implicit ‘any’ type error.

> 'a' implicitly has an 'any' type.

This error occurs because TypeScript doesn't have enough information to infer a type, so defaults it to 'any'.

The solution is to add type annotations to the function's arguments.

In this case, both `a` and `b` should be typed as `number`:

```typescript
export const addTwoNumbers = (a: number, b: number) => {
  return a + b;
};

```

## Type Annotations are Critical to Understanding TypeScript

TypeScript relies on type annotations to understand the contracts the function must meet. Type annotations are critical to understanding TypeScript.

**Whenever you create a function, you must always specify the types of each argument!**

To help you remember this fundamental rule, I recommend turning on strict mode for all TypeScript projects.

When strict mode is enabled, you'll get the `implicitly has 'any' type` error whenever you leave type annotations out.

_But why can't TypeScript just look at the `+` and know that `a` and `b` are numbers?_

### Experiment with Different Types

Try setting the types of `a` and `b` to be `string`.

Running the test again, TypeScript would give you an error:

```typescript
Argument of type 'number' is not assignable to parameter of type 'string'

```

Updating the test code to pass strings into `addTwoNumbers` ends up giving runtime errors.

Changing a type to a Boolean won't work because you can't add a boolean to a number.

A string can have a number appended to it with `+`, but the test would fail.

Fix the Implicit 'Any' Error

0:00 The solution, then, is to add some type annotations to the function's arguments. A, now, is typed as a number and B is typed a number. We can change this, if we want to. We can change this to string and string here, but then we start getting errors further down, addTwoNumbers.  
0:19 It says, "Argument of type 'number' is not assignable to parameter of type 'string'". We'd have to parse in a couple of strings here. Then, of course, things are going to fail at runtime.

0:31 This idea that you need to annotate and make TypeScript understand the contracts that your functions must meet, the things you must parse into your functions, is critical to understanding TypeScript.

0:46 We could change this to a boolean, as well, if we want to. Actually, booleans can't be added together here. "Operator '+' cannot be applied to types 'boolean' and 'number'". You can't add a boolean to a number.

0:56 Weirdly, you can add a string to a number here, but what would happen is it would get appended together. We would have a two here. It's expecting it to be a number six, but it actually ends up being 24 there because it's adding the four, concatenating it to the two.

1:15 You may be asking yourself why doesn't TypeScript understand this? It sees that there's a plus between the two things here. Why can't it understand that A is a number and B is a number without us needing to add this?

1:29 Well, it's because TypeScript, at the source of its functions, like whenever you create a function you need to make that contract so TypeScript understands what you can parse to the function exactly. That's one of TypeScript's fundamental rules, is that every function you create you must always specify the types of each argument.

1:53 If you don't, you're going to get this pretty confusing error, but that's exactly what this error means. In tsconfig, we have enabled strict mode. Strict mode means that if you don't specify these, then you're going to get an error.

2:08 I recommend turning on strict mode for all TypeScript projects. That is your first solution. Well done.

The Implicit ‘Any’ Type Error

0:00 We've got some code here that looks like perfectly valid JavaScript, but TypeScript is yelling at us. We've got a function called add two numbers, which takes in a and b and adds them together. We can see in our terminal, in the tests that it's parsing here.

0:16 We can mess this up. If we want, we can say a-b and that will start failing our tests. We can see that it is actually working at runtime, but time script is not happy. Your job here is to work out why it's not happy. To decode these error messages, parameter a implicitly has in any type.

0:34 What on earth could that mean? Parameter b implicitly has in any type. Have a look in the documentation and see if you can find any hints as to what can fix these TypeScript errors.

Get hands-on interactive practice with this free TypeScript tutorial and learn the foundational knowledge and skills you need to become a TypeScript Wizard.

In this TypeScript tutorial you will:

* Learn to type variables, functions, and errors
* Become familiar with the TypeScript documentation
* Gain experience with modern TypeScript tooling

[Start now](https://totaltypescript.com/tutorials/beginners-typescript/implicit-any-type-error), and see why TypeScript’s an essential tool for modern web developers!

<Testimonial author={{name: "David Stinemetze", image: "https://cdn.sanity.io/images/z9io1e0u/production/6b24aef92c60f25c88fd8da44e97a1a47cb64e7b-150x150.png"}}>The Beginner’s course is fantastic. Very well explained, and easy to navigate through. I went through it in preparation for the <a href="https://totaltypescript.com/workshops" target="_blank" rel="noopener">extra paid workshops</a>, just to ensure I had a solid foundation and even then I learned some new things. Thanks Matt!</Testimonial>

## Instructions

This Beginner’s TypeScript tutorial is split into several exercises. Each features a `problem` that encourages you to take an active, exploratory learning approach to finding a `solution`.

To attempt a solution, you’ll need to:

1. Watch and read the `problem` introduction.
2. Check out [the TypeScript docs](https://www.typescriptlang.org/docs/).
3. Search for relevant keywords.
4. Give it a go to see if it solves the problem (there may be more than one solution!)

Whether you succeed or get stuck, watch & read the `solution` and check out the included code.

### Prerequisites

You’ll need a working understanding of JavaScript.

### Running the Exercises Locally

Clone [the Beginner’s TypeScript Tutorial repo](https://github.com/total-typescript/beginners-typescript-tutorial), and use npm or yarn to install dependencies.

If you [follow this link to use gitpod](https://gitpod.io/#https://github.com/total-typescript/beginners-typescript-tutorial), you can work in a full VS Code coding environment running in your browser.

Follow the [instructions in the README](https://github.com/total-typescript/beginners-typescript-tutorial) for more.

Free interactive video tutorial that will help you get started with TypeScript.

Beginner's TypeScript Tutorial Repo

Not all of the functions you write will take primitive types. When you need to pass objects as parameters, there are a few different ways to type them properly.

Add Types to Object Params

Working with Object Params

TypeScript can’t tell by itself if your code will still work when object properties are missing. For these situations, you need to specify which are optional.

Denote an Optional Property

Set Properties as Optional

Just as we saw with object properties, function parameters can be set as optional as well.

Mark a Function Parameter as Optional

Optional Parameters

Assigning types to variables allows TypeScript to provide more useful error messages on the lines where they occur.

Make a Variable Conform to an Interface

Assigning Types to Variables

TypeScript allows us to constrain a property’s value to one of a set number of things. For example, a medal that could only be gold, silver, or bronze.

Delineate Types a Value Can Be

Constraining Value Types

Arrays are one of the most common data structures in development. In this lesson, find out how they are represented in TypeScript.

Two Ways to Represent Arrays

Working with Arrays

Being strict about what is returned from your functions ensures that your code is safe on the inside as well as the outside.

Annotate a Function to Specify its Return Type

Function Return Type Annotations

Almost every web application involves making API calls. But how can we tell TypeScript what to expect when we’re expecting data?

Update Return Type Annotations for Async Functions

Typing Promises and Async Requests

One of the most crucial TypeScript concepts to understand is how type arguments work with certain functions and constructors.

Pass a Type Argument to Restrict Potential Types

Passing Type Arguments

Seeing “index” in a type error message usually refers to the key of an object. In this lesson are a few techniques for properly typing dynamic object keys.

Techniques for Typing Dynamic Object Keys

Assigning Dynamic Keys to an Object

TypeScript offers powerful features for narrowing down branches when working with third party APIs or functions that support data in different forms.

Change Function Returns Based on Type

Narrowing Down Union Types

When using a try-catch in TypeScript, it’s important that you type the error appropriately. There are a few different techniques to accomplish this.

Techniques for Coercing an Unknown Type

Typing Errors in a Try-Catch

Interfaces can inherit properties from other interfaces. This allows us to DRY out our code and have a neater way to work with complex data models.

Extend Interfaces From Other Interfaces

Inheriting Interface Properties

TypeScript allows for composing types together to create new types. This is useful when returning data that is a combination of multiple different types.

Combine Inline or at the Type Level

Combining Types to Create New Types

TypeScript provides us with tools for being more selective when creating new types based on others.

Two Techniques for Creating New Types Based on Others

Selectively Construct Types from Other Types

TypeScript supports typing functions that are passed in as arguments, including the arguments that they take.

Specify the Type of a Function

Typing Functions

TypeScript supports typing the returns from asynchronous functions– great for real world processes like fetching from databases or other third-party APIs.

Transcript

The Implicit ‘Any’ Type Error

Transcript