बैक-टेस्ट कंसोल: कोड से ट्रेडिंग रणनीतियाँ परखें

डिज़ाइन से सुरक्षित। आपकी स्क्रिप्ट केवल आपके ब्राउज़र में, बिना इंटरनेट पहुँच वाले सैंडबॉक्स में चलती है: वह दी गई कैंडल पढ़ सकती है और कुछ नहीं (न आपका खाता, न यह साइट, न दूसरी वेबसाइटें)। आप जो लिखते हैं उसमें से कुछ भी हमारे सर्वरों पर नहीं चलता।

एक मिनट में शुरू करें

1. कोई भी चार्ट खोलें, जैसे EURUSD, और परखने के लिए टाइमफ़्रेम चुनें (H1, D1…)।
2. चार्ट के टूलबार में रणनीति दबाएँ। कंसोल चार्ट के नीचे खुलता है।
3. कोई बिल्ट-इन रणनीति चुनें, जैसे मूविंग एवरेज क्रॉसओवर। यह तुरंत चलती है: चार्ट पर तीर हर एंट्री और एग्ज़िट दिखाते हैं।
4. कोई इनपुट बदलें (जैसे धीमा औसत 30 से 50): टेस्ट अपने-आप फिर चलता है।
5. कुल योग के लिए सारांश, हर ट्रेड के लिए ट्रेड, समय के साथ खाते के लिए इक्विटी कर्व पढ़ें।
6. उसे अपनी स्क्रिप्ट बनाने के लिए प्रति संपादित करें दबाएँ, बदलें, और टेस्ट चलाएँ दबाएँ (या Ctrl+Enter)।

कंसोल, हिस्सा-दर-हिस्सा

सेटिंग्स

नतीजे पढ़ना

ट्रेड टैब हर ट्रेड को उसकी दिशा, एंट्री और एग्ज़िट समय व कीमत, साइज़, पैसे और % में लाभ, कितनी कैंडल चला, क्यों बंद हुआ (सिग्नल, स्टॉप लॉस, टेक प्रॉफ़िट, पलटा गया, अंत में अब भी खुला) और आपकी टिप्पणी के साथ सूचीबद्ध करता है। CSV डाउनलोड करें उसे स्प्रेडशीट के लिए निर्यात करता है। इक्विटी कर्व खाते को बाय-एंड-होल्ड के मुकाबले दिखाता है। Log दिखाता है कि आपकी स्क्रिप्ट ने log() से क्या लिखा।

ऑर्डर कैसे भरे जाते हैं

• आगे झाँकना नहीं। onBar(i) में लगाया गया ऑर्डर अगली कैंडल के ओपन (i + 1) पर भरता है। रणनीति कभी उस कीमत पर ट्रेड नहीं कर सकती जो उसे पता नहीं हो सकती थी।
• कैंडल के भीतर स्टॉप। स्टॉप लॉस और टेक प्रॉफ़िट हर कैंडल के हाई और लो से जाँचे जाते हैं। अगर दोनों एक ही कैंडल में पहुँच सकते थे, तो स्टॉप गिना जाता है (सतर्क धारणा)। स्टॉप के पार गैप ओपन पर भरता है, जैसे असली बाज़ारों में।
• एक समय में एक पोज़िशन। शॉर्ट रहते long() शॉर्ट बंद करके लॉन्ग खोलता है ("पलटा गया"); पहले से लॉन्ग रहते long() केवल दिए गए स्टॉप अपडेट करता है।
• हर भराव पर लागत। स्लिपेज हर भराव कीमत को आपके विरुद्ध खिसकाता है; कमीशन एंट्री और एग्ज़िट दोनों पर लगता है।
• अंत। आख़िरी कैंडल के बाद भी खुला ट्रेड आख़िरी क्लोज़ पर बंद होता है और "अंत में अब भी खुला" चिह्नित होता है।

अपनी रणनीति लिखना

रणनीति दो हिस्सों वाला एक छोटा JavaScript प्रोग्राम है:

