मैं C # में प्रथम नाम और अंतिम नाम के पहले अक्षर को कैसे बड़ा करूं?

Question

क्या एक स्ट्रिंग के पहले अक्षर को कैपिटल करने और उसके बाकी हिस्सों को कम करने का एक आसान तरीका है? वहाँ एक विधि में बनाया गया है या मुझे अपना खुद का बनाने की आवश्यकता है?

Comments

मुझे आपके विशेष एप्लिकेशन के बारे में कुछ नहीं पता है, लेकिन मुझे लगता है कि एक सामान्य चेतावनी यह है: प्रोग्रामर इस पद्धति को वास्तविक नामों पर लागू नहीं करना चाहिए। मुझे लगता है कि पुराने जॉन मैकडोनाल्ड इस विधि को अपने नाम से परेशान होंगे, ईई कमिंग्स, घंटी के हुक, दानाह बॉयड, 行 फिनोट 行 弘, अंतिम नाम "ओ'डॉयल" वाले लोगों को "वॉन" वाले लोगों का उल्लेख नहीं करना चाहिए , आदि, आदि, अधिकांश नाम उस पूंजीकरण (और पूंजीगत वर्णों में) के साथ "प्रथम अंतिम" प्रारूप के नहीं हैं; मैं kalzumeus.com/2010/06/17/…

— निक

@ निक बिल्कुल सही है। आप यह भी नहीं मान सकते हैं कि अपर-केस के बाद लोअर-केस गलत है - आयरिश नाम "assume hAirt" जैसी चीजें करते हैं। मान लें कि किसी भी सम्मेलन के लिए आप अपने सिर के ऊपर से सोच सकते हैं, एक संस्कृति / भाषा होगी जो आपको आश्चर्यचकित करेगी।

— जेम्स मूर

Answer 1

TextInfo.ToTitleCase()एक स्ट्रिंग के प्रत्येक टोकन में पहले वर्ण को कैपिटल करता है।
यदि उरपार्कासिंग को बनाए रखने की कोई आवश्यकता नहीं है, तो आपको शामिल करना चाहिए ToLower()।

string s = "JOHN DOE";
s = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(s.ToLower());
// Produces "John Doe"

यदि करंट अनुपलब्ध है, तो उपयोग करें:

string s = "JOHN DOE";
s = new System.Globalization.CultureInfo("en-US", false).TextInfo.ToTitleCase(s.ToLower());

विस्तृत विवरण के लिए MSDN लिंक देखें ।

Comments

यहां एक बात ध्यान देने वाली है कि यह काम नहीं करता है यदि स्ट्रिंग सभी राजधानियों है। यह सोचता है कि सभी कैप एक परिचित हैं।

— माइक रोज़ा

मैंने इनमें से कई के साथ देखा है कि आप उन पर भरोसा नहीं कर सकते हैं। यह काम नहीं करेगा अगर नाम मैककेन जैसा कुछ है या यदि आप अधिक विदेशी नामों को मारना शुरू करते हैं।

— माइक

@roosa - के लिए कि ToTitleCase (val.ToLower ()) आसान ठीक

— Simon_Weaver

+1 मुझे पता था कि यह पहले से ही एफसीएल में होना था, और Google ने मुझे यहाँ लाया = D

— gideon

नीचे नाथन के उत्तर के विपरीत, मुझे एक त्रुटि मिलती है: "गैर-स्थैतिक क्षेत्र, विधि, या संपत्ति के लिए एक वस्तु संदर्भ आवश्यक है ......." दुर्भाग्य से।

— डब्ल्यू में दान डब्ल्यू

Answer 2

CultureInfo.CurrentCulture.TextInfo.ToTitleCase("hello world");

Comments

आह! अच्छा उत्तर। मैं हमेशा वैश्वीकरण के सामान के बारे में भूल जाता हूं।

— माइकल हरेन

महान समाधान! VB.Net में:sItem = Globalization.CultureInfo.CurrentCulture.TextInfo.ToTitleCase(sItem.ToLower) 'first char upper case

— नसनबेर

