webentwicklung-frage-antwort-db.com.de

Konvertieren Sie die Zeichenfolge mit JavaScript in einen Titel

Gibt es eine einfache Möglichkeit, eine Zeichenfolge in einen Titel zu konvertieren? Z.B. john smith wird zu John Smith. Ich suche nicht nach etwas Kompliziertem wie John Resig's Lösung , nur (hoffentlich) nach einer Art Ein- oder Zweiliner.

464
MDCore

Versuche dies:

    function toTitleCase(str) {
        return str.replace(
            /\w\S*/g,
            function(txt) {
                return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
            }
        );
    }
<form>
Input:
<br /><textarea name="input" onchange="form.output.value=toTitleCase(this.value)"  onkeyup="form.output.value=toTitleCase(this.value)"></textarea>
<br />Output:
<br /><textarea name="output" readonly onclick="select(this)"></textarea>
</form>

665
Greg Dean

Ein etwas eleganterer Weg, Greg Deans Funktion anzupassen:

String.prototype.toProperCase = function () {
    return this.replace(/\w\S*/g, function(txt){return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();});
};

Nenne es wie:

"Pascal".toProperCase();
184
Tuan

Versuchen Sie, den text-transform CSS-Stil auf Ihre Steuerelemente anzuwenden.

zB: (text-transform: capitalize); 

Verwenden Sie einen JS-Ansatz nur, wenn dies unbedingt erforderlich ist.

141
Talha Ashfaque

Hier ist meine Funktion, die in Groß-/Kleinschreibung konvertiert wird, aber definierte Akronyme als Groß- und Nebenwörter als Kleinschreibung beibehält:

String.prototype.toTitleCase = function() {
  var i, j, str, lowers, uppers;
  str = this.replace(/([^\W_]+[^\s-]*) */g, function(txt) {
    return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
  });

  // Certain minor words should be left lowercase unless 
  // they are the first or last words in the string
  lowers = ['A', 'An', 'The', 'And', 'But', 'Or', 'For', 'Nor', 'As', 'At', 
  'By', 'For', 'From', 'In', 'Into', 'Near', 'Of', 'On', 'Onto', 'To', 'With'];
  for (i = 0, j = lowers.length; i < j; i++)
    str = str.replace(new RegExp('\\s' + lowers[i] + '\\s', 'g'), 
      function(txt) {
        return txt.toLowerCase();
      });

  // Certain words such as initialisms or acronyms should be left uppercase
  uppers = ['Id', 'Tv'];
  for (i = 0, j = uppers.length; i < j; i++)
    str = str.replace(new RegExp('\\b' + uppers[i] + '\\b', 'g'), 
      uppers[i].toUpperCase());

  return str;
}

Zum Beispiel:

"TO LOGIN TO THIS SITE and watch tv, please enter a valid id:".toTitleCase();
// Returns: "To Login to This Site and Watch TV, Please Enter a Valid ID:"
89
Geoffrey Booth

Hier ist meine Version, IMO ist leicht verständlich und elegant.

var str = "foo bar baz"

str.split(' ')
   .map(w => w[0].toUpperCase() + w.substr(1).toLowerCase())
   .join(' ')

// returns "Foo Bar Baz"
86
a8m

Ich bevorzuge das Folgende den anderen Antworten. Es stimmt nur mit dem ersten Buchstaben jedes Wortes überein und schreibt es groß. Einfacherer Code, einfacher zu lesen und weniger Bytes. Bestehende Großbuchstaben werden beibehalten, um eine Verfälschung der Akronyme zu vermeiden. Sie können jedoch toLowerCase() immer zuerst in Ihrer Zeichenfolge aufrufen.

function title(str) {
  return str.replace(/(^|\s)\S/g, function(t) { return t.toUpperCase() });
}

Sie können dies Ihrem String-Prototyp hinzufügen, der es Ihnen ermöglicht, 'my string'.toTitle() wie folgt zu verwenden:

String.prototype.toTitle = function() {
  return this.replace(/(^|\s)\S/g, function(t) { return t.toUpperCase() });
}
29
Tom Kay

Ohne Regex nur als Referenz zu verwenden:

String.prototype.toProperCase = function() {
  var words = this.split(' ');
  var results = [];
  for (var i=0; i < words.length; i++) {
      var letter = words[i].charAt(0).toUpperCase();
      results.Push(letter + words[i].slice(1));
  }
  return results.join(' ');
};

'john smith'.toProperCase();
15
Mike

Nur für den Fall, dass Sie sich Sorgen um diese Füllwörter machen, können Sie der Funktion immer nur sagen, was nicht zu groß ist.

