DEV Community: Yash Desai

Exploring the Power of TypeScript Utility Types

Yash Desai — Fri, 04 Aug 2023 15:18:28 +0000

Introduction

TypeScript, an open-source language built on top of JavaScript, brings static typing and advanced type-checking capabilities to the world of web development. One of the most powerful features of TypeScript is its utility types, which enable developers to manipulate and transform types in clever and concise ways. In this blog, we'll dive into TypeScript utility types and explore how they can streamline our code and make it more maintainable and robust.

Understanding TypeScript Utility Types

TypeScript utility types are predefined type transformations provided by the language. These utilities act as building blocks that allow developers to perform common type manipulations without reinventing the wheel. They are accessible without any additional setup or installation and can be used out of the box.

Some of the popular TypeScript utility types include Partial, Required, Readonly, Pick, Omit, Record, Exclude, Extract, NonNullable, and many more. Each utility serves a specific purpose, and combining them can lead to powerful type compositions.

Examples of TypeScript Utility Types

Partial and Required: Partial allows us to mark all properties of an interface as optional, while Required does the opposite by making all properties required.

   interface User {
     name: string;
     age: number;
   }

   type PartialUser = Partial<User>;
   // { name?: string; age?: number; }

   type RequiredUser = Required<User>;
   // { name: string; age: number; }

2.
Pick and Omit:
Pick allows us to select specific properties from an interface, while Omit lets us exclude certain properties.

type PartialUser = Pick<User, 'name'>;
// { name: string; }

type UserWithoutAge = Omit<User, 'age'>;
// { name: string; }

3.
Record:
Record constructs a new type with specified keys and a given value type.

type UserProfile = Record<'username' | 'email', string>;
// { username: string; email: string; }

Practical Applications

API Responses: When dealing with API responses, utility types like Partial and Required can help create consistent interfaces to handle both optional and mandatory data from the server.
Form Validation: In form validation scenarios, TypeScript utility types can be used to represent form inputs and their validation rules.
Redux State Management: When managing state in Redux or similar libraries, TypeScript utility types like Pick, Omit, and Record can help define actions and reducers with strong typing.

Conclusion

TypeScript utility types are a treasure trove for developers seeking to enhance their codebase's type safety, maintainability, and productivity. By using these predefined type transformations, we can streamline our development process, reduce errors, and make our code more self-documenting.

As TypeScript continues to evolve, new utility types and improvements are likely to emerge, so staying updated with the latest features can provide even more powerful tools for type manipulation. So, leverage the power of TypeScript utility types and take your TypeScript coding to the next level!

TypeScript Handbook - Utility Types: TypeScript Handbook - Utility Types

Do you often use border property to figure out and focus elements in CSS

Yash Desai — Sun, 11 Apr 2021 15:29:41 +0000

Are you bored to type border: 1px solid red; each time to figure out some elements or to debug them?

Now all you need to just add a class ? at the end of your element's class list, that's it.

Add this tag into your <head> tag

<link rel="stylesheet"
href="https://cdn.jsdelivr.net/gh/YashDDesai/question-mark-css@2.0.0/question-mark.css"
/>

now, just add a class ? at the end of your element's class list

for example:

<div class="h-36 w-36 bg-green-100 ?">
  <!-- to-do -->
</div>

Need more colors!

Border Color	class
Red (default)	?
Green	?g
Blue	?b
Purple	?p
Yellow	?y
White	?w

Dynamic Memory Allocation for NxM (2D) Array Using Pointer | C++

Yash Desai — Wed, 06 Jan 2021 17:59:36 +0000

Define `class MxN_matrix`

#include <iostream>
using namespace std;

class MxN_Matrix
{
    int row, col;
    int *Matrix;

public:
    MxN_Matrix()
    {
        row = 0;
        col = 0;
    }
    ~MxN_Matrix()
    {
        // deallocate memory
        delete[] Matrix;
    }
    void create(int row, int col);

    void print();
};

`void create(int row, int col)`

