Type Guards in TypeScript

Remember to consider the specific characteristics of your code and the requirements for number manipulation when choosing the most appropriate operator for performing right shifts.

There are several ways to implement type guards in TypeScript, each suitable for different situations. Below, I will explain some of the main approaches.

1) 'typeof': The 'typeof' operator is used to check the primitive type of a variable. For example:

function processData(data: string | number) { 
    if (typeof data === 'string') { 
         //  Manipulating data as a string
         console.log(data.toUpperCase()); 
     } else { 
         // Manipulating data as a number
         console.log(data.toFixed(2)); 
     } 
}

In this example, the 'typeof data === "string"' is a type guard that checks if the variable 'data' is of type 'string'. If the condition is true, the code block inside the 'if' will be executed with the assurance that 'data' is a string.

2) 'instanceof': The 'instanceof' operator is used to check if an object is an instance of a specific class. For example:

class Animal { 
    name: string; 
     constructor(name: string) { 
         this.name = name; 
    } 
} 
class Dog extends Animal { 
    bark() { 
        console.log('Woof!'); 
    } 
} 
class Cat extends Animal {
    meow() { 
        console.log('Meow!'); 
    } 
} 
function processAnimal(animal: Animal) { 
    if (animal instanceof Dog) { 
         // Manipulate object as a dog animal.
        bark(); 
    } else if (animal instanceof Cat) { 
        // Manipulate object as a cat.
         animal. Meow(); 
    } else { 
        console.log('Unknown animal!'); 
    } 
}

In this example, 'animal instanceof Dog' and 'animal instanceof Cat' are type guards that check if 'animal' is an instance of 'Dog' or 'Cat', respectively. Depending on the type, the code inside the appropriate conditional block will be executed.

3) 'in': The 'in' operator is used to check if a property exists in an object. For example:

interface Circle {
      kind: 'circle';
      radius: number;
}
interface Square {
      kind: 'square';
      sideLength: number;
}
type Shape = Circle | Square;
function calculateArea(shape: Shape) {
      if ('radius' in shape) {
            // Manipulate shape as a circle
            const area = Math.PI * shape.radius ** 2;
            console.log(`Circle area: ${area.toFixed(2)}`);
      } else if ('sideLength' in shape) {
            // Manipulate shape as a square
            const area = shape.sideLength ** 2;
            console.log(`Square area: ${area.toFixed(2)}`);
      }
}

In this example, '"radius" in shape' and '"sideLength" in shape' are type guards that check if the 'radius' or 'sideLength' property exists in the 'shape' object. Depending on the check, the code inside the corresponding conditional block will be executed.

These are just a few of the common approaches to type guards in TypeScript. There are other techniques, such as using discriminated unions and user-defined type guards, that allow checking and refining types in more complex ways. Type guards are a powerful tool for dealing with types at runtime and help in writing safer and more expressive code in TypeScript.