Großschreibung von Wörtern in Zeichenfolgen

Was ist der beste Ansatz, um Wörter in einer Zeichenfolge groß zu schreiben?

/**
 * Capitalizes first letters of words in string.
 * @param {string} str String to be modified
 * @param {boolean=false} lower Whether all other letters should be lowercased
 * @return {string}
 * @usage
 *   capitalize('fix this string');     // -> 'Fix This String'
 *   capitalize('javaSCrIPT');          // -> 'JavaSCrIPT'
 *   capitalize('javaSCrIPT', true);    // -> 'Javascript'
 */
const capitalize = (str, lower = false) =>
  (lower ? str.toLowerCase() : str).replace(/(?:^|\s|["'([{])+\S/g, match => match.toUpperCase());
;

• behebt die Lösung von Marco Demaio , bei der der erste Buchstabe mit einem vorangestellten Leerzeichen nicht groß geschrieben wird.

capitalize(' javascript'); // -> ' Javascript'

• kann mit nationalen Symbolen und Buchstaben mit Akzent umgehen.

capitalize('бабушка курит трубку');  // -> 'Бабушка Курит Трубку'
capitalize('località àtilacol')      // -> 'Località Àtilacol'

• kann mit Anführungszeichen und Klammern umgehen.

capitalize(`"quotes" 'and' (braces) {braces} [braces]`);  // -> "Quotes" 'And' (Braces) {Braces} [Braces]

Die kürzeste Implementierung zum Großschreiben von Wörtern innerhalb einer Zeichenfolge ist die folgende mit den Pfeilfunktionen von ES6:

'your string'.replace(/\b\w/g, l => l.toUpperCase())
// => 'Your String'

ES5-kompatible Implementierung:

'your string'.replace(/\b\w/g, function(l){ return l.toUpperCase() })
// => 'Your String'

Der reguläre Ausdruck entspricht im Wesentlichen dem ersten Buchstaben jedes Wortes innerhalb der angegebenen Zeichenfolge und wandelt nur diesen Buchstaben in Großbuchstaben um:

• \ b entspricht einer Wortgrenze (Anfang oder Ende des Wortes);
• \ w entspricht dem folgenden Metazeichen [a-zA-Z0-9].

Informationen zu Nicht-ASCII-Zeichen finden Sie stattdessen in dieser Lösung

'ÿöur striñg'.replace(/(^|\s)\S/g, l => l.toUpperCase())

Dieser reguläre Ausdruck entspricht dem ersten Buchstaben und jedem Nicht-Leerzeichen, dem ein Leerzeichen in der angegebenen Zeichenfolge vorangestellt ist, und wandelt nur diesen Buchstaben in Großbuchstaben um:

• \ s entspricht einem Leerzeichen
• \ S entspricht einem Nicht-Leerzeichen
• (x | y) entspricht einer der angegebenen Alternativen

Eine nicht erfassende Gruppe hätte hier wie folgt verwendet werden können, /(?:^|\s)\S/gobwohl das gFlag in unserem regulären Ausdruck ohnehin keine Untergruppen beabsichtigt.

Prost!

function capitalize(s){
    return s.toLowerCase().replace( /\b./g, function(a){ return a.toUpperCase(); } );
};

capitalize('this IS THE wOrst string eVeR');

Ausgabe: "Dies ist die schlechteste Zeichenfolge aller Zeiten"

Aktualisieren:

Es scheint, dass diese Lösung meine ersetzt: https://stackoverflow.com/a/7592235/104380

Die Antwort von vsync funktioniert , solange Sie keine Buchstaben mit Akzent in der Eingabezeichenfolge haben.

Ich kenne den Grund nicht, aber anscheinend \bstimmen die in regulären Ausdrücken auch mit Akzentbuchstaben überein (getestet in IE8 und Chrome), sodass eine Zeichenfolge wie "località"falsch in"LocalitÀ"à Großbuchstaben umgewandelt wird (der Buchstabe wird großgeschrieben, weil der reguläre Ausdruck denkt, dass es sich um eine Wortgrenze handelt).

Eine allgemeinere Funktion, die auch mit Buchstaben mit Akzent funktioniert, ist diese:

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

Sie können es so verwenden:

alert( "hello località".toCapitalize() );

Da Ihnen jeder die von Ihnen angeforderte JavaScript-Antwort gegeben hat, werde ich darauf hinweisen, dass die CSS-Eigenschaft text-transform: capitalizegenau dies tut.

Mir ist klar, dass dies möglicherweise nicht das ist, wonach Sie fragen - Sie haben uns keinen Kontext angegeben, in dem Sie dies ausführen -, aber wenn es nur zur Präsentation dient, würde ich definitiv die CSS-Alternative wählen.

John Resig (von jQuery) portierte ein von John Gruber geschriebenes Perl-Skript nach JavaScript. Dieses Skript wird intelligenter großgeschrieben, es werden keine kleinen Wörter wie "von" und "und" großgeschrieben.

Sie finden es hier: Titel Großschreibung in JavaScript

Verwenden von JavaScript und HTML

String.prototype.capitalize = function() {
  return this.replace(/(^|\s)([a-z])/g, function(m, p1, p2) {
    return p1 + p2.toUpperCase();
  });
};

<form name="form1" method="post">
  <input name="instring" type="text" value="this is the text string" size="30">
  <input type="button" name="Capitalize" value="Capitalize >>" onclick="form1.outstring.value=form1.instring.value.capitalize();">
  <input name="outstring" type="text" value="" size="30">
</form>

Grundsätzlich können Sie dies tun string.capitalize()und es wird jeder erste Buchstabe jedes Wortes groß geschrieben.

Quelle: http://www.mediacollege.com/internet/javascript/text/case-capitalize.html

Ivos Antwort ist gut, aber ich ziehe es vor, nicht mitzuhalten, \wda 0-9 und AZ nicht groß geschrieben werden müssen. Wir können diese ignorieren und nur auf az übereinstimmen.

'your string'.replace(/\b[a-z]/g, match => match.toUpperCase())
// => 'Your String'

Es ist die gleiche Ausgabe, aber ich denke klarer in Bezug auf selbstdokumentierenden Code.

Wenn Sie lodash in Ihrer JavaScript-Anwendung verwenden, können Sie _.capitalize verwenden :

console.log( _.capitalize('ÿöur striñg') );
 

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js"></script>

Eine prägnante ES6-Methode könnte ungefähr so ​​aussehen.

const capitalizeFirstLetter = s => s.charAt(0).toUpperCase() + s.slice(1)

Dies setzt nur den ersten Buchstaben in Großbuchstaben und wirkt sich nicht auf den Rest des Satzes aus.

Dies sollte die meisten grundlegenden Anwendungsfälle abdecken.

const capitalize = (str) => {
    if (typeof str !== 'string') {
      throw Error('Feed me string')
    } else if (!str) {
      return ''
    } else {
      return str
        .split(' ')
        .map(s => {
            if (s.length == 1 ) {
                return s.toUpperCase()
            } else {
                const firstLetter = s.split('')[0].toUpperCase()
                const restOfStr = s.substr(1, s.length).toLowerCase()
                return firstLetter + restOfStr
            }     
        })
        .join(' ')
    }
}


capitalize('THIS IS A BOOK') // => This Is A Book
capitalize('this is a book') // => This Is A Book
capitalize('a 2nd 5 hour boOk thIs weEk') // => A 2nd 5 Hour Book This Week

Bearbeiten: Verbesserte Lesbarkeit der Zuordnung.

Diese Lösung verwendet keinen regulären Ausdruck, unterstützt Zeichen mit Akzent und wird auch von fast jedem Browser unterstützt.

function capitalizeIt(str) {
    if (str && typeof(str) === "string") {
        str = str.split(" ");    
        for (var i = 0, x = str.length; i < x; i++) {
            if (str[i]) {
                str[i] = str[i][0].toUpperCase() + str[i].substr(1);
            }
        }
        return str.join(" ");
    } else {
        return str;
    }
}    

Verwendung:

console.log (capitalizeIt ('çao 2nd im Javascript-Programm'));

Ausgabe:

Çao 2nd Inside Javascript-Programm

Meine Lösung:

String.prototype.toCapital = function () {
    return this.toLowerCase().split(' ').map(function (i) {
        if (i.length > 2) {
            return i.charAt(0).toUpperCase() + i.substr(1);
        }

        return i;
    }).join(' ');
};

Beispiel:

'álL riGht'.toCapital();
// Returns 'Áll Right'

http://www.mediacollege.com/internet/javascript/text/case-capitalize.html ist eine von vielen Antworten.

Google kann alles sein, was Sie für solche Probleme benötigen.

Ein naiver Ansatz wäre, die Zeichenfolge durch Leerzeichen zu teilen, den ersten Buchstaben jedes Elements des resultierenden Arrays in Großbuchstaben zu schreiben und wieder zusammenzufügen. Dies lässt die vorhandene Großschreibung in Ruhe (z. B. bleibt HTML HTML und wird nicht zu etwas Dummem wie HTML). Wenn Sie diesen Effekt nicht möchten, wandeln Sie die gesamte Zeichenfolge in Kleinbuchstaben um, bevor Sie sie aufteilen.

Dieser Code schreibt Wörter nach Punkt groß:

function capitalizeAfterPeriod(input) { 
    var text = '';
    var str = $(input).val();
    text = convert(str.toLowerCase().split('. ')).join('. ');
    var textoFormatado = convert(text.split('.')).join('.');
    $(input).val(textoFormatado);
}

function convert(str) {
   for(var i = 0; i < str.length; i++){
      str[i] = str[i].split('');
      if (str[i][0] !== undefined) {
         str[i][0] = str[i][0].toUpperCase();
      }
      str[i] = str[i].join('');
   }
   return str;
}

Ich mag es, mit einfachen Prozessen zu gehen. Ändern Sie zuerst die Zeichenfolge in Array, um das Iterieren zu vereinfachen, und ändern Sie dann mithilfe der Kartenfunktion jedes Wort so, wie Sie es möchten.

function capitalizeCase(str) {
    var arr = str.split(' ');
    var t;
    var newt;
    var newarr = arr.map(function(d){
        t = d.split('');
        newt = t.map(function(d, i){
                  if(i === 0) {
                     return d.toUpperCase();
                    }
                 return d.toLowerCase();
               });
        return newt.join('');
      });
    var s = newarr.join(' ');
    return s;
  }

Jquery oder Javascipt bieten keine integrierte Methode, um dies zu erreichen.

Die CSS-Testtransformation (Texttransformation: großschreiben;) aktiviert die Daten der Zeichenfolge nicht wirklich, zeigt jedoch ein großgeschriebenes Rendering auf dem Bildschirm an.

Wenn Sie nach einer legitimeren Möglichkeit suchen, dies auf Datenebene mit einfachem VanillaJS zu erreichen, verwenden Sie diese Lösung =>

var capitalizeString = function (word) {    
    word = word.toLowerCase();
    if (word.indexOf(" ") != -1) { // passed param contains 1 + words
        word = word.replace(/\s/g, "--");
        var result = $.camelCase("-" + word);
        return result.replace(/-/g, " ");
    } else {
    return $.camelCase("-" + word);
    }
}

Benutze das:

String.prototype.toTitleCase = function() {
  return this.charAt(0).toUpperCase() + this.slice(1);
}

let str = 'text';
document.querySelector('#demo').innerText = str.toTitleCase();

<div class = "app">
  <p id = "demo"></p>
</div>

Sie können Folgendes verwenden, um Wörter in einer Zeichenfolge groß zu schreiben:

function capitalizeAll(str){

    var partes = str.split(' ');

    var nuevoStr = ""; 

    for(i=0; i<partes.length; i++){
    nuevoStr += " "+partes[i].toLowerCase().replace(/\b\w/g, l => l.toUpperCase()).trim(); 
    }    

    return nuevoStr;

}

Es gibt auch locutus: https://locutus.io/php/strings/ucwords/, der es so definiert:

function ucwords(str) {
  //  discuss at: http://locutus.io/php/ucwords/
  // original by: Jonas Raoni Soares Silva (http://www.jsfromhell.com)
  // improved by: Waldo Malqui Silva (http://waldo.malqui.info)
  // improved by: Robin
  // improved by: Kevin van Zonneveld (http://kvz.io)
  // bugfixed by: Onno Marsman (https://twitter.com/onnomarsman)
  // bugfixed by: Cetvertacov Alexandr (https://github.com/cetver)
  //    input by: James (http://www.james-bell.co.uk/)
  //   example 1: ucwords('kevin van  zonneveld')
  //   returns 1: 'Kevin Van  Zonneveld'
  //   example 2: ucwords('HELLO WORLD')
  //   returns 2: 'HELLO WORLD'
  //   example 3: ucwords('у мэри был маленький ягненок и она его очень любила')
  //   returns 3: 'У Мэри Был Маленький Ягненок И Она Его Очень Любила'
  //   example 4: ucwords('τάχιστη αλώπηξ βαφής ψημένη γη, δρασκελίζει υπέρ νωθρού κυνός')
  //   returns 4: 'Τάχιστη Αλώπηξ Βαφής Ψημένη Γη, Δρασκελίζει Υπέρ Νωθρού Κυνός'

  return (str + '').replace(/^(.)|\s+(.)/g, function ($1) {
    return $1.toUpperCase();
  });
};

Ich würde Regex für diesen Zweck verwenden:

myString = '  this Is my sTring.  ';
myString.trim().toLowerCase().replace(/\w\S*/g, (w) => (w.replace(/^\w/, (c) => c.toUpperCase())));