/**
 * @param String str The text to be converted to titleCase.
 * @param Array glue the words to leave in lowercase. 
 */
var titleCase = function(str, glue){
    glue = (glue) ? glue : ['of', 'for', 'and'];
    return str.replace(/(\w)(\w*)/g, function(_, i, r){
        var j = i.toUpperCase() + (r != null ? r : "");
        return (glue.indexOf(j.toLowerCase())<0)?j:j.toLowerCase();
    });
};

Hoffe das hilft dir raus.

bearbeiten

Wenn Sie mit führenden Glue-Wörtern umgehen möchten, können Sie diese mit einer weiteren Variablen nachverfolgen:

var titleCase = function(str, glue){
    glue = !!glue ? glue : ['of', 'for', 'and', 'a'];
    var first = true;
    return str.replace(/(\w)(\w*)/g, function(_, i, r) {
        var j = i.toUpperCase() + (r != null ? r : '').toLowerCase();
        var result = ((glue.indexOf(j.toLowerCase()) < 0) || first) ? j : j.toLowerCase();
        first = false;
        return result;
    });
};
15
fncomp

Wenn der in den obigen Lösungen verwendete Regex Sie verwirrt, versuchen Sie diesen Code:

function titleCase(str) {
  return str.split(' ').map(function(val){ 
    return val.charAt(0).toUpperCase() + val.substr(1).toLowerCase();
  }).join(' ');
}
15
immazharkhan

Dies funktioniert nur für eine Word-Zeichenkette, aber das war es, was ich brauchte:

'string'.replace(/^[a-z]/, function (x) {return x.toUpperCase()}) // String

JSFiddle:https://jsfiddle.net/simo/gou2uhLm/

14
simo

Sie könnten sofort die Zeichenfolge toLowerCase und dann nur den ersten Buchstaben jedes Wortes toUpperCase. Wird zu einem sehr einfachen 1 Liner:

function titleCase(str) {
  return str.toLowerCase().replace(/\b(\w)/g, s => s.toUpperCase());
}

console.log(titleCase('iron man'));
console.log(titleCase('iNcrEdible hulK'));

9
KevBot

ES 6

str.split(' ')
   .map(s => s.slice(0, 1).toUpperCase() + s.slice(1).toLowerCase())
   .join(' ')

else

str.split(' ').map(function (s) {
    return s.slice(0, 1).toUpperCase() + s.slice(1).toLowerCase();
}).join(' ')
8
jssridhar

Ich habe diese Funktion erstellt, die mit Nachnamen umgehen kann (also nicht mit dem Titel.), Wie "McDonald" oder "MacDonald" oder "O'Toole" oder "D'Orazio". Es behandelt jedoch keine deutschen oder niederländischen Namen mit "van" oder "von", die oft in Kleinbuchstaben geschrieben sind. Ich glaube, dass "de" oft auch Kleinbuchstaben wie "Robert de Niro" ist. Diese müssten noch angegangen werden.

function toProperCase(s)
{
  return s.toLowerCase().replace( /\b((m)(a?c))?(\w)/g,
          function($1, $2, $3, $4, $5) { if($2){return $3.toUpperCase()+$4+$5.toUpperCase();} return $1.toUpperCase(); });
}
8
Lwangaman

Versuche dies

String.prototype.toProperCase = function(){
    return this.toLowerCase().replace(/(^[a-z]| [a-z]|-[a-z])/g, 
        function($1){
            return $1.toUpperCase();
        }
    );
};

Beispiel

var str = 'john smith';
str.toProperCase();
7
Maxi Baez
var toMatch = "john w. smith";
var result = toMatch.replace(/(\w)(\w*)/g, function (_, i, r) {
      return i.toUpperCase() + (r != null ? r : "");
    }
)

Scheint zu funktionieren ... Getestet mit den oben genannten, "die schnell-braun, Fuchs?/Springt/^ über ^ den ¡Lazy! Hund ..." und "C:/Programmdateien/einige Anbieter/ihre 2. Anwendung/eine Datei1.txt ".

Wenn Sie 2Nd anstelle von 2nd wünschen, können Sie zu /([a-z])(\w*)/g wechseln.

Das erste Formular kann vereinfacht werden als:

function toTitleCase(toTransform) {
  return toTransform.replace(/\b([a-z])/g, function (_, initial) {
      return initial.toUpperCase();
  });
}
7
PhiLho

Versuchen Sie diesen kürzesten Weg:

str.replace(/(^[a-z])|(\s+[a-z])/g, txt => txt.toUpperCase());
7
Vikram

Ich denke, das einfachste ist die Verwendung von css. 

