What Is The Usage Of Typeof In Javascript?

typeof returns the primitive data type but I am not getting why it is used in javascript?

Solution 1:

I am not getting why it is used in javascript?

typeof is used to

return[s] the primitive data

For example, if I wanted to know if something was undefined, I could do

if (typeofobject === 'undefined')

to check because if it is undefined there is no datatype (because it's undefined). This is generally why typeof would be used other than for logging purposes, to see what is received through ajax, or for making functions that accept a parameter that can have different types and checking that type with typeof, etc.

Solution 2:

typeof is an unary operator that is placed before a single operand which can be of any type. Its value is a string that specifies the type of operand.

   - x                             typeof x

   undefined"undefined"null"object"true or false"boolean"anynumber or NaN                "number"anystring"string"anyfunction"function"any non function native object"object"

The typeof works sufficiently well with primitive values except null.typeof cannot distinguish between null & object because null is falsy & objects are truthy.Here are few case studies which may be useful. typeof evaluates to object for all object and array values other than function.How typeof deals with function is probably beyond the scope of this question.

Hope this will help you.

Solution 3:

The typeof operator returns a string which represents the type of the operand. We can use this to check the type of a value in the following manner:

let nr = 5;

if (typeof nr === 'number') {
  console.log('nr is number');
}


let str = 'hi';

if (typeof str === 'string') {
  console.log('str is string');
}

This can be especially useful when a variable can have multiple values. For example, null, undefined, or a number. In this case we can use the typeof operator in conjunction with an if statement in order to execute the right code for a given scenario.

Solution 4:

You can use the JavaScript typeof operator to find the type of a JavaScript variable. It is also use to validate a variable or input.Explain better => http://www.w3schools.com/js/js_datatypes.aspExample typeof "John" // Returns string typeof 3.14 // Returns number typeof false // Returns boolean typeof [1,2,3,4] // Returns object typeof {name :'John', age:34} // Returns object

Solution 5:

typeof in javascript why it is used?

Sometimes you might need to check what kind of data is stored in a variable for example, typeof is an operator not a function and it's completely different from the return statement that stops the execution of a function and returns a value from that function.

The typeof operator returns a string indicating the type of the unevaluated operand.

console.log(typeof'name');
// expected output: "string"console.log(typeof74);
// expected output: "number"console.log(typeoftrue);
// expected output: "boolean"console.log(typeof declaredButUndefinedVariable);
// expected output: "undefined";

typeof MDN web docs

The typeof operator is always followed by its operand:

typeof UnaryExpression => keep in mind that parentheses are optional but remember that: Parentheses are very useful to determine the data type for expressions.

vardata = 100;
typeof data + ' Bye'; // return 'number Bye'
typeof (data + 'Bye'); // return 'string'

Other examples:

// Numberstypeof37 === 'number';
typeof3.14 === 'number';
typeof(42) === 'number';
typeofMath.LN2 === 'number';
typeofInfinity === 'number';
typeofNaN === 'number'; // Despite being "Not-A-Number"typeofNumber('1') === 'number'; // Number tries to parse things into numbers// Stringstypeof'' === 'string';
typeof'bla' === 'string';
typeof`template literal` === 'string';
typeof'1' === 'string'; // note that a number within a string is still typeof stringtypeof (typeof1) === 'string'; // typeof always returns a stringtypeofString(1) === 'string'; // String converts anything into a string, safer than toString// Booleanstypeoftrue === 'boolean';
typeoffalse === 'boolean';
typeofBoolean(1) === 'boolean'; // Boolean will convert values based on if they're truthy or falsy, equivalent to !!// SymbolstypeofSymbol() === 'symbol'typeofSymbol('foo') === 'symbol'typeofSymbol.iterator === 'symbol'// Undefinedtypeofundefined === 'undefined';
typeof declaredButUndefinedVariable === 'undefined';
typeof undeclaredVariable === 'undefined'; 


// Objectstypeof {a: 1} === 'object';

// use Array.isArray or Object.prototype.toString.call// to differentiate regular objects from arraystypeof [1, 2, 4] === 'object';

typeofnewDate() === 'object';
typeof /regex/ === 'object'; // See Regular expressions section for historical results