1. ऊपरी हिस्सा एक बार चलता है: input() से अपने इनपुट पढ़ें, ta.* या ind() से पूरी सीरीज़ गणना करें, और plot() से उन्हें बनाएँ।
2. function onBar(i) { … } हर कैंडल के लिए चलता है, सबसे पुरानी पहले। i कैंडल की संख्या है (0 = सबसे पुरानी)। यहाँ तय करें: long(), short(), exit(), या कुछ नहीं।

// 1. once: inputs and series
const len = input("Average length", 50, { min: 5, max: 400 });
const avg = ta.sma(close, len);           // one value per candle
plot(avg, "SMA " + len, "#2F80ED");       // drawn on the price chart

// 2. every candle
function onBar(i) {
  if (avg[i] == null) return;             // the first len - 1 values are null (warming up)
  if (position === 0 && close[i] > avg[i]) long();
  if (position > 0 && close[i] < avg[i]) exit("below the average");
}

शुरू से जानने योग्य बातें:

• सीरीज़ ऐरे हैं, हर कैंडल का एक मान, सबसे पुराना पहले: close[i] इस कैंडल का क्लोज़ है, close[i - 1] पिछली का। गणना की गई सीरीज़ पर्याप्त कैंडल होने तक null रहती हैं; इस्तेमाल से पहले जाँचें।
• onBar(i) के भीतर आप केवल i तक की कैंडल पढ़ सकते हैं। close[i + 1] टेस्ट को त्रुटि के साथ रोक देता है: यह भविष्य में झाँकना होगा।
• const और let हमेशा की तरह इस्तेमाल करें; आपके अपने वेरिएबल कैंडल के बीच अपने मान बनाए रखते हैं (ट्रेलिंग स्टॉप के लिए उपयोगी)।
• कीमतें चार्ट की अपनी इकाइयों में हैं (EURUSD के लिए 1.0850, सोने के लिए 2650.40); समय UTC सेकंड में।

संदर्भ

कैंडल और वर्तमान स्थिति

इनपुट

30 इनपुट तक। उनके मान रणनीति के साथ सहेजे जाते हैं और किसी आइडिया में प्रकाशित करने पर उसके साथ जाते हैं।

गणनाएँ (ta.*)

src कोई भी सीरीज़ है: close, high, कोई दूसरा नतीजा, या आपका अपना ऐरे। हर फ़ंक्शन एक नया ऐरे लौटाता है; कुछ भी कैंडल नहीं बदलता।

सिग्नल

ऑर्डर

आउटपुट

कोड में चार्ट के सभी 71 इंडिकेटर: ind()

ind(id, inputs) चार्ट का कोई भी इंडिकेटर ठीक वैसे ही गणना करता है जैसे चार्ट करता है। यह उसकी पहली लाइन सीरीज़ के रूप में लौटाता है; सभी लाइनें .lines में और उनके नाम .names में हैं। छोड़े गए इनपुट दिखाया गया डिफ़ॉल्ट लेते हैं। method इनमें से एक है: SMA, EMA, SMMA, LWMA; price इनमें से एक: close, open, high, low, median, typical, weighted।

const st = ind("stoch", { k: 14, d: 3, slowing: 3 });   // st = %K, st.lines[1] = %D
const ich = ind("ichimoku");                            // ich.names: Tenkan, Kijun, Span A, Span B, Chikou
const kijun = ich.lines[1];

उदाहरण

हर उदाहरण जैसा है वैसा चलता है: कॉपी करें दबाएँ, कंसोल खोलें, नई स्क्रिप्ट… चुनें, चिपकाएँ और टेस्ट चलाएँ दबाएँ। नतीजे टिकर, टाइमफ़्रेम और अवधि पर निर्भर हैं; उदाहरण तकनीक सिखाते हैं, सिफ़ारिशें नहीं हैं।

const len = input("Average length", 50, { min: 5, max: 400 });
const avg = ta.sma(close, len);
plot(avg, "SMA " + len, "#2F80ED");

function onBar(i) {
  if (avg[i] == null) return;                 // still warming up
  if (position === 0 && close[i] > avg[i]) long({ comment: "close above the average" });
  if (position > 0 && close[i] < avg[i]) exit("close below the average");
}

const fast = ta.ema(close, input("Fast EMA", 12, { min: 2, max: 200 }));
const slow = ta.ema(close, input("Slow EMA", 26, { min: 3, max: 400 }));
plot(fast, "Fast", "#2F80ED");
plot(slow, "Slow", "#E39B2D");