void MxN_Matrix::create(int row, int col)
{
    this->row = row;
    this->col = col;

    // Dynamically allocate memory of size row*col
    Matrix = new int[row * col];

    // assign values to allocated memory
    for (int i = 0; i < row; i++)
        for (int j = 0; j < col; j++)
        {
            cout << "row = " << i << " col = " << j << ": ";
            cin >> *(Matrix + i * col + j);
        }
}

`void print()`

void MxN_Matrix::print()
{
    cout << "\nMatrix" << endl;
    // print the matrix
    for (int i = 0; i < row; i++)
    {
        for (int j = 0; j < col; j++)
            cout << *(Matrix + i * col + j) << "\t"; // or (Matrix + i*col)[j])

        cout << endl;
    }
}

`int main()`

int main()
{
    MxN_Matrix *matrix = new MxN_Matrix();

    matrix->create(2, 3);

    matrix->print();

    delete matrix; // deallocate memory

    return 0;
}

Also available on YouTube

I/O Stream or Shift Operators Overloading | C++

Yash Desai — Wed, 06 Jan 2021 13:55:36 +0000

The `Data` class

#include <iostream>
using namespace std;

class Data
{
private:
    int n, m;
public:
    Data() { n = 0; m = 0; }
    Data(int n, int m) { this->n = n; this->m = m; }

    //stuff for ostream operator << ...
    //stuff for istream operator >> ...
};

Inside "Data" class...

    friend ostream &operator<<(ostream &myout, Data &data)
    {
        myout << "n: " << data.n << " m: " << data.m << endl;
        return myout;
    }
    friend istream &operator>>(istream &myin, Data &data)
    {
        myin >> data.n;
        myin >> data.m;

        return myin;
    }

Now the `main()`

int main()
{
    Data data(5, 7);
    Data data1;

    cout << data;

    cin >> data1;

    cout << data1;

    return 0;
}

Output

Also available on YouTube

++ Operator Overloading for a Matrix using Friend function in C++

Yash Desai — Wed, 06 Jan 2021 09:11:53 +0000

Define a class named "Matrix"

#include <iostream>
using namespace std;

class Matrix
{
private:
    int numbers[3][3];

public:
    void setNumbers(int n[][3]);
    void getNumbers();

    friend Matrix operator++(Matrix);
};

Implement `void setNumbers(int n[][3])`

void Matrix::setNumbers(int n[][3])
{
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            numbers[i][j] = n[i][j];
        }
    }
}

Implement `void getNumbers()`

void Matrix::getNumbers()
{
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            cout << numbers[i][j] << "\t";
        }
        cout << endl;
    }
    cout << endl;
}

Implement `Matrix operator++(Matrix n)`

Matrix operator++(Matrix n)
{
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            n.numbers[i][j] = ++(n.numbers[i][j]);
        }
    }
    return n;
}

Implement `int main()`

int main()
{

    Matrix matrix;
    int numbers[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9},
    };

    matrix.setNumbers(numbers);
    matrix.getNumbers();

    matrix = ++matrix;

    matrix.getNumbers();

    return 0;
}

Available on YouTube

Stack Implementation in C

Yash Desai — Fri, 25 Dec 2020 18:02:57 +0000

We need these header files...

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>

Let's define some constants...

// constants
#define MAX 5              // Max capacity of a stack
#define ERR "\x1B[31m"     // Error Color
#define SUCCESS "\x1B[32m" // Success Color
#define RESET "\033[0m"    // Reset Color

Constants defined in above lines of code such as `ERR`,`SUCCESS` and `RESET` will be used to color the text of `printf()`. `MAX` defines the maximum capacity of the stack

Now we'll declare a stack...

//declaration of stack
typedef struct stack
{
    int entry[MAX];
    int top;
} stack;

Initialization of stack

//stack initialization
void init(stack *sptr)
{
    sptr->top = 0;
}

A function to check if Stack is empty...

