How To Combine Columns In Google Sheets

Combining columns in Google Sheets is one of the most practical spreadsheet tasks because real business data is often stored in separate fields that later need to become one readable output. A first name may need to be joined with a last name, a product code may need to be attached to a product name, or a city may need to be merged with a region for a report or dashboard.

That is why this topic matters so much.

Teams often need to combine columns for:

• full names
• location strings
• product labels
• reporting descriptions
• export-ready fields
• category tags
• dashboard labels
• readable summary columns

Without the right formula, users often rely on manual typing or messy copy-paste work. Google Sheets makes this much easier by letting formulas combine values dynamically.

This guide explains how to combine columns in Google Sheets, which formulas work best, how to handle spaces and separators cleanly, how to avoid ugly blank-driven results, and how to scale combined-column logic across shared spreadsheets.

Overview

Combining columns means joining values from two or more cells into one result.

For example:

• column A contains first names
• column B contains last names
• the output column should show full names

Or:

• column A contains product codes
• column B contains product names
• the output column should show one combined product label

This is usually done with formulas.

The most common methods in Google Sheets include:

• the ampersand operator &
• CONCATENATE
• TEXTJOIN
• ARRAYFORMULA for scalable row-by-row output

The best choice depends on how simple or advanced the workflow is.

Why combining columns matters so much

A lot of raw spreadsheet data is stored in a structured way for systems, not for people.

That means separate columns are often useful for:

• calculations
• filtering
• sorting
• clean data structure

But reporting and communication often need more readable combined output.

For example:

• a dashboard may need Cape Town, South Africa
• a tracker may need P100 - Laptop
• a contact sheet may need Jane Smith
• a summary table may need Finance | Approved
• a CRM export may need Customer ID - Customer Name

That is why combining columns is not just cosmetic. It helps turn structured data into useful display fields.

The simplest way to combine columns

The most common method is using the ampersand operator.

Example:

=A2&B2

This joins the values in A2 and B2 directly.

If:

• A2 = Jane
• B2 = Smith

the result becomes:

JaneSmith

That works, but in most practical cases you also want a separator.

Adding a space between combined columns

To combine values with a space:

=A2&" "&B2

If:

• A2 = Jane
• B2 = Smith

the result becomes:

Jane Smith

This is one of the most common Google Sheets formulas.

It is useful for:

• first name + last name
• city + country
• department + status
• code + label

Combining columns with commas, dashes, or other separators

You do not have to use a space. Any text separator can be used.

Comma-separated example

=A2&", "&B2

Result: Cape Town, South Africa

Dash-separated example

=A2&" - "&B2

Result: P100 - Laptop

Pipe-separated example

=A2&" | "&B2

Result: Finance | Approved

This flexibility is one of the reasons combining columns is so useful in reporting workflows.

Using CONCATENATE

Another way to combine values is with CONCATENATE.

Example:

=CONCATENATE(A2," ",B2)

This produces the same result as:

=A2&" "&B2

In many modern workflows, users often prefer the ampersand because it is shorter and easier to read.

Still, CONCATENATE is useful to know because you may encounter it in existing sheets.

Using TEXTJOIN

TEXTJOIN is often one of the best methods when you want cleaner separator handling, especially if blank values may appear.

Example:

=TEXTJOIN(" ",TRUE,A2,B2)

This joins A2 and B2 with a space between them and ignores blank cells.

If:

• A2 = Jane
• B2 = blank

the result becomes:

Jane

instead of an awkward output with extra separators.

This is one of the biggest advantages of TEXTJOIN.

Why TEXTJOIN is often better in messy real-world sheets

Real spreadsheet data is rarely perfect.

Some rows may have:

• first name but no last name
• city but no region
• code but missing category
• optional descriptive fields

If you use basic ampersand formulas, you may end up with:

• double spaces
• stray commas
• awkward dashes
• ugly blank-driven output

TEXTJOIN helps avoid that by letting you:

• choose a separator
• ignore blank values

This makes it extremely useful in reporting, exports, and dashboard labels.

A simple name example

Suppose:

• A2 contains first name
• B2 contains last name

Simple formula:

=A2&" "&B2

Cleaner blank-tolerant formula:

=TEXTJOIN(" ",TRUE,A2,B2)

Both work, but TEXTJOIN is often better when blank cells are possible.

Combining three or more columns

You are not limited to two columns.

For example, if:

• A2 = city
• B2 = region
• C2 = country

you can use:

=A2&", "&B2&", "&C2

or more cleanly:

=TEXTJOIN(", ",TRUE,A2,B2,C2)

This is useful for:

• location strings
• address blocks
• category stacks
• dashboard descriptors
• export-ready identifiers

The more columns you combine, the more valuable TEXTJOIN becomes.

A product label example

Suppose:

• A2 = P100
• B2 = Laptop
• C2 = Hardware

You may want a display field such as:

P100 - Laptop - Hardware

Formula:

=TEXTJOIN(" - ",TRUE,A2,B2,C2)

This is very useful in product reporting and category summaries.

How to combine columns automatically for many rows

A lot of users start by writing one formula in one row and then copying it down.

That works, but shared spreadsheets often benefit from something more scalable.

This is where ARRAYFORMULA becomes useful.

Example:

=ARRAYFORMULA(IF(A2:A="","",A2:A&" "&B2:B))

This means:

• if column A is blank, return blank
• otherwise combine column A and column B with a space
• do it for all rows automatically

This is one of the most practical patterns for live Google Sheets workflows.

Why ARRAYFORMULA matters here