function format_str(str) {
    str = str.toLowerCase();
    return '<span style="text-transform: capitalize">'+ str +'</span>';
}
6
wondim

Die meisten dieser Antworten scheinen die Möglichkeit der Verwendung des Word-Begrenzungs-Metazeichens (\ b) zu ignorieren. Eine kürzere Version der Antwort von Greg Dean, die sie verwendet:

function toTitleCase(str)
{
    return str.replace(/\b\w/g, function (txt) { return txt.toUpperCase(); });
}

Funktioniert auch für Namen mit Bindestrich wie Jim-Bob.

6
lewax00
"john f. kennedy".replace(/\b\S/g, t => t.toUpperCase())
5
Proximo

Verwenden Sie /\S+/g, um diakritische Zeichen zu unterstützen:

function toTitleCase(str) {
  return str.replace(/\S+/g, str => str.charAt(0).toUpperCase() + str.substr(1).toLowerCase());
}

console.log(toTitleCase("a city named örebro")); // A City Named Örebro

Jedoch: "s unshine (y bellow)" ⇒ "S unshine (y hunter)

5
le_m

Wenn Sie in Ihrem Code Bibliotheken von Drittanbietern verwenden können, hat lodash eine Hilfsfunktion für uns.

https://lodash.com/docs/4.17.3#startCase

_.startCase('foo bar');
// => 'Foo Bar'

_.startCase('--foo-bar--');
// => 'Foo Bar'
 
_.startCase('fooBar');
// => 'Foo Bar'
 
_.startCase('__FOO_BAR__');
// => 'FOO BAR'

5
waqas

Unter Verwendung der "lewax00" -Lösung habe ich diese einfache Lösung erstellt, die "w" beginnend mit dem Leerzeichen oder "w" erzwingt, das de Word initiiert, die zusätzlichen Zwischenräume jedoch nicht entfernen kann.

"SOFÍA vergara".toLowerCase().replace(/\b(\s\w|^\w)/g, function (txt) { return txt.toUpperCase(); });

Das Ergebnis ist "Sofía Vergara".

4
Asereware

Wir haben hier im Büro eine Diskussion geführt und denken, dass der Versuch, die Eingabe von Namen in der von Ihnen gewünschten Weise automatisch zu korrigieren, mit möglichen Problemen behaftet ist.

Wir haben uns mehrere Fälle ausgedacht, in denen verschiedene Arten der automatischen Großschreibung auseinanderfallen und diese nur für englische Namen gelten. Jede Sprache hat ihre eigenen Komplexitäten.

Probleme mit der Großschreibung des ersten Buchstabens jedes Namens:

• Akronyme wie IBM dürfen nicht eingegeben werden und werden zu IBM.

• Der Name McDonald würde zu Mcdonald werden, was falsch ist. Das Gleiche gilt auch für MacDonald.

• Doppelte Namen wie Marie-Tonks werden zu Marie-Tonks.

• Namen wie O’Connor werden zu O’connor.

Für die meisten davon können Sie benutzerdefinierte Regeln schreiben, um damit umzugehen. Dies hat jedoch nach wie vor Probleme mit Akronymen und Sie erhalten ein neues Problem:

• Wenn Sie eine Regel hinzufügen, um Namen mit Mac wie MacDonald zu korrigieren, werden die Umbruchnamen wie Macy in MacY umgewandelt.

Die einzige Lösung, die wir gefunden haben und die niemals falsch ist, besteht darin, jeden Buchstaben in Großbuchstaben zu schreiben. Dies ist eine Brute-Force-Methode, die anscheinend auch vom DBS verwendet wird.

Wenn Sie also den Prozess automatisieren möchten, ist es so gut wie unmöglich, auf ein Wörterbuch mit jedem einzelnen Namen und Wort zu verzichten, und wie es kapituliert werden sollte. Wenn Sie keine Regel haben, ist das so deckt alles ab, benutze es nicht, da es nur deine Benutzer und Eingabeaufforderer nervt, die ihre Namen korrekt eingeben wollen, um woanders hinzugehen.

3
jjr2000

Für diejenigen von uns, die Angst vor regulären Ausdrücken haben (lol):

function titleCase(str)
{
    var words = str.split(" ");
    for ( var i = 0; i < words.length; i++ )
    {
        var j = words[i].charAt(0).toUpperCase();
        words[i] = j + words[i].substr(1);
    }
    return words.join(" ");
}

3
lashja

Hier ist meine Funktion, die sich um akzentuierte Charaktere kümmert (wichtig für Französisch!), Und die die Handhabung niedrigerer Ausnahmen ein- und ausschalten kann. Hoffentlich hilft das.

