1. صفحه نخست
  2. معاملات متاتریدر
  3. اِسکَلپینگ راحت

اِسکَلپینگ راحت

اِسکَلپینگ راحت

اِسکَلپینگ راحت

در این مقاله به بررسی یک الگوریتمِ باز کردنِ معامله می‌پردازیم که این امکان را به ما می‌دهد اِسکلپینگ راحت‌تری داشته باشیم. هرچند، از این الگوریتم در دیگر رویکردهای معاملاتی هم می‌‌توان استفاده کرد. در واقع، این مقاله روشی را ارائه می‌دهد که می‌توانید با این روش، ترید سریع را تجربه کنید.

به‌طور کلی، اِسکلپینگ را از نوع معاملات بسیار استرس‌زا می‌دانند، و نکته‌ی بسیار مهم این است که هر بار بایستی مقدار لاتیج، حد سود و حد ضرر را تعیین کرد که این کار حواس شما را از نمودار پَرت می‌کند.

این مقاله به‌نوعی ادامه‌ی مقاله‌ی “Betting Modeling as Means of Developing “Market Intuition”“ است. توصیه می‌کنم قبل از خواندن این مقاله، مقاله‌ی اشاره‌شده را حتما مطالعه کنید.
جهت یادآوری باید بگوییم اِسکلپینگ روشی برای سریع ترید کردن است. معمولاً در این نوع ترید، سودی ثابت بین ۱ تا ۱۰ پیپ (پوینت) داریم. اِسکلپینگ را به‌خاطر پیچیده بودن، استرس‌زا بودن، و دقت بسیار بالایی که می‌طلبد، می‌شناسند. بعضی‌ها آن را جدی نمی‌گیرند و بعضی‌ها آن را روشی کامل و یا اصطلاحاً سلطان [روش‌ها] می‌نامند. من قصد ندارم این نوع ترید را (با سایر روش‌ها و استراتژی‌ها) مقایسه کنم؛ در این مورد بسیار بحث شده و هرکس نظر خود را دارد.

مفهوم

احتمالاً هر تریدری حداقل یک بار سراغ اِسکلپینگ رفته است. برای برخی‌ها اِسکلپینگ راحت‌ترین حالت ترید است و برخی نیز عکس این قضیه برایشان صدق می‌کند. برخی اِسکلپینگ را وقت تلف کردن می‌دانند ولی برخی آن را جالب‌ترین روش معامله در بازار. با این حال، همه‌ی افراد در این نوع ترید بر سر نیاز به دقت بالا در کار و توجه به بازار و معاملات بازشده، توافق نظر دارند.

بسیاری از تریدرها اِسکلپینگ را برای خود ممنوع می‌کنند که دلیلش همان استرس بسیار بالا و نیاز به تلاش فراوان است. با این حال، راهی برای کمک به اِسکلپرها وجود دارد.

فرض کنید یک تریدر در هر معامله، با سیستم اِسکلپینگ و با لاتیج و حد سود ثابت، کار می‌کند. مسلماً، کار منطقی این است که لزومِ تعیین این پارامترها برای هر بار معامله را از میان برداریم. زیرا هر بار تعیین این پارامترها، علاوه بر وقت‌گیر بودن، حواس ما را نیز از نمودار پَرت می‌کند.

و این یعنی به ابزاری نیاز داریم که به‌خواست تریدر، معامله را با حجم، و حد سود/ضرر ثابت، باز کند. این ابزار باید نهایتِ ساده‌بودن در عملکرد را دارا باشد؛ و تقریباً اصلا نباید حواس تریدر را از نمودار پَرت کند.

چنین ابزاری را با کمک MQL4 به‌سادگی می‌توان در اختیار داشت.

اجرای کار

به‌عنوان مبنای کار، از یک بازی که در مقاله‌ی “Betting Modeling as Means of Developing “Market Intuition”“ توصیف شده‌است، استفاده می‌کنیم. ابزاری می‌سازیم که به ما کمک می‌کند این بازی را انجام دهیم و همزمان ترید کنیم.

توضیحی کوتاه درباره‌ی این بازی: دو خط (= فِلِش، Arrow) روی نمودار رسم می‌کنیم: [جهت] بالا و پایین. تریدر، فِلِش غیرضروری را حذف می‌کند، بنابراین، تصمیم‌گیری را انجام داده و نظر خود را می‌گوید؛ که سهام (اَرز) صعود خواهد کرد یا نزول. هنگامی که کندل جدید تشکیل می‌شود، اکسپرت بررسی می‌کند که پیش‌بینی تریدر درست بوده است یا نه. درست‌بودنِ پیش‌بینی، روی امتیاز بازی تاثیر می‌گذارد. بعلاوه اینکه، تریدر باید تصمیمش را در مدت زمان محدودی بگیرد، و این زمان ممکن است تغییر کند (تعیین زمان بر عهده‌ی تریدر است؛ می‌تواند آن را تعیین کند و می‌تواند این کار را انجام ندهد).

