Skip to main content

If Else in Pine Script: Making Your Code Actually Think

· 11 min read
Pineify Team
Pineify Team

You know what's frustrating? When you're trying to build a trading indicator and it just... does the same thing every single time. Like, you want it to actually react to what's happening in the market, but your code is just sitting there like a brick.

That's where if else statements come in. They're basically how you teach your Pine Script to make decisions instead of just blindly following orders. Think of them as the brain of your trading scripts - the part that makes everything smart and responsive.

If Else in Pine Script

What Are If Else Statements in Pine Script?​

Think of it like this: when you're trading manually, you look at a chart and think "if the price is above the moving average, I might buy. Otherwise, I'll wait." If else statements are just you teaching your code to think the same way.

Instead of your indicator painting everything the same color or giving the same signal every time, it can actually look at what's happening and respond differently. Pretty neat, right?

This is fundamental programming logic that makes Pine Script incredibly powerful for creating responsive trading indicators and strategies. Whether you're just starting out or coming from other programming languages, understanding conditional logic is crucial for building effective TradingView scripts.

The Basic Syntax (It's Actually Simple)​

Here's how you write if else statements in Pine Script. Don't overthink this:

if condition
    // Do this thing
else
    // Do that other thing

That's literally it. The condition is just something that evaluates to true or false, like:

  • close > open (current price above opening price)
  • rsi > 70 (RSI indicator above 70)
  • volume > ta.sma(volume, 20) (volume above 20-period average)

The beauty of Pine Script's syntax is that it's incredibly readable. Even if you're new to programming, you can probably guess what most conditions do just by reading them.

Real-World Example: Smart Bar Coloring​

Here's something you can actually use right now. Want to make your bars green when the day was bullish and red when it was bearish?

//@version=5
indicator("Smart Bar Colors", overlay=true)

if close > open
    barcolor(color.green)
else
    barcolor(color.red)

Boom. Now your chart isn't just a bunch of identical bars - it actually tells you something about each day's sentiment. This simple script transforms your boring default chart into a visual representation of market sentiment.

But let's make it even smarter. What if we want to consider the strength of the move?

//@version=5
indicator("Advanced Bar Colors", overlay=true)

// Calculate the size of the candle body
body_size = math.abs(close - open)
average_body = ta.sma(body_size, 20)

if close > open and body_size > average_body
    barcolor(color.lime)  // Strong bullish
else if close > open
    barcolor(color.green) // Weak bullish
else if close < open and body_size > average_body
    barcolor(color.red)   // Strong bearish
else
    barcolor(color.maroon) // Weak bearish

Now we're getting somewhere! This script not only shows direction but also strength. If you're interested in learning more about how to write Pine Script in TradingView, that guide covers everything you need to get started with the basics.

Why Conditional Logic Is Essential for Trading Scripts​

Look, without if else statements, your indicators are like that friend who gives the same advice regardless of the situation. "Just buy everything!" Not helpful.

With if else statements, you can:

1. Create Market-Responsive Indicators Your scripts can adapt to different market conditions. Trending markets need different signals than ranging markets, and if else statements let you code for both scenarios.

2. Build Smart Alert Systems Instead of getting pinged every time price moves, you can create alerts that only fire when specific conditions align. This reduces noise and helps you focus on high-probability setups.

3. Develop Robust Trading Strategies Complex trading strategies often require multiple conditions to be met before entering or exiting trades. If else statements make this possible.

4. Handle Edge Cases Markets do weird things. Good Pine Script code anticipates these situations and handles them gracefully using conditional logic.

Advanced Conditional Patterns​

Multiple Conditions with else if​

Sometimes you need more than just "this or that." Maybe you want different colors for different market conditions:

//@version=5
indicator("Market Regime Detector", overlay=true)

rsi = ta.rsi(close, 14)
ma20 = ta.sma(close, 20)
ma50 = ta.sma(close, 50)

if close > ma20 and ma20 > ma50 and rsi > 50
    barcolor(color.lime)    // Strong uptrend
else if close > ma20 and ma20 > ma50 and rsi <= 50
    barcolor(color.green)   // Weak uptrend
else if close < ma20 and ma20 < ma50 and rsi < 50
    barcolor(color.red)     // Strong downtrend
else if close < ma20 and ma20 < ma50 and rsi >= 50
    barcolor(color.maroon)  // Weak downtrend
else
    barcolor(color.gray)    // Sideways/unclear

This script identifies five different market regimes using multiple conditions. The else if statements let you chain conditions together without creating messy nested code.

Combining Conditions with Logical Operators​

Pine Script supports logical operators that make complex conditions more readable:

// AND operator (both conditions must be true)
if close > open and volume > ta.sma(volume, 20)
    // Strong bullish signal

// OR operator (either condition can be true)
if rsi > 70 or rsi < 30
    // Overbought or oversold

// NOT operator (condition must be false)
if not (close > ma20)
    // Same as: if close <= ma20

If you want to dive deeper into combining multiple indicators effectively, check out this guide on how to combine two indicators in TradingView Pine Script.

Common Mistakes to Avoid​

1. Nesting Hell​

Here's what NOT to do:

// DON'T DO THIS
if condition1
    if condition2
        if condition3
            if condition4
                // Do something
            else
                // Do something else
        else
            // More nesting...
    else
        // Even more nesting...

Instead, use logical operators:

// DO THIS INSTEAD
if condition1 and condition2 and condition3 and condition4
    // Do something
else if condition1 and condition2 and condition3
    // Do something else
else
    // Default action

2. Overly Complex Conditions​

Keep your conditions readable. If you can't understand what you wrote last week, neither will anyone else:

// Hard to read
if (close > open and ta.rsi(close, 14) > 50 and ta.sma(close, 20) > ta.sma(close, 50)) or (close < open and ta.rsi(close, 14) < 50 and ta.sma(close, 20) < ta.sma(close, 50))

// Much better
rsi = ta.rsi(close, 14)
ma20 = ta.sma(close, 20)
ma50 = ta.sma(close, 50)

bullish_setup = close > open and rsi > 50 and ma20 > ma50
bearish_setup = close < open and rsi < 50 and ma20 < ma50

if bullish_setup or bearish_setup
    // Much clearer!

3. Forgetting the else Case​

Always consider what should happen when your main condition isn't met. Even if it's just a comment:

if special_condition
    // Do special thing
else
    // Continue normal operation

Practical Trading Applications​

Dynamic Stop Loss Levels​

//@version=5
strategy("Dynamic Stops", overlay=true)

atr = ta.atr(14)
volatility_multiplier = 2.0

if strategy.position_size > 0  // Long position
    stop_level = strategy.position_avg_price - (atr * volatility_multiplier)
    strategy.exit("Stop", stop=stop_level)
else if strategy.position_size < 0  // Short position
    stop_level = strategy.position_avg_price + (atr * volatility_multiplier)
    strategy.exit("Stop", stop=stop_level)

This example shows how to use conditional logic to set different stop losses based on position direction. The stops adjust automatically based on market volatility (ATR).

Time-Based Trading Rules​

//@version=5
strategy("Session Trading", overlay=true)

// Define trading sessions
us_session = time(timeframe.period, "0930-1600:1234567", "America/New_York")
asian_session = time(timeframe.period, "2000-0400:1234567", "Asia/Tokyo")

// Different strategies for different sessions
if us_session
    // More aggressive strategy during US hours
    if ta.crossover(ta.sma(close, 10), ta.sma(close, 20))
        strategy.entry("US Long", strategy.long)
else if asian_session
    // More conservative during Asian hours
    if ta.crossover(ta.sma(close, 20), ta.sma(close, 50))
        strategy.entry("Asia Long", strategy.long)

Performance Considerations​

When writing conditional logic, consider performance:

Use Variables for Repeated Calculations​

// Inefficient
if ta.rsi(close, 14) > 70 and ta.rsi(close, 14) < 80
    // RSI calculated twice

// Efficient
rsi = ta.rsi(close, 14)
if rsi > 70 and rsi < 80
    // RSI calculated once

Order Conditions by Likelihood​

Put the most likely conditions first:

// If trending conditions are more common
if trending_condition
    // Handle trending market
else if ranging_condition
    // Handle ranging market

Ternary Operators: The Shortcut​

For simple if-else logic, Pine Script supports ternary operators:

// Instead of this:
if close > open
    color_choice = color.green
else
    color_choice = color.red

// You can write this:
color_choice = close > open ? color.green : color.red

// Or even inline:
barcolor(close > open ? color.green : color.red)

Ternary operators are great for simple conditions but can become unreadable with complex logic. Use them wisely.

Debugging Your Conditional Logic​

When your if else statements aren't working as expected:

1. Use plotchar() to Debug Conditions​

condition = close > ta.sma(close, 20)
plotchar(condition, "Condition", "⬆", location.belowbar, color=condition ? color.green : color.red)

2. Break Down Complex Conditions​

// Instead of one complex condition
// if close > open and ta.rsi(close, 14) > 50 and volume > ta.sma(volume, 20)

// Break it down:
bullish_candle = close > open
rsi_bullish = ta.rsi(close, 14) > 50
volume_confirm = volume > ta.sma(volume, 20)

final_condition = bullish_candle and rsi_bullish and volume_confirm

// Plot each component
plotchar(bullish_candle, "Bullish Candle", "1", location.belowbar)
plotchar(rsi_bullish, "RSI Bullish", "2", location.belowbar)
plotchar(volume_confirm, "Volume Confirm", "3", location.belowbar)

For more advanced debugging techniques, the Pine Script tutorial for beginners covers troubleshooting in detail.

Real-World Strategy Example​

Let's put it all together with a complete trading strategy that uses multiple if else statements:

//@version=5
strategy("Smart Trend Strategy", overlay=true, initial_capital=10000)

// Inputs
fast_ma_length = input.int(10, "Fast MA Length")
slow_ma_length = input.int(20, "Slow MA Length")
rsi_length = input.int(14, "RSI Length")
volume_ma_length = input.int(20, "Volume MA Length")

// Calculations
fast_ma = ta.sma(close, fast_ma_length)
slow_ma = ta.sma(close, slow_ma_length)
rsi = ta.rsi(close, rsi_length)
volume_ma = ta.sma(volume, volume_ma_length)

// Define market conditions
trending_up = fast_ma > slow_ma
trending_down = fast_ma < slow_ma
high_volume = volume > volume_ma * 1.5
rsi_oversold = rsi < 30
rsi_overbought = rsi > 70

// Entry conditions
long_condition = trending_up and ta.crossover(close, fast_ma) and high_volume and not rsi_overbought
short_condition = trending_down and ta.crossunder(close, fast_ma) and high_volume and not rsi_oversold

// Exit conditions
long_exit = rsi_overbought or ta.crossunder(close, slow_ma)
short_exit = rsi_oversold or ta.crossover(close, slow_ma)

// Execute trades
if long_condition and strategy.position_size == 0
    strategy.entry("Long", strategy.long)
else if short_condition and strategy.position_size == 0
    strategy.entry("Short", strategy.short)

if strategy.position_size > 0 and long_exit
    strategy.close("Long")
else if strategy.position_size < 0 and short_exit
    strategy.close("Short")

// Plot indicators
plot(fast_ma, "Fast MA", color.blue)
plot(slow_ma, "Slow MA", color.red)

This strategy demonstrates how multiple if else statements can work together to create sophisticated trading logic. Each condition is clearly defined and serves a specific purpose in the overall strategy.

Taking It Further​

Once you're comfortable with basic if else statements, you can explore more advanced topics:

  • Switch statements for handling multiple discrete values
  • Functions with conditional returns for cleaner code organization
  • State machines for complex multi-step trading logic
  • Custom alerts that fire only when specific condition combinations occur

If you're ready to dive deeper into Pine Script development, consider exploring our comprehensive Pine Script tutorial guide or learning about advanced backtesting techniques.

The Bottom Line​

If else statements aren't some fancy advanced technique - they're the foundation that makes Pine Script actually useful for trading. They're how you make your indicators smart, your strategies adaptive, and your alerts meaningful.

Start with simple conditions like "if close > open" and gradually build up to more complex logic. The key is to keep things readable and logical. If you can't explain your condition in plain English, it's probably too complex.

The best part? Once you get comfortable with conditional logic, you'll start seeing opportunities everywhere. "Oh, I could make my indicator do X when Y happens..." That's when Pine Script development becomes really fun.

Remember: every successful trading strategy uses conditional logic somewhere. Whether it's deciding when to enter trades, how to manage risk, or when to exit positions, if else statements are the building blocks that make it all possible.

Got questions about if else statements or want to share what you're building? The Pine Script community is always eager to help fellow traders level up their coding skills.

The Best Pine Script Generator