I never knew what those double brackets in Excel meant — now I use them in almost every formula

You’ve probably come across a formula filled with brackets inside brackets, pound signs, colons, and column names. When it’s a shared sheet or someone else’s workbook, the usual instinct is to ignore it and move on rather than stress your brain to decode what’s going on.

But it’s not as complex or incomprehensible as it first appears. Double brackets in Excel allow you to combine multiple components of a table into a single formula. Once you start using Excel tables regularly, as I do, it quickly becomes clear that understanding how these double brackets work isn’t optional; it’s what makes those more advanced formulas readable and usable.

The logic behind [[ ]] in Excel

What exactly are those extra brackets doing behind the scenes?

Before double brackets make sense, you need to understand how Excel tables differ from a regular spreadsheet range. When you convert a range of data into a proper Excel table (Ctrl + T or Insert -> Table), Excel stops thinking in terms of column letters and row numbers. Instead of “Column G,” it starts thinking in terms of “Order ID.”

Every column gets a name, and every formula you write can reference that name directly. This system is called structured references, and it adjusts automatically; when you add a new row to your table, formulas referencing it automatically include the new data without any extra input or manual updates on your end.

Double brackets come into play when you need to reference more than one component of a table in a single expression. Think of [[ ]] like a shipping container: the outer brackets bundle specific parts together, so Excel can read them as a single, unified instruction rather than a string of unrelated symbols. Whenever a structured reference contains one specifier nested inside another, that outer set of brackets is Excel’s way of saying, “These pieces belong together.”

Combining table parts ([[#Specifier], [Column]])

Excel tables come with built-in special item specifiers, basically predefined labels that let you target specific sections of a table. The main ones are #All, #Data, #Headers, and #Totals, each pointing to a different horizontal slice of your table.

Used on their own, these specifiers are already useful. But they become even more useful when you pair them with a specific column name. Say you have a table called SalesTable, and you’ve enabled the Total Row at the bottom. To pull the grand total from the Total Profit column, your formula would look like this:

=SalesTable[[#Totals],[Total Profit]]

The outer brackets wrap the entire reference, both the where (#Totals) and what (Total Profit), into a single address. Without that outer layer, Excel can’t tell whether you’re pointing to two separate elements or a single combined location.

The same logic applies to headers. If you want a formula that returns the text label from the top of a column, which is useful when building dynamic reports that need to display column names, you would write:

=SalesTable[[#Headers],[Total Profit]]

This returns the literal text “Total Profit” from the header row. If you later rename that column to “Net Profit,” any cell referencing this formula will automatically update its output.

Referencing ranges ([[Column1]:[Column2]])

Sometimes you need a block of adjacent columns to feed into a larger formula or a dynamic array. In a normal spreadsheet, you might write something like A:E. In a table, you use column names with a colon between them, wrapped in outer brackets:

=SalesTable[[Region]:[Order Priority]]

This tells Excel to treat everything from the Region column through to the Order Priority column as a single continuous block of data. The outer brackets act as a clear boundary, so Excel doesn’t confuse the colon as part of the table name rather than part of the column range.

This becomes especially useful with newer dynamic array functions. Instead of hardcoding a range like A2:E500 and having to update it every time your table grows, this syntax automatically expands to capture the full column span, no matter how many rows you add.

Building Excel formulas with [[ ]]

Target rows, columns, and totals without breaking your formulas

One of the most common places you’ll encounter double brackets in your day-to-day work is in calculated columns, especially when the @ symbol appears alongside column headers that contain spaces.

The @ symbol means “this row only.” When you’re working in an Excel table and want a formula to operate on just the current row rather than the entire column, @ becomes your anchor. For example, imagine you’re adding a new column called Calculated Revenue. You want to multiply Units Sold by Unit Price for only the row you’re currently working on. You’d write:

=[@[Units Sold]] * [@[Unit Price]]

The @ tells Excel, “Don’t evaluate the entire column of 100 rows; just use the value in this specific row.” Because the column names contain spaces, Excel wraps them in brackets to keep each name intact as a single reference. The outer structure then wraps the @ and the column name together so Excel treats it as one coherent instruction. Without that structure, Excel would interpret “Units” and “Sold” as separate values, and the formula would fail with a #VALUE! error, which is one of Excel's peskiest errors.

Once you understand this pattern, a formula like the following starts to make more sense:

=[@[Total Profit]] / SalesTable[[#Totals],[Total Profit]]

Here, the numerator pulls the Total Profit value for the current row. The denominator pulls the grand total from the Totals row at the bottom of the Total Profit column. Together, the formula calculates how much the row contributes to the overall total profit.

Double brackets may look complex, but they’re how Excel keeps everything in place

Double brackets look scarier than they really are. Once you understand that they’re simply Excel’s way of bundling a location and a column name into one tidy package, you start to see that they actually make formulas easier to read, not harder. Instead of juggling cell coordinates that shift as your sheet changes, you’re working with named references that stay meaningful no matter how your table evolves.

More importantly, your formulas become easier to audit and far more resilient to changes in your data because they’re built around names rather than fixed positions.