برای اجرای کار، ما دو فِلِش دیگر روی یک کندل عقب‌تر از کندل کنونی رسم می‌کنیم. کندل کنونی کماکان برای شرط‌بندی استفاده می‌شود. حذف یکی از فِلِش‌ها روی کندل قبلی، سیگنالی خواهد بود برای اکسپرت تا معامله‌ای در جهت موردنیاز باز کند. ضمناً، برای معامله کردن، محدودیت زمانی برای انتخاب جهت معامله وجود نخواهد داشت. این پارامتر‌های تغییرپذیر را نیز خواهیم داشت: خط‌‌های (Levelهای) حد سود و حد ضرر، لاتیج، اُفت قابل ‌قبول، و عدد جادویی. از طرف دیگر، معامله کردن را می‌توان با استفاده از متغیرِ منطقیِ خارجی، غیرفعال کرد، بنابراین، اکسپرت فقط برای شرط‌بندی استفاده خواهد شد.

علاوه بر اینها، هنگام باز شدن معامله، فِلِشی با نام “Buy” یا “Sell” روی نمودار رسم خواهد شد، که این به بازشدن معامله درست در لحظه‌ی مقرر، بستگی دارد. این کار به‌منظور جلوگیری از بازشدن معاملات جدید روی این کندل توسط اکسپرت، انجام می‌شود. این فِلِش ۳۰۰ پوینت دورتر از قیمتِ بازشدنِ کندل، رسم می‌شود، بنابراین کاربر حتی ممکن است متوجه آن هم نشود.

خودِ اکسپرت به دو بلوک تقسیم می‌شود – بازی و باز کردن معامله. از این رو، خواننده می‌تواند ببیندد چه چیزی به کد اضافه شده‌است.

در اینجا کد برنامه را داریم:

