The other answers are right, but when you're dealing with interfaces you cannot use typeof or instanceof because interfaces don't get compiled to javascript.

Instead you can use a typecast + function check typeguard to check your variable:

interface Car {
    drive(): void;
    honkTheHorn(): void;
}

interface Bike {
    drive(): void;
    ringTheBell(): void;
}

function start(vehicle: Bike | Car ) {
    vehicle.drive();

    // typecast and check if the function exists
    if ((<Bike>vehicle).ringTheBell) {
        const bike = (<Bike>vehicle);
        bike.ringTheBell();
    } else {
        const car = (<Car>vehicle);
        car.honkTheHorn();
    }
}

And this is the compiled JavaScript in ES2017:

function start(vehicle) {
    vehicle.drive();
    if (vehicle.ringTheBell) {
        const bike = vehicle;
        bike.ringTheBell();
    }
    else {
        const car = vehicle;
        car.honkTheHorn();
    }
}

I'd like to add that TypeGuards only work on strings or numbers, if you want to compare an object use instanceof

if(task.id instanceof UUID) {
  //foo
}

I suspect you can adjust your approach a little and use something along the lines of the example here:

https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates

function isFish(pet: Fish | Bird): pet is Fish {
  return (pet as Fish).swim !== undefined;
}

I have checked a variable if it is a boolean or not as below

console.log(isBoolean(this.myVariable));

Similarly we have

isNumber(this.myVariable);
isString(this.myvariable);

and so on.

Type guards in typescript

To determine the type of a variable after a conditional statement you can use type guards. A type guard in typescript is the following:

An expression which allows you to narrow down the type of something within a conditional block.

In other words it is an expression within a conditional block from where the typescript compiler has enough information to narrow down the type. The type will be more specific within the block of the type guard because the compiler has inferred more information about the type.

Example

declare let abc: number | string;

// typeof abc === 'string' is a type guard
if (typeof abc === 'string') {
    // abc: string
    console.log('abc is a string here')
} else {
    // abc: number, only option because the previous type guard removed the option of string
    console.log('abc is a number here')
}

Besides the typeof operator there are built in type guards like instanceof, in and even your own type guards.

type of can be used for this

if (typeof abc === "number") {
    // number
} else if (typeof abc === "string"){
//string
}

since Typescript 4.4 you can do like bellow:

function foo(arg: unknown) {
    const argIsString = typeof arg === "string";
    if (argIsString) {
        console.log(arg.toUpperCase());
    }
}

Here's a way to do it if your variable's type is a union that includes multiple object interfaces that you want to decide between:

interface A {
  a: number;
}

interface B {
  b: boolean;
}

let x: string | A | B = /* ... */;

if (typeof x === 'string') {
  // x: string
} else if ('a' in x) {
  // x: A
} else if ('b' in x) {
  // x: B
}

If you want to make sure that you handled every option, you can add an exhaustiveness check. Once you've handled every option, TypeScript will notice that there are no remaining types the variable could possibly be at this point. It expresses this by giving it the never type.

If we add a final else branch that requires the variable to be the never type, we'll be proving to the type checker (and to ourselves) that this branch will never be called:

// As long as a variable never holds a type it's not supposed to,
// this function will never actually be called.
function exhaustiveCheck(param: never): never {
  throw Error('exhaustiveCheck got called somehow');
}

if (typeof x === 'string') {
  // x: string
} else if ('a' in x) {
  // x: A
} else if ('b' in x) {
  // x: B
} else {
  // x: never
  exhaustiveCheck(x);
}

If you forget to handle a case, you'll get a type error:

if (typeof x === 'string') {
  // x: string
} else if ('b' in x) {
  // x: B
} else {
  // x: A
  exhaustiveCheck(x); // TYPE ERROR: Argument of type 'A' is not
                      // assignable to parameter of type 'never'.
}

I have searched a lot how to check if my string variable is equal to my type and didn't found anything meaningful because any type of interface is not exist in runtime. So we need have this in runtime. There is solution that I figure out for my case.

type MyType = 'one'|'two';
function isMyType(val: string): val is MyType {
    const list:MyType[] = ['one','two'];
    return list.includes(val as MyType);
}
...
const incomingValue = 'one';
if(isMyType(incomingValue)) {
    // here typescript see incomingValue as MyType
}