//checking stack is empty or not.
int isEmpty(stack *sptr)
{
    if (sptr->top == 0)
        return (1);
    else
        return (0);
}

A function to check if stack is overflowed...

//checking stack is full or not.
int isFull(stack *sptr)
{
    if (sptr->top == MAX)
        return (1);
    else
        return (0);
}

A function to push/insert a new element into the stack...

//Inserting element into stack
void push(stack *sptr)
{
    int item;
    if (isFull(sptr))
        printf(ERR "\tSTACK IS FULL" RESET);
    else
    {
        printf("\n\tEnter the element: ");
        scanf("%d", &item);
        sptr->entry[sptr->top] = item;
        sptr->top++;
    }
}

A function to pop/remove elements from the stack...

//Deleting element from the stack
void pop(stack *sptr)
{
    int item;

    if (isEmpty(sptr))
        printf(ERR "\tSTACK IS EMPTY" RESET);
    else
    {
        sptr->top--;
        item = (sptr->entry[sptr->top]);
        printf(SUCCESS "\t%d HAS BEEN REMOVED" RESET, item);
    }
}

A function to traverse though the stack or print all the elements of the stack

//Traversing the elements of stack
void traverse(stack *sptr)
{
    if (isEmpty(sptr))
        printf(ERR "\tSTACK IS EMPTY" RESET);
    else
    {
        int i;

        for (i = sptr->top - 1; i >= 0; i--)
            printf("\t-> %d\n", sptr->entry[i]);
    }
}

And finally the `main()` function...

int main()
{
    stack s;
    int choice;

    init(&s);

    do
    {
        printf("\n 1. PUSH");
        printf("\n 2. POP");
        printf("\n 3. TRAVERSE");
        printf("\n 4. EXIT");
        printf("\n\nEnter the choice: ");
        scanf(" %d", &choice);
        switch (choice)
        {
        case 1:
            push(&s);
            break;
        case 2:
            pop(&s);
            break;
        case 3:
            traverse(&s);
            break;
        case 4:
            exit(0);
            break;
        default:
            printf(ERR "\tWRONG CHOICE" RESET);
        }
    } while (1);

    return 0;
    getch();
}

Output

Pushed 5 elements to the stack. `(max capacity=5)`

Removed two elements from the stack

Removed all elements until the stack is empty

Enjoy :)

Binary Search (Recursively) in Java

Yash Desai — Wed, 23 Dec 2020 17:40:16 +0000

Create a method `binarySearch()` inside `BinarySearch` class

public class BinarySearch {

    int binarySearch(int arr[], int left, int right, int key) {
       //todo
    }
}

    int binarySearch(int arr[], int left, int right, int key) {
       if (right >= left) {
            int middle = left + (right - 1) / 2;

            //todo
        }
    }

    int binarySearch(int arr[], int left, int right, int key) {
       if (right >= left) {
            int middle = left + (right - 1) / 2;

            if (arr[middle] == key) {
                return middle;
            }
            //todo
        }
    }

    int binarySearch(int arr[], int left, int right, int key) {
       if (right >= left) {
            int middle = left + (right - 1) / 2;

            if (arr[middle] == key) {
                return middle;
            }
            if (arr[middle] > key) {
                return binarySearch(arr, left, middle - 1, key);
            }
            //todo
        }
    }

    int binarySearch(int arr[], int left, int right, int key) {
       if (right >= left) {
            int middle = left + (right - 1) / 2;

            if (arr[middle] == key) {
                return middle;
            }
            if (arr[middle] > key) {
                return binarySearch(arr, left, middle - 1, key);
            }
            return binarySearch(arr, middle + 1, right, key);

            //todo
       }
    }

    int binarySearch(int arr[], int left, int right, int key) {
       if (right >= left) {
            int middle = left + (right - 1) / 2;

            if (arr[middle] == key) {
                return middle;
            }
            if (arr[middle] > key) {
                return binarySearch(arr, left, middle - 1, key);
            }
            return binarySearch(arr, middle + 1, right, key);
       }
        return -1;
    }