String.prototype.titlecase = function(lang, withLowers = false) {
    var i, string, lowers, uppers;

    string = this.replace(/([^\s:\-'])([^\s:\-']*)/g, function(txt) {
        return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
    }).replace(/Mc(.)/g, function(match, next) {
        return 'Mc' + next.toUpperCase();
    });

    if (withLowers) {
        if (lang == 'EN') {
            lowers = ['A', 'An', 'The', 'At', 'By', 'For', 'In', 'Of', 'On', 'To', 'Up', 'And', 'As', 'But', 'Or', 'Nor', 'Not'];
        }
        else {
            lowers = ['Un', 'Une', 'Le', 'La', 'Les', 'Du', 'De', 'Des', 'À', 'Au', 'Aux', 'Par', 'Pour', 'Dans', 'Sur', 'Et', 'Comme', 'Mais', 'Ou', 'Où', 'Ne', 'Ni', 'Pas'];
        }
        for (i = 0; i < lowers.length; i++) {
            string = string.replace(new RegExp('\\s' + lowers[i] + '\\s', 'g'), function(txt) {
                return txt.toLowerCase();
            });
        }
    }

    uppers = ['Id', 'R&d'];
    for (i = 0; i < uppers.length; i++) {
        string = string.replace(new RegExp('\\b' + uppers[i] + '\\b', 'g'), uppers[i].toUpperCase());
    }

    return string;
}
3
Ouatataz

Ich wollte meine eigene Antwort hinzufügen, da ich eine robuste toTitleCase-Funktion benötigte, die Grammatikregeln hier aufgeführt (von Google empfohlener Artikel) berücksichtigt. Es gibt verschiedene Regeln, die von der Länge der Eingabezeichenfolge abhängen. Nachfolgend finden Sie die Funktion + Unit-Tests.

Die Funktion konsolidiert auch Leerzeichen und entfernt Sonderzeichen (Regex nach Ihren Wünschen ändern).

toTitleCase-Funktion

const toTitleCase = (str) => {
  const articles = ['a', 'an', 'the'];
  const conjunctions = ['for', 'and', 'nor', 'but', 'or', 'yet', 'so'];
  const prepositions = [
    'with', 'at', 'from', 'into','upon', 'of', 'to', 'in', 'for',
    'on', 'by', 'like', 'over', 'plus', 'but', 'up', 'down', 'off', 'near'
  ];

  // The list of spacial characters can be tweaked here
  const replaceCharsWithSpace = (str) => str.replace(/[^0-9a-z&/\\]/gi, ' ').replace(/(\s\s+)/gi, ' ');
  const capitalizeFirstLetter = (str) => str.charAt(0).toUpperCase() + str.substr(1);
  const normalizeStr = (str) => str.toLowerCase().trim();
  const shouldCapitalize = (Word, fullWordList, posWithinStr) => {
    if ((posWithinStr == 0) || (posWithinStr == fullWordList.length - 1)) {
      return true;
    }

    return !(articles.includes(Word) || conjunctions.includes(Word) || prepositions.includes(Word));
  }

  str = replaceCharsWithSpace(str);
  str = normalizeStr(str);

  let words = str.split(' ');
  if (words.length <= 2) { // Strings less than 3 words long should always have first words capitalized
    words = words.map(w => capitalizeFirstLetter(w));
  }
  else {
    for (let i = 0; i < words.length; i++) {
      words[i] = (shouldCapitalize(words[i], words, i) ? capitalizeFirstLetter(words[i], words, i) : words[i]);
    }
  }

  return words.join(' ');
}

Unit-Tests zur Sicherstellung der Korrektheit

import { expect } from 'chai';
import { toTitleCase } from '../../src/lib/stringHelper';

