cyberangles blog

Google Case of a Given Sentence

In the world of text manipulation and data formatting, the "Google case" (also known as "sentence case" or "title case with some exceptions") is a common requirement. It refers to a style where the first letter of each word in a sentence is capitalized, except for certain small words like "the", "and", "of", "a", etc. (depending on the specific rules you follow). This blog post will delve into how to achieve the Google case for a given sentence, covering common practices, best practices, and providing example usage.

2026-07

Table of Contents#

  1. Understanding the Basics of Google Case
  2. Common Practices in Implementing Google Case
  3. Best Practices for Google Case
  4. Example Usage in Different Programming Languages
    • Python
    • JavaScript
    • Java
  5. References

1. Understanding the Basics of Google Case#

The core idea of Google case is to make text look more presentable and follow a standard for headings, titles, etc. in a way that is easy to read. For example, the sentence "the quick brown fox jumps over the lazy dog" in Google case would become "The Quick Brown Fox Jumps Over the Lazy Dog". The key is to identify which words should be capitalized and which should remain in lowercase.

2. Common Practices in Implementing Google Case#

  • Splitting the Sentence: First, split the input sentence into individual words. This can be done using string splitting functions available in most programming languages (e.g., split() in Python, JavaScript, and Java).
  • Defining the List of Small Words: Maintain a list of words (like "the", "and", "or", "a", "an", "of", "in", "on", etc.) that should not be capitalized (except when they are the first word of the sentence).
  • Capitalizing Words: For each word in the split sentence, check if it's in the list of small words. If it's the first word, always capitalize it. For non - first words, only capitalize if it's not in the small word list.

3. Best Practices for Google Case#

  • Case Insensitivity: When checking if a word is in the small word list, make sure the comparison is case - insensitive. For example, in Python, you can convert both the word and the elements in the small word list to lowercase for comparison.
  • Edge Cases Handling:
    • Empty Sentences: Handle the case when the input sentence is empty gracefully (return an empty string).
    • Single - Word Sentences: Capitalize the single word if it's not a small word (but if it is a small word, still capitalize it as it's the only word).
    • Punctuation: Decide how to handle punctuation. For example, should a sentence like "hello, world!" be processed as "Hello, World!"? In most cases, it's better to process the text before punctuation (split on non - alphanumeric characters if needed).

4. Example Usage in Different Programming Languages#

Python#

def google_case(sentence):
    small_words = ["the", "and", "or", "a", "an", "of", "in", "on", "at", "to"]
    words = sentence.split()
    if not words:
        return ""
    result = [words[0].capitalize()]
    for word in words[1:]:
        lowercase_word = word.lower()
        if lowercase_word not in small_words:
            result.append(word.capitalize())
        else:
            result.append(lowercase_word)
    return " ".join(result)
 
 
# Example usage
sentence = "the quick brown fox jumps over the lazy dog"
print(google_case(sentence))

JavaScript#

function googleCase(sentence) {
    const smallWords = ["the", "and", "or", "a", "an", "of", "in", "on", "at", "to"];
    const words = sentence.split(' ');
    if (words.length === 0) {
        return "";
    }
    let result = [words[0].charAt(0).toUpperCase() + words[0].slice(1).toLowerCase()];
    for (let i = 1; i < words.length; i++) {
        let word = words[i];
        let lowercaseWord = word.toLowerCase();
        if (smallWords.includes(lowercaseWord)) {
            result.push(lowercaseWord);
        } else {
            result.push(word.charAt(0).toUpperCase() + word.slice(1).toLowerCase());
        }
    }
    return result.join(' ');
}
 
// Example usage
let sentence = "the quick brown fox jumps over the lazy dog";
console.log(googleCase(sentence));

Java#

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
 
public class GoogleCase {
    public static String googleCase(String sentence) {
        List<String> smallWords = Arrays.asList("the", "and", "or", "a", "an", "of", "in", "on", "at", "to");
        String[] words = sentence.split(" ");
        if (words.length == 0) {
            return "";
        }
        List<String> result = new ArrayList<>();
        result.add(words[0].substring(0, 1).toUpperCase() + words[0].substring(1).toLowerCase());
        for (int i = 1; i < words.length; i++) {
            String word = words[i];
            String lowercaseWord = word.toLowerCase();
            if (smallWords.contains(lowercaseWord)) {
                result.add(lowercaseWord);
            } else {
                result.add(word.substring(0, 1).toUpperCase() + word.substring(1).toLowerCase());
            }
        }
        return String.join(" ", result);
    }
 
    public static void main(String[] args) {
        String sentence = "the quick brown fox jumps over the lazy dog";
        System.out.println(googleCase(sentence));
    }
}

5. References#