//+------------------------------------------------------------------+
//|                                                       trener.mq4 |
//|                                       Copyright © ۲۰۰۸, FXRaider |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "Copyright © ۲۰۰۸, FXRaider"
extern int gap=2;
extern bool Trading=true;
extern int TP=2;
extern int SL=20;
extern double Lots=0.02;
extern int slippage=1;
extern int MagicNumber=777;
extern int time_limit=30;
int start()
  {
//----
//#################################################################################
//####################################### GAME ####################################
//------------------------------
string solution="none"; 
int point, 
    point_neg, 
    point_pos;
//------------------------------    
//+---------------------------------------------------------------+
//|                      "up" choice searching                    | 
 if(
    ObjectGet("up", OBJPROP_PRICE1)==Open[1]+gap*Point
    &&iBarShift(NULL,0,ObjectGet("up",OBJPROP_TIME1))==1
    &&ObjectFind("down") != 0
    &&ObjectFind("up") == 0
    )
    {
     solution="up";
    }
//|                      "up" choice searching                    |  
//+---------------------------------------------------------------+
  
//+---------------------------------------------------------------+
//|                      "down" choice searching                  |     
 if(
    ObjectGet("down", OBJPROP_PRICE1)==Open[1]-gap*Point
    &&iBarShift(NULL,0,ObjectGet("down",OBJPROP_TIME1))==1    
    &&ObjectFind("up") != 0
    &&ObjectFind("down") == 0
    )
    {
     solution="down";
    }
//|                      "down" choice searching                  |       
//+---------------------------------------------------------------+    
 
//+---------------------------------------------------------------+
//|             counting points at a positive answer              |
    if((solution=="up"&&Open[1]<Close[1])
      ||(solution=="down"&&Open[1]>Close[1]))
    {
     point=1;
     point_pos=1;
     point_neg=0;     
    }  
//|             counting points at a positive answer              |   
//+---------------------------------------------------------------+
 
//+---------------------------------------------------------------+
//|             counting points at a negative answer              |    
    if((solution=="up"&&Open[1]>Close[1])
      ||(solution=="down"&&Open[1]<Close[1]))
    {
     point=-1;
     point_pos=0;
     point_neg=1;     
    } 
//|             counting points at a negative answer              |
//+---------------------------------------------------------------+
 
//+----------------------------------------------------------------------------------+
//|                              working with an external file                       |       
      int handle; 
      double points,     //total score
             points_pos, //score of positive answers
             points_neg; //score of negative answers 
       handle=FileOpen("trener_"+Symbol()+"_"+Period()+".csv",
                       FILE_CSV|FILE_WRITE|FILE_READ,";");
       if(handle>0) //if there is a file, read it
       { 
        points=NormalizeDouble(StrToDouble(FileReadString(handle)),Digits); 
        points_pos=NormalizeDouble(StrToDouble(FileReadString(handle)),Digits); 
        points_neg=NormalizeDouble(StrToDouble(FileReadString(handle)),Digits);       
        FileClose(handle);
       } 
       
    if(solution!="none") //if a choice has been made made 
    {        
      handle=FileOpen("trener_"+Symbol()+"_"+Period()+".csv",
                      FILE_CSV|FILE_WRITE|FILE_READ,";");
      FileWrite(handle ,points+point);         //write the total score
      FileWrite(handle ,points_pos+point_pos); //write the score of positive answers
      FileWrite(handle ,points_neg+point_neg); //write the score of negative answers                    
      FileClose(handle); 
    } 
//|                              working with an external file                       | 
//+----------------------------------------------------------------------------------+    
 
//+------------------------------------------------------------------------------------+
//|                                 working with objects                               |   
  if(iBarShift(NULL,0,ObjectGet("down",OBJPROP_TIME1))>0
     ||ObjectGet("down",OBJPROP_PRICE1)!=Open[0]-gap*Point) 
    {
     ObjectDelete("down"); 
    }  
 if(iBarShift(NULL,0,ObjectGet("up",OBJPROP_TIME1))>0
    ||ObjectGet("up",OBJPROP_PRICE1)!=Open[0]+gap*Point)            
    { 
     ObjectDelete("up"); 
    } 
   
  int sec_lim;  
  if(!time_limit)
  {
   sec_lim=0; 
  }
  else
  {
   sec_lim=TimeCurrent()-time_limit;
  }
  if(sec_lim>ObjectGet("up",OBJPROP_TIME1)
     &&sec_lim>ObjectGet("down",OBJPROP_TIME1) 
     &&ObjectFind("down") == 0&&ObjectFind("up") == 0
     &&iBarShift(NULL,0,ObjectGet("down",OBJPROP_TIME1))==0
     &&iBarShift(NULL,0,ObjectGet("up",OBJPROP_TIME1))==0)            
    { 
     ObjectDelete("up"); 
     ObjectDelete("down");      
    } 
  
   if((ObjectFind("down") != 0&&ObjectFind("up") != 0) //if no object
      &&sec_lim<Time[0])
   {
     ObjectCreate("down", OBJ_ARROW, 0, Time[0], Open[0]-gap*Point); //draw a down arrow
     ObjectSet("down", OBJPROP_STYLE, STYLE_DOT);
     ObjectSet("down", OBJPROP_ARROWCODE, SYMBOL_ARROWDOWN);
     ObjectSet("down", OBJPROP_COLOR, Red);
 
     ObjectCreate("up", OBJ_ARROW, 0, Time[0], Open[0]+gap*Point); //draw an up arrow
     ObjectSet("up", OBJPROP_STYLE, STYLE_DOT);
     ObjectSet("up", OBJPROP_ARROWCODE, SYMBOL_ARROWUP);
     ObjectSet("up", OBJPROP_COLOR, Blue);
    }      
//|                                 working with objects                               |   
//+------------------------------------------------------------------------------------+
//####################################### GAME ####################################
//#################################################################################
 
 
//#################################################################################
//#################################### TRADING ####################################
//+------------------------------------------------------------------------------------+  
//|                                working with objects I                              | 
  if(iBarShift(NULL,0,ObjectGet("down_1",OBJPROP_TIME1))>1
  ||ObjectGet("down_1",OBJPROP_PRICE1)!=Open[0]-gap*Point
  ||!Trading)  
  {
   ObjectDelete("down_1"); 
  }  
  
  if(iBarShift(NULL,0,ObjectGet("up_1",OBJPROP_TIME1))>1
  ||ObjectGet("up_1",OBJPROP_PRICE1)!=Open[0]+gap*Point
  ||!Trading)  
  { 
   ObjectDelete("up_1"); 
  } 
  
  if(iBarShift(NULL,0,ObjectGet("sell",OBJPROP_TIME1))>0
  ||ObjectGet("sell",OBJPROP_PRICE1)!=Open[0]-300*Point
  ||!Trading) 
  {
   ObjectDelete("sell"); 
  }
  if(iBarShift(NULL,0,ObjectGet("buy",OBJPROP_TIME1))>0
  ||ObjectGet("buy",OBJPROP_PRICE1)!=Open[0]+300*Point 
  ||!Trading)
  
  {
   ObjectDelete("buy"); 
  } 
  
   if(ObjectFind("down_1") != 0&&ObjectFind("up_1") != 0 && Trading)
   {
     ObjectCreate("down_1", OBJ_ARROW, 0, Time[1], Open[0]-gap*Point);
     ObjectSet("down_1", OBJPROP_STYLE, STYLE_DOT);
     ObjectSet("down_1", OBJPROP_ARROWCODE, SYMBOL_ARROWDOWN);
     ObjectSet("down_1", OBJPROP_COLOR, Red);
 
     ObjectCreate("up_1", OBJ_ARROW, 0, Time[1], Open[0]+gap*Point);
     ObjectSet("up_1", OBJPROP_STYLE, STYLE_DOT);
     ObjectSet("up_1", OBJPROP_ARROWCODE, SYMBOL_ARROWUP);
     ObjectSet("up_1", OBJPROP_COLOR, Blue);
    }  
//|                                working with objects I                              |    
//+------------------------------------------------------------------------------------+     
 if(Trading)
 {
//+----------------------------------------------------------------------------------------------+
//|                              searching open orders for a security                            |
    int pos_sell=0, bar_op_buy, bar_op_sell;
  for (int i_op_sell=OrdersTotal()-1; i_op_sell>=0; i_op_sell--) 
  { 
   if (!OrderSelect(i_op_sell,SELECT_BY_POS,MODE_TRADES)) break; 
   if (Symbol()==OrderSymbol()
   &&(OrderType()==OP_SELLSTOP||OrderType()==OP_SELL)
   &&(OrderMagicNumber()==MagicNumber)
   &&iBarShift(NULL,0,OrderOpenTime())==0)
   {
    pos_sell=1; break;   
   } 
  }
    
    int pos_buy=0;
  for (int i_op_buy=OrdersTotal()-1; i_op_buy>=0; i_op_buy--) 
  { 
   if (!OrderSelect(i_op_buy,SELECT_BY_POS,MODE_TRADES)) break; 
   if (Symbol()==OrderSymbol()
   &&(OrderType()==OP_BUYSTOP||OrderType()==OP_BUY)
   &&(OrderMagicNumber()==MagicNumber)
   &&iBarShift(NULL,0,OrderOpenTime())==0)
   {
    pos_buy=1; break;   
   } 
  }    
//|                              searching open orders for a security                            |
//+----------------------------------------------------------------------------------------------+ 
 
//+------------------------------------------------------------------------------------+  
//|                                working with objects II                             |   
 if(pos_buy==1)
 {   
      ObjectCreate("buy", OBJ_ARROW, 0, Time[0], Open[0]+300*Point);
      ObjectSet("buy", OBJPROP_STYLE, STYLE_DOT);
      ObjectSet("buy", OBJPROP_ARROWCODE, SYMBOL_ARROWUP);
      ObjectSet("buy", OBJPROP_COLOR, Red);
 }
 
 if(pos_sell==1)
 {
      ObjectCreate("sell", OBJ_ARROW, 0, Time[0], Open[0]-300*Point);
      ObjectSet("sell", OBJPROP_STYLE, STYLE_DOT);
      ObjectSet("sell", OBJPROP_ARROWCODE, SYMBOL_ARROWDOWN);
      ObjectSet("sell", OBJPROP_COLOR, Red);    
 }
//|                                working with objects II                             |   
//+------------------------------------------------------------------------------------+ 
  
//+------------------------------------------------------------------------------------+ 
//|                                   opening trades                                   |
double sl_buy, sl_sell;
 if(!SL)
 { 
  sl_buy=0;
  sl_sell=0;
 }
 else
 {
  sl_buy=Ask-SL*Point;
  sl_sell=Bid+SL*Point;
 }
  if(
     ObjectGet("up_1", OBJPROP_PRICE1)==Open[0]+gap*Point
     &&iBarShift(NULL,0,ObjectGet("up_1",OBJPROP_TIME1))==1
     &&ObjectFind("down_1") != 0
     &&ObjectFind("up_1") == 0
     &&!pos_buy
     &&ObjectFind("buy") != 0    
     )
     {
      OrderSend(Symbol(),OP_BUY, Lots,Ask,slippage,sl_buy,Ask+TP*Point,"trener",MagicNumber,0,Blue);            
     }
  if(
     ObjectGet("down_1", OBJPROP_PRICE1)==Open[0]-gap*Point
     &&iBarShift(NULL,0,ObjectGet("down_1",OBJPROP_TIME1))==1
     &&ObjectFind("up_1") != 0
     &&ObjectFind("down_1") == 0
     &&!pos_sell
     &&ObjectFind("sell") != 0
     )
     {
      OrderSend(Symbol(),OP_SELL, Lots,Bid,slippage,sl_sell,Bid-TP*Point,"trener",MagicNumber,0,Red);  
     }
//|                                   opening trades                                   |  
//+------------------------------------------------------------------------------------+   
 }
//#################################### TRADING ####################################
//#################################################################################
 
Comment("Score: ", points," (",points_pos,"/",points_neg,   //displaying score
        ") | Time: ", Hour(),":", Minute(),":", Seconds()); //displaying time (for convenience)
     
   return(0);
  }