Without ARRAYFORMULA, users often:

• copy formulas manually
• forget to extend them to new rows
• overwrite logic by mistake
• create inconsistent formulas down the column

ARRAYFORMULA helps by centralizing the logic into one place.

That makes it especially useful for:

• shared trackers
• imported data sheets
• form response files
• growing operational logs
• dashboard support columns

A scalable TEXTJOIN-style column combination pattern

TEXTJOIN is great row by row, but ARRAYFORMULA is usually the better scaling tool for column-based output.

For example, if you want to combine first and last names for a whole dataset:

=ARRAYFORMULA(IF(A2:A="","",A2:A&" "&B2:B))

This is a very practical shared-sheet pattern.

Handling blanks cleanly

Blank handling is one of the most important parts of combining columns well.

For example, this formula:

=A2&" - "&B2

can produce awkward output if B2 is blank.

You may end up with: P100 -

That is not ideal for reports.

A better pattern may be:

• use TEXTJOIN
• or use IF logic to return cleaner output

Example:

=IF(B2="",
 A2,
 A2&" - "&B2)

This ensures the separator only appears when the second value exists.

Combining columns for reporting workflows

Combining columns is especially useful in reporting because display labels often need to be more readable than the raw source data.

Examples include:

• full employee names
• team + status labels
• customer ID + customer name
• region + month descriptors
• product code + description
• city + country combinations

This is one reason combined columns appear so often in:

• dashboards
• exports
• trackers
• lookup tables
• shared reports

Common business use cases

Finance

Finance teams combine columns for:

• account code + account name
• department + cost center
• vendor ID + vendor name
• region + month labels

Operations

Operations teams combine columns for:

• task owner + status
• site + issue type
• queue + priority
• product code + item name

Analytics

Analysts combine columns for:

• report labels
• dashboard categories
• export-ready fields
• combined identifiers
• more readable dimension values

These are everyday spreadsheet tasks.

Common mistakes when combining columns

Forgetting separators

Without a separator, combined text can become unreadable.

Example: JaneSmith

That may be technically correct but not useful.

Using the wrong separator

Sometimes users add a dash when a comma or space would make more sense for the reporting context.

Not handling blanks

This is one of the most common real-world issues.

If some values are blank, the output can become messy unless the formula is designed carefully.

Overcomplicating simple joins

For two columns with a guaranteed value, a simple ampersand formula is often enough. Not every task needs TEXTJOIN or more complex logic.

Under-designing shared sheets

In collaborative sheets, copied formulas may break more easily than centralized ARRAYFORMULA logic.

That is why workflow context matters.

Step-by-step workflow

If you want to combine columns well in Google Sheets, this is a strong process.

Step 1: Decide what the combined output should look like

Ask: What is the final readable label or field?

Examples:

• First Name + Last Name
• City, Country
• Product Code - Product Name
• Department | Status

Step 2: Choose the separator

Common options include:

• space
• comma and space
• dash
• slash
• pipe

Step 3: Pick the right method

Use:

• & for simple combinations
• TEXTJOIN when blanks and cleaner separators matter
• ARRAYFORMULA when the logic should scale automatically across many rows

Step 4: Test blank rows and messy cases

Check what happens when one of the cells is empty.

Step 5: Review the output in reporting context

Ask: Does this combined value actually make the report easier to read?

Practical formula examples

Combine two columns with a space

=A2&" "&B2

Combine two columns with a dash

=A2&" - "&B2

Combine three columns with commas

=TEXTJOIN(", ",TRUE,A2,B2,C2)

Combine columns while ignoring blanks

=TEXTJOIN(" ",TRUE,A2,B2)

Combine full columns automatically

=ARRAYFORMULA(IF(A2:A="","",A2:A&" "&B2:B))

These cover many practical spreadsheet workflows.

When each method is the better choice

Use ampersands when:

• the task is simple
• the output uses one clear separator
• blank handling is not complex
• readability is still good

Use TEXTJOIN when:

• blanks are common
• cleaner separator behavior matters
• more than two columns are involved
• you want more polished output

Use ARRAYFORMULA when:

• the logic should apply to many rows automatically
• the sheet grows over time
• manual copy-down should be avoided
• the spreadsheet is shared and should stay maintainable

That is the practical decision framework.

FAQ

How do I combine two columns in Google Sheets?

You can combine two columns in Google Sheets with a formula such as =A2&" "&B2, which joins the values with a space between them.

What is the best way to combine columns in Google Sheets?

The best method depends on the task. For simple joins, ampersands work well. For cleaner separator handling, TEXTJOIN is often better. For scalable row-by-row logic, ARRAYFORMULA is often the strongest option.

How do I combine columns without extra spaces or separators?

You can use IF logic or TEXTJOIN to handle blanks more cleanly so the output does not contain awkward double spaces, repeated commas, or empty separators.

Can I combine full columns automatically in Google Sheets?

Yes. You can combine full columns automatically by using ARRAYFORMULA so the logic applies to many rows without manually copying the formula down.

Final thoughts

Combining columns in Google Sheets is one of the most practical spreadsheet skills because a lot of reporting depends on turning structured fields into readable output.

Whether you are building full names, location strings, product labels, category descriptors, or dashboard-ready values, the right formula makes the sheet cleaner and more useful.

The key is not just knowing one formula.

It is understanding when simple ampersands are enough, when TEXTJOIN is the cleaner choice, and when ARRAYFORMULA should be used to scale the logic across many rows. Once that clicks, combining columns becomes a simple but powerful way to improve spreadsheet workflows in Google Sheets.