MetaTrader 5 herunterladen

Strings: Tabelle mit ASCII Zeichen und ihre Verwendung

8 Februar 2016, 16:13
Antoniuk Oleg
0
473


Einführung

In diesem Artikel analysieren wir die Tabelle mit ASCII Zeichen und die Wege, in denen sie verwendet werden können. Wir werden uns außerdem mit einigen neuen Funktionen, dem Prinzip der Arbeitsweise, die auf den den Besonderheiten der ASCII Tabelle basiert, beschäftigen, und dann werden wir eine neue Bibliothek (Libary) erstellen, die diese Funktionen enthält. Sie sind in anderen Programmiersprachen ziemlich beliebt, aber sie sind nicht in der Liste eingebauter Funktionen der MQL 4 Sprache enthalten. Außerdem werden wir die Grundlagen der Arbeit mit Strings im Detail untersuchen. Also, ich glaube, Sie werden sicherlich etwas Neues über diesen nützlichen Datentyp erfahren.


Was ist ASCII ?

ASCII ist der amerikanische Codier-Standard für Informationsaustausch (American Standard Code for Information Interchange). Dieser Standard basiert auf dem englischen Alphabet. ASCII Codes zeigen einen Text in Computern, Kommunikationsausrüstung und anderen Geräten, die mit Texten arbeiten. ASCII wurde im Jahr 1963 geschaffen, jedoch als Standard erst im Jahr 1967 veröffentlicht. Die letzten Änderungen wurden im Jahr 1986 vorgenommen. Detailliertere Informationen über ASCII sind hier zu finden: https://en.wikipedia.org/wiki/ASCII. Des Weiteren werden wir sehen, wie wir ASCII mit Verwendung der MQL4 Optionen anzeigen, aber zuerst untersuchen wir die Grundlagen der Arbeit mit Strings.



Grundlagen des Schreibens einer Bibliothek

Eine Bibliothek dieser Art zu schreiben, lässt und einige wesentliche Momente verstehen. Betrachten wir zuerst wie wir alle Zeichen durchlaufen können, wie das Verfahren mit Datenarrays. Auf die gleiche Weise werden Codeteile in jede Funktion immer wiederholt, gedacht für zeichenweise Verarbeitung. Schreiben wir als Beispiel ein einfaches Script, das zuerst einen allgemeinen String zeigt und dann einen verarbeiteten, bei dem jedes Zeichen durch ein Leerzeichen unterteilt ist.


//+------------------------------------------------------------------+
//|                                          StringExpereriment1.mq4 |
//|         Copyright © 2007, Antonio Banderass. All rights reserved |
//|                                               banderassa@ukr.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2007, Antonio Banderass. All rights reserved"
#property link      "banderassa@ukr.net"
//+------------------------------------------------------------------+
//| start                                                            |
//+------------------------------------------------------------------+
int start()
  {
   string s1 = "Just_a_string", s2, symbol = "s";
   int lenght = StringLen(s1);
   MessageBox(s1);
   for(int x = 0; x < lenght; x++)
     {
       symbol = StringSetChar(symbol, 0, StringGetChar(s1, x));
       s2 = s2 + symbol + " ";
     }
   MessageBox(s2);
   return(0);
  }
//+------------------------------------------------------------------+

Untersuchen wir den Wert von jedem String.

string s1 = "Just_a_string", s2, symbol = "s";

Bestimmen Sie drei Variablen aus einem String-Typ:

  • s1 - anfänglicher String, den wir verarbeiten wollen,
  • s2 - String, der das Ergebnis enthalten wird,
  • symbol - String, der für die temporäre Speicherung von jedem Zeichen verwendet wird.

Beachten Sie, dass er durch ein Zeichen initialisiert wird. Wenn wir dies nicht machen, erhalten wir als Ergebnis eine Zeichenfolge ohne das erste Zeichen. Der Grund dafür ist, die Standard MQL4 Funktion StringGetChar() ändert bereits erstellte Zeichen, weshalb wir mindestens ein Zeichen für den regulären Betrieb benötigen.

int lenght = StringLen(s1);

Bestimmen Sie die Variable vom Typ Integer um die Stringlänge zu speichern. Zu diesem Zweck rufen Sie die Standardfunktion StringLen() zur Bestimmung der Stringlänge auf, die einen einzelnen Parameter hat - den String, die Länge die wir kennen müssen.

MessageBox(s1);

MessageBox Anzeigen.

for(int x = 0; x < lenght; x++)