//+------------------------------------------------------------------+

این کد حاوی تمام کامنت‌های مورد نیاز است.

بعد از اینکه اکسپرت روی نمودار اجرا شد، چنین چیزی خواهیم داشت:

اِسکَلپینگ راحت
اِسکَلپینگ راحت

در اینجا دو فِلِش آخر برای بازی درنظر گرفته شده‌اند، و دو فِلِش قبل از آنها نیز برای باز کردن معاملات استفاده می‌شوند.

حذف یک فلش روی کندل قبلی منجر به اجرای تابع ()OrderSend خواهد شد و معامله‌ی مربوطه باز می‌شود:

اِسکَلپینگ راحت
اِسکَلپینگ راحت

در اینجا تَبِ (tab) تغییر پارامترهای ورودی را داریم:

اِسکَلپینگ راحت
اِسکَلپینگ راحت

متغیر “gap” مسئولِ تعداد پوینت‌هایی است که [تعداد این پوینت‌ها] برابر با فاصله‌ی بین یک فِلِش و قیمت بازشدن یک کندل می‌باشد. متغیر “Trading” تابع ترید را مشخص می‌کند، “TP” – حد سود در واحد پوینت، “SL” حد ضرر در واحد پوینت. متغیر “Lots” حجم پوزیشن‌های بازشده را عهده‌دار است: “slippage” اُفت قابل‌قبول را در واحد پوینت مشخص می‌کند که ما حاضر به پذیرش آن هستیم. “MagicNumber” عدد جادویی‌ای را که اکسپرت به معاملات باز اختصاص داده را، مشخص می‌کند (برای اکسپرت ضروری است زیرا قادر است معاملات “خودش” را با این عدد پیگیری کند). متغیر محدود[کننده] “time_limit” تعداد ثانیه‌هایی را که کاربر باید در آن ثانیه‌ها تصمیمش را بگیرد، تعیین می‌کند. اگر “۰” باشد، محدودیت زمان نداریم، به‌عبارت دیگر، می‌توانیم حین شکل‌گیری کندل، هر وقت که خواستیم، تصمیم‌گیری را انجام دهیم.

