Qualcuno ha un buon Corretta Caso algoritmo

Qualcuno ha una fiducia apposita Custodia o PCase algoritmo (simile a un UCase o Superiore)? Sto cercando qualcosa che prende un valore, ad esempio "GEORGE BURDELL" o "george burdell" e lo trasforma in "George Burdell".

Ho un semplice uno che gestisce i casi semplici. L’ideale sarebbe avere qualcosa in grado di gestire le cose come "O'REILLY" e di trasformarlo in "O'Reilly", ma so che è più difficile.

Sono concentrati principalmente sulla lingua inglese se che semplifica le cose.


AGGIORNAMENTO: sto usando C# come linguaggio, ma posso convertire quasi qualsiasi cosa (supponendo che come funzionalità è presente).

Sono d’accordo che il Mcdonald’s scneario è un duro. Volevo ricordare che, insieme con il mio O’Reilly esempio, ma non nel post originale.

InformationsquelleAutor jttraino | 2008-08-28

 

13 Replies
  1. 18

    A meno che ho capito male la tua domanda non credo che avete bisogno di rotolare il vostro proprio, TextInfo classe è in grado di farlo per voi.

    using System.Globalization;
    
    CultureInfo.InvariantCulture.TextInfo.ToTitleCase("GeOrGE bUrdEll")
    

    Tornerà “George Burdell. E si può utilizzare la propria cultura, se ci sono alcune regole speciali coinvolti.

    Aggiornamento: Michael (in un commento a questa risposta) ha sottolineato che questo non funzionerà se l’input è tutto in maiuscolo dato che il metodo assume che è un acronimo. L’ingenuo soluzione per questo è di .ToLower() il testo prima di inviarlo al ToTitleCase.

    • In realtà, questo non è corretto. Un esempio sarà il ritorno di GEORGE BURDELL” Dal docs : in genere, titolo involucro converte il primo carattere di una parola in maiuscolo e il resto dei caratteri minuscoli. Tuttavia, una parola che è interamente in maiuscolo, come un acronimo, non viene convertito.
    • A destra si sono… credo che il modo più semplice per evitare che sarebbe quello di garantire che l’ingresso è minuscole per iniziare con. Voglio aggiornare la mia risposta per riflettere questo.
    • Il InvariantCulture è utilizzato per le operazioni che richiedono una componente culturale, ma che non corrispondono ad alcuna effettiva cultura umana. Dal momento che il poster originale è focalizzata su un vero e proprio linguaggio umano (in inglese), è necessario l’utilizzo di una cultura oggetto che è impostata su inglese.
    • Questo non consente di gestire O’Reilly tipo di cose..
  2. 9

    @Zack: io faccio il post come un separato risposta.

    Ecco un esempio basato su kronoz post.

    void Main()
    {
        List<string> names = new List<string>() {
            "bill o'reilly", 
            "johannes diderik van der waals", 
            "mr. moseley-williams", 
            "Joe VanWyck", 
            "mcdonald's", 
            "william the third", 
            "hrh prince charles", 
            "h.r.m. queen elizabeth the third",
            "william gates, iii", 
            "pope leo xii",
            "a.k. jennings"
        };
    
        names.Select(name => name.ToProperCase()).Dump();
    }
    
    //http://stackoverflow.com/questions/32149/does-anyone-have-a-good-proper-case-algorithm
    public static class ProperCaseHelper
    {
        public static string ToProperCase(this string input)
        {
            if (IsAllUpperOrAllLower(input))
            {
                //fix the ALL UPPERCASE or all lowercase names
                return string.Join(" ", input.Split(' ').Select(word => wordToProperCase(word)));
            }
            else
            {
                //leave the CamelCase or Propercase names alone
                return input;
            }
        }
    
        public static bool IsAllUpperOrAllLower(this string input)
        {
            return (input.ToLower().Equals(input) || input.ToUpper().Equals(input));
        }
    
        private static string wordToProperCase(string word)
        {
            if (string.IsNullOrEmpty(word)) return word;
    
            //Standard case
            string ret = capitaliseFirstLetter(word);
    
            //Special cases:
            ret = properSuffix(ret, "'");   //D'Artagnon, D'Silva
            ret = properSuffix(ret, ".");   //???
            ret = properSuffix(ret, "-");       //Oscar-Meyer-Weiner
            ret = properSuffix(ret, "Mc", t => t.Length > 4);      //Scots
            ret = properSuffix(ret, "Mac", t => t.Length > 5);     //Scots except Macey
    
            //Special words:
            ret = specialWords(ret, "van");     //Dick van Dyke
            ret = specialWords(ret, "von");     //Baron von Bruin-Valt
            ret = specialWords(ret, "de");
            ret = specialWords(ret, "di");
            ret = specialWords(ret, "da");      //Leonardo da Vinci, Eduardo da Silva
            ret = specialWords(ret, "of");      //The Grand Old Duke of York
            ret = specialWords(ret, "the");     //William the Conqueror
            ret = specialWords(ret, "HRH");     //His/Her Royal Highness
            ret = specialWords(ret, "HRM");     //His/Her Royal Majesty
            ret = specialWords(ret, "H.R.H.");  //His/Her Royal Highness
            ret = specialWords(ret, "H.R.M.");  //His/Her Royal Majesty
    
            ret = dealWithRomanNumerals(ret);   //William Gates, III
    
            return ret;
        }
    
        private static string properSuffix(string word, string prefix, Func<string, bool> condition = null)
        {
            if (string.IsNullOrEmpty(word)) return word;
            if (condition != null && ! condition(word)) return word;
    
            string lowerWord = word.ToLower();
            string lowerPrefix = prefix.ToLower();
    
            if (!lowerWord.Contains(lowerPrefix)) return word;
    
            int index = lowerWord.IndexOf(lowerPrefix);
    
            //If the search string is at the end of the word ignore.
            if (index + prefix.Length == word.Length) return word;
    
            return word.Substring(0, index) + prefix +
                capitaliseFirstLetter(word.Substring(index + prefix.Length));
        }
    
        private static string specialWords(string word, string specialWord)
        {
            if (word.Equals(specialWord, StringComparison.InvariantCultureIgnoreCase))
            {
                return specialWord;
            }
            else
            {
                return word;
            }
        }
    
        private static string dealWithRomanNumerals(string word)
        {
            //Roman Numeral parser thanks to [Hannobo](https://stackoverflow.com/users/785111/hannobo)
            //Note that it excludes the Chinese last name Xi
            return new Regex(@"\b(?!Xi\b)(X|XX|XXX|XL|L|LX|LXX|LXXX|XC|C)?(I|II|III|IV|V|VI|VII|VIII|IX)?\b", RegexOptions.IgnoreCase).Replace(word, match => match.Value.ToUpperInvariant());
        }
    
        private static string capitaliseFirstLetter(string word)
        {
            return char.ToUpper(word[0]) + word.Substring(1).ToLower();
        }
    
    }
    
    • Abbiamo messo nel nostro sistema produttivo. Ci sono voluti 15 minuti per uno dei nostri clienti a chiedere perché “Macey” è stato impostato a “MacEy”… Così abbiamo rimosso quella particolare linea di codice e lascia tutto il resto. Grazie!
    • Grazie! In realtà so che un Macey così. Hmm… Quando avrò tempo cercherò di raschiare la pagina di Wikipedia in Gaelico Scozzese nomi per tutti maiuscole e minuscole parole, e aggiungere quelli. en.wikipedia.org/wiki/List_of_Scottish_Gaelic_surnames
    • Questo ha esito negativo se il numero romano si trova accanto a un simbolo, come “Sir William III.”. Ho cambiato DealWithRomanNumerals per questa one-liner, che funziona alla grande: return new Regex(@"\b(?!Xi\b)(X|XX|XXX|XL|L|LX|LXX|LXXX|XC|C)?(I|II|III|IV|V|VI|VII|VIII|IX)?\b", RegexOptions.IgnoreCase).Replace(word, match => match.Value.ToUpperInvariant()); — Anche filtra il nome comune Cinese “Xi”.
  3. 4

    C’è anche questo pulito script Perl per il titolo, corpo del testo.

    http://daringfireball.net/2008/08/title_case_update

    #!/usr/bin/perl
    
    #     This filter changes all words to Title Caps, and attempts to be clever
    # about *un*capitalizing small words like a/an/the in the input.
    #
    # The list of "small words" which are not capped comes from
    # the New York Times Manual of Style, plus 'vs' and 'v'. 
    #
    # 10 May 2008
    # Original version by John Gruber:
    # http://daringfireball.net/2008/05/title_case
    #
    # 28 July 2008
    # Re-written and much improved by Aristotle Pagaltzis:
    # http://plasmasturm.org/code/titlecase/
    #
    #   Full change log at __END__.
    #
    # License: http://www.opensource.org/licenses/mit-license.php
    #
    
    
    use strict;
    use warnings;
    use utf8;
    use open qw( :encoding(UTF-8) :std );
    
    
    my @small_words = qw( (?<!q&)a an and as at(?!&t) but by en for if in of on or the to v[.]? via vs[.]? );
    my $small_re = join '|', @small_words;
    
    my $apos = qr/(?: ['’] [[:lower:]]* )? /x;
    
    while ( <> ) {
      s{\A\s+}{}, s{\s+\z}{};
    
      $_ = lc $_ if not /[[:lower:]]/;
    
      s{
          \b (_*) (?:
              ( (?<=[ ][/\\]) [[:alpha:]]+ [-_[:alpha:]/\\]+ |   # file path or
                [-_[:alpha:]]+ [@.:] [-_[:alpha:]@.:/]+ $apos )  # URL, domain, or email
              |
              ( (?i: $small_re ) $apos )                         # or small word (case-insensitive)
              |
              ( [[:alpha:]] [[:lower:]'’()\[\]{}]* $apos )       # or word w/o internal caps
              |
              ( [[:alpha:]] [[:alpha:]'’()\[\]{}]* $apos )       # or some other word
          ) (_*) \b
      }{
          $1 . (
            defined $2 ? $2         # preserve URL, domain, or email
          : defined $3 ? "\L$3"     # lowercase small word
          : defined $4 ? "\u\L$4"   # capitalize word w/o internal caps
          : $5                      # preserve other kinds of word
          ) . $6
      }xeg;
    
    
      # Exceptions for small words: capitalize at start and end of title
      s{
          (  \A [[:punct:]]*         # start of title...
          |  [:.;?!][ ]+             # or of subsentence...
          |  [ ]['"“‘(\[][ ]*     )  # or of inserted subphrase...
          ( $small_re ) \b           # ... followed by small word
      }{$1\u\L$2}xig;
    
      s{
          \b ( $small_re )      # small word...
          (?= [[:punct:]]* \Z   # ... at the end of the title...
          |   ['"’”)\]] [ ] )   # ... or of an inserted subphrase?
      }{\u\L$1}xig;
    
      # Exceptions for small words in hyphenated compound words
      ## e.g. "in-flight" -> In-Flight
      s{
          \b
          (?<! -)                 # Negative lookbehind for a hyphen; we don't want to match man-in-the-middle but do want (in-flight)
          ( $small_re )
          (?= -[[:alpha:]]+)      # lookahead for "-someword"
      }{\u\L$1}xig;
    
      ## # e.g. "Stand-in" -> "Stand-In" (Stand is already capped at this point)
      s{
          \b
          (?<!…)                  # Negative lookbehind for a hyphen; we don't want to match man-in-the-middle but do want (stand-in)
          ( [[:alpha:]]+- )       # $1 = first word and hyphen, should already be properly capped
          ( $small_re )           # ... followed by small word
          (?! - )                 # Negative lookahead for another '-'
      }{$1\u$2}xig;
    
      print "$_";
    }
    
    __END__
    

    Ma suona come da apposito caso vuoi dire.. per i nomi di persone solo.

  4. 2

    Mi ha scritto oggi da implementare in un app a cui sto lavorando. Penso che questo codice è abbastanza auto esplicativo, con i commenti. Non è accurato al 100% in tutti i casi, ma in grado di gestire la maggior parte del vostro western nomi facilmente.

    Esempi:

    mary-jane => Mary-Jane

    o'brien => O'Brien

    Joël VON WINTEREGG => Joël von Winteregg

    jose de la acosta => Jose de la Acosta

    Il codice è estendibile in che è possibile aggiungere qualsiasi valore di stringa per le matrici in alto per soddisfare le vostre esigenze. Si prega di studiare e aggiungere qualsiasi funzionalità speciali che possono essere richiesti.

    function name_title_case($str)
    {
      //name parts that should be lowercase in most cases
      $ok_to_be_lower = array('av','af','da','dal','de','del','der','di','la','le','van','der','den','vel','von');
      //name parts that should be lower even if at the beginning of a name
      $always_lower   = array('van', 'der');
    
      //Create an array from the parts of the string passed in
      $parts = explode(" ", mb_strtolower($str));
    
      foreach ($parts as $part)
      {
        (in_array($part, $ok_to_be_lower)) ? $rules[$part] = 'nocaps' : $rules[$part] = 'caps';
      }
    
      //Determine the first part in the string
      reset($rules);
      $first_part = key($rules);
    
      //Loop through and cap-or-dont-cap
      foreach ($rules as $part => $rule)
      {
        if ($rule == 'caps')
        {
          //ucfirst() words and also takes into account apostrophes and hyphens like this:
          //O'brien -> O'Brien || mary-kaye -> Mary-Kaye
          $part = str_replace('- ','-',ucwords(str_replace('-','- ', $part)));
          $c13n[] = str_replace('\' ', '\'', ucwords(str_replace('\'', '\' ', $part)));
        }
        else if ($part == $first_part && !in_array($part, $always_lower))
        {
          //If the first part of the string is ok_to_be_lower, cap it anyway
          $c13n[] = ucfirst($part);
        }
        else
        {
          $c13n[] = $part;
        }
      }
    
      $titleized = implode(' ', $c13n);
    
      return trim($titleized);
    }
    
  5. 2

    Ho fatto un rapido C# porta di https://github.com/tamtamchik/namecase, che si basa sulla Lingua::IT::NameCase.

    public static class CIQNameCase
    {
        static Dictionary<string, string> _exceptions = new Dictionary<string, string>
            {
                {@"\bMacEdo"     ,"Macedo"},
                {@"\bMacEvicius" ,"Macevicius"},
                {@"\bMacHado"    ,"Machado"},
                {@"\bMacHar"     ,"Machar"},
                {@"\bMacHin"     ,"Machin"},
                {@"\bMacHlin"    ,"Machlin"},
                {@"\bMacIas"     ,"Macias"},
                {@"\bMacIulis"   ,"Maciulis"},
                {@"\bMacKie"     ,"Mackie"},
                {@"\bMacKle"     ,"Mackle"},
                {@"\bMacKlin"    ,"Macklin"},
                {@"\bMacKmin"    ,"Mackmin"},
                {@"\bMacQuarie"  ,"Macquarie"}
            };
    
        static Dictionary<string, string> _replacements = new Dictionary<string, string>
            {
                {@"\bAl(?=\s+\w)"         , @"al"},        //al Arabic or forename Al.
                {@"\b(Bin|Binti|Binte)\b" , @"bin"},       //bin, binti, binte Arabic
                {@"\bAp\b"                , @"ap"},        //ap Welsh.
                {@"\bBen(?=\s+\w)"        , @"ben"},       //ben Hebrew or forename Ben.
                {@"\bDell([ae])\b"        , @"dell$1"},    //della and delle Italian.
                {@"\bD([aeiou])\b"        , @"d$1"},       //da, de, di Italian; du French; do Brasil
                {@"\bD([ao]s)\b"          , @"d$1"},       //das, dos Brasileiros
                {@"\bDe([lrn])\b"         , @"de$1"},      //del Italian; der/den Dutch/Flemish.
                {@"\bEl\b"                , @"el"},        //el Greek or El Spanish.
                {@"\bLa\b"                , @"la"},        //la French or La Spanish.
                {@"\bL([eo])\b"           , @"l$1"},       //lo Italian; le French.
                {@"\bVan(?=\s+\w)"        , @"van"},       //van German or forename Van.
                {@"\bVon\b"               , @"von"}        //von Dutch/Flemish
            };
    
        static string[] _conjunctions = { "Y", "E", "I" };
    
        static string _romanRegex = @"\b((?:[Xx]{1,3}|[Xx][Ll]|[Ll][Xx]{0,3})?(?:[Ii]{1,3}|[Ii][VvXx]|[Vv][Ii]{0,3})?)\b";
    
        ///<summary>
        ///Case a name field into its appropriate case format 
        ///e.g. Smith, de la Cruz, Mary-Jane,  O'Brien, McTaggart
        ///</summary>
        ///<param name="nameString"></param>
        ///<returns></returns>
        public static string NameCase(string nameString)
        {
            //Capitalize
            nameString = Capitalize(nameString);
            nameString = UpdateIrish(nameString);
    
            //Fixes for "son (daughter) of" etc
            foreach (var replacement in _replacements.Keys)
            {
                if (Regex.IsMatch(nameString, replacement))
                {
                    Regex rgx = new Regex(replacement);
                    nameString = rgx.Replace(nameString, _replacements[replacement]);
                }                    
            }
    
            nameString = UpdateRoman(nameString);
            nameString = FixConjunction(nameString);
    
            return nameString;
        }
    
        ///<summary>
        ///Capitalize first letters.
        ///</summary>
        ///<param name="nameString"></param>
        ///<returns></returns>
        private static string Capitalize(string nameString)
        {
            nameString = nameString.ToLower();
            nameString = Regex.Replace(nameString, @"\b\w", x => x.ToString().ToUpper());
            nameString = Regex.Replace(nameString, @"'\w\b", x => x.ToString().ToLower()); //Lowercase 's
            return nameString;
        }
    
        ///<summary>
        ///Update for Irish names.
        ///</summary>
        ///<param name="nameString"></param>
        ///<returns></returns>
        private static string UpdateIrish(string nameString)
        {
            if(Regex.IsMatch(nameString, @".*?\bMac[A-Za-z^aciozj]{2,}\b") || Regex.IsMatch(nameString, @".*?\bMc"))
            {
                nameString = UpdateMac(nameString);
            }            
            return nameString;
        }
    
        ///<summary>
        ///Updates irish Mac & Mc.
        ///</summary>
        ///<param name="nameString"></param>
        ///<returns></returns>
        private static string UpdateMac(string nameString)
        {
            MatchCollection matches = Regex.Matches(nameString, @"\b(Ma?c)([A-Za-z]+)");
            if(matches.Count == 1 && matches[0].Groups.Count == 3)
            {
                string replacement = matches[0].Groups[1].Value;
                replacement += matches[0].Groups[2].Value.Substring(0, 1).ToUpper();
                replacement += matches[0].Groups[2].Value.Substring(1);
                nameString = nameString.Replace(matches[0].Groups[0].Value, replacement);
    
                //Now fix "Mac" exceptions
                foreach (var exception in _exceptions.Keys)
                {
                    nameString = Regex.Replace(nameString, exception, _exceptions[exception]);
                }
            }
            return nameString;
        }
    
        ///<summary>
        ///Fix roman numeral names.
        ///</summary>
        ///<param name="nameString"></param>
        ///<returns></returns>
        private static string UpdateRoman(string nameString)
        {
            MatchCollection matches = Regex.Matches(nameString, _romanRegex);
            if (matches.Count > 1)
            {
                foreach(Match match in matches)
                {
                    if(!string.IsNullOrEmpty(match.Value))
                    {
                        nameString = Regex.Replace(nameString, match.Value, x => x.ToString().ToUpper());
                    }
                }
            }
            return nameString;
        }
    
        ///<summary>
        ///Fix Spanish conjunctions.
        ///</summary>
        ///<param name=""></param>
        ///<returns></returns>
        private static string FixConjunction(string nameString)
        {            
            foreach (var conjunction in _conjunctions)
            {
                nameString = Regex.Replace(nameString, @"\b" + conjunction + @"\b", x => x.ToString().ToLower());
            }
            return nameString;
        }
    }

    Utilizzo

    string name_cased = CIQNameCase.NameCase("McCarthy");

    Questo è il mio metodo di prova, tutto sembra passare OK:

    [TestMethod]
    public void Test_NameCase_1()
    {
        string[] names = {
            "Keith", "Yuri's", "Leigh-Williams", "McCarthy",
            //Mac exceptions
            "Machin", "Machlin", "Machar",
            "Mackle", "Macklin", "Mackie",
            "Macquarie", "Machado", "Macevicius",
            "Maciulis", "Macias", "MacMurdo",
            //General
            "O'Callaghan", "St. John", "von Streit",
            "van Dyke", "Van", "ap Llwyd Dafydd",
            "al Fahd", "Al",
            "el Grecco",
            "ben Gurion", "Ben",
            "da Vinci",
            "di Caprio", "du Pont", "de Legate",
            "del Crond", "der Sind", "van der Post", "van den Thillart",
            "von Trapp", "la Poisson", "le Figaro",
            "Mack Knife", "Dougal MacDonald",
            "Ruiz y Picasso", "Dato e Iradier", "Mas i Gavarró",
            //Roman numerals
            "Henry VIII", "Louis III", "Louis XIV",
            "Charles II", "Fred XLIX", "Yusof bin Ishak",
        };
    
        foreach(string name in names)
        {
            string name_upper = name.ToUpper();
            string name_cased = CIQNameCase.NameCase(name_upper);
            Console.WriteLine(string.Format("name: {0} -> {1}  -> {2}", name, name_upper, name_cased));
            Assert.IsTrue(name == name_cased);
        }
    
    }
  6. 1

    Che linguaggio di programmazione in uso? Molte lingue consentire le funzioni di callback per l’espressione regolare corrisponde. Questi possono essere usati per propercase facilmente la vittoria. L’espressione regolare che potrebbe essere utilizzato è abbastanza semplice, basta abbinare tutti i caratteri della parola, in questo modo:

    /\w+/
    

    In alternativa, si può già estratto il primo personaggio ad essere una partita in più:

    /(\w)(\w*)/
    

    Ora è possibile accedere al primo carattere e caratteri in sequenza nella partita separatamente. La funzione di callback può quindi semplicemente restituire una concatenazione di colpi. In pseudo Python (in realtà non so Python):

    def make_proper(match):
        return match[1].to_upper + match[2]
    

    Per inciso, questo anche a gestire il caso di “O’Reilly” perché “O” e “Reilly” sarebbe adatto separatamente e sia propercased. Ci sono tuttavia altri casi particolari che non sono gestiti bene dall’algoritmo, ad esempio, “Mcdonald’s” o, in generale, qualsiasi apostrophed parola. L’algoritmo di produrre “Mcdonald’S” per la seconda. Una gestione speciale per l’apostrofo potrebbe essere implementato, ma che potrebbe interferire con il primo caso. Trovare un thereotical soluzione perfetta non è possibile. In pratica, potrebbe aiutare considerando la lunghezza del pezzo dopo l’apostrofo.

  7. 1

    Ecco forse ingenuo implementazione C#: –

    public class ProperCaseHelper {
      public string ToProperCase(string input) {
        string ret = string.Empty;
    
        var words = input.Split(' ');
    
        for (int i = 0; i < words.Length; ++i) {
          ret += wordToProperCase(words[i]);
          if (i < words.Length - 1) ret += " ";
        }
    
        return ret;
      }
    
      private string wordToProperCase(string word) {
        if (string.IsNullOrEmpty(word)) return word;
    
        //Standard case
        string ret = capitaliseFirstLetter(word);
    
        //Special cases:
        ret = properSuffix(ret, "'");
        ret = properSuffix(ret, ".");
        ret = properSuffix(ret, "Mc");
        ret = properSuffix(ret, "Mac");
    
        return ret;
      }
    
      private string properSuffix(string word, string prefix) {
        if(string.IsNullOrEmpty(word)) return word;
    
        string lowerWord = word.ToLower(), lowerPrefix = prefix.ToLower();
        if (!lowerWord.Contains(lowerPrefix)) return word;
    
        int index = lowerWord.IndexOf(lowerPrefix);
    
        //If the search string is at the end of the word ignore.
        if (index + prefix.Length == word.Length) return word;
    
        return word.Substring(0, index) + prefix +
          capitaliseFirstLetter(word.Substring(index + prefix.Length));
      }
    
      private string capitaliseFirstLetter(string word) {
        return char.ToUpper(word[0]) + word.Substring(1).ToLower();
      }
    }
    
    • posta la tua versione come la sua propria risposta, non modifica di qualcun altro a rispondere in modo così radicale.
  8. 0

    un modo semplice per rendere maiuscola la prima lettera di ogni parola (separati da uno spazio)

    $words = explode(” “, $string);
    for ($i=0; $i<count($words); $i++) {
    $s = strtolower($words[$i]);
    $s = substr_replace($s, strtoupper(substr($s, 0, 1)), 0, 1);
    $result .= “$s “;
    }
    $string = trim($result);
    

    in termini di catturare il “O’REILLY” esempio che hai dato
    dividere la stringa in entrambi gli spazi, e ‘ non funziona come vorresti sfruttare qualsiasi lettera che è apparso dopo un apostraphe cioè la s di Fred

    così sarebbe probabilmente cercare qualcosa di simile

    $words = explode(” “, $string);
    for ($i=0; $i<count($words); $i++) {
    
    $s = strtolower($words[$i]);
    
    if (substr($s, 0, 2) === "o'"){
    $s = substr_replace($s, strtoupper(substr($s, 0, 3)), 0, 3);
    }else{
    $s = substr_replace($s, strtoupper(substr($s, 0, 1)), 0, 1);
    }
    $result .= “$s “;
    }
    $string = trim($result);
    

    Questo dovrebbe prendere O’Reilly, Ore, O’Donnell ecc speranza che aiuta

    Si prega di notare che questo codice non è testato.

  9. 0

    Kronoz, grazie. Ho trovato nella funzione e che la linea:

    `if (!lowerWord.Contains(lowerPrefix)) return word`;
    

    deve dire

    if (!lowerWord.StartsWith(lowerPrefix)) return word;
    

    così “información” non è cambiata “InforMacIón”

    migliori,

    Enrique

  10. 0

    Io uso questa come l’evento textchanged gestore di caselle di testo. La voce supporto di “McDonald”

    Public Shared Function DoProperCaseConvert(ByVal str As String, Optional ByVal allowCapital As Boolean = True) As String
        Dim strCon As String = ""
        Dim wordbreak As String = " ,.1234567890;/\-()#$%^&*€[email protected]"
        Dim nextShouldBeCapital As Boolean = True
    
        'Improve to recognize all caps input
        'If str.Equals(str.ToUpper) Then
        '    str = str.ToLower
        'End If
    
        For Each s As Char In str.ToCharArray
    
            If allowCapital Then
                strCon = strCon & If(nextShouldBeCapital, s.ToString.ToUpper, s)
            Else
                strCon = strCon & If(nextShouldBeCapital, s.ToString.ToUpper, s.ToLower)
            End If
    
            If wordbreak.Contains(s.ToString) Then
                nextShouldBeCapital = True
            Else
                nextShouldBeCapital = False
            End If
        Next
    
        Return strCon
    End Function
    
    • C’è un motivo per parola interruzioni di includere Messicano in pesos, dollari Americani e Irlandesi euro, ma non l’inglese di sterline? C’è un motivo per parola interruzioni di non includere caratteri di sottolineatura?
    • semplicemente NON. Si può mettere qualsiasi di quei personaggi c’nella matrice. Anche se è sarcasmo si sono dopo non credo che si può mettere in là.
  11. 0

    Un sacco di buone risposte qui. Il mio è piuttosto semplice e prende in considerazione solo i nomi che abbiamo nella nostra organizzazione. Si può espandere come si desidera. Questa non è una soluzione perfetta e cambiare vancouver a vancouver, che è sbagliato. Quindi modificarlo se lo si utilizza.

    Qui è stata la mia soluzione in C#. Questo hard-codici i nomi in programma, ma con un po ‘ di lavoro si potrebbe tenere un file di testo al di fuori del programma e leggere il nome eccezioni (cioè Van, Mc, Mac) e loop attraverso di loro.

    public static String toProperName(String name)
    {
        if (name != null)
        {
            if (name.Length >= 2 && name.ToLower().Substring(0, 2) == "mc")  //Changes mcdonald to "McDonald"
                return "Mc" + Regex.Replace(name.ToLower().Substring(2), @"\b[a-z]", m => m.Value.ToUpper());
    
            if (name.Length >= 3 && name.ToLower().Substring(0, 3) == "van")  //Changes vanwinkle to "VanWinkle"
                return "Van" + Regex.Replace(name.ToLower().Substring(3), @"\b[a-z]", m => m.Value.ToUpper());
    
            return Regex.Replace(name.ToLower(), @"\b[a-z]", m => m.Value.ToUpper());  //Changes to title case but also fixes 
                                                                                       //appostrophes like O'HARE or o'hare to O'Hare
        }
    
        return "";
    }
    
  12. 0

    So che questo thread è stato aperto per un po’, ma stavo facendo delle ricerche per questo problema mi sono imbattuto in questo sito nifty, che permette di incollare i nomi in maiuscolo abbastanza rapidamente: https://dialect.ca/code/name-case/. Ho voluto inserire qui per riferimento per gli altri a fare una simile ricerca/progetti.

    Hanno comunicato l’algoritmo che hanno scritto in php a questo link: https://dialect.ca/code/name-case/name_case.phps

    Un test preliminare e la lettura del codice suggerisce che essi sono stati abbastanza approfondita.

  13. -1

    Tu non parlare che la lingua la soluzione, quindi, ecco alcuni pseudo-codice.

    Loop through each character
        If the previous character was an alphabet letter
            Make the character lower case
        Otherwise
            Make the character upper case
    End loop
    

Lascia un commento