Splitting, joining and cleaning up

Text you did not write is messy in predictable ways. Someone types "red, green ,, blue ," into a tags box: a space after some commas and not others, an extra comma where they changed their mind, a trailing comma because they were about to add a fourth. Someone else pastes a name from a spreadsheet and brings a tab and a line break with it.

None of that is user error. It is what real input looks like, and code that only works on tidy input is code that only works in the demo. This lesson is the standard tool kit for turning messy text into clean data: cut it into pieces, tidy each piece, throw away the ones that are empty, and — when you need text again — glue the survivors back together.

`text.split(separator)` gives you an ARRAY of pieces, cutting at every occurrence of the separator and throwing the separator itself away. `"a,b,c".split(",")` gives `["a", "b", "c"]`.

The original string is untouched, as always. What you get back is a new array, and from that point on you are working with arrays — every tool from module 5 applies, which is the real reason split is so useful.

Two special separators are worth knowing. `split("")` — an empty separator — cuts between every character, so `"abc".split("")` gives `["a", "b", "c"]`. And `split(" ")` for words is a common first attempt that goes wrong the moment there are two spaces in a row; the regular-expression lesson gives you a better tool for that.

split also takes an optional second argument, a limit on how many pieces you want back: `"a,b,c".split(",", 2)` gives `["a", "b"]`. It simply stops after that many; the remaining text is not appended anywhere, so use it only when you genuinely want the rest discarded.

`list.join(separator)` is the mirror image. It converts each item to text and glues the results together with your separator in between: `["red", "green"].join(" | ")` gives `"red | green"`.

Watch the default. Calling `join()` with no argument uses a comma, NOT a space and not an empty string — `["a", "b"].join()` is `"a,b"`. If you want the pieces run together, ask for it explicitly with `join("")`.

join is a method on arrays, not on strings, which is the giveaway that you have crossed back over: split takes you from text to data, join takes you from data to text. Most text-processing jobs are exactly that round trip with some array work in the middle.

`text.trim()` returns a new string with whitespace removed from BOTH ends. Whitespace means spaces, tabs and line breaks — everything the user cannot see and did not mean to type.

`trimStart()` and `trimEnd()` do one end each, for the rarer cases where the leading indentation is meaningful or the trailing newline is.

The crucial limit: trim only touches the ENDS. `"a b".trim()` is still `"a b"` — the three spaces in the middle are part of the text, and squeezing those out is a different job needing a regular expression.

Trim early, at the boundary where text enters your program, and you will not have to wonder later whether a value has a stray space on it. An untrimmed value is why `"ada " === "ada"` is false and why the user swears they typed the right thing.

split never merges separators, and this surprises everyone once. `"a,,b".split(",")` gives THREE pieces — `["a", "", "b"]` — because there genuinely is nothing between the two commas, and split reports what it finds rather than what you hoped for.

The same rule explains the other two: a trailing separator produces an empty piece at the end, and `"".split(",")` gives `[""]`, an array holding ONE empty string, not an empty array. That last one catches people who assume "no input means no pieces", and it is why a naive tag parser reports one blank tag for an empty box.

The fix is not to fight split. Let it produce the empty pieces and then remove them: `.filter((piece) => piece !== "")` after trimming. Trim first, or a piece containing only spaces will survive the filter.

Split into pieces. Trim each piece with `.map()`. Drop the empties with `.filter()`. Do whatever the job actually needs. Then, if you need text back, join.

It is worth committing that order to memory, because the order matters: filtering before trimming leaves pieces that are nothing but spaces, and joining before filtering leaves you with a doubled separator in the output.

Everything in the middle is ordinary array work from module 5 — the same `map`, `filter` and `reduce` you already know. Text processing is not a separate skill; it is array work with a split at the front and a join at the back.

split(sep) makes an array, join(sep) makes a string, and join() with no argument uses a comma. trim() strips both ends only, never the middle.

split reports empty pieces honestly: "a,,b" gives three, and "" gives [""]. Handle them with trim then filter, in that order.