نتیجه‌گیری

نتیجتاً اینکه اَرز یا سهامی داشته و قصد داریم راحت ترید کرده و معاملاتی با پارامترهای استاندارد، درج کنیم (حد سود، حد ضرر، اُفت قابل‌ قبول، لاتیج). این ابزار در اینجا و در هر نوع معامله‌ی دیگری برای ما سودمند است. هرچند، بیشترین کاربرد این ابزار زمانی است که چندین معامله‌ی کوتاه‌مدت باز داشته باشیم. مثل: اِسکلپینگ.

با استفاده از این برنامه، تریدر مجبور نیست پارامترهای یک معامله‌ی بازشده را هر بار تعیین کند. بنابراین، بیشترین توجهش را به نمودار معطوف می‌سازد. بی‌شک این کار عامل موثری در پیشرفت معاملات ما به‌حساب خواهد آمد.

این مقاله دارای فایل پیوست است.

فایل پیوست مقاله را میتوانید از اینجا دانلود کنید .

 

مقالات پیشنهادی :

برچسب ها:

M23admin

→ خواندن مطلب قبلی

مارتینگل چیست و آیا استفاده از آن عاقلانه است؟

خواندن مطلب بعدی ←

شکارِ رَوَند

۳۵ مورد نظر

نوشتن نظر شما

نشانی ایمیل شما منتشر نخواهد شد. بخش‌های موردنیاز علامت‌گذاری شده‌اند *