Wie kann man den ersten Buchstaben einer Zeichenfolge in Dart groß schreiben?

Wie kann ich das erste Zeichen einer Zeichenfolge groß schreiben, ohne die Groß- und Kleinschreibung eines der anderen Buchstaben zu ändern?

Zum Beispiel sollte "Dies ist eine Zeichenfolge" "Dies ist eine Zeichenfolge" ergeben.

Seit Dart Version 2.6 unterstützt Dart Erweiterungen:

extension StringExtension on String {
    String capitalize() {
      return "${this[0].toUpperCase()}${this.substring(1)}";
    }
}

Sie können Ihre Nebenstelle also einfach so anrufen:

import "string_extension.dart";

var someCapitalizedString = "someString".capitalize();

Kopieren Sie dies irgendwo:

extension CapExtension on String {
  String get inCaps => '${this[0].toUpperCase()}${this.substring(1)}';
  String get allInCaps => this.toUpperCase();
  String get capitalizeFirstofEach => this.split(" ").map((str) => str.capitalize).join(" ");
}

Verwendung:

final helloWorld = 'hello world'.inCaps; // 'Hello world'
final helloWorld = 'hello world'.allInCaps; // 'HELLO WORLD'
final helloWorld = 'hello world'.capitalizeFirstofEach; // 'Hello World'

Alte Antwort:

main() {
  String s = 'this is a string';
  print('${s[0].toUpperCase()}${s.substring(1)}');
}

void main() {
  print(capitalize("this is a string"));
  // displays "This is a string"
}

String capitalize(String s) => s[0].toUpperCase() + s.substring(1);

Sehen Sie sich dieses Snippet auf DartPad an: https://dartpad.dartlang.org/c8ffb8995abe259e9643

Alternativ können Sie das Zeichenfolgenpaket verwenden , siehe Großschreibung .

Das Analysieren von Teilzeichenfolgen in den anderen Antworten berücksichtigt keine Gebietsschema-Abweichungen. Die Funktion toBeginningOfSentenceCase () im intl/intl.dartPaket verarbeitet die einfache Satzumhüllung und das gepunktete "i" in Türkisch und Aserbaidschanisch.

import 'package:intl/intl.dart';
...
String sentence = toBeginningOfSentenceCase('this is a string'); // This is a string

Es gibt ein Utils-Paket, das diese Funktion abdeckt. Es gibt einige weitere nette Methoden für die Operation an Strings.

Installieren Sie es mit:

dependencies:
  basic_utils: ^1.2.0

Verwendung :

String capitalized = StringUtils.capitalize("helloworld");

Github:

https://github.com/Ephenodrom/Dart-Basic-Utils

Sie können dieses Paket in Flatter ReCase verwenden. Es bietet Ihnen verschiedene Funktionen zur Fallkonvertierung wie:

• snake_case
• dot.case
• Pfad / Fall
• param-case
• PascalCase
• Header-Case
• Titel Fall
• camelCase
• Satzfall

• CONSTANT_CASE

  ReCase sample = new ReCase('hello world');
  
  print(sample.sentenceCase); // Prints 'Hello world'
  

So suchen Sie nach Null- und Leerzeichenfolgen, auch mit den Kurznotationen:

  String capitalizeFirstLetter(String s) =>
  (s?.isNotEmpty ?? false) ? '${s[0].toUpperCase()}${s.substring(1)}' : s;

String capitalize(String s) => (s != null && s.length > 1)
    ? s[0].toUpperCase() + s.substring(1)
    : s != null ? s.toUpperCase() : null;

Es besteht Tests:

test('null input', () {
  expect(capitalize(null), null);
});
test('empty input', () {
  expect(capitalize(''), '');
});
test('single char input', () {
  expect(capitalize('a'), 'A');
});
test('crazy input', () {
  expect(capitalize('?a!'), '?a!');
});
test('normal input', () {
  expect(capitalize('take it easy bro!'), 'Take it easy bro!');
});

void allWordsCapitilize (String str) {
    return str.toLowerCase().split(' ').map((word) {
      String leftText = (word.length > 1) ? word.substring(1, word.length) : '';
      return word[0].toUpperCase() + leftText;
    }).join(' ');
}
allWordsCapitilize('THIS IS A TEST'); //This Is A Test

Sie sollten auch überprüfen, ob die Zeichenfolge null oder leer ist.

String capitalize(String input) {
  if (input == null) {
    throw new ArgumentError("string: $input");
  }
  if (input.length == 0) {
    return input;
  }
  return input[0].toUpperCase() + input.substring(1);
}

Wie bereits von Ephenodrom erwähnt, können Sie das Paket basic_utils in Ihre Datei pubspeck.yaml einfügen und in Ihren Dart-Dateien wie folgt verwenden:

StringUtils.capitalize("yourString");

Das ist für eine einzelne Funktion akzeptabel, aber in einer größeren Kette von Operationen wird es unangenehm.

Wie in der Dokumentation zur Dart-Sprache erläutert :

