Script (MQL4)

From binaryoption
Jump to navigation Jump to search
Баннер1
  1. Script (MQL4)

Scripts in MetaQuotes Language 4 (MQL4) are powerful tools within the MetaTrader 4 (MT4) platform that allow traders to automate single, non-continuous tasks. Unlike Expert Advisors which run continuously and react to price changes, scripts execute once based on specific conditions and then terminate. This makes them ideal for tasks like closing all open orders, calculating lot sizes, displaying information on the chart, or modifying chart settings. This article provides a comprehensive introduction to MQL4 scripts for beginners, covering their purpose, structure, creation, debugging, and practical examples.

What are MQL4 Scripts?

MQL4 scripts are essentially small programs written in the MQL4 language, designed to perform a specific action when executed. They are not designed to constantly monitor the market or make trading decisions autonomously like Expert Advisors. Instead, they operate on a "run-once" basis. Think of them as automated commands you can run on your chart.

Here's a breakdown of key characteristics:

  • **Single Execution:** Scripts run a single time and then stop. They do not loop or continuously monitor market data.
  • **Event-Driven (Initial Execution):** A script is typically executed manually by the user (double-clicking in the Navigator window) or triggered by a specific event, like chart initialization.
  • **No Continuous Monitoring:** Unlike EAs, scripts don't have `OnTick()` or `OnTimer()` functions that cause them to run repeatedly.
  • **Ideal for One-Time Tasks:** They are perfect for automating tasks that need to be done only once, such as closing all trades at the end of the day or setting a specific stop-loss level for all open positions.
  • **Compilation:** MQL4 scripts, like EAs and Custom Indicators, must be compiled into an executable file (.ex4) before they can be used in MetaTrader 4.

Script Structure

An MQL4 script's structure is relatively simple. Here’s a basic template:

```mql4 //+------------------------------------------------------------------+ //| ScriptExample.mq4 | //| Copyright 2023, Your Name or Company Name | //| https://yourwebsite.com | //+------------------------------------------------------------------+

  1. property copyright "Copyright 2023, Your Name or Company Name"
  2. property link "https://yourwebsite.com"
  3. property version "1.00"

//--- Include Files (Optional)

  1. include <Trade\Trade.mqh> // For trade operations

//--- Global Variables (Optional) int MagicNumber = 12345; // A unique identifier for trades

//--- Script Program Start Function int start() 

 {
  //--- Your Code Here

  Print("Script execution completed."); // Display a message in the Experts tab

  return(0); // Return 0 to indicate successful execution
 }

//+------------------------------------------------------------------+ ```

Let's dissect the components:

  • **Comment Block:** The initial block with `//+` and `//-` is a comment block providing information about the script (name, copyright, link, version). This is good practice for organization and documentation.
  • **#property Directives:** These directives define properties of the script, such as copyright information, a link to a website, and the script's version.
  • **#include Directives:** Allows you to include pre-written code from other MQL4 files (like `Trade.mqh` for trade functions). This promotes code reusability and organization.
  • **Global Variables:** Variables declared outside of any function are global and accessible throughout the script. Use them sparingly and with caution.
  • **`start()` Function:** This is the main entry point of the script. When the script is executed, the code within the `start()` function is run. It *must* return an integer value. A return value of 0 typically indicates successful execution.

Creating Your First Script

1. **Open MetaEditor:** In MetaTrader 4, press F4 to open the MetaEditor. 2. **New Script:** Go to File > New, and select "Script". 3. **Name the Script:** Give your script a descriptive name (e.g., "CloseAllOrders"). 4. **Paste the Template:** Copy and paste the script template above into the editor. 5. **Write Your Code:** Add your code within the `start()` function to perform the desired task. For example, to close all open orders:

```mql4 int start() 

 {
  int totalOrders = OrdersTotal();
  for (int i = totalOrders - 1; i >= 0; i--)
    {
     if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
       {
        if (OrderType() == OP_BUY)
          {
           OrderClose(OrderTicket(), OrderLots(), Bid, 3, Red);
          }
        else if (OrderType() == OP_SELL)
          {
           OrderClose(OrderTicket(), OrderLots(), Ask, 3, Red);
          }
       }
    }
  Print("All orders closed.");
  return(0);
 }

```

6. **Compile the Script:** Press F7 or click the "Compile" button. If there are errors, MetaEditor will highlight them. 7. **Run the Script:** In MetaTrader 4, find your script in the Navigator window (under "Scripts"). Double-click it to execute it on the current chart.

Important MQL4 Functions for Scripts

Here are some commonly used MQL4 functions that are especially useful in scripts:

  • **`OrdersTotal()`:** Returns the total number of open and pending orders.
  • **`OrderSelect()`:** Selects an order based on its index, ticket number, or other criteria. Essential for iterating through open orders.
  • **`OrderType()`:** Returns the type of the selected order (e.g., `OP_BUY`, `OP_SELL`).
  • **`OrderClose()`:** Closes an open order.
  • **`OrderModify()`:** Modifies an open order (e.g., stop-loss, take-profit).
  • **`Comment()`:** Sets a comment on the chart.
  • **`Print()`:** Prints text to the "Experts" tab in the Terminal window. Used for debugging and displaying information.
  • **`Alert()`:** Displays an alert message.
  • **`TimeCurrent()`:** Returns the current server time.
  • **`iTime()`:** Returns the time of a specific bar on the chart.
  • **`iClose()`:** Returns the closing price of a specific bar.
  • **`NormalizeDouble()`:** Rounds a double value to a specified number of decimal places. Crucial for correct lot size calculations and price manipulation.
  • **`StringFormat()`:** Formats a number as a string with a specified number of decimal places.