Bestimmen Sie den Zyklus, in dem die zeichenweise Verarbeitung stattfinden wird. Beachten Sie, dass der Zähler bei Null initialisiert wird, weil Zeichen im String wie in Arrays von Null indexiert werden. In den Bedingungen der Zyklusausführung wird der Vergleichsoperator "less" verwendet, weil die Länge-Position des letzten Zeichen 1 ist.

symbol = StringSetChar(symbol, 0, StringGetChar(s1, x));


In diesem String werden zwei Standardfunktionen verwendet: StringSetChar() und StringGetChar(). Die erste ermöglicht eines der Zeichen des Strings zu ersetzen, der zweite - erhält den Zeichencode immer in der angegebenen Position. Die Funktion StringSetChar() hat drei Parameter:

  • String, in dem ein Zeichen ersetzt werden soll,
  • Position des Zeichens, das ersetzt werden soll (denken Sie daran, dass Strings von Null indexiert werden, wie Arrays,
  • Code des Zeichen, das ersetzt.

Die Funktion gibt das Ergebnis in Form eines geänderten Strings zurück. Eine weitere wichtige Funktion - StringGetChar. Sie hat zwei Parameter:

  • String mit einem Zeichen, dessen Code erkannt werden soll,
  • Position des Zeichen, dessen Code erkannt werden soll.

Die Funktion gibt den Zeichencode zurück. Während die Funktion StringGetChar den Zeichencode zurückgibt, befindet sich ihr Aufruf an der Stelle des Parameters der Funktion StringSetChar. Daher erinnern wir uns mit Verwendung dieser Funktion an das aktuelle Zeichen zur weiteren Verarbeitung. Während der Ausführung des Zyklus wird jedes Zeichen des Strings s1 einer Variable zugewiesen.

s2 = s2 + symbol + " ";
Wir können Strings leicht binden (Verkettung) mit Additionsoperation (+). Hier fügen wir bei jedem Zyklusdurchlauf dem resultierenden String ein Zeichen und ein Leerzeichen hinzu.

MessageBox(s2);
Das Ergebnis anzeigen. Beachten Sie, dass wir jedes Zeichen lesen, beginnend mit dem ersten, obwohl es auch umgekehrt durchgeführt werden kann. In diesem Fall haben wir einen kürzeren Code und weniger Variablen. Wenn es in der String-Verarbeitung egal ist, von welcher Seite man beginnt, verwenden Sie die folgende Variante:

//+------------------------------------------------------------------+
//|                                            StringExperiment2.mq4 |
//|         Copyright © 2007, Antonio Banderass. All rights reserved |
//|                                               banderassa@ukr.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2007, Antonio Banderass. All rights reserved"
#property link      "banderassa@ukr.net"
//+------------------------------------------------------------------+
//| start                                                            |
//+------------------------------------------------------------------+
int start()
  {
   string s1 = "Just_a_string", s2, symbol = "s";
   int lenght = StringLen(s1) - 1;
   MessageBox(s1);
   while(lenght >= 0)
     {
       symbol = StringSetChar(symbol, 0, StringGetChar(s1, lenght));
       s2 = s2 + symbol + " ";
       lenght--;
     }
   MessageBox(s2);
   return(0);
  }
//+------------------------------------------------------------------+

Sie sehen, statt des Zyklus 'for' verwenden wir nun 'while', was das Weglassen des Zählers x ermöglicht. Zu diesem Zweck verwenden wir die Variable length. Ferner verwenden wir eine der beiden Vorlagen für das Schreiben von Funktionen, abhängig davon, ob die Verarbeitungssequenz wichtig ist, oder nicht. In unserem Fall erhalten wir den String mit Zeichen in umgekehrter Reihenfolge, d.h. hier ist die Verarbeitungssequenz wichtig.


Alle ASCII Zeichen anzeigen

Versuchen wir nun alle ASCII Zeichen anzuzeigen. Denken Sie an die Funktionen StringSetChar() und StringGetChar(), welche entsprechend an der angegebenen Position ein Zeichen von ASCII an den Code einfügen und den Code und den Code an das Zeichen zurückgeben. StringSetChar() den dritten Parameter int value. Dies ist ein Code von der Tabelle mit ASCII Zeichen. Schreiben wir ein spezielles Script, um den Code für jedes Zeichen zu bestimmen:

//+------------------------------------------------------------------+
//|                                            StringExperiment3.mq4 |
//|         Copyright © 2007, Antonio Banderass. All rights reserved |
//|                                               banderassa@ukr.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2007, Antonio Banderass. All rights reserved"
#property link      "banderassa@ukr.net"
//+------------------------------------------------------------------+
//| start                                                            |
//+------------------------------------------------------------------+
int start()
  {
   string s, symbol = "s";
   for(int x = 0; x < 256; x++)
    {
      symbol = StringSetChar(symbol, 0, x);
      s = s + x + " = " + symbol + " \t";
      if(x % 10 == 0)
          s = s + " \n";
    }
   MessageBox(s);
   return(0);
  }
//+------------------------------------------------------------------+

Das Script verwendet eingebaute MQL4 Funktionen, und String-Konstanten eines neuen Strings und Tabellierung für die Visualisierung der Tabelle. Kompilieren Sie jetzt und starten Sie es. Sie werden die Tabelle mit ASCII Zeichen sehen:




Sehen Sie sie aufmerksam an. Sie werden absolut alle Zeichen sehen, die benötigt werden könnten, von Zahlen und Buchstaben bis zu speziellen Zeichen, einige von ihnen könnten neu für Sie sein. Zuerst kommt ein Code, und dann nach dem "=" kommt das Zeichen selbst. Ich habe einige wichtige Zeichensätze markiert:




Beachten Sie die Anordnung von Buchstaben. Sie sind in alphabetischer Reihenfolge angeordnet. Diese Eigenschaft wird später zum Schreiben einiger Funktionen verwendet, zum Beispiel, für das Übertragen von Buchstaben aus der Großschreibung in die Kleinschreibung und umgekehrt.

Und nun befassen wir uns mit neuen Funktionen und erstellen am Ende eine auf deren Grundlage Bibliothek.



StringUpperCase und StringLowerCase

Dies sind zwei sehr beliebte Funktionen zum Übertragen eines Strings in Groß- oder Kleinschreibung. Ihre Implementierung basiert auf der Tatsache, das alle Codes der Großschreibung-Zeichen um 32 von den Buchstaben der Kleinschreibung verschoben sind. Es ist aus der Tabelle ersichtlich. In der Praxis, wenn wir versuchen die Codes von den Zeichen 'A', 'Z', 'a', 'z' zu finden, verwenden Sie zum Beispiel diesen Code:

string s = "AZaz";
MessageBox("A = " + StringGetChar(s, 0));
MessageBox("Z = " + StringGetChar(s, 1));
MessageBox("a = " + StringGetChar(s, 2));
MessageBox("z = " + StringGetChar(s, 3));


die Ergebnisse werden die folgenden sein: A= 65, Z= 90, a= 97, z= 122 dementsprechend. Wir sollten also diese Besonderheit berücksichtigen. Betrachten wir den Quellcode der Funktion:


//+------------------------------------------------------------------+
//| StringUpperCase                                                  |
//+------------------------------------------------------------------+
string StringUpperCase(string str)
  {
   string s = str;
   int lenght = StringLen(str) - 1, symbol;
   while(lenght >= 0)
     {
       symbol = StringGetChar(s, lenght);
       if((symbol > 96 && symbol < 123) || (symbol > 223 && symbol < 256))
           s = StringSetChar(s, lenght, symbol - 32);
       else 
           if(symbol > -33 && symbol < 0)
               s = StringSetChar(s, lenght, symbol + 224);
       lenght--;
     }
   return(s);
  }
//+------------------------------------------------------------------+
//| StringLowerCase                                                  |
//+------------------------------------------------------------------+
string StringLowerCase(string str)
  {
   string s = str;
   int lenght = StringLen(str) - 1, symbol;
   while(lenght >= 0)
     {
       symbol = StringGetChar(s, lenght);
       if((symbol > 64 && symbol < 91) || (symbol > 191 && symbol < 224))
           s = StringSetChar(s, lenght, symbol + 32);
       else 
           if(symbol > -65 && symbol < -32)
               s = StringSetChar(s, lenght, symbol + 288);
       lenght--;
     }
   return(s);
  }

Da die Reihenfolge der Verarbeitung keine Rolle spielt, verwenden Sie den Zyklus 'while'. Es ist sehr einfach die Funktion zu verwenden, der einzige Parameter ist der String, der in die richtige Schreibung übertragen werden soll:


 string s1 = "UPPER_REGISTER_STRING";
  string s2 = "lower_register_string";
   
  MessageBox(StringLowerCase(s1)); // upper_register_string
  MessageBox(StringUpperCase(s2)); // LOWER_REGISTER_STRING


StringCompare

In MQL4 wird der Vergleich von Strings auf der Ebene von Operatorn mit "==" durchgeführt. Interessant ist die Tatsache, das Vergleich von Groß- und Kleinschreibung abhängig ist, das heißt Strings "STRING" und "string" sind unterschiedlich:

   if("STRING" == "string") // FALSE
      MessageBox("TRUE");
   else
      MessageBox("FALSE");

Wenn wir zwei Strings vergleichen müssen, ohne die Schreibung zu ignorieren, verwenden wir die Funktion StringCompare(). Sie gibt bool-Typ Werte zurück, wie den Operator des Vergleichs. Die Implementierung ist einfach. Sie vergleicht Strings, die vorher in Kleinschreibung übertragen wurden:

//+------------------------------------------------------------------+
//| StringCompare                                                    |
//+------------------------------------------------------------------+
bool StringCompare(string s1, string s2)
  {
    return(StringLowerCase(s1) == StringLowerCase(s2));
  }
Anwendungsbeispiel:
   if(StringCompare("STRING", "string")) // TRUE
      MessageBox("TRUE");
   else
      MessageBox("FALSE");

StringIsDigit

Diese Funktion prüft die Inhalte des Strings. Wenn der String nur Zahlen enthält, gibt sie true zurück, andernfalls - false. Die Implementierung ist ziemlich einfach und basiert auf der Tatsache, dass die Zeichen von Zahlen in einer Reihe sind und Codes von 48 bis 58 haben.


//+------------------------------------------------------------------+
//| StringIsDigit                                                    |
//+------------------------------------------------------------------+
bool StringIsDigit(string str)
  {
   bool result = true;
   string s = str;
   int lenght = StringLen(str) - 1, symbol;
   while(lenght > 0)
     {
       symbol = StringGetChar(s, lenght);
       if(!(symbol > 47 && symbol < 58))
         {
           result = false;
           break;
         }
       lenght--;
     }
   return(result);
  }

Anwendungsbeispiel:

  if(StringIsDigit("1234567890")) // TRUE
      MessageBox("TRUE");
  else
      MessageBox("FALSE");
 
  if(StringIsDigit("1234notdigit")) // FALSE
      MessageBox("TRUE");
  else
      MessageBox("FALSE");

StringIsAlpha

Diese Funktion, wie die vorherige, ermöglicht zu bestimmen, ob ein String nur Buchstaben enthält. Ihre Implementierung ist analog:

//+------------------------------------------------------------------+
//| StringIsAlpha                                                    |
//+------------------------------------------------------------------+
bool StringIsAlpha(string str)
  {
   bool result = false;
   string s = str;
   int lenght = StringLen(str) - 1, symbol;
   while(lenght > 0)
     {
       symbol = StringGetChar(s, lenght);
       if((symbol > 96  && symbol < 123) || (symbol > 64 && symbol < 91) ||
          (symbol > 191 && symbol < 256) || (symbol > -65 && symbol < 0))
 
         {
           result = true;
           break;
         }
       lenght--;
     }
   return(result);
  }


Anwendungsbeispiel:

  if(StringIsAlpha("thereAreSomeLetters")) // TRUE
      MessageBox("TRUE");
  else
      MessageBox("FALSE");
 
  if(StringIsAlpha("thereAreSomeDigits12345")) // FALSE
      MessageBox("TRUE");
  else
      MessageBox("FALSE");

Eine Bibliothek erstellen

Lassen Sie uns nun alle diese Funktionen in einer Bibliothek versammeln. Zu diesem Zweck klicken Sie in MetaEditor 4 auf 'File -> New -> Library -> Weiter'. In das Feld 'Name' schreiben Sie stringProcess und klicken 'Fertig stellen'. Dann geben Sie den Code der oben beschriebenen Funktionen ein und speichern. Danach erstellen Sie eine Datei mit den Funktions-Prototypen, klicken 'File -> New -> Include(*. MQH) -> Weiter'. In das Feld 'Name' schreiben Sie stringProcess, -> Fertig stellen. Jetzt fügen sie die Prototypen aller neuen Funktionen ein und geben die Anweisung für den Import an:

//+------------------------------------------------------------------+ 
//|                                                stringProcess.mqh |
//|                               Antonio Banderass Copyright © 2007 | 
//|                                               banderassa@ukr.net |
//+------------------------------------------------------------------+ 
#property copyright "Antonio Banderass Copyright © 2007"
#property link      "banderassa@ukr.net"
//+--- 
#import "stringProcess.ex4"
//+------------------------------------------------------------------+
//| prototypes                                                       | 
//+------------------------------------------------------------------+
string StringUpperCase(string str); 
string StringLowerCase(string str);
bool StringCompare(string s1, string s2);
bool StringIsDigit(string str);
bool StringIsAlpha(string str);

Verwenden der Bibliothek stringProcess

Um die Bibliothek zu verwenden, fügen Sie die Header-Datei mit den Prototypen der Funktionen ein, danach können Sie alle benötigten Funktionen aufrufen. Hier ist ein Anwendungsbeispiel in einem Script:

//+------------------------------------------------------------------+
//|                                     stringProcessLibraryTest.mq4 |
//|                               Antonio Banderass Copyright © 2007 |
//|                                               banderassa@ukr.net |
//+------------------------------------------------------------------+
#property copyright "Antonio Banderass Copyright © 2007"
#property link      "banderassa@ukr.net"
 
#include <stringProcess.mqh>
//+------------------------------------------------------------------+
//| script program start function                                    |
//+------------------------------------------------------------------+
int start()
  {
   if(StringIsDigit("1234567890")) // TRUE
       MessageBox("TRUE");
   else
       MessageBox("FALSE");
   if(StringIsDigit("1234notdigit")) // FALSE
       MessageBox("TRUE");
   else
       MessageBox("FALSE");
   return(0);
  }

Fazit

Also, Sie haben einiges über die Tabelle mit ASCII Zeichen erfahren und wie Sie die Besonderheiten ihrer Konstruktion für die Gestaltung neuer Funktionen nutzen können. Sie haben neue Funktionen geschrieben, die in anderen Programmiersprachen sehr beliebt sind, in MQL4 aber nicht enthalten. AUf diesen basierend haben Sie eine kleine Bibliothek für die Stringverarbeitung erstellt. Ich denke, diese Bibliothek wird nicht während des Trading, sondern beim Empfang der Ergebnisse verwendet werden. Zum Beispiel, wenn Sie Ihr eigenes System von Berichten für Ihren Expert Advisor entwickeln, werden einige der Funktionen nützlich für Sie sein. Darüber hinaus werden Sie viele Anwendungsbereiche finden, die ich vielleicht nicht kenne. Viel Glück und Profite für sie!



Übersetzt aus dem Englischen von MetaQuotes Software Corp.
Originalartikel: https://www.mql5.com/en/articles/1474

Wie man das Erkennen und Beheben von Fehlern in einem Expert Advisor Code einfacher macht Wie man das Erkennen und Beheben von Fehlern in einem Expert Advisor Code einfacher macht

In der Expert Advisor Entwicklung, sind die Fragen der Fehlererkennung im Code und deren Behebung sehr wichtig. Die Besonderheit ist, dass ein nicht rechtzeitig entdeckter Fehler, eine wertvolle Idee für ein Handelssystem bereits auf der Stufe der ersten Tests ruinieren kann. Deshalb berücksichtigt jeder vernünftige EA Entwickler solche Probleme von Anfang an. Dieser Artikel beschäftigt sich mit einigen Ansätzen, die in dieser schwierigen Angelegenheit helfen.

Praktische Anwendung von Cluster Indikatoren im Devisenhandel Praktische Anwendung von Cluster Indikatoren im Devisenhandel

Cluster Indikatoren sind Sätze aus Indikatoren, die Währungspaar in einzelne Währungen teilen. Indikatoren ermöglichen es die relative Wechselkursschwankung zu verfolgen, das Potential der Bildung eines neuen Währungstrends zu bestimmen, Handelssignale zu erhalten, sowie mittel- und langfristigen Positionen zu folgen.

MQL4 Sprache für Einsteiger. Einführung MQL4 Sprache für Einsteiger. Einführung

Diese Artikelreihe ist für Trader gedacht, die nichts über Programmierung wissen, aber den Wunsch haben MQL4 so schnell wie möglich mit minimal aufgewendeter Zeit und Anstrengung zu lernen. Wenn Sie Angst vor solchen Begriffen wie "Objektorientierung" oder "dreidimensionale Arrays" haben, ist dieser Artikel das was Sie brauchen. Die Lektionen sind für ein maximal schnelles Ergebnis entworfen. Darüber hinaus werden die Informationen in verständlicher Form geliefert. Wie werden nicht zu tief in die Theorie gehen, aber Sie werden den praktischen Nutzen bereits ab der ersten Lektion gewinnen.

So können Sie Ihre eigenen Optimierungskriterien implementieren So können Sie Ihre eigenen Optimierungskriterien implementieren

In diesem Artikel finden Sie ein Beispiel für die Optimierung nach dem Kriterium Gewinn/Kreditinanspruchnahme, wobei die Resultate in einer Datei zusammengefasst werden, die für die Verwendung mit einem standardisierten "Expert Advisor" - dem Gleitenden Durchschnitt - geeignet ist.