Arrays in Pine Script are dynamic collections that help you store, manage, and analyze multiple values in your trading strategies. Think of them as smart lists that can hold your price data, indicators, or trading signals, making it easier to build sophisticated trading systems that can look back in time or process multiple conditions at once.

What Are Arrays & Why They Matter

Arrays are your secret weapon for building smarter trading indicators. They let you store and manipulate collections of data – perfect for tracking multiple timeframes, managing complex indicators, or maintaining trading state. Unlike simple variables, arrays give you the power to work with entire sets of data at once, opening up possibilities for sophisticated pattern recognition and risk management.

Real-World Applications

Pattern Recognition

Store and analyze price action patterns across multiple timeframes
Track divergence patterns between price and indicators
Maintain history of support/resistance levels
Calculate success rates of pattern completions

Risk Management

Track multiple position sizes in portfolio management
Monitor drawdown levels across different timeframes
Store and update stop-loss levels dynamically
Calculate position sizing based on volatility history

Signal Generation

Combine multiple indicator signals for confirmation
Track signal strength across different timeframes
Store and analyze false signal history
Calculate adaptive thresholds based on market conditions

Basic Usage: Your First Array

Let's start with a practical example that shows how to use arrays for tracking price action patterns:

//@version=6
indicator("Smart Price Pattern Tracker", overlay=true)

// Initialize our price pattern array
var pricePatterns = array.new_float(0)  // Start with empty array

// Add new prices to our pattern array
if array.size(pricePatterns) >= 10
    array.shift(pricePatterns)  // Remove oldest price if array is full
array.push(pricePatterns, close)  // Add current close price

// Calculate pattern characteristics
float patternAvg = array.avg(pricePatterns)
float patternStdev = array.stdev(pricePatterns)

// Plot the results
plot(patternAvg, "Pattern Average", color=color.blue)
plot(patternAvg + patternStdev, "Upper Band", color=color.green)
plot(patternAvg - patternStdev, "Lower Band", color=color.red)

Let's break down what this code does:

We create a dynamic array to store price patterns
We maintain a rolling window of the last 10 prices
We use array.shift() to remove the oldest price when we reach capacity
We calculate average and standard deviation to understand the pattern
We visualize the pattern with bands around the average

Common Patterns and Best Practices

Pattern 1: Dynamic Signal Buffer

This example shows how to use arrays to create a smart signal buffer that adapts to market conditions:

//@version=6
indicator("Adaptive Signal Buffer")

// Initialize our signal buffer
var signals = array.new_float(0)
var signalStrengths = array.new_float(0)

// Calculate current signal
float currentSignal = ta.rsi(close, 14) - 50  // Center RSI around 0
float signalStrength = math.abs(currentSignal) / 50  // Normalize strength

// Manage our signal buffer
if array.size(signals) > 20
    // Remove oldest signals when buffer is full
    array.shift(signals)
    array.shift(signalStrengths)

// Add new signal
array.push(signals, currentSignal)
array.push(signalStrengths, signalStrength)

// Calculate weighted average signal
float weightedSignal = 0.0
float totalWeight = 0.0
for i = 0 to array.size(signals) - 1
    weight = array.get(signalStrengths, i)
    weightedSignal += array.get(signals, i) * weight
    totalWeight += weight

float finalSignal = weightedSignal / totalWeight

// Plot with dynamic coloring
color signalColor = finalSignal > 0 ? color.green : color.red
plot(finalSignal, "Weighted Signal", color=signalColor, linewidth=2)

This advanced pattern demonstrates:

Using multiple arrays to track related data (signals and their strengths)
Implementing a weighted average system
Managing buffer size efficiently
Creating dynamic visualizations based on array calculations

Pattern 2: Multi-Timeframe Pattern Scanner

Here's how to use arrays to scan for patterns across multiple timeframes:

//@version=6
indicator("Multi-Timeframe Pattern Scanner", overlay=false)

// Initialize storage
var float[] highs = array.new_float()
var float[] lows = array.new_float()
var string[] patterns = array.new_string()

// Identify pattern type function
patternType(float high, float low, float prevHigh, float prevLow) =>
    high > prevHigh and low > prevLow ? "Higher High" :
      high < prevHigh and low < prevLow ? "Lower Low" :
      "Sideways"

// Update arrays only on confirmed bars
if barstate.isconfirmed
    if array.size(highs) >= 5
        array.shift(highs)
        array.shift(lows)
        array.shift(patterns)
    array.push(highs, high)
    array.push(lows, low)
    if array.size(highs) > 1
        float currHigh  = array.get(highs, array.size(highs)-1)
        float currLow   = array.get(lows,  array.size(lows)-1)
        float prevHigh  = array.get(highs, array.size(highs)-2)
        float prevLow   = array.get(lows,  array.size(lows)-2)
        string newPattern = patternType(currHigh, currLow, prevHigh, prevLow)
        array.push(patterns, newPattern)
    else
        array.push(patterns, "N/A")

// Table creation
var table patternTable = table.new(position.top_right, 2, 6, border_width=1)

// Draw table header (only on first bar)
if bar_index == 0
    table.cell(patternTable, 0, 0, "Index", bgcolor=color.gray, text_color=color.white)
    table.cell(patternTable, 1, 0, "Pattern", bgcolor=color.rgb(42, 64, 144), text_color=color.white)
table.set_position(patternTable, position.middle_center)

// Fill the table with history (latest 5, most recent at top)
for i = 0 to math.min(4, array.size(patterns)-1)
    table.cell(patternTable, 0, i+1, str.tostring(array.size(patterns)-i))
    table.cell(patternTable, 1, i+1, array.get(patterns, array.size(patterns)-1-i))

This pattern shows:

Using multiple arrays to track different aspects of market structure
Implementing pattern recognition logic
Creating a visual history display
Managing data across multiple timeframes

Performance Tips

Memory Management

Initialize arrays with a reasonable size estimate
Clear unused arrays with array.clear()
Remove old data regularly using array.shift()
Use appropriate data types (float vs. int)

Calculation Efficiency

Avoid recalculating array values every bar
Cache frequently accessed array elements
Use built-in array functions instead of loops
Implement early exit conditions in loops

Data Structure Optimization

Choose appropriate array size for your timeframe
Use parallel arrays for related data
Implement circular buffers for fixed-size data
Clear temporary arrays when no longer needed

Common Issues and Solutions

Issue 1: Growing Memory Usage

Problem: Arrays consuming too much memory over time
Solution:

// Implement a circular buffer pattern
maxSize = 100
if array.size(myArray) > maxSize
    array.shift(myArray)
array.push(myArray, newValue)

Issue 2: Calculation Overhead

Problem: Slow performance when processing large arrays
Solution:

// Cache calculations and process efficiently
var float[] processedValues = array.new_float(0)
if barstate.isconfirmed  // Only process on confirmed bars
    if array.size(processedValues) > 0
        // Update only the latest value
        array.pop(processedValues)
    array.push(processedValues, newCalculation)

Issue 3: Data Synchronization

Problem: Arrays getting out of sync with each other
Solution:

// Use a structured approach to manage related arrays
var float[] prices = array.new_float(0)
var float[] volumes = array.new_float(0)

updateArrays(price, volume) =>
    if array.size(prices) > maxSize
        array.shift(prices)
        array.shift(volumes)
    array.push(prices, price)
    array.push(volumes, volume)

Advanced Pine Script Arrays: Build Smarter Trading Systems