`main` method...

    public static void main(String[] args) throws Exception {
        int arr[] = { 0, 5, 7, 12, 45, 53 };
        int key = -3;
        BinarySearch bs = new BinarySearch();

        int index = bs.binarySearch(arr, 0, arr.length - 1, key);

        if (index == -1) {
            System.out.println("" + key + " not found");
        } else {
            System.out.println("" + key + " found at " + index);
        }

    }

Final Code...

public class BinarySearch {

    int binarySearch(int arr[], int left, int right, int key) {
        if (right >= left) {
            int middle = left + (right - 1) / 2;

            if (arr[middle] == key) {
                return middle;
            }
            if (arr[middle] > key) {
                return binarySearch(arr, left, middle - 1, key);
            }

            return binarySearch(arr, middle + 1, right, key);
        }

        return -1;
    }

    public static void main(String[] args) throws Exception {
        int arr[] = { 0, 5, 7, 12, 45, 53 };
        int key = -3;
        BinarySearch bs = new BinarySearch();

        int index = bs.binarySearch(arr, 0, arr.length - 1, key);

        if (index == -1) {
            System.out.println("" + key + " not found");
        } else {
            System.out.println("" + key + " found at " + index);
        }

    }
}

Watch Full video on YouTube

How to write C/C++ Code in VS Code?

Yash Desai — Wed, 09 Dec 2020 04:06:05 +0000

Install VS Code

Click here to download the latest version of VS Code.

Install VS Code extension for C/C++

Click here to install latest version of extension for c/c++

OR

You can directly install it from VS Code extension menu.

To compile and Debug your C/C++ code you need to install compiler. Here I'm using GCC Compiler with Mingw, so we need to install Mingw-w64

DEV Community: Yash Desai

Exploring the Power of TypeScript Utility Types

Introduction

Understanding TypeScript Utility Types

Examples of TypeScript Utility Types

Practical Applications

Conclusion

Do you often use border property to figure out and focus elements in CSS

Need more colors!

Dynamic Memory Allocation for NxM (2D) Array Using Pointer | C++

Define class MxN_matrix

void create(int row, int col)

void print()

int main()

I/O Stream or Shift Operators Overloading | C++

The Data class

Inside "Data" class...

Now the main()

Output

++ Operator Overloading for a Matrix using Friend function in C++

Define a class named "Matrix"

Implement void setNumbers(int n[][3])

Implement void getNumbers()

Implement Matrix operator++(Matrix n)

Implement int main()

Stack Implementation in C

We need these header files...

Let's define some constants...

Constants defined in above lines of code such as ERR,SUCCESS and RESET will be used to color the text of printf(). MAX defines the maximum capacity of the stack

Now we'll declare a stack...

Initialization of stack

A function to check if Stack is empty...

A function to check if stack is overflowed...

A function to push/insert a new element into the stack...

A function to pop/remove elements from the stack...

A function to traverse though the stack or print all the elements of the stack

And finally the main() function...

Output

Pushed 5 elements to the stack. (max capacity=5)

Removed two elements from the stack

Removed all elements until the stack is empty

Enjoy :)

Binary Search (Recursively) in Java

Create a method binarySearch() inside BinarySearch class

main method...

Final Code...

Watch Full video on YouTube

How to write C/C++ Code in VS Code?

Install VS Code

Install VS Code extension for C/C++

OR

Define `class MxN_matrix`

`void create(int row, int col)`

`void print()`

`int main()`

The `Data` class

Now the `main()`

Implement `void setNumbers(int n[][3])`

Implement `void getNumbers()`

Implement `Matrix operator++(Matrix n)`

Implement `int main()`

Constants defined in above lines of code such as `ERR`,`SUCCESS` and `RESET` will be used to color the text of `printf()`. `MAX` defines the maximum capacity of the stack

And finally the `main()` function...

Pushed 5 elements to the stack. `(max capacity=5)`

Create a method `binarySearch()` inside `BinarySearch` class

`main` method...