Four ways to check if a variable is a string in JavaScript (with examples)
Tags: beginners, tutorial, programming, javascript
Published: 2023-05-10 16:48:32

> ✋ **Update:** This post was originally published on my blog [decodingweb.dev](https://www.decodingweb.dev), where you can read the [latest version](https://www.decodingweb.dev/javascript-check-if-string) for a 💯 user experience. _~reza_

When working with strings in JavaScript, it’s important to check if a variable is a string before performing any string-related operations – specially when you get the value from an API . This quick guide explores four methods for checking if a variable is a string in JavaScript.

JavaScript is a [dynamically typed](https://www.decodingweb.dev/how-to-learn-a-programming-language#type-systems) language meaning the data type of a variable can change at runtime. That said, it’s essential to determine the data type of a variable before performing any operation on it, and string values are no exception.

## How to check if a variable is a string

In this section, we’ll explore four common approaches to checking whether a value is a string in JavaScript:

1. <u>Using typeof</u>
2. <u>Using Object.prototype.constructor.name</u>
3. <u>Using Object.prototype.toString.call(obj)</u>
4. <u>Using instanceof</u>

**1. Using typeof:** The `typeof` operator is the go-to method when testing data types. It simply returns a string value representing the data type of its operand. For instance, `typeof "hello"` returns `"string"`. 

This is how you can use `typeof` to test if a variable is a string:

```javascript
let str = 'hello';

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

In the above example, the variable `str` contains the string value `hello`, and the value returned by `typeof` confirms that.

The `typeof` operator only works with string literals, though. If your code, for some reason, contains string objects, you need to add more checks (more on this below).

**2. Using Object.prototype.constructor.name:** Every JavaScript object has a constructor property that refers to the constructor function that created it (e.g., `str.constructor`). 

This constructor has an attribute called `name`, which returns the function name (as a string) that created the respective object. 

In the case of string values, the function name is `String`. This work well with string literals as well as string objects:

```javascript
let str = 'hello';

if (str.constructor.name === 'String') {
  console.log('str is a string');
}
```

**3. Using Object.prototype.toString.call(obj):**  This method can be considered a detailed version of `typeof` because it returns the object type name when given an object.

The returned value is usually in the form of `[object Type]` where Type can be Array, String, Number, Function, etc.

Let's try it out with a string:

```javascript
let str = 'hello';

if (Object.prototype.toString.call(str) === '[object String]') {
  console.log('str is a string');
}
```

Just like `Object.prototype.constructor`, you can use this approach for both string literals and objects.

**4. Using instanceof:** This approach only works with string objects (e.g., `new String('test')`).

The `instanceof` checks if its first operand is an instance of its second operand. Or more precisely, it checks if an object's _prototype chain_ includes the prototype property of a constructor.

```javascript
let a = new String('test')

console.log(a instanceof String)
// Output true
```

Please note there is a difference between primitive strings (a.k.a string literals) and String objects.

A string literal (wrapped in single/double quotation marks) is a primitive value. String values created via calling the `String` function **without** using the new keyword are primitive strings too.

```javascript
let a = 'test'
let b = String('test')
let c = new String('test')

console.log(a === b)
// Output: true

console.log(a === c)
// Output: false

console.log(b === c)
// Output: false
```

That said, `instanceof` doesn't work with string literals.

Defining a string value by using the `String` as a constructor (`new String('text')`) is discouraged by many developers, as it's almost useless. You should rarely find yourself using String as a constructor.

Then, why should I even consider this approach? You may ask.

Well, there's one scenario you might want to use `instanceof` to check strings in JavaScript, and that's when you need to create a universal utility function that works with all string types - no matter how they are defined:

```javascript
function isString(value) {
return typeof value === 'string' || value instanceof String
}
```

You can use `constructor.name`, or `toString.call(obj)` to achieve the same result.

## Wrapping up

In this article, we have discussed four different approaches to checking if a variable is a string in JavaScript. The most common approach is to use `typeof` to test if the value is string. And if your code contains both string literals and objects, you can use `typeof` in conjunction with `instanceof`.

Alternatively, you can use `constructor.name`, or `toString.call(obj)` to get the class constructor name that created the string value.

Alright! I think it does it for today! I hope you found this quick guide helpful.

Thanks for reading.