function onBar(i) {
  if (ta.crossover(fast, slow, i)) long();
  if (ta.crossunder(fast, slow, i)) short();
}

const r = ta.rsi(close, 14);
const sl = input("Stop loss %", 1.5, { min: 0.1, max: 20, step: 0.1 });
const tp = input("Take profit %", 3, { min: 0.1, max: 50, step: 0.1 });

function onBar(i) {
  if (position !== 0) return;                 // one trade at a time
  if (ta.crossover(r, 30, i)) long({ slPct: sl, tpPct: tp, comment: "RSI back above 30" });
  if (ta.crossunder(r, 70, i)) short({ slPct: sl, tpPct: tp, comment: "RSI back below 70" });
}

const a = ta.atr(14);
const hi = ta.highest(high, 20);
const mult = input("Stop (ATR multiple)", 2, { min: 0.5, max: 6, step: 0.5 });

function onBar(i) {
  if (i < 1 || a[i] == null || hi[i - 1] == null || position !== 0) return;
  if (close[i] > hi[i - 1]) {                  // a new 20-candle high
    const stop = close[i] - mult * a[i];
    const target = close[i] + 2 * mult * a[i];
    long({ sl: stop, tp: target, comment: "breakout, risk " + (mult * a[i]).toFixed(5) });
  }
}

const a = ta.atr(14);
const fast = ta.ema(close, 20), slow = ta.ema(close, 50);
let stop = null;

function onBar(i) {
  if (a[i] == null || slow[i] == null) return;
  if (position === 0) {
    stop = null;
    if (ta.crossover(fast, slow, i)) long({ comment: "trend up" });
    return;
  }
  const candidate = close[i] - 3 * a[i];
  if (stop === null || candidate > stop) {     // only ever raise it
    stop = candidate;
    stopLoss(stop);
  }
}

const adx = ind("adx", { period: 14 });      // .lines[0] ADX, [1] +DI, [2] -DI
const plusDI = adx.lines[1], minusDI = adx.lines[2];
const m = ta.macd(close, 12, 26, 9);
const minAdx = input("Minimum ADX", 25, { min: 10, max: 50 });

function onBar(i) {
  if (adx[i] == null || adx[i] < minAdx) return;
  if (ta.crossover(m.macd, m.signal, i) && plusDI[i] > minusDI[i]) long();
  if (ta.crossunder(m.macd, m.signal, i) && minusDI[i] > plusDI[i]) short();
}

const b = ta.bb(close, input("Period", 20, { min: 5, max: 200 }), input("Width", 2, { min: 0.5, max: 4, step: 0.1 }));
plot(b.upper, "Upper", "#8E44AD");
plot(b.lower, "Lower", "#8E44AD");

function onBar(i) {
  if (b.middle[i] == null) return;
  if (position === 0 && close[i] < b.lower[i]) long({ comment: "below the lower band" });
  else if (position === 0 && close[i] > b.upper[i]) short({ comment: "above the upper band" });
  else if (position > 0 && close[i] >= b.middle[i]) exit("middle band");
  else if (position < 0 && close[i] <= b.middle[i]) exit("middle band");
}

const from = input("Start hour (UTC)", 7, { min: 0, max: 23 });
const to = input("End hour (UTC)", 16, { min: 1, max: 24 });
const fast = ta.sma(close, 10), slow = ta.sma(close, 30);

function onBar(i) {
  const hour = new Date(time[i] * 1000).getUTCHours();
  if (position !== 0 && hour >= 20) { exit("end of the day"); return; }
  if (hour < from || hour >= to) return;
  if (ta.crossover(fast, slow, i)) long();
  if (ta.crossunder(fast, slow, i)) short();
}

const k = input("Range multiple", 0.5, { min: 0.1, max: 2, step: 0.1 });
const range = high.map((h, i) => (i ? high[i - 1] - low[i - 1] : null));   // the previous candle's range
const trigger = open.map((o, i) => (range[i] == null ? null : o + k * range[i]));
plot(trigger, "Trigger", "#16A085");

