 Resources from Kamran Ahmed in 2024

Learn to use some of the tips and tricks that can help you write better TypeScript. 

We'll look at some utility types, understand how immutable types work, learn how to use conditional types, and finally go through some examples to see how we can write them better.

TypeScript is a typed superset of JavaScript that compiles to plain JavaScript.

typescript

TypeScript: Tips and Tricks

MongoDB has a quite powerful aggregation framework that allows you to write data processing pipelines. Documents in the MongoDB collection go through a series of stages or a pipeline that transforms them into an aggregated result. In this short video series, you will learn how to write aggregations in MongoDB.

mongodb

MongoDB Aggregation Framework

In this lesson, we learn how to use TypeScript's `Partial` types to make the `required` properties of your types optional; allowing you to reuse the same types for the cases where you may not have all the data.

Use Partial to Create Partially Fillable Types in TypeScript

In our [last lesson](https://egghead.io/lessons/javascript-use-partial-to-create-partially-fillable-types-in-typescript), we saw how we can make all the required fields in a type to be optional. Here we learn the opposite i.e. how to make all the optional fields to be required with the help of `Required`.

Make your optional fields required in TypeScript

There might be cases where you would want to create a type while excluding some of the properties from a type. Let's say you have a database query on a `users` table where you are not selecting the `password` field. In this case, you will not be able to assign the query results to your `User` type because it is not going to have all the fields available. 

In this lesson, we are going to learn how we can use TypeScript's `Omit` utility type to exclude properties from a type. 

Exclude Properties from a Type in TypeScript

There might be cases where you have selective data for your entities. Let's say that you are building a public API endpoint to get all the registered users from your `users` collection. Now there might be sensitive data in your `User` entity type that you may not want to return in the response. In such cases, `Pick` can help you be selective and get only the properties you need.

In this lesson, we will learn how to extract properties from a type and create a new type from it. 

Create a Type with Some Fields of Another Type in TypeScript with Pick

Unlike JavaScript's `const` variable declarations, TypeScript allows you to create fully immutable types. In this lesson, we learn how to create immutable types in TypeScript with the help of `as const`, `readonly` and `Readonly<T>`.

Create Immutable Types in TypeScript

Aggregation in MongoDB is really powerful and allows you to create solid pipelines to extract and transform data. This is an introductory video that aims to demonstrate the basics of aggregation — we will see how to create some basic pipeline to extract data using `$match` and manipulate the output using `$project` stages.

The aggregation stages/operators covered in this video are:

* [`$match`](https://docs.mongodb.com/manual/reference/operator/aggregation/match/index.html)
* [`$project`](https://docs.mongodb.com/manual/reference/operator/aggregation/project/index.html)
* [`$concat`](https://docs.mongodb.com/manual/reference/operator/aggregation/concat/)

You can see the list of all the [available operators in the MongoDB docs](https://docs.mongodb.com/manual/reference/operator/aggregation/)


Find and Manipulate Data using Aggregation in MongoDB

In our last lesson, we learnt the basics of MongoDB aggregation and saw how we can [find and manipulate data](https://egghead.io/lessons/mongodb-find-and-manipulate-data-using-aggregation-in-mongodb). In this continuation, we will see how we can sort, skip and limit records during our aggregation stages.

The aggregation stages/operators covered in this video are:

* [`$sort`](https://docs.mongodb.com/manual/reference/operator/aggregation/sort/index.html)
* [`$skip`](https://docs.mongodb.com/manual/reference/operator/aggregation/skip/index.html)
* [`$limit`](https://docs.mongodb.com/manual/reference/operator/aggregation/limit/index.html)

You can see the list of all the [available operators in the MongoDB docs.](https://docs.mongodb.com/manual/reference/operator/aggregation/)

Sort, Skip and Limit Records in MongoDB Aggregation

Unlike the relational databases, MongoDB doesn't allow you to join collections using the simple `find` queries, but you can write the join queries using the aggregation framework. In this lesson, we learn how to join two collections to get the data in the format we want.

The aggregation operators that we cover in this video are:

- [`$lookup`](https://docs.mongodb.com/manual/reference/operator/aggregation/lookup/index.html)
- [`$project`](https://docs.mongodb.com/manual/reference/operator/aggregation/project/index.html)
- [`$arrayElemAt`](https://docs.mongodb.com/manual/reference/operator/aggregation/arrayElemAt/index.html)

You can see the list of all the [available operators in the MongoDB docs.](https://docs.mongodb.com/manual/reference/operator/aggregation/)

Write Joins in MongoDB

In this lesson, we learn how to group documents in a collection using `$group` operator similar to `GROUP BY` in SQL. We also look at `$sum` operator and see how we can use it to count the number of documents as well as get sum of some field in our grouped results.

Here is the list of operators that we cover in this lesson:

* [`$group`](https://docs.mongodb.com/manual/reference/operator/aggregation/group/index.html)
* [`$sum`](https://docs.mongodb.com/manual/reference/operator/aggregation/sum/index.html)
* [`$sort`](https://docs.mongodb.com/manual/reference/operator/aggregation/sort/index.html)

You can see the list of all the [available operators in the MongoDB docs](https://docs.mongodb.com/manual/reference/operator/aggregation/).


Group By and Sum in MongoDB

[In our last lesson](https://egghead.io/lessons/mongodb-group-by-and-sum-in-mongodb?pl=mongodb-aggregation-framework-3e5d), we saw how we can use `$group` operator to simulate `GROUP BY` operations that you might be aware from SQL. A minor gimmick with `$group` is that it only works with the scalar field values and not arrays. There might be times when you would want to group by some array fields; in this lesson, we learn how to do that using `$unwind` operator

Here is the list of operators that we cover in this lesson:

- [$unwind](https://docs.mongodb.com/manual/reference/operator/aggregation/unwind/index.html)
- [$group](https://docs.mongodb.com/manual/reference/operator/aggregation/group/index.html)
- [$sort](https://docs.mongodb.com/manual/reference/operator/aggregation/sort/index.html)
- [$limit](https://docs.mongodb.com/manual/reference/operator/aggregation/limit/index.html)

You can see the list of all the [available operators in the MongoDB docs](https://docs.mongodb.com/manual/reference/operator/aggregation/).


Perform Group Operations on Array Fields in MongoDB

JavaScript® (often shortened to JS) is a lightweight, interpreted, object-oriented language with first-class functions, most known as the scripting language for Web pages, but used in many non-browser environments as well such as node.js or Apache CouchDB. It is a prototype-based, multi-paradigm scripting language that is dynamic, and supports object-oriented, imperative, and functional programming styles.

javascript

Template literal types allow you to create dynamically typed strings. In this lesson, we learn how to further solidify your typings using the template literal types. They have the same syntax as template literal strings in JavaScript, but are used in type positions. When used with concrete literal types, a template literal produces a new string literal type by concatenating the contents.

```typescript
type World = "world";

// Greeting type can now only be assigned hello world
type Greeting = `hello ${World}`;
```

When a union is used in the interpolated position, the type is the set of every possible string literal that could be represented by each union member:

```typescript
type EmailLocaleIDs = "welcome_email" | "email_heading";
type FooterLocaleIDs = "footer_title" | "footer_sendoff";

// Possible values for this type: "welcome_email_id" | "email_heading_id" | "footer_title_id" | "footer_sendoff_id"
type AllLocaleIDs = `${EmailLocaleIDs | FooterLocaleIDs}_id`;
```

You can also read more about them in the [TypeScript documentation](https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html).

Create Dynamically Typed Strings Using Template Literal Types

Instead of manually creating the class properties and assigning them values in the constructor, TypeScript has a better way to let you create and assign values to class properties. All you have to do is prefix the constructor arguments with private or public, TypeScript will automatically create the class properties for the given argument name with the proper access specifier.

Create Class Properties using Constructor Assignment

`unknown` is the type-safe counterpart of the `any` type. The main difference between `unknown` and `any` is that with `any` you can do anything with the variable with the type set as `any`; while the variable with the type `unknown` only allows you to assign it the values and perform equality checks i.e. `===`, `==`, `!==` and `!=`, for any other operation, you must either create a type guard or specify the type using `val as SomeType`. 

You should prefer to use `unknown` over `any` whenever possible because it gives you the same flexibility of `any` when assigning values to the variables but you must specify the type while using the variable.

Avoid errors using unknown type

Record type allows you to create object types in a shorter way. Types for objects are normally defined in the below format:

```typescript
type UserDetailType = {
  name: string;
  age: string;
};

type Users = {
   [name: string]: UserDetailType
};
```

However, with the `Record` utility you can construct the same type as follows

```typescript
type UserDetailType = {
  name: string;
  age: string;
};

type Users = Record<string, UserDetailType>;
```

Create mapped types using Record type

TypeScript allows us to create reusable types called Generics i.e. creating types that can work as a variety of types. Let's say that we have a `Box` type which can hold different types of `content` i.e.

```typescript
type Box = {
   name: string;
   content: string;
}
```
In the above type, we can only store the `content` of the type `string`. Using generic types, we can modify our type as follows to allow storing different types of `content`.

```typescript
type Box<T> = {
   name: string;
   content: T;
}

// It can now be used as follows to store contents of type 
// string, number, boolean or any other type
type NumberBox = Box<number>;
type StringBox = Box<string>;
type BooleanBox = Box<boolean>;
```
In this lesson, we discuss how we can benefit from generic types to avoid duplicate types. You can also learn more about the [Generic types in the TypeScript docs](https://www.typescriptlang.org/docs/handbook/2/generics.html).


Reduce duplicate types with Generic Types

You can use the non-null assertion operator in TypeScript to take a typed variable and remove the `undefined` and `null` types from it. In this lesson, we look at different ways to work around the null/undefined typed values; including `as [type]` and the use of non-null assertion operator which is as simple as adding an exclamation mark to the end of any given variable while reading the value from it.

Ignore Null or Undefined Values with TypeScript Non-Null Assertion Operator

TypeScript can infer the type of a variable by looking at the data assigned to it. It also allows you to create a reusable type that it has inferred and later reuse it in your application. In this lesson, we look at the `typeof` operator and see how we can use it to create reusable types from data.

Create Type From Any Given Data in TypeScript

Bite-size video tutorials for badass web developers.

egghead

Data structures are the in-memory representation of the data. In this lesson, you will learn what the data structures are, why they are needed and what are the most common data structures.

Understand what are Data Structures

There might be times when you want to extend a type, i.e., to add new fields to it. Instead of copying the types and creating duplicates, the better way to do that is to use the intersection operator `&`. In this quick lesson, you will learn what it does and how you can use it to reduce duplicate types.

Topics

Instructors

Content Type

Kamran Ahmed