आपको प्रत्येक व्यक्तिगत नाम की संस्कृति का पता लगाने की आवश्यकता है , वर्तमान संस्कृति की नहीं। यह नामों के लिए काम नहीं करता है।

— जेम्स मूर

चूंकि यह निर्भर करता है CurrentCulture, इसलिए हम कैसे सुनिश्चित कर सकते हैं कि कोई संस्कृति नहीं है जो इसे अलग तरह से संभालती है?

— रुडी

Answer 3

String test = "HELLO HOW ARE YOU";
string s = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(test);

उपरोक्त कोड अभ्यस्त काम .....

इसलिए नीचे दिए गए कोड को निम्न में बदलें और फिर फ़ंक्शन को लागू करें

String test = "HELLO HOW ARE YOU";
string s = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(test.ToLower());

Answer 4

ऐसे कुछ मामले हैं जो CultureInfo.CurrentCulture.TextInfo.ToTitleCaseसंभाल नहीं सकते हैं, उदाहरण के लिए: एपोस्ट्रोफी '।

string input = CultureInfo.CurrentCulture.TextInfo.ToTitleCase("o'reilly, m'grego, d'angelo");
// input = O'reilly, M'grego, D'angelo

एक शब्द सीमा के बाद एक शब्द के शुरुआती चरित्र की पहचान करने के लिए एक रेगेक्स का भी उपयोग किया जा सकता है , फिर हमें इसके ऊपरी मामले समतुल्य विधि द्वारा मैच को बदलने की आवश्यकता है : विधि\b[a-zA-Z]\bRegex.Replace(string input,string pattern,MatchEvaluator evaluator)

string input = "o'reilly, m'grego, d'angelo";
input = Regex.Replace(input.ToLower(), @"\b[a-zA-Z]", m => m.Value.ToUpper());
// input = O'Reilly, M'Grego, D'Angelo

रेगुलर एक्सप्रेशन से अगर जरूरत देखते जा सकता है, उदाहरण के लिए, अगर हम हैंडल करना चाहते हैं MacDonaldऔर McFryमामलों regex हो जाता है:(?<=\b(?:mc|mac)?)[a-zA-Z]

string input = "o'reilly, m'grego, d'angelo, macdonald's, mcfry";
input = Regex.Replace(input.ToLower(), @"(?<=\b(?:mc|mac)?)[a-zA-Z]", m => m.Value.ToUpper());
// input = O'Reilly, M'Grego, D'Angelo, MacDonald'S, McFry

हम और अधिक उपसर्गों को संभालने के लिए की जरूरत है कि हम केवल समूह संशोधित करने की आवश्यकता (?:mc|mac)उदाहरण फ्रेंच उपसर्गों जोड़ने के लिए, du, de: (?:mc|mac|du|de)।

अंत में, हम महसूस कर सकते हैं कि यह रेगेक्स भी मामले MacDonald'Sमें आखिरी के लिए मेल खाता है, 'sइसलिए हमें इसे रेगेक्स में एक नकारात्मक नज़र के साथ संभालने की आवश्यकता है (?<!'s\b)। अंत में हमारे पास है:

string input = "o'reilly, m'grego, d'angelo, macdonald's, mcfry";
input = Regex.Replace(input.ToLower(), @"(?<=\b(?:mc|mac)?)[a-zA-Z](?<!'s\b)", m => m.Value.ToUpper());
// input = O'Reilly, M'Grego, D'Angelo, MacDonald's, McFry

Comments

@polkduran मैं नाम के अंत में रोमन अंकों से निपटने का एक तरीका खोजने के लिए संघर्ष कर रहा हूं; मैं उन सभी को बड़ा बनाना चाहता हूं: जॉन स्मिथ III। क्या नकारात्मक नजरिया इसके पीछे हस्तक्षेप करेगा?

— मैट

जैसा कि आमतौर पर होता है, मैं आखिरकार अपने सवाल का जवाब देने में सक्षम था। मैंने रोमन अंकों के मिलान के लिए एक वैकल्पिक समूह जोड़ा (जिसे ऊपरी आवरण मिलेगा)। यहाँ अब मैं उपयोग कर रहा हूँ पूरा रेगेक्स: (? <= \ B (?: Mc | mac)?) [A-zA-Z] (? <?! S \ b) (?: ii | iv) v | vi | vii | viii | ix)?

