You already know how to make a string in Dart. You put some text in quotes and you are done. The part that trips people up comes right after, when the text is not quite the shape you need. A user types their name with a stray space at the front. A price arrives with a comma in it and you need a plain number. You have one long line and you only want the piece before the first comma. This is where Dart string methods earn their keep. They are small built-in functions that take a string and hand you back a cleaned-up, reshaped, or checked version of it, and you will reach for them constantly once you start wiring up real Flutter screens. By the end of this post you will know the handful that cover almost everything: trimming, changing case, checking what is inside, splitting, replacing, and building new strings with interpolation.
Start with a sample string and clean it up
Everything below works on a small string or two so you can watch the method instead of the data. Most of the Dart string methods in this post start the same way, with a value you need to tidy up before you use it. Say a form hands you a name with extra spaces around it, which happens more often than you would think.
String name = ' Ada Lovelace ';
print(name.trim()); // Ada Lovelace
print(name.toUpperCase()); // ADA LOVELACE
print(name); // Ada Lovelace
Run that and the first line prints the name with the spaces gone. The trim method strips whitespace off the front and back of a string, and it is usually the very first thing you do with anything a user typed. Notice what trim does not do: it leaves the single space between Ada and Lovelace alone. It only touches the ends.
The next line changes case. toUpperCase and its partner toLowerCase do exactly what they say, and they are handy for comparing text without worrying about how someone capitalized it. Look closely at the uppercase line, though. The outer spaces are still there. Changing case does not trim, and trimming does not change case. Each method does one job.
Here is the part that surprises beginners: that last print shows the original name, spaces and all, completely unchanged. Strings in Dart are immutable, which is a fancy way of saying you cannot edit one in place. Every string method builds and returns a brand new string instead of touching the one you started with. So if you want the cleaned-up version, you have to catch it in a variable.
String clean = name.trim().toLowerCase();
print(clean); // ada lovelace
You can chain methods too, and they run left to right: trim first, then lowercase the trimmed result. One readable line, and the original name is still sitting there untouched if you need it.
Check what is inside a string
Cleaning text is one job. Asking questions about it is the other big one, and you do it constantly when you validate what a user gave you. Four methods cover most of it.
String email = 'ada@school.edu';
print(email.contains('@')); // true
print(email.startsWith('ada')); // true
print(email.endsWith('.com')); // false
print(email.indexOf('@')); // 3
contains asks a simple yes-or-no question: is this smaller piece anywhere in the string? It is perfect for a rough check, like making sure an email field at least has an at sign in it before you go further. startsWith and endsWith are the more precise cousins, checking only the front or only the back. Here endsWith('.com') comes back false because this address ends in .edu, which is exactly the kind of check that catches a typo.
indexOf goes a step further and tells you where a piece sits, counting from zero. The at sign is the fourth character, so it sits at position 3. If indexOf does not find what you asked for, it returns -1 instead of crashing, so you will often see people test for that -1 to mean “not found.”
Once you know where something is, substring pulls out the piece you want. You give it a start position, and optionally an end, and it hands back that slice.
String code = 'DART2026';
print(code.substring(0, 4)); // DART
print(code.substring(4)); // 2026
The first call grabs characters zero through three and stops just before position four. That is the rule worth burning into memory: the end index is not included. The second call, with no end given, runs from position four all the way to the finish.
Split text apart and put it back together
A huge amount of real text arrives as one string that is really several values crammed together with a separator: a comma-separated line, a full name, a file path. split is how you break it into pieces you can actually work with.
String csv = 'apple,banana,cherry';
List<String> fruits = csv.split(',');
print(fruits); // [apple, banana, cherry]
print(fruits.length); // 3
print(fruits.join(' and ')); // apple and banana and cherry
split walks the string, cuts it at every comma, and hands you back a List of the pieces. Now you have a real list, so everything you know about lists applies, including length and every tool from the Dart list methods post. The return trip is join, which takes a list and glues it back into one string with whatever separator you pass. Split to pull apart, join to put back together.
When you want to swap text rather than break it up, replaceAll is the tool. Say a price arrives with a comma you do not want in a number.
String price = '\$1,299.00';
print(price.replaceAll(',', '')); // $1299.00
print(price.replaceFirst('9', '8')); // $1,289.00
replaceAll finds every match and swaps it, so if there were two commas both would go. Its quieter sibling replaceFirst changes only the first match and leaves the rest, which is what the second line shows: only the first 9 became an 8. Pick the one that matches what you actually mean, because reaching for replaceAll when you meant replaceFirst is a bug that hides well. And that backslash in front of the dollar sign is not a typo, which is the perfect lead-in to the last method.
Build new strings with interpolation
Sooner or later you stop taking strings apart and start building them, usually by dropping a variable into the middle of some text. The clumsy way is to glue pieces together with plus signs. Dart gives you something much nicer called string interpolation.
String user = 'Ada';
int score = 92;
print('$user scored $score points.'); // Ada scored 92 points.
print('Aim for ${score + 5} next time.'); // Aim for 97 next time.
A dollar sign followed by a variable name drops that variable’s value right into the string. When you need more than a plain variable, like a bit of math or a method call, wrap it in curly braces after the dollar sign, and Dart runs the code and slots the result in. This reads far better than stringing pieces together with plus signs, and it is what you will use to build labels, messages, and Text widgets all day long in Flutter.
This is also why that escaped dollar sign earlier mattered. Because a dollar sign is how interpolation starts, a real dollar sign in your text has to be escaped with a backslash so Dart knows you mean the character and not the start of a variable.
Where Dart string methods meet Flutter
Here is the payoff, and the reason these matter more once you leave plain practice files. Every one of them shows up the moment you build a screen. You trim what a user types before you save it. You lowercase two strings before comparing them so capitalization does not break the match. You split a stored line back into parts to display. And you use interpolation constantly to turn data into the text a widget shows.
String raw = ' JANE_DOE ';
String display = raw.trim().toLowerCase().replaceAll('_', ' ');
print(display); // jane doe
That one line does three jobs in order: trim the ends, lowercase the whole thing, then swap the underscore for a space, turning a stored username into something you can show a person. Read it left to right like a sentence and it explains itself. If a value might be missing before you start calling these methods on it, that is a null question, and the Dart null safety post covers how to handle it without crashes.
Your next step
A short list of Dart string methods carries you a long way: trim to clean the ends, toUpperCase and toLowerCase to normalize case, contains and startsWith to check what is inside, indexOf and substring to find and slice, split and join to break text apart and rebuild it, replaceAll and replaceFirst to swap pieces, and interpolation to build new strings. Learn these and most everyday text work stops feeling like a puzzle.
The best way to make them stick is to retype the snippets and change them. Trim and lowercase your own name. Split a sentence on spaces and count the words with length. Turn a comma line into something joined by dashes. Build a greeting with interpolation that does a little math inside the braces. The official Dart String documentation lists every method on the class, and the Dart language tour has a friendly section on strings once these click. Open your editor, paste in that first name string, and run each method once. Seeing the output yourself is what turns these from words on a page into tools you own.