Debugging MQL4 Scripts

Debugging is a critical part of script development. Here are some techniques:

  • **`Print()` Statements:** Insert `Print()` statements throughout your code to display the values of variables and track the execution flow.
  • **Experts Tab:** Monitor the "Experts" tab in the Terminal window for output from your `Print()` statements.
  • **Alerts:** Use `Alert()` to display important messages during execution.
  • **Step-by-Step Execution:** In MetaEditor, you can set breakpoints and step through your code line by line to observe its behavior. (Debug > Step Into, Step Over, etc.)
  • **Error Messages:** Pay close attention to any error messages generated by the compiler. They provide valuable clues about what's wrong with your code.
  • **Testing on a Demo Account:** Always test your scripts thoroughly on a demo account before using them with real money.

Practical Script Examples

  • **Close All Orders by Symbol:** This script closes all orders for a specific symbol.

```mql4 int start() 

 {
  string symbol = Symbol(); // Get the current symbol
  int totalOrders = OrdersTotal();
  for (int i = totalOrders - 1; i >= 0; i--)
    {
     if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
       {
        if (OrderSymbol() == symbol)
          {
           if (OrderType() == OP_BUY)
             {
              OrderClose(OrderTicket(), OrderLots(), Bid, 3, Red);
             }
           else if (OrderType() == OP_SELL)
             {
              OrderClose(OrderTicket(), OrderLots(), Ask, 3, Red);
             }
          }
       }
    }
  Print("All orders for " + symbol + " closed.");
  return(0);
 }

```

  • **Set Stop-Loss for All Open Orders:** This script sets a specific stop-loss level for all open orders.

```mql4 int start() 

 {
  double stopLossPips = 50; // Stop-loss in pips
  double pointValue = Point();
  double stopLossLevel = Ask - stopLossPips * pointValue;

  int totalOrders = OrdersTotal();
  for (int i = totalOrders - 1; i >= 0; i--)
    {
     if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
       {
        if (OrderType() == OP_BUY)
          {
           OrderModify(OrderTicket(), OrderOpenPrice(), stopLossLevel, OrderTakeProfit(), 0, Red);
          }
        else if (OrderType() == OP_SELL)
          {
           OrderModify(OrderTicket(), OrderOpenPrice(), stopLossLevel, OrderTakeProfit(), 0, Red);
          }
       }
    }
  Print("Stop-loss set for all orders.");
  return(0);
 }

```

  • **Display Account Information:** This script displays account balance and equity in a comment on the chart.

```mql4 int start() 

 {
  double balance = AccountBalance();
  double equity = AccountEquity();
  Comment("Balance: ", balance, "\nEquity: ", equity);
  return(0);
 }

```

Differences Between Scripts, Expert Advisors, and Indicators

It's important to understand the differences between these three MQL4 program types:

  • **Scripts:** Run once and terminate. Used for one-time tasks.
  • **Expert Advisors (EAs):** Run continuously, monitoring the market and making trading decisions based on predefined rules. They have `OnTick()` and `OnTimer()` functions. Trading Strategies are often implemented using EAs.
  • **Custom Indicators:** Calculate and display information on the chart based on price data. They don't execute trades directly. Examples include Moving Averages, MACD, RSI, and Bollinger Bands.

Best Practices

  • **Comment Your Code:** Add comments to explain what your code does. This makes it easier to understand and maintain.
  • **Use Descriptive Variable Names:** Choose variable names that clearly indicate their purpose.
  • **Error Handling:** Include error handling to gracefully handle unexpected situations.
  • **Test Thoroughly:** Always test your scripts on a demo account before using them with real money.
  • **Keep it Simple:** Avoid unnecessary complexity. Break down complex tasks into smaller, more manageable functions.
  • **Use Functions:** Create reusable functions to avoid code duplication.
  • **Understand Risk Management:** Be aware of the risks involved in automated trading and use appropriate risk management techniques. Consider using tools for Position Sizing.
  • **Stay Updated on Market Trends:** Understanding Trend Following and other market analysis techniques can help you create more effective scripts.
  • **Learn Technical Analysis:** Familiarize yourself with Candlestick Patterns and other technical indicators to build more informed scripts.
  • **Explore Different Trading Strategies:** Consider employing Scalping, Day Trading, or Swing Trading strategies in your scripts.
  • **Study Market Sentiment:** Understanding Fear and Greed Index and other sentiment indicators can improve your script's performance.
  • **Master Fibonacci Retracements**: Utilize Fibonacci levels for precise entry and exit points in your scripts.
  • **Learn about Elliott Wave Theory**: Incorporate Elliott Wave principles for identifying potential trend reversals.
  • **Understand Support and Resistance**: Use Support and Resistance levels to define trade targets and stop-loss orders.
  • **Analyze Chart Patterns**: Implement chart pattern recognition in your scripts for enhanced decision-making.
  • **Explore Volume Analysis**: Integrate volume indicators to confirm price movements and identify potential breakouts.

By following these guidelines, you can create powerful and reliable MQL4 scripts to automate tasks and improve your trading efficiency.

MQL4 Reference Expert Advisor Custom Indicator MetaTrader 4 Trading Strategies Risk Management Technical Analysis Order Management MetaEditor MQL4 Community

Start Trading Now

Sign up at IQ Option (Minimum deposit $10) Open an account at Pocket Option (Minimum deposit $5)

Join Our Community

Subscribe to our Telegram channel @strategybin to receive: ✓ Daily trading signals ✓ Exclusive strategy analysis ✓ Market trend alerts ✓ Educational materials for beginners

Баннер
Retrieved from "https://binaryoption.wiki/index.php?title=Script_(MQL4)&oldid=49843"