— मैट

आपका मामला एक विशेष है, जवाब में रेगेक्स प्रत्येक नाम (अंतिम नाम) को इनपुट स्ट्रिंग में एक अलग शब्द के रूप में मानता है (परीक्षण इनपुट स्ट्रिंग में कई नाम हैं) इसलिए इसमें 'नाम के अंत' की धारणा नहीं है । यदि आप एक ही नाम के रूप में इनपुट स्ट्रिंग का इलाज करते हैं \b[ivxlcdm]+$|तो आप अपने मामले से निपटने के लिए रीजेक्स को एक साधारण स्थिति के साथ उपसर्ग कर सकते हैं: इसलिए आपके पास है \b[ivxlcdm]+$|(?<=\b(?:mc|mac)?)[a-zA-Z](?<!'s\b)। यह एक सख्त रोमन अंक प्रारूप ( ivxlcdm) नहीं होने वाले नाम के सभी समाप्त होने वाले शब्दों को बनाएगा । हालाँकि आपके कुछ अवांछित परिणाम हो सकते हैं, उदाहरण के लिए 'Li' 'LI' बन जाएगा

— polkduran

दिलचस्प। मुझे लगता है कि संरचना के संबंध में आपका जोड़ शायद अधिक सही है, लेकिन मैं सहमत हूं ... मुझे लगता है कि आपके द्वारा बताए गए कुछ मुद्दे होंगे। उपरोक्त मेरे समाधान में, मैंने "ix" तक के प्रत्ययों को हार्ड-कोडित किया है जो मेरे मामले में काम करेंगे लेकिन मैं मानता हूं कि हर किसी के लिए उपयुक्त नहीं हो सकता है।

— मैट

@ Si8, क्या आपने इसका परीक्षण किया है? Regex.Replace("JOHN DOE".ToLower(), @"(?<=\b(?:mc|mac)?)[a-zA-Z](?<!'s\b)", m => m.Value.ToUpper())

— पोल्कदुरन

Answer 5

मैक और मैक पूरे अमेरिका में आम उपनाम उपसर्ग हैं, और अन्य हैं। TextInfo.ToTitleCase उन मामलों को नहीं संभालता है और इस उद्देश्य के लिए उपयोग नहीं किया जाना चाहिए। यहाँ मैं यह कैसे कर रहा हूँ:

    public static string ToTitleCase(string str)
    {
        string result = str;
        if (!string.IsNullOrEmpty(str))
        {
            var words = str.Split(' ');
            for (int index = 0; index < words.Length; index++)
            {
                var s = words[index];
                if (s.Length > 0)
                {
                    words[index] = s[0].ToString().ToUpper() + s.Substring(1);
                }
            }
            result = string.Join(" ", words);
        }
        return result;
    }

Answer 6

ToTitleCase () आप के लिए काम करना चाहिए।

http://support.microsoft.com/kb/312890

Answer 7

सबसे सीधा विकल्प .NET में उपलब्ध होने वाले ToTitleCase फ़ंक्शन का उपयोग करने वाला है जो कि ज्यादातर समय नाम का ध्यान रखना चाहिए। जैसा कि edg ने बताया कि कुछ ऐसे नाम हैं जो इसके लिए काम नहीं करेंगे, लेकिन ये काफी दुर्लभ हैं, जब तक कि आप एक संस्कृति को लक्षित नहीं कर रहे हैं, जहां ऐसे नाम आम हैं, यह आवश्यक नहीं है कि आपको बहुत चिंता करनी होगी।

हालाँकि, यदि आप .NET लैंग्वेज से काम नहीं कर रहे हैं, तो यह इस बात पर निर्भर करता है कि इनपुट कैसा दिखता है - यदि आपके पास पहले नाम और अंतिम नाम के लिए दो अलग-अलग फ़ील्ड हैं, तो आप पहले अक्षर को बड़े अक्षरों में कम कर सकते हैं, बाकी का उपयोग करके सबस्ट्रिंग।

firstName = firstName.Substring(0, 1).ToUpper() + firstName.Substring(1).ToLower();
lastName = lastName.Substring(0, 1).ToUpper() + lastName.Substring(1).ToLower();

हालांकि, यदि आपको एक ही स्ट्रिंग के भाग के रूप में कई नाम प्रदान किए गए हैं, तो आपको यह जानना होगा कि आपको जानकारी कैसे मिल रही है और तदनुसार विभाजित करें । तो अगर आपको "जॉन डो" जैसा नाम मिल रहा है, तो आप अंतरिक्ष चरित्र के आधार पर स्ट्रिंग को विभाजित करेंगे। यदि यह "डो, जॉन" जैसे प्रारूप में है, तो आपको इसे अल्पविराम के आधार पर विभाजित करने की आवश्यकता होगी। हालाँकि, एक बार जब आप इसे अलग कर लेते हैं तो आप पहले दिखाए गए कोड को लागू करते हैं।

Answer 8

CultureInfo.CurrentCulture.TextInfo.ToTitleCase ("मेरा नाम");

रिटर्न ~ मेरा नाम

लेकिन समस्या अभी भी मैकफली जैसे नामों के साथ मौजूद है जैसा कि पहले कहा गया था।

Comments

McFry! कोनिचीवा, मिस्टर फुगित्सु-सान

— इयान बॉयड

@ डेविड C रिक्त स्थान को शून्य से बदलने का प्रयास करें !! जैसे string.replace ('', '')

— चिंतन

Answer 9

मैं इसे ठीक करने के लिए अपनी विधि का उपयोग करता हूं:

उदाहरण के लिए वाक्यांश: "हैलो वर्ल्ड। हैलो यह स्टैकओवरफ्लो दुनिया है।" हो जाएगा "हैलो वर्ल्ड। हैलो दिस इज़ द स्टैकओवरफ़्लो वर्ल्ड।"। Regex \ b (एक शब्द की शुरुआत) \ w (शब्द का पहला अक्षर) ट्रिक करेगा।

/// <summary>
/// Makes each first letter of a word uppercase. The rest will be lowercase
/// </summary>
/// <param name="Phrase"></param>
/// <returns></returns>
public static string FormatWordsWithFirstCapital(string Phrase)
{
     MatchCollection Matches = Regex.Matches(Phrase, "\\b\\w");
     Phrase = Phrase.ToLower();
     foreach (Match Match in Matches)
         Phrase = Phrase.Remove(Match.Index, 1).Insert(Match.Index, Match.Value.ToUpper());

     return Phrase;
}

Answer 10

ToTitleCase का उपयोग करने के सुझाव उन स्ट्रिंग के लिए काम नहीं करेंगे जो सभी ऊपरी मामले हैं। तो आप पहले चार पर ToUpper और शेष पात्रों पर ToLower को बुलाने वाले हैं।

Comments

ToTitleCase को कॉल करने से पहले इनपुट स्ट्रिंग पर ToLower क्यों नहीं?

— एंडी रोज

Answer 11

यह वर्ग चालबाजी करता है। आप नए उपसर्गों को _prefixes स्थिर स्ट्रिंग सरणी में जोड़ सकते हैं ।

public static class StringExtensions
{
        public static string ToProperCase( this string original )
        {
            if( String.IsNullOrEmpty( original ) )
                return original;

            string result = _properNameRx.Replace( original.ToLower( CultureInfo.CurrentCulture ), HandleWord );
            return result;
        }

        public static string WordToProperCase( this string word )
        {
            if( String.IsNullOrEmpty( word ) )
                return word;

            if( word.Length > 1 )
                return Char.ToUpper( word[0], CultureInfo.CurrentCulture ) + word.Substring( 1 );

            return word.ToUpper( CultureInfo.CurrentCulture );
        }

        private static readonly Regex _properNameRx = new Regex( @"\b(\w+)\b" );
        private static readonly string[] _prefixes = {
                                                         "mc"
                                                     };

        private static string HandleWord( Match m )
        {
            string word = m.Groups[1].Value;

            foreach( string prefix in _prefixes )
            {
                if( word.StartsWith( prefix, StringComparison.CurrentCultureIgnoreCase ) )
                    return prefix.WordToProperCase() + word.Substring( prefix.Length ).WordToProperCase();
            }

            return word.WordToProperCase();
        }
}

Answer 12

यदि आपका vS2k8 का उपयोग कर रहे हैं, तो आप इसे स्ट्रिंग क्लास में जोड़ने के लिए एक एक्सटेंशन विधि का उपयोग कर सकते हैं:

public static string FirstLetterToUpper(this String input)
{
    return input = input.Substring(0, 1).ToUpper() + 
       input.Substring(1, input.Length - 1);
}

Comments

Char.ToUpper(input[0]) + input.Substring(1)अधिक पठनीय IMHO है।

— होसम ऐली

IMHO input.FirstLetterToUpper()निश्चित रूप से अधिक पठनीय बनाम Char.ToUpper(input[0]) + input.Substring(1), लेकिन कम पारदर्शी है

— माइकल

Answer 13

कुछ मुद्दों / समस्याओं के बारे में जानने के लिए, जिन्होंने बेन हाइलाइट किया है, मैं सुझाव दूंगा कि स्ट्रिंग को पहले लोअर केस में परिवर्तित किया जाए और फिर ToTitleCase पद्धति को कॉल किया जाए। फिर आप विशेष मामलों को निर्धारित करने के लिए IndexOf ("Mc") या IndexOf ("O \ '") का उपयोग कर सकते हैं जिन पर अधिक ध्यान देने की आवश्यकता है।

inputString = inputString.ToLower();
inputString = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(inputString);
int indexOfMc = inputString.IndexOf(" Mc");
if(indexOfMc  > 0)
{
   inputString.Substring(0, indexOfMc + 3) + inputString[indexOfMc + 3].ToString().ToUpper() + inputString.Substring(indexOfMc + 4);
}

Answer 14

मुझे यह तरीका पसंद है:

using System.Globalization;
...
TextInfo myTi = new CultureInfo("en-Us",false).TextInfo;
string raw = "THIS IS ALL CAPS";
string firstCapOnly = myTi.ToTitleCase(raw.ToLower());

इस MSDN लेख से उठा ।

Answer 15

आशा है कि यह आपकी मदद करता है।

String fName = "firstname";
String lName = "lastname";
String capitalizedFName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(fName);
String capitalizedLName = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(lName);

Answer 16

 public static string ConvertToCaptilize(string input)
        {
            if (!string.IsNullOrEmpty(input))
            {
                string[] arrUserInput = input.Split(' ');


                // Initialize a string builder object for the output
                StringBuilder sbOutPut = new StringBuilder();


                // Loop thru each character in the string array
                foreach (string str in arrUserInput)
                {
                    if (!string.IsNullOrEmpty(str))
                    {
                        var charArray = str.ToCharArray();
                        int k = 0;
                        foreach (var cr in charArray)
                        {
                            char c;
                            c = k == 0 ? char.ToUpper(cr) : char.ToLower(cr);
                            sbOutPut.Append(c);
                            k++;
                        }


                    }
                    sbOutPut.Append(" ");
                }
                return sbOutPut.ToString();
            }
            return string.Empty;

        }

Answer 17

ईडीजी के संकेत की तरह, आपको विशेष नामों को संभालने के लिए अधिक जटिल एल्गोरिथ्म की आवश्यकता होगी (यह शायद इसलिए कई जगह ऊपरी मामले में सब कुछ मजबूर करता है)।

कुछ इस तरह के अप्रयुक्त सी # को आपके द्वारा अनुरोध किए गए सरल मामले को संभालना चाहिए:

public string SentenceCase(string input)
{
    return input(0, 1).ToUpper + input.Substring(1).ToLower;
}

Comments

इसे भूल जाइए - वैश्वीकरण वर्ग का उपयोग करें stackoverflow.com/questions/72831/…

— माइकल हैरेन