describe('toTitleCase', () => {
  it('Capitalizes first letter of each Word irrespective of articles, conjunctions or prepositions if string is no greater than two words long', function(){
    expect(toTitleCase('the dog')).to.equal('The Dog'); // Capitalize articles when only two words long
    expect(toTitleCase('for all')).to.equal('For All'); // Capitalize conjunctions when only two words long
    expect(toTitleCase('with cats')).to.equal('With Cats'); // Capitalize prepositions when only two words long
  });

  it('Always capitalize first and last words in a string irrespective of articles, conjunctions or prepositions', function(){
    expect(toTitleCase('the beautiful dog')).to.equal('The Beautiful Dog');
    expect(toTitleCase('for all the deadly ninjas, be it so')).to.equal('For All the Deadly Ninjas Be It So');
    expect(toTitleCase('with cats and dogs we are near')).to.equal('With Cats and Dogs We Are Near');
  });

  it('Replace special characters with space', function(){
    expect(toTitleCase('[wolves & lions]: be careful')).to.equal('Wolves & Lions Be Careful');
    expect(toTitleCase('wolves & lions, be careful')).to.equal('Wolves & Lions Be Careful');
  });

  it('Trim whitespace at beginning and end', function(){
    expect(toTitleCase(' mario & Luigi superstar saga ')).to.equal('Mario & Luigi Superstar Saga');
  });

  it('articles, conjunctions and prepositions should not be capitalized in strings of 3+ words', function(){
    expect(toTitleCase('The wolf and the lion: a tale of two like animals')).to.equal('The Wolf and the Lion a Tale of Two like Animals');
    expect(toTitleCase('the  three Musketeers  And plus ')).to.equal('The Three Musketeers and Plus');
  });
});

Bitte beachten Sie, dass ich einige Sonderzeichen aus den bereitgestellten Zeichenfolgen entferne. Sie müssen den Regex anpassen, um die Anforderungen Ihres Projekts zu erfüllen.

3
dipole_moment

Meine einfache und einfache Version zum Problem:

    function titlecase(str){
    var arr=[];  
    var str1=str.split(' ');
    for (var i = 0; i < str1.length; i++) {
    var upper= str1[i].charAt(0).toUpperCase()+ str1[i].substr(1);
    arr.Push(upper);
     };
      return arr.join(' ');
    }
    titlecase('my name is suryatapa roy');
2
Suryatapa

Konvertieren Sie zuerst Ihre string in ein Array durch Aufteilen durch Leerzeichen:

var words = str.split(' ');

Erstellen Sie dann mit array.map ein neues Array mit den großgeschriebenen Wörtern.

var capitalized = words.map(function(Word) {
    return Word.charAt(0).toUpperCase() + Word.substring(1, Word.length);
});

Dann join das neue Array mit Leerzeichen:

capitalized.join(" ");

function titleCase(str) {
  str = str.toLowerCase(); //ensure the HeLlo will become Hello at the end
  var words = str.split(" ");

  var capitalized = words.map(function(Word) {
    return Word.charAt(0).toUpperCase() + Word.substring(1, Word.length);
  });
  return capitalized.join(" ");
}

console.log(titleCase("I'm a little tea pot"));

HINWEIS:

Dies hat natürlich einen Nachteil. Dadurch wird nur der erste Buchstabe jedes Wortes großgeschrieben. Bei Word bedeutet dies, dass jede Zeichenfolge, die meine Leerzeichen getrennt, als 1 Wort behandelt wird.

Angeblich hast du:

str = "I'm a little/small tea pot";

Das wird produzieren 

Ich bin A Little/small Tea Pot

im Vergleich zu den erwarteten

Ich bin eine kleine/kleine Teekanne

In diesem Fall machen Regex und .replace den Trick:

mit ES6:

const capitalize = str => str.length
  ? str[0].toUpperCase() +
    str.slice(1).toLowerCase()
  : '';

const escape = str => str.replace(/./g, c => `\\${c}`);
const titleCase = (sentence, seps = ' _-/') => {
  let wordPattern = new RegExp(`[^${escape(seps)}]+`, 'g');
  
  return sentence.replace(wordPattern, capitalize);
};
console.log( titleCase("I'm a little/small tea pot.") );

oder ohne ES6:

function capitalize(str) {
  return str.charAt(0).toUpperCase() + str.substring(1, str.length).toLowerCase();
}

function titleCase(str) {
  return str.replace(/[^\ \/\-\_]+/g, capitalize);
}

console.log(titleCase("hello/hi world"));

2
Geoman Yabes

Dies basiert auf meiner Lösung für FreeCodeCamps Bonfire "Title Case" , bei der Sie die angegebene Zeichenfolge zunächst in Kleinbuchstaben und dann jedes Zeichen mit Leerzeichen in Großbuchstaben konvertieren müssen.

Ohne Regex zu verwenden:

function titleCase(str) {
 return str.toLowerCase().split(' ').map(function(val) { return val.replace(val[0], val[0].toUpperCase()); }).join(' ');
}
2

Es ist nicht kurz, aber hier habe ich kürzlich eine Aufgabe in der Schule gefunden:

var myPoem = 'What is a jQuery but a misunderstood object?'
//What is a jQuery but a misunderstood object? --> What Is A JQuery But A Misunderstood Object?

  //code here
