How to Combine Text from Two Cells in Google Sheets

Why this skill matters in real-world work

According to How To Sheets, the ability to cleanly join text from two cells is foundational when building names, addresses, or composite identifiers—common tasks for students, analysts, and small business owners. When you work with datasets, labels like "FirstName LastName" or "City, State" often live in separate cells. Being able to merge these fields quickly saves time, reduces manual copy-paste errors, and improves the readability of reports and exports. This skill scales: a well-constructed join in a single row can be copied down a column, enabling consistent formatting across hundreds or thousands of records. In the 2026 How To Sheets Analysis, practitioners who standardize their join logic report smoother data pipelines and fewer downstream corrections.

Key takeaway: mastering simple joins sets a foundation for more advanced data cleaning and transformation tasks in Google Sheets.

The simplest methods: & operator, CONCAT, and CONCATENATE

There are multiple ways to merge text from two cells in Google Sheets, each with its own quirks. The ampersand (&) operator is the most direct: =A2 & " " & B2 joins A2 and B2 with a space in between. If you need to insert different delimiters, replace the quoted space with your delimiter, e.g., =A2 & ", " & B2 for a comma-delimited result. CONCAT is designed to join two text items, so =CONCAT(A2, B2) is straightforward but lacks a delimiter unless you insert one manually: =CONCAT(A2, " ", B2) is not valid syntax — instead use the ampersand approach or CONCAT with a delimiter by explicit joining. CONCATENATE behaves similarly to CONCAT but accepts more arguments, so =CONCATENATE(A2, " ", B2) yields the same readable result as the ampersand method. Practical tip: CONCATENATE and CONCAT are great for quick, two-part joins; for more flexible formatting, the & operator wins for readability and control.

• Example using ampersand: =A2 & " " & B2
• Example using CONCAT: =CONCAT(A2, B2) (no delimiter; use with an explicit delimiter if needed: =A2 & " " & B2)
• Example using CONCATENATE: =CONCATENATE(A2, " ", B2)

Pro tip: In most day-to-day sheets, the ampersand method is easiest to read and maintain, especially when you are experimenting with different delimiters.

TEXTJOIN: cleaner for many cells or ignored blanks

TEXTJOIN shines when you want a clean delimiter between two or more pieces of text, especially if some cells might be blank. For a single row, you can simply use =TEXTJOIN(" ", TRUE, A2, B2). The first argument is the delimiter (a single space in quotes here), the second argument tells Sheets to ignore empty cells, and the remaining arguments are the text items to join. If you’re joining many columns within a single row, TEXTJOIN remains readable and robust: =TEXTJOIN(", ", TRUE, A2:C2) would join A2, B2, and C2 with commas, skipping blanks. Important nuance: TEXTJOIN operates on ranges or arrays, but when combining just two cells, the ampersand or CONCAT methods are often more lightweight; TEXTJOIN pays off when the delimiter is consistent and you may encounter blanks.

Practical example: =TEXTJOIN(" ", TRUE, TRIM(A2), TRIM(B2)) ensures you don’t carry over stray spaces.

Handling blanks and delimiters: TRIM, IF, and LEN

Blanks and extra spaces can ruin clean joins. To ensure tidy results, wrap inputs with TRIM to remove leading/trailing spaces, then join using your preferred method. For example: =TRIM(A2) & " " & TRIM(B2) removes stray spaces around each value before joining. If both cells are blank, return an empty string: =IF(LEN(TRIM(A2))=0, "", TRIM(A2) & " " & TRIM(B2)). If one cell is blank, this approach still produces a sensible result like B2 alone or A2 alone, depending on which is non-empty. These small guards prevent awkward results in reports and dashboards.

Advanced scenario: combine with a conditional delimiter, e.g., use if both parts exist, otherwise use the non-empty part: =IF(AND(A2<>"", B2<>""), A2 & " (" & B2 & ")", A2 & B2).

Applying to an entire column with ARRAYFORMULA

When you want to create a joined column for every row in a dataset, avoid dragging formulas down manually and instead use ARRAYFORMULA. A robust pattern for two-cell joins per row is: =ARRAYFORMULA(IF((A2:A="")*(B2:B=""), "", IF(B2:B="", A2:A, IF(A2:A="", B2:B, A2:A & " " & B2:B)))) This handles three common cases: both cells blank, one cell blank, or both filled. For more complex delimiters, you can adapt the inner logic, but the key idea is to apply the operation once across the entire column to reduce manual maintenance. Performance considerations: limit the range to what you actually need (e.g., A2:A1000) to avoid recalculation overhead on very large sheets.

Real-world pattern: create a separate joined column (e.g., Column C) and keep the source data in Columns A and B intact for auditing and data integrity.

Practical examples you can reuse today

1. Names: =A2 & " " & B2 (FirstName and LastName) often used for mail merges and badges. 2) Addresses: =TRIM(A2) & ", " & TRIM(B2) & ", " & TRIM(C2) (Street, City, State) to create a single printable address. 3) Product codes: =A2 & "-" & B2 & "-" & C2 (Piece, Batch, Code) for generating composite identifiers. For datasets with blanks or optional components, TEXTJOIN with TRUE (ignoring blanks) is a clean default, and ARRAYFORMULA keeps your sheet scalable as data grows. A well-chosen delimiter improves readability and downstream parsing in dashboards and exports.

Troubleshooting and common pitfalls

Common mistakes include forgetting to account for blanks, which can yield stray spaces, or using CONCAT with more than two items without a delimiter. To avoid these issues, combine TRIM with a delimiter, and consider TEXTJOIN when you have multiple items. Also beware of data types: if a numeric value is involved, Sheets will coerce to text in a join, which may affect formatting; you can wrap numbers with TEXT function to preserve desired formatting (e.g., TEXT(A2, "0#0")). If performance becomes an issue in very large spreadsheets, prefer using ARRAYFORMULA with a fixed range rather than volatile, iterative recopying of formulas. Finally, validate results by spot-checking edge cases: empty cells, cells with leading spaces, and cells containing non-breaking spaces introduced by copy-paste from external sources.

Quick tips to boost performance and readability

• Use named ranges to simplify formulas and reduce errors when references shift. - Keep joins in a dedicated column for auditing and to avoid breaking downstream formulas. - Prefer TEXTJOIN for multi-item joins; saveAMPersand for simple two-cell combinations that require explicit delimiters. - If you expect blanks regularly, enable ignore-blank behavior to maintain clean output. - Periodically trim and clean incoming data (using TRIM and CLEAN) before joining to ensure consistency across datasets.