function onBar(i) {
  if (trigger[i] == null) return;
  if (position === 0 && close[i] > trigger[i]) {
    long({ slPct: 1, comment: "close above open + " + k + " x range" });
    log("signal at", close[i], "trigger", trigger[i]);
  } else if (position > 0 && i - entryBar >= 3) {
    exit("held 3 candles");
  }
}

const a = ta.atr(14);
const riskPct = input("Risk per trade %", 1, { min: 0.1, max: 5, step: 0.1 });
const fast = ta.ema(close, 20), slow = ta.ema(close, 50);

function onBar(i) {
  if (a[i] == null || slow[i] == null || position !== 0) return;
  if (ta.crossover(fast, slow, i)) {
    const stopDistance = 2 * a[i];
    const qty = (equity * riskPct / 100) / stopDistance;
    long({ qty: qty, sl: close[i] - stopDistance, tp: close[i] + 3 * stopDistance,
           comment: "risk " + riskPct + "%" });
  }
}

const trend = ta.sma(close, 200), fast = ta.ema(close, 20), r = ta.rsi(close, 14);

function onBar(i) {
  if (trend[i] == null || i < 5) return;
  let dipped = false;
  for (let k = 0; k < 5; k++) if (r[i - k] != null && r[i - k] < 40) dipped = true;
  if (position === 0 && close[i] > trend[i] && dipped && ta.crossover(close, fast, i)) {
    long({ slPct: 2, tpPct: 4, comment: "pullback bought" });
  }
}

त्रुटियाँ और उन्हें कैसे ठीक करें

भरोसेमंद टेस्टिंग

• अपनी लागत जोड़ें। बार-बार ट्रेड करने वाली रणनीति शून्य लागत पर शानदार दिख सकती है और वास्तविक स्प्रेड पर पैसा गँवा सकती है। स्लिपेज (स्प्रेड) और कमीशन हमेशा भरें।
• पर्याप्त ट्रेड इस्तेमाल करें। लगभग 30 ट्रेड से कम पर आँकड़े ज़्यादातर संयोग होते हैं। और कैंडल लोड करें या छोटा टाइमफ़्रेम इस्तेमाल करें।
• अतीत के अनुसार न ढालें। परिणाम परफ़ेक्ट होने तक कई इनपुट आज़माने से उस अवधि का शोर मिलता है, काम करने वाला नियम नहीं। इतिहास के एक हिस्से पर ट्यून करें, फिर वही इनपुट दूसरी अवधि और कुछ और टिकरों पर जाँचें।
• बाय-एंड-होल्ड से तुलना करें और केवल लाभ नहीं, ड्रॉडाउन भी देखें।
• चरम मानों पर नज़र रखें। अगर एक या दो ट्रेड ही सारा लाभ देते हैं, तो रणनीति किस्मत पर निर्भर है।
• पैसा जोखिम में डालने से पहले अभ्यास करें। रणनीति को पेपर ट्रेडिंग या बार रीप्ले पर आगे चलाएँ, और उसके सिग्नल के लिए अलर्ट लगाएँ।

बैक-टेस्ट पिछली बिड कैंडल इस्तेमाल करते हैं और स्वैप, फ़ाइनेंसिंग और बाज़ार के साथ बदलते स्प्रेड को अनदेखा करते हैं। पिछले नतीजे भविष्य के नतीजों की गारंटी नहीं देते। यह निवेश सलाह नहीं है।

सहेजें, साझा करें, प्रकाशित करें

• सहेजें (साइन इन होने पर) 50 रणनीतियों तक उनके इनपुट और सेटिंग के साथ रखता है; वे हर चार्ट की सूची में दिखती हैं।
• चार्ट से आइडिया प्रकाशित करें और रणनीति जोड़ें: पाठक आपका चार्ट खोलकर आपके इनपुट के साथ रणनीति ख़ुद चला सकते हैं। देखें आइडिया।
• किसी क्लब में अपनी टीम के साथ अपना विश्लेषण साझा करें।
• ट्रेड टैब पर CSV डाउनलोड करें ट्रेड को स्प्रेडशीट में निर्यात करता है।
• भारी शोध के लिए वही कैंडल प्राइस API (GET /bars) से Python, R या Excel में लें।

सीमाएँ

प्रश्न