Konvertieren von string zu Titel Fall mit JavaScript

Etwas eleganter Weg, die Anpassung Greg Dean ' s-Funktion:

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

Nennen mag:

"pascal".toProperCase();

InformationsquelleAutor Tuan

Hier ist meine version, IMO ist es einfach zu verstehen und elegant zu.

var str = "foo bar baz"

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

//returns "Foo Bar Baz"

InformationsquelleAutor a8m

Bevorzuge ich die folgenden über die anderen Antworten. Es entspricht nur den ersten Buchstaben von jedem Wort und nutzt es. Einfacher code, einfacher zu Lesen und weniger bytes. Es behält bestehende Großbuchstaben, um zu verhindern, verzerren Akronyme. Jedoch können Sie immer rufen toLowerCase() auf Ihren string-ersten.

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

Können Sie fügen Sie diese zu Ihrem string Prototyp mit denen Sie 'my string'.toTitle() wie folgt:

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

InformationsquelleAutor Tom Kay

Den Fall, Sie sind besorgt über diese filler-Wörter, Sie kann immer nur sagen, die Funktion, was nicht zu nutzen.

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

Bearbeiten

Wenn Sie wollen führende Kleber Worten, Sie können verfolgen, diese w/noch eine variable:

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

InformationsquelleAutor fncomp

Dies funktioniert nur für ein-Wort-strings, aber das ist das, was ich brauchte:

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

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

InformationsquelleAutor simo

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 der oben genannten "quick-brown-fox? /springt/^über^ die ¡faul! Hund..." und "C:/program Dateien/einige Verkäufer/die 2. Anwendung/ein file1.txt".

Wenn Sie wollen 2. anstelle von 2. Sie ändern können, um /([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();
  });
}

InformationsquelleAutor PhiLho

Versuchen, diese, kürzester Weg:

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

InformationsquelleAutor Vikram

Meisten dieser Antworten scheinen zu ignorieren, die Möglichkeit der Verwendung des Wortes Grenze Metazeichen (\b). Eine kürzere version von Greg Dean ' s Antwort, die es nutzen:

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

Werke für Bindestrich-Namen wie Jim-Bob zu.

InformationsquelleAutor lewax00

Hier ist meine Funktion, die kümmert sich um Zeichen mit Akzenten (wichtig für die französische !) und, dass können schalten Sie on/off der Umgang senkt Ausnahmen. 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;
}

InformationsquelleAutor Ouatataz

Wollte ich hinzufügen, dass meine eigene Antwort, wie ich brauchte eine robuste toTitleCase Funktion, die berücksichtigt, Grammatik-Regeln hier aufgelistet (Google empfohlenen Artikel). Es gibt verschiedene Regeln, die abhängig von der Länge der Eingabe-Zeichenkette. Unten ist die Funktion + unit-tests.

Die Funktion auch konsolidiert Leerzeichen und entfernt Sonderzeichen (ändern regex für 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, um Sicherzustellen, 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 bin der Beseitigung einiges an Sonderzeichen aus strings zur Verfügung gestellt. Müssen Sie zwicken die regex-zu-Adresse, die den Anforderungen Ihres Projekts.

InformationsquelleAutor dipole_moment

Meine simple und einfache Variante für das 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');

InformationsquelleAutor Suryatapa

Als full-featured als John Resig ' s Lösung, aber als one-liner: (basierend auf dieses 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..." ) );

InformationsquelleAutor Billy Moon