var capitalize = function(str) {
  var strArr = str.split(' ');
  var newArr = [];
  for (var i = 0; i < strArr.length; i++) {
    newArr.Push(strArr[i].charAt(0).toUpperCase() + strArr[i].slice(1))
  };
  return newArr.join(' ')  
}

var fixedPoem = capitalize(myPoem);
alert(fixedPoem);

1

So umfassend wie die Lösung von John Resig, aber als One-Liner: (basierend auf diesem Github-Projekt )

function toTitleCase(e){var t=/^(a|an|and|as|at|but|by|en|for|if|in|of|on|or|the|to|vs?\.?|via)$/i;return e.replace(/([^\W_]+[^\s-]*) */g,function(e,n,r,i){return r>0&&r+n.length!==i.length&&n.search(t)>-1&&i.charAt(r-2)!==":"&&i.charAt(r-1).search(/[^\s-]/)<0?e.toLowerCase():n.substr(1).search(/[A-Z]|\../)>-1?e:e.charAt(0).toUpperCase()+e.substr(1)})};

console.log( toTitleCase( "ignores mixed case words like iTunes, and allows AT&A and website.com/address etc..." ) );
1
Billy Moon

hier ist eine andere Lösung, die css verwendet (und Javascript, wenn der zu transformierende Text in Großbuchstaben ist):

html

<span id='text'>JOHN SMITH</span>

js

var str = document.getElementById('text').innerHtml;
var return_text = str.toLowerCase();

css

#text{text-transform:capitalize;}
1
henrie

https://lodash.com/docs/4.17.11#capitalize

Verwenden Sie Lodash Library .. !! Zuverlässiger

_.capitalize('FRED'); => 'Fred'
1
Siddharth Joshi

this is a test ---> This Is A Test

function capitalize(str) {

  const Word = [];

  for (let char of str.split(' ')) {
    Word.Push(char[0].toUpperCase() + char.slice(1))
  }

  return Word.join(' ');

}

console.log(capitalize("this is a test"));

1
bajran

Hier ist eine kompakte Lösung für das Problem:

function Title_Case(phrase) 
{
  var revised = phrase.charAt(0).toUpperCase();

  for ( var i = 1; i < phrase.length; i++ ) {

    if (phrase.charAt(i - 1) == " ") {
     revised += phrase.charAt(i).toUpperCase(); }
    else {
     revised += phrase.charAt(i).toLowerCase(); }

   }

return revised;
}
1
Covfefe

Robuste Funktionale Programmierweise Title Case Function

Exaplin Version

function toTitleCase(input){
    let output = input
        .split(' ')  // 'HOw aRe YOU' => ['HOw' 'aRe' 'YOU']
        .map((letter) => {
            let firstLetter = letter[0].toUpperCase() // H , a , Y  => H , A , Y
            let restLetters = letter.substring(1).toLowerCase() // Ow, Re, OU => ow, re, ou
            return firstLetter + restLetters // conbine together
        })
        .join(' ') //['How' 'Are' 'You'] => 'How Are You'
    return output
}

Implementierungsversion

function toTitleCase(input){
    return input
            .split(' ')
            .map(i => i[0].toUpperCase() + i.substring(1).toLowerCase())
            .join(' ') 
}

toTitleCase('HoW ARe yoU') // reuturn 'How Are You'
1
Wayne Chiu

Prototyplösung der Lösung von Greg Dean:

String.prototype.capitalize = function() {
  return this.replace(/\w\S*/g, function(txt){return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();});
}
1
dipole_moment

Einfachere, performantere Version mit einfachem Caching. 

  var TITLE_CASE_LOWER_MAP = {
    'a': 1, 'an': 1, 'and': 1, 'as': 1, 'at': 1, 'but': 1, 'by': 1, 'en':1, 'with': 1,
    'for': 1, 'if': 1, 'in': 1, 'of': 1, 'on': 1, 'the': 1, 'to': 1, 'via': 1
  };

  // LEAK/CACHE TODO: evaluate using LRU.
  var TITLE_CASE_CACHE = new Object();

  toTitleCase: function (title) {
    if (!title) return null;

    var result = TITLE_CASE_CACHE[title];
    if (result) {
      return result;
    }

    result = "";
    var split = title.toLowerCase().split(" ");
    for (var i=0; i < split.length; i++) {

      if (i > 0) {
        result += " ";
      }

      var Word = split[i];
      if (i == 0 || TITLE_CASE_LOWER_MAP[Word] != 1) {
        Word = Word.substr(0,1).toUpperCase() + Word.substr(1);
      }

      result += Word;
    }

    TITLE_CASE_CACHE[title] = result;

    return result;
  },

1
Rafael Sanches

Es gab einige großartige Antworten, aber mit vielen Leuten, die Regex verwenden, um das Wort zu finden, aber aus irgendeinem Grund verwendet niemand sonst Regex, um das erste Zeichen zu ersetzen. Zur Erklärung werde ich eine lange und eine kürzere Lösung anbieten.

Die lange Lösung (erklärender). Mit dem regulären Ausdruck [^\s_\-/]* können wir jedes Wort im Satz finden. Anschließend können wir den regulären Ausdruck . verwenden, um das erste Zeichen in einem Word zu finden. Wenn Sie die reguläre Ausdrucksversion von replace für beide verwenden, können Sie die Lösung folgendermaßen ändern:

function toUpperCase(str) { return str.toUpperCase(); }
function capitalizeWord(Word) { return Word.replace(/./, toUpperCase); }
function capitalize(sentence) { return sentence.toLowerCase().replace(/[^\s_\-/]*/g, capitalizeWord); }

console.log(capitalize("hello world")); // Outputs: Hello World

Für eine einzelne Funktion, die dasselbe tut, verschachteln wir die replace-Aufrufe wie folgt:

function capitalize(sentence) {
  return sentence.toLowerCase().replace(/[^\s_\-/]*/g, function (Word) {
    return Word.replace(/./, function (ch) { return ch.toUpperCase(); } );
  } );
}

console.log(capitalize("hello world")); // Outputs: Hello World

1
Stephen Quan

john Smith -> John Smith

'john smith'.replace(/(^\w|\s+\w){1}/g, function(str){ return str.toUpperCase() } );
0
iMartin

Diese Lösung berücksichtigt die Satzzeichen für neue Sätze, verarbeitet Zitate, wandelt kleinere Wörter in Kleinbuchstaben um und ignoriert Akronyme oder Großbuchstaben.

var stopWordsArray = new Array("a", "all", "am", "an", "and", "any", "are", "as", "at", "be", "but", "by", "can", "can't", "did", "didn't", "do", "does", "doesn't", "don't", "else", "for", "get", "gets", "go", "got", "had", "has", "he", "he's", "her", "here", "hers", "hi", "him", "his", "how", "i'd", "i'll", "i'm", "i've", "if", "in", "is", "isn't", "it", "it's", "its", "let", "let's", "may", "me", "my", "no", "of", "off", "on", "our", "ours", "she", "so", "than", "that", "that's", "thats", "the", "their", "theirs", "them", "then", "there", "there's", "these", "they", "they'd", "they'll", "they're", "they've", "this", "those", "to", "too", "try", "until", "us", "want", "wants", "was", "wasn't", "we", "we'd", "we'll", "we're", "we've", "well", "went", "were", "weren't", "what", "what's", "when", "where", "which", "who", "who's", "whose", "why", "will", "with", "won't", "would", "yes", "yet", "you", "you'd", "you'll", "you're", "you've", "your");

// Only significant words are transformed. Handles acronyms and punctuation
String.prototype.toTitleCase = function() {
    var newSentence = true;
    return this.split(/\s+/).map(function(Word) {
        if (Word == "") { return; }
        var canCapitalise = true;
        // Get the pos of the first alpha char (Word might start with " or ')
        var firstAlphaCharPos = Word.search(/\w/);
        // Check for uppercase char that is not the first char (might be acronym or all caps)
        if (Word.search(/[A-Z]/) > 0) {
            canCapitalise = false;
        } else if (stopWordsArray.indexOf(Word) != -1) {
            // Is a stop Word and not a new sentence
            Word.toLowerCase();
            if (!newSentence) {
                canCapitalise = false;
            }
        }
        // Is this the last Word in a sentence?
        newSentence = (Word.search(/[\.!\?:]['"]?$/) > 0)? true : false;
        return (canCapitalise)? Word.replace(Word[firstAlphaCharPos], Word[firstAlphaCharPos].toUpperCase()) : Word;
    }).join(' ');
}

// Pass a string using dot notation:
alert("A critical examination of Plato's view of the human nature".toTitleCase());
var str = "Ten years on: a study into the effectiveness of NCEA in New Zealand schools";
str.toTitleCase());
str = "\"Where to from here?\" the effectivness of eLearning in childhood education";
alert(str.toTitleCase());

/* Result:
A Critical Examination of Plato's View of the Human Nature.
Ten Years On: A Study Into the Effectiveness of NCEA in New Zealand Schools.
"Where to From Here?" The Effectivness of eLearning in Childhood Education. */
0
chasnz

Eine Methode verwenden reduzieren

function titleCase(str) {
  const arr = str.split(" ");
  const result = arr.reduce((acc, cur) => {
    const newStr = cur[0].toUpperCase() + cur.slice(1).toLowerCase();
    return acc += `${newStr} `
  },"")
  return result.slice(0, result.length-1);
}

0
Wayne Li
function toTitleCase(str) {
  var strnew = "";
  var i = 0;

  for (i = 0; i < str.length; i++) {
    if (i == 0) {
      strnew = strnew + str[i].toUpperCase();
    } else if (i != 0 && str[i - 1] == " ") {
      strnew = strnew + str[i].toUpperCase();
    } else {
      strnew = strnew + str[i];
    }
  }

  alert(strnew);
}

toTitleCase("hello world how are u");
0
vijayscode
ES-6 way to get title case of a Word or entire line.
ex. input = 'hEllo' --> result = 'Hello'
ex. input = 'heLLo woRLd' --> result = 'Hello World'

const getTitleCase = (str) => {
  if(str.toLowerCase().indexOf(' ') > 0) {
    return str.toLowerCase().split(' ').map((Word) => {
      return Word.replace(Word[0], Word[0].toUpperCase());
    }).join(' ');
  }
  else {
    return str.slice(0, 1).toUpperCase() + str.slice(1).toLowerCase();
  }
}
0
Mayur Nandane

Meine einzeilige Lösung:

String.prototype.capitalizeWords = function() {
    return this.split(" ").map(function(ele){ return ele[0].toUpperCase() + ele.slice(1).toLowerCase();}).join(" ");
};

Anschließend können Sie die Methode capitalizeWords() für eine beliebige Zeichenfolge aufrufen. Zum Beispiel:

var myS = "this actually works!";
myS.capitalizeWords();

>>> This Actually Works

Meine andere Lösung:

function capitalizeFirstLetter(Word) {
    return Word[0].toUpperCase() + Word.slice(1).toLowerCase();
}
String.prototype.capitalizeAllWords = function() {
    var arr = this.split(" ");
    for(var i = 0; i < arr.length; i++) {
        arr[i] = capitalizeFirstLetter(arr[i]);
    }
    return arr.join(" ");
};

Anschließend können Sie die Methode capitalizeWords() für eine beliebige Zeichenfolge aufrufen. Zum Beispiel:

var myStr = "this one works too!";
myStr.capitalizeWords();

>>> This One Works Too

Alternative Lösung basierend auf der Antwort von Greg Dean:

function capitalizeFirstLetter(Word) {
    return Word[0].toUpperCase() + Word.slice(1).toLowerCase();
}
String.prototype.capitalizeWords = function() {
    return this.replace(/\w\S*/g, capitalizeFirstLetter);
};

Anschließend können Sie die Methode capitalizeWords() für eine beliebige Zeichenfolge aufrufen. Zum Beispiel:

var myString = "yes and no";
myString.capitalizeWords()

>>> Yes And No
0
FouadDev
function titleCase(str) {
    str = str.toLowerCase();

    var strArray = str.split(" ");


    for(var i = 0; i < strArray.length; i++){
        strArray[i] = strArray[i].charAt(0).toUpperCase() + strArray[i].substr(1);

    }

    var result = strArray.join(" ");

    //Return the string
    return result;
}
0
Pro N00P
String.prototype.capitalize = function() {
    return this.toLowerCase().split(' ').map(capFirst).join(' ');
    function capFirst(str) {
        return str.length === 0 ? str : str[0].toUpperCase() + str.substr(1);
    }
}

Verwendungszweck:

"hello world".capitalize()
0
zurfyx

Ein anderer Ansatz, um etwas Ähnliches zu erreichen, kann wie folgt aussehen.

formatName(name) {
    let nam = '';
    name.split(' ').map((Word, index) => {
        if (index === 0) {
            nam += Word.split('').map((l, i) => i === 0 ? l.toUpperCase() : l.toLowerCase()).join('');
        } else {
            nam += ' ' + Word.split('').map(l => l.toLowerCase()).join('');
        }
    });
    return nam;
}
0
Muhammad Usman

Dies ist eine einzeilige Lösung. Wenn Sie jede Arbeit in der Zeichenfolge konvertieren möchten, teilen Sie die Zeichenfolge durch "", wiederholen Sie die Teile und wenden Sie diese Lösung auf jeden Teil an. Fügen Sie jeden konvertierten Teil einem Array hinzu und verknüpfen Sie ihn mit "".

var stringToConvert = 'john';
stringToConvert = stringToConvert.charAt(0).toUpperCase() + Array.prototype.slice.call(stringToConvert, 1).join('');
console.log(stringToConvert);

0
CodeMaxter