language agnostic - शीर्षक मामले के लिए प्रारूप स्ट्रिंग

Here is a simple static method to do this in C#:

public static string ToTitleCaseInvariant(string targetString)
{
    return System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(targetString);
}

I would be wary of automatically upcasing all whitespace-preceded-words in scenarios where I would run the risk of attracting the fury of nitpickers.

I would at least consider implementing a dictionary for exception cases like articles and conjunctions. Behold:

"Beauty and the Beast"

And when it comes to proper nouns, the thing gets much uglier.

Here's a Perl solution http://daringfireball.net/2008/05/title_case

Here's a Ruby solution http://frankschmitt.org/projects/title-case

Here's a Ruby one-liner solution: http://snippets.dzone.com/posts/show/4702

'some string here'.gsub(/\b\w/){$&.upcase}

What the one-liner is doing is using a regular expression substitution of the first character of each word with the uppercase version of it.

To capatilise it in, say, C - use the ascii codes (http://www.asciitable.com/) to find the integer value of the char and subtract 32 from it.

This is a poor solution if you ever plan to accept characters beyond a-z and A-Z.

For instance: ASCII 134: å, ASCII 143: Å.
Using arithmetic gets you: ASCII 102: f

Use library calls, don't assume you can use integer arithmetic on your characters to get back something useful. Unicode is tricky.

In Silverlight there is no ToTitleCase in the TextInfo class.

Here's a simple regex based way.

Note: Silverlight doesn't have precompiled regexes, but for me this performance loss is not an issue.

    public string TitleCase(string str)
    {
        return Regex.Replace(str, @"\w+", (m) =>
        {
            string tmp = m.Value;
            return char.ToUpper(tmp[0]) + tmp.Substring(1, tmp.Length - 1).ToLower();
        });
    }

In Perl:

$string =~ s/(\w+)/\u\L$1/g;

That's even in the FAQ.

If the language you are using has a supported method/function then just use that (as in the C# ToTitleCase method)

If it does not, then you will want to do something like the following:

1. Read in the string
2. Take the first word
3. Capitalize the first letter of that word ¹
4. Go forward and find the next word
5. Go to 3 if not at the end of the string, otherwise exit

¹ To capitalize it in, say, C - use the ascii codes to find the integer value of the char and subtract 32 from it.

There would need to be much more error checking in the code (ensuring valid letters etc.), and the "Capitalize" function will need to impose some sort of "title-case scheme" on the letters to check for words that do not need to be capatilised ('and', 'but' etc. Here is a good scheme)

In what language?

In PHP it is:

ucwords()

example:

$HelloWorld = ucwords('hello world');

In Java, you can use the following code.

public String titleCase(String str) {
    char[] chars = str.toCharArray();
    for (int i = 0; i < chars.length; i++) {
        if (i == 0) {
            chars[i] = Character.toUpperCase(chars[i]);
        } else if ((i + 1) < chars.length && chars[i] == ' ') {
            chars[i + 1] = Character.toUpperCase(chars[i + 1]);
        }
    }
    return new String(chars);
}

Excel-like PROPER:

public static string ExcelProper(string s) {
    bool upper_needed = true;
    string result = "";
    foreach (char c in s) {
        bool is_letter = Char.IsLetter(c);
        if (is_letter)
            if (upper_needed)
                result += Char.ToUpper(c);
            else
                result += Char.ToLower(c);
        else
            result += c;
        upper_needed = !is_letter;
    }
    return result;
}

/out/aHR0cDovL3RpdGxlY2FzZS5jb20=/ has an API

There is a built-in formula PROPER(n) in Excel.

Was quite pleased to see I didn't have to write it myself!

Here's an implementation in Python: https://launchpad.net/titlecase.py

And a port of this implementation that I've just done in C++: http://codepad.org/RrfcsZzO

I think using the CultureInfo is not always reliable, this the the simple and handy way to manipulate string manually:

string sourceName = txtTextBox.Text.ToLower();
string destinationName = sourceName[0].ToUpper();

for (int i = 0; i < (sourceName.Length - 1); i++) {
  if (sourceName[i + 1] == "")  {
    destinationName += sourceName[i + 1];
  }
  else {
    destinationName += sourceName[i + 1];
  }
}
txtTextBox.Text = desinationName;

Here is a simple example of how to do it :

public static string ToTitleCaseInvariant(string str)
{
    return System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(str);
}

Without using a ready-made function, a super-simple low-level algorithm to convert a string to title case:

convert first character to uppercase.
for each character in string,
    if the previous character is whitespace,
        convert character to uppercase.

This asssumes the "convert character to uppercase" will do that correctly regardless of whether or not the character is case-sensitive (e.g., '+').

Here you have a C++ version. It's got a set of non uppercaseable words like prononuns and prepositions. However, I would not recommend automating this process if you are to deal with important texts.

#include <iostream>
#include <string>
#include <vector>
#include <cctype>
#include <set>

using namespace std;

typedef vector<pair<string, int> > subDivision;
set<string> nonUpperCaseAble;

subDivision split(string & cadena, string delim = " "){
    subDivision retorno;
    int pos, inic = 0;
    while((pos = cadena.find_first_of(delim, inic)) != cadena.npos){
        if(pos-inic > 0){
            retorno.push_back(make_pair(cadena.substr(inic, pos-inic), inic));
        }
        inic = pos+1;
    }
    if(inic != cadena.length()){
        retorno.push_back(make_pair(cadena.substr(inic, cadena.length() - inic), inic));
    }
    return retorno;
}

string firstUpper (string & pal){
    pal[0] = toupper(pal[0]);
    return pal;
}

int main()
{
    nonUpperCaseAble.insert("the");
    nonUpperCaseAble.insert("of");
    nonUpperCaseAble.insert("in");
    // ...

    string linea, resultado;
    cout << "Type the line you want to convert: " << endl;
    getline(cin, linea);

    subDivision trozos = split(linea);
    for(int i = 0; i < trozos.size(); i++){
        if(trozos[i].second == 0)
        {
            resultado += firstUpper(trozos[i].first);
        }
        else if (linea[trozos[i].second-1] == ' ')
        {
            if(nonUpperCaseAble.find(trozos[i].first) == nonUpperCaseAble.end())
            {
                resultado += " " + firstUpper(trozos[i].first);
            }else{
                resultado += " " + trozos[i].first;
            }
        }
        else
        {
            resultado += trozos[i].first;
        }       
    }

    cout << resultado << endl;
    getchar();
    return 0;
}

With perl you could do this:

my $tc_string = join ' ', map { ucfirst($\_) } split /\s+/, $string;