doMyOtherStuff(doMyStuff(something.doStuff()).doOtherStuff())

Dieser Code ist viel weniger lesbar als:

something.doStuff().doMyStuff().doOtherStuff().doMyOtherStuff()

Der Code ist auch viel weniger auffindbar , da eine IDE doMyStuff () nach etwas.doStuff () vorschlagen kann, aber es ist unwahrscheinlich, dass doMyOtherStuff (…) um den Ausdruck gesetzt wird.

Aus diesen Gründen sollten Sie dem String-Typ eine Erweiterungsmethode hinzufügen (Sie können dies seit Dart 2.6 tun!), Wie folgt:

/// Example : hello => Hello, WORLD => World
extension Capitalized on String {
  String capitalized() => this.substring(0, 1).toUpperCase() + this.substring(1).toLowerCase();
}```

and call it using dot notation:

`'yourString'.capitalized()`

or, if your value can be null, replacing the dot with a '?.' in the invocation:

`myObject.property?.toString()?.capitalized()`

Dieser Code funktioniert für mich.

String name = 'amina';    

print(${name[0].toUpperCase()}${name.substring(1).toLowerCase()});

Dies ist eine weitere Alternative, um Strings in Dart mithilfe der String-Klassenmethode groß zu schreiben splitMapJoin:

var str = 'this is a test';
str = str.splitMapJoin(RegExp(r'\w+'),onMatch: (m)=> '${m.group(0)}'.substring(0,1).toUpperCase() +'${m.group(0)}'.substring(1).toLowerCase() ,onNonMatch: (n)=> ' ');
print(str);  // This Is A Test 

Sie können die Methode capitalize () der Zeichenfolgenbibliothek verwenden, die jetzt in der Version 0.1.2 verfügbar ist, und die Abhängigkeit in der Datei pubspec.yaml hinzufügen:

dependencies:
  strings: ^0.1.2

und importiere es in die Dart-Datei:

import 'package:strings/strings.dart';

und jetzt können Sie die Methode verwenden, die den folgenden Prototyp hat:

String capitalize(String string)

Beispiel:

print(capitalize("mark")); => Mark 

Seltsam, dass dies zunächst nicht in Dart verfügbar ist. Unten finden Sie eine Erweiterung, um Folgendes zu aktivieren String:

extension StringExtension on String {
  String capitalized() {
    if (this.isEmpty) return this;
    return this[0].toUpperCase() + this.substring(1);
  }
}

StringZunächst wird überprüft, ob das nicht leer ist. Dann wird nur der erste Buchstabe groß geschrieben und der Rest hinzugefügt

Verwendung:

import "path/to/extension/string_extension_file_name.dart";

var capitalizedString = '${'alexander'.capitalized()} ${'hamilton, my name is'.capitalized()} ${'alexander'.capitalized()} ${'hamilton'.capitalized()}');
// Print result: "Alexander Hamilton, my name is Alexander Hamilton"

var orig = "this is a string";
var changed = orig.substring(0, 1).toUpperCase + orig.substring(1)

Einige der populäreren anderen Antworten scheinen nicht mit nullund umzugehen ''. Ich ziehe es vor, mich nicht mit diesen Situationen im Client-Code befassen zu müssen, ich möchte nur eine StringGegenleistung, egal was passiert - auch wenn dies im Falle von eine leere bedeutet null.

String upperCaseFirst(String s) => (s??'').length<1 ? '' : s[0].toUpperCase() + s.substring(1)

Sie können das Text_Tools-Paket verwenden, das einfach zu verwenden ist:

https://pub.dev/packages/text_tools

Ihr Code würde so aussehen:

//This will print 'This is a string
print(TextTools.toUppercaseFirstLetter(text: 'this is a string'));

Die einfachste Antwort ist hier:

Machen Sie zuerst den ersten Buchstaben der Zeichenfolge in Großbuchstaben, indem Sie den Index verwenden, und verknüpfen Sie dann den Rest der Zeichenfolge.

Hier ist der Benutzername die Zeichenfolge.

Benutzername [0] .toUpperCase () + Benutzername.substring (1);

String fullNameString =
    txtControllerName.value.text.trim().substring(0, 1).toUpperCase() +
        txtControllerName.value.text.trim().substring(1).toLowerCase();

Hier ist meine Antwort mit Dart-String-Methoden.

String name = "big";
String getFirstLetter = name.substring(0, 1);    
String capitalizedFirstLetter =
      name.replaceRange(0, 1, getFirstLetter.toUpperCase());  
print(capitalizedFirstLetter);

Hiermit teile ich meine Antwort

void main() {
  var data = allWordsCapitilize(" hi ram good day");
  print(data);
}

String allWordsCapitilize(String value) {
  var result = value[0].toUpperCase();
  for (int i = 1; i < value.length; i++) {
    if (value[i - 1] == " ") {
      result = result + value[i].toUpperCase();
    } else {
      result = result + value[i];
    }
  }
  return result;
}