Skip to main content

How to Check if a Character is Uppercase or Lowercase in JavaScript

Validating or formatting the case of characters and strings is a fundamental task in programming. You might need to check if a password contains an uppercase letter, capitalize a user's name, or verify the case of the first letter of a sentence.

This guide will teach you the modern, standard methods for checking the case of a character in JavaScript. You will learn the robust comparison method that works for all Unicode characters and a simpler alternative using regular expressions for basic ASCII checks.

The Core Method: Comparing Against Case Conversions​

The most intuitive and robust way to check a character's case is to see what happens when you convert it. The logic is simple: if a character is already uppercase, converting it to uppercase will not change it.

The logic:

  • To check for uppercase: char === char.toUpperCase()
  • To check for lowercase: char === char.toLowerCase()

However, this simple check has a flaw: it returns true for characters that don't have a case, like numbers, symbols, or spaces.

'A'.toUpperCase() === 'A' // true (correct)
'a'.toUpperCase() === 'a' // false (correct)
'5'.toUpperCase() === '5' // true (incorrectly identified as uppercase)
'?'.toUpperCase() === '?' // true (incorrectly identified as uppercase)

The Robust Solution:

  • To fix this, we must add a second condition: the character must also be different from its lowercase equivalent. This correctly filters out symbols and numbers.
function isUpperCase(char) {
  return char === char.toUpperCase() && char !== char.toLowerCase();
}

function isLowerCase(char) {
  return char === char.toLowerCase() && char !== char.toUpperCase();
}

// Example Usage:
console.log(isUpperCase('A')); // Output: true
console.log(isUpperCase('a')); // Output: false
console.log(isUpperCase('5')); // Output: false
console.log(isUpperCase('?')); // Output: false

console.log(isLowerCase('b')); // Output: true
console.log(isLowerCase('B')); // Output: false
note

This method works correctly for all Unicode characters that have distinct upper and lower case forms.

An Alternative Method: Using Regular Expressions​

If you only need to check for standard English (ASCII) letters, a regular expression is a very concise alternative.

In the logic: we use the test() method of a regular expression to see if a character matches a specific pattern.

  • /[A-Z]/.test(char): Checks if the character is in the range A-Z.
  • /[a-z]/.test(char): Checks if the character is in the range a-z.

Solution:

function isUpperCase(char) {
  return /^[A-Z]$/.test(char);
}

function isLowerCase(char) {
  return /^[a-z]$/.test(char);
}
// Note: The ^ and $ anchors ensure the string contains ONLY one uppercase/lowercase character.
// For a simple check, `/[A-Z]/.test(char)` is sufficient.

// Example Usage:
console.log(isUpperCase('A')); // Output: true
console.log(isUpperCase('a')); // Output: false
console.log(isUpperCase('5')); // Output: false
note

Important: This method is simpler but less robust than the comparison method, as it will not work for non-ASCII characters like Ä or é. For international applications, the comparison method is superior.

Use Case: Checking the First Letter of a String​

A common application of these checks is to validate the first character of a string. You can access the first character using bracket notation (str[0]) or the charAt(0) method.

Problem: we need to verify if a string starts with a capital letter.

// Problem: Does this string start with an uppercase letter?
const myString = 'Hello, world!';

Solution:

function startsWithUppercase(str) {
  if (str.length === 0) {
    return false; // Handle empty string case
  }
  const firstChar = str[0];
  return firstChar === firstChar.toUpperCase() && firstChar !== firstChar.toLowerCase();
}

// Example Usage:
console.log(startsWithUppercase('Hello')); // Output: true
console.log(startsWithUppercase('hello')); // Output: false
console.log(startsWithUppercase('123 Hello')); // Output: false
note

This reuses our robust comparison logic to solve a specific, practical problem.

Once you can identify the first letter, capitalizing it is a simple matter of string manipulation.

The logic:

  1. Get the first character (str[0]) and convert it to uppercase.
  2. Get the rest of the string using the slice(1) method.
  3. Concatenate the two parts.

Solution:

function capitalizeFirstLetter(str) {
  if (str.length === 0) {
    return '';
  }
  return str[0].toUpperCase() + str.slice(1);
}

// Example Usage:
console.log(capitalizeFirstLetter('hello')); // Output: "Hello"
console.log(capitalizeFirstLetter('WORLD')); // Output: "WORLD"

This is a common and useful utility function for formatting names, sentences, and other text.

Conclusion​

Checking and manipulating character case is a fundamental skill in JavaScript.

  • The most robust method for checking if a character is uppercase or lowercase is to compare it against both its uppercase and lowercase conversions. This works for all Unicode characters and correctly ignores symbols and numbers.
  • For simple ASCII-only checks, a regular expression (/[A-Z]/.test(char)) offers a more concise alternative.
  • These core methods can be easily applied to specific use cases, such as validating the first letter of a string or capitalizing text.

Table of Contents