Our next example starts similarly to the last: a form input validator that supports an optional value.

This time the `Form` has a `repoName` and an optional array of `keywords`:

```typescript
const Form = z.object({
  repoName: z.string(),
  keywords: z.array(z.string()).optional(),
});
```

In order to make things easier for the actual form, we want to set this up so that an array of strings doesn't have to be passed in.

## Challenge

Update the `Form` so that `keywords` will default to an empty array of strings if no strings are passed into the validator function.

Zod's <a href="https://zod.dev/?id=default" target="_blank" rel="noopener">.default schema method</a> allows us to pass in a value to use if no other value is provided.

In this case, we'll set it to an empty array with `.default([])`.

Before:

```typescript
keywords: z.array(z.string()).optional()
```

After:

```typescript
keywords: z.array(z.string()).default([])
```

Because we are adding a default value, we no longer need `.optional()` because optional is included within it.

With this change, our test now passes.

## The Input is Different than the Output

We've reached the point with Zod where our input is different than our output.

In other words, you can generate types based on input as well as generating types based on the output.

For example, let's create `FormInput` and `FormOutput` types:

```typescript
type FormInput = z.infer<typeof Form>
type FormOutput = z.infer<typeof Form>
```

## Introducing `z.input`

As written above, the input is not quite correct because when we input into `validateFormInput`, we don't need to pass in any keywords.

Instead, we can update the the `FormInput` to use `z.input` instead of `z.infer`.

This gives us a way to slightly tweak the types we generate if there is a difference between the input and output of our validator.

```typescript
type FormInput = z.input<typeof Form>
```

Set a Default Value with Zod

Matt Pocock: 0:00 The way to do a default in Zod is just by specifying default here. This means that you don't need to specify it's optional. You can say optional().default. What it actually means is it includes optional within it.

0:13 Now, our test is parsing because even if we parse in no keywords whatsoever, the result to keywords is always going to be this. There's something really cool about this, which is we're getting to a point with Zod now where the input is different from the output. That means that you can actually generate types based on the input and based on the output.

0:34 We can say `FormInput = z.infer<typeof Form>` here, and let's say we do the same with the output, then these are going to be the same. This input is not quite correct because when we input to the validate form thing, we didn't need to parse these keywords.

0:54 We can actually use z.input instead. This means that you don't need to parse them. This is a really cool way to slightly tweak the types that you're generating if you have a difference between the input to your validator and the output.

Matt Pocock: 0:00 We've now got a similar problem here, which is we're validating a form input. This one is for when you create a new repository. We've got the repoName here. We've got a set of keywords, except we want to make it a little bit easier on the form here.

0:16 We want to say you didn't need to parse this array of strings for the keyword. We've made it optional here, except we don't want to have to deal with undefined or array. If they don't parse any keywords, we want it to default to an empty array. That's what our test is validating down there.

0:37 What we end up with is we've got string this or undefined, which isn't what we want really. We want it to just say if they don't parse any keywords, just default it to an empty array. Your challenge is to somehow find how you can do a default in Zod.

TypeScript is great for checking variables at the type level.

For example, you can specify that the `age` property for a `User` should be a number.

However, you can’t always be sure what you’re going to get from a form input. TypeScript will present an error if it’s not a number, but on its own it doesn’t know if a number is too low or too high to be realistic for your use case.

There’s a similar problem with third-party API responses.

You can reference documentation to get an idea for what a response includes, but TypeScript can’t tell how to type it. And what happens if you get an error instead?

Zod allows you to work around uncertainty by checking types at the _runtime_ level as well at the type level.

In this tutorial, you’ll gain hands-on practice with Zod by working through a series of exercises that demonstrate how useful runtime checking is.

## **What is Zod?**

Zod ([github](https://github.com/colinhacks/zod#introduction)) is a TypeScript-first schema declaration and validation library. I'm using the term "schema" to broadly refer to any data type, from a simple **`string`** to a complex nested object.

Zod is designed to be as developer-friendly as possible. The goal is to eliminate duplicative type declarations. With Zod, you declare a validator _once_ and Zod will automatically infer the static TypeScript type. It's easy to compose simpler types into complex data structures.

## **Instructions**

This tutorial is a set of problem exercises for you to work through. Each exercise has a short video that presents the problem along with a code editor to solve the problem in the browser.

You'll know you've solved the exercise when the tests pass.

This Zod tutorial encourages **active, exploratory learning**. In each exercise, I'll explain a problem, and **you'll be asked to try to find a solution**.

To attempt a solution, you'll need to:

1. Look for any 🕵️‍♂️ emojis to give you a hint on what to change
2. Check out <a href="https://github.com/colinhacks/zod" target="_blank" rel="noopener">Zod's docs</a>
3. Try to find something that looks relevant.
4. Give it a go to see if it solves the problem.

You'll know if you've succeeded because the tests will pass.

**If you succeed**, or **if you get stuck**, watch the solution video and check out the **`*.solution.ts`**.

You can see if your solution is better or worse than mine!

### **Prerequisites**

You'll need a working understanding of JavaScript, but even if you are new to TypeScript this tutorial is for you.

### **Running the Exercises Locally**

You'll want to have an understanding of git to clone the repository, basic node and npm (yarn) , as well as TypeScript itself to work through this tutorial.

If you want to save your work or work in a different environment, you can also [clone the git repository](https://github.com/total-typescript/zod-tutorial) and work locally in the editor of your choice. If you [follow this link to use gitpod](https://gitpod.io/#https://github.com/total-typescript/zod-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/zod-tutorial/blob/main/README.md) to get the exercises running.

Zod is a TypeScript-first schema declaration and validation library. In this tutorial, Matt Pocock has prepared a set of exercises that will help you level up.

Transcript

Set a Default Value with Zod

Transcript