Konvertieren Sie die Zeichenfolge mit JavaScript in Groß- und Kleinschreibung

Gibt es eine einfache Möglichkeit, eine Zeichenfolge in Groß- und Kleinschreibung umzuwandeln? ZB john smithwird John Smith. Ich suche nicht nach etwas Kompliziertem wie John Resigs Lösung , sondern (hoffentlich) nach einer Art Ein- oder Zweiliner.

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>

Eine etwas elegantere Art, 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();});
};

Nennen Sie es wie:

"pascal".toProperCase();

Versuchen Sie, die anzuwenden text-trans CSS Stil , um Ihre Kontrollen.

z.B: (text-transform: capitalize);

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

Hier ist meine Version, IMO, es ist leicht zu verstehen und auch elegant.

var str = "foo bar baz"

console.log(

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

)
// returns "Foo Bar Baz"

Hier ist meine Funktion, die in Groß- und Kleinschreibung konvertiert wird, aber auch definierte Akronyme als Groß- und Kleinwörter als Kleinbuchstaben 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:"

Ich bevorzuge das Folgende gegenüber 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 bleiben erhalten, um verzerrende Akronyme zu vermeiden. Sie können jedoch immer toLowerCase()zuerst Ihre Zeichenfolge aufrufen .

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

Sie können dies zu Ihrem String-Prototyp hinzufügen, wodurch Sie 'my string'.toTitle()Folgendes tun können:

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

Beispiel:

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

console.log('all lower case ->','all lower case'.toTitle());
console.log('ALL UPPER CASE ->','ALL UPPER CASE'.toTitle());
console.log("I'm a little teapot ->","I'm a little teapot".toTitle());

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(' ');
};

console.log(
  'john smith'.toProperCase()
)

Sie könnten sofort toLowerCasedie Zeichenfolge und dann nur toUpperCaseden ersten Buchstaben jedes Wortes. Wird ein sehr einfacher 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'));

Nur für den Fall, dass Sie sich über diese Füllwörter Sorgen machen, können Sie der Funktion immer nur mitteilen, was nicht groß geschrieben werden soll.

/**
 * @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 weiter.

bearbeiten

Wenn Sie mit führenden Leimwörtern umgehen möchten, können Sie diese mit einer weiteren Variablen verfolgen:

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;
    });
};

Wenn der in den oben genannten Lösungen verwendete reguläre Ausdruck 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(' ');
}

Ich habe diese Funktion erstellt, die Nachnamen (also keine Groß- und Kleinschreibung) wie "McDonald" oder "MacDonald" oder "O'Toole" oder "D'Orazio" verarbeiten kann. Deutsche oder niederländische Namen mit "van" oder "von", die oft in Kleinbuchstaben geschrieben sind, werden jedoch nicht behandelt. Ich glaube, "de" ist oft auch in Kleinbuchstaben wie "Robert de Niro". 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(); });
}

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 dem oben Gesagten: "Der schnell braune Fuchs? / Springt / ^ über ^ den ¡faulen! Hund ..." und "C: / Programme / einige Anbieter / ihre 2. Anwendung / a file1.txt ".

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

Die erste Form kann vereinfacht werden als:

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

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();

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'

Versuchen Sie dies auf kürzestem Weg:

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

ES 6

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

sonst

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

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

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

Funktioniert auch für getrennte Namen wie Jim-Bob.

Ich denke, das einfachste ist die Verwendung von CSS.

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

Verwenden Sie /\S+/gzur Unterstützung diakritische Zeichen:

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

Allerdings: " s unshine ( y ellow)" ⇒ " S unshine ( y ellow)"

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

Die Funktion konsolidiert auch Leerzeichen und entfernt Sonderzeichen (ändern Sie den regulären Ausdruck an Ihre Bedürfnisse).

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 Richtigkeit

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 regulären Ausdruck anpassen, um die Anforderungen Ihres Projekts zu erfüllen.

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

Mit der "lewax00" -Lösung habe ich diese einfache Lösung erstellt, die "w" beginnend mit Leerzeichen oder "w" erzwingt, die de word initiieren, aber die zusätzlichen Zwischenräume nicht entfernen kann.

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

Das Ergebnis ist "Sofía Vergara".

Hier ist meine Funktion, die sich um akzentuierte Zeichen kümmert (wichtig für Französisch!) Und die Behandlung von niedrigeren Ausnahmen ein- und ausschalten kann. Ich hoffe, das hilft.

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;
}

Wir haben hier im Büro eine Diskussion geführt und sind der Meinung, dass der Versuch, die Art und Weise, wie Personen Namen eingeben, automatisch so zu korrigieren, wie Sie es möchten, 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 eigene Komplexität.

Probleme beim Großschreiben des ersten Buchstabens jedes Namens:

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

• Der Name McDonald würde sich in Mcdonald verwandeln, was falsch ist, das gleiche gilt auch für MacDonald.

• Doppelte Namen wie Marie-Tonks würden zu Marie-Tonks.

• Namen wie O'Connor würden zu O'connor.

Für die meisten von ihnen könnten Sie benutzerdefinierte Regeln schreiben, um damit umzugehen. Dies hat jedoch weiterhin Probleme mit Akronymen wie zuvor und Sie erhalten ein neues Problem:

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

Die einzige Lösung, die wir gefunden haben und die niemals falsch ist, besteht darin, jeden Buchstaben groß zu schreiben, was eine Brute-Force-Methode ist, die das DBS anscheinend auch verwendet.

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 darauf, wie es kapituliert werden sollte. Wenn Sie keine Regel haben, die alles abdeckt, verwenden Sie es nicht so, wie es ist ärgert nur Ihre Benutzer und fordert Personen, die ihre Namen korrekt eingeben möchten, auf, woanders hinzugehen.

Hier ist eine andere Lösung mit CSS (und Javascript, wenn der zu transformierende Text in Großbuchstaben geschrieben 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;}

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(" ");
}

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 Greg Dean Antwort:

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

Überrascht zu sehen, dass niemand die Verwendung von Ruheparametern erwähnte. Hier ist ein einfacher Einzeiler, der ES6 Rest-Parameter verwendet.

let str="john smith"
str=str.split(" ").map(([firstChar,...rest])=>firstChar.toUpperCase()+rest.join("").toLowerCase()).join(" ")
console.log(str)

Dies basiert auf meiner Lösung für FreeCodeCamps Bonfire "Title Case" , bei der Sie zuerst die angegebene Zeichenfolge in Kleinbuchstaben konvertieren und dann jedes Zeichen, das ein Leerzeichen in Großbuchstaben umwandelt, 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(' ');
}