heim Herausgeber

1c Erstellung einer Wertetabelle. Welche Methoden gibt es und wie kann man nach mehreren Werten gleichzeitig suchen?

Veröffentlicht am 21. September 2011

Wertetabelle 1C – Teil 3. Metadaten. Durchlaufen der Wertetabellenspalten

In diesem Artikel erkläre ich Ihnen, wie Sie mit einer Wertetabelle einer „unbekannten“ Struktur arbeiten, wie Sie die Spalten einer Wertetabelle durchlaufen und wie Sie Daten aus Spalten und Zeilen extrahieren, ohne Spaltennamen zu verwenden. (Dieser Artikel gehört zur Artikelserie 1C von Grund auf; Programmierung von 1C von Grund auf; Tabelle der 1C-Werte)

Um das Material zu erklären und unsere Codebeispiele „live“ ausführen zu können, benötigen wir welche Testwertetabelle 1C. Einige unserer Beispiele extrahieren Daten aus einer Wertetabelle, also erstellen wir eine Tabelle mit drei Spalten „Nachname“, „Vorname“, „Zweiter Vorname“ und geben eine kleine Datenmenge ein – bis zu 3 Reihen :)

Erstellen wir also eine Testtabelle mit 1C-Werten und füllen sie aus:

MyTZ = Neue Wertetabelle; // eine neue Wertetabelle erstellen, die in der Variablen „MyTZ“ gespeichert ist MyTZ.Columns.Add("Last Name"); // Spalte „Nachname“ erstellen MyTZ.Columns.Add("Name"); // die Spalte „Name“ erstellen MyTZ.Columns.Add("Patronymic"); // die Spalte „Zweiter Vorname“ erstellen // die erste Zeile zu unserer Wertetabelle hinzufügen NewLine = MyTZ.Add(); NewString.LastName = "Chapaev"; NewLine.Name = "Vasily"; NewString.Middle name = "Ivanovich"; // füge die zweite Zeile hinzu NewLine = MyTZ.Add(); NewString.LastName = "Dzerzhinsky"; NewRow.Name = "Felix"; NewString.Middle name = "Edmundovich"; // füge die dritte Zeile hinzu NewLine = MyTZ.Add(); NewLine.LastName = "Kotovsky"; NewLine.Name = "Gregory"; NewString.Middle name = "Ivanovich";

Unsere Testtabelle besteht aus drei Spalten: Vorname, Nachname, Patronym; und enthält drei ausgefüllte Zeilen mit den Namen von Bürgerkriegshelden.

Das erste Codebeispiel listet die Spalten einer 1C-Wertetabelle als Sammlung auf.

// die Namen aller Spalten des TK für jede Spalte aus MyTZ.Columns Cycle Report anzeigen("Column name: " + Column.Name); EndCycle;

Unser Zyklus zeigt alle Spaltennamen im 1C-Nachrichtenfenster an:

Spaltenname: Nachname Spaltenname: Vorname Spaltenname: Zweiter Vorname

Wir sehen, dass zum Durchlaufen von Spalten ein spezieller Sammlungsiterationszyklus verwendet wird, ähnlich dem Zeileniterationszyklus (im vorherigen Artikel). MyTZ.Columns- Dies ist eine Sammlung von Spalten der 1C-Wertetabelle „MeinTZ“. Die Sammlung enthält Objekte des Typs „Wertetabellenspalte“ Jedes Objekt dieses Typs ist eine Spalte der Wertetabelle und enthält Eigenschaften und Methoden. Durch den Zugriff auf diese Eigenschaften und Methoden erhalten wir die erforderlichen Informationen zu einer Spalte oder führen andere Aktionen damit durch.

Zum Beispiel der Zutritt zum Grundstück "Name" (Spaltenname) erhalten wir den Namen der aktuellen Spalte.

Ich möchte Sie auf den Titel der Serie aufmerksam machen: „Für alle Spalte Aus MyTZ.Column Cycle“ Variable mit Namen "Spalte" von uns erfunden. Es ist nicht notwendig, denselben Namen zu verwenden. Sie können diese Variable beispielsweise beliebig nennen „MeineAktuelleSpalte“ Dann würde das obige Beispiel so aussehen:

// die Namen aller Spalten des TK für jede MyCurrentColumn From MyTK.Columns Cycle Report("Column name: " + MyCurrentColumn.Name); anzeigen EndCycle;

Wenn das 1C-Ausführungssubsystem auf einen Zyklus dieses Typs trifft, weist es bei jedem Zyklusdurchlauf einer Variablen mit dem angegebenen Namen ein Element aus unserer Sammlung zu, in diesem Fall - ein Sammlungselement Wertetabellenspalten MyTZ.Columns Und dann greifen wir auf die Variable zu, die die aktuelle Spalte enthält, und verwenden die Eigenschaft "Name".

Ich schlage vor, neben dem Spaltennamen die Nummer jeder Spalte in der Spaltensammlung anzuzeigen:

// Anzahl und Namen aller Spalten der Wertetabelle anzeigen Für jede Spalte aus MyTZ.Columns Cycle ColumnNumber = MyTZ.Columns.Index(Column); // die Spaltennummer abrufen ColumnName = Column.Name; // den Spaltennamen abrufen Report("Spaltennummer:" + Spaltennummer + " Spaltenname: " + Spaltenname); EndCycle;

Im 1C-Nachrichtenfenster wird folgender Text angezeigt:

Spaltennummer:0 Spaltenname: Nachname Spaltennummer:1 Spaltenname: Vorname Spaltennummer:2 Spaltenname: Zweiter Vorname

Bitte beachten Sie, dass die Spalten in der 1C-Wertetabelle ebenso wie die Zeilen der Wertetabelle von Null beginnend nummeriert sind.

Anzahl der Spalten in der 1C-Wertetabelle

Um die Anzahl der Spalten in der Wertetabelle herauszufinden, verwenden wir die Methode „Count()“ für die Spaltensammlung.

Anzahl der Spalten = MyTZ.Columns.Quantity(); Bericht (Anzahl der Spalten);

Auf dem Bildschirm wird die Zahl „3“ angezeigt. Tatsächlich besteht unsere Tabelle aus drei Spalten: „Nachname“, „Vorname“, „Patronymie“.

Abrufen eines Spaltenobjekts anhand seiner Nummer (Index) und Auflisten von Spalten mithilfe des Spaltenindex

Lassen Sie uns einen Zyklus zum Durchsuchen aller Spalten der Wertetabelle mithilfe von Spaltenindizes (Zahlen) durchführen. Denken Sie daran, dass die Spaltennummerierung bei Null beginnt. Daher müssen wir den Zykluszähler „Sch“ von Null auf eine Zahl erhöhen, die der Anzahl der Spalten minus eins entspricht.

For Account = 0 By MyTZ.Columns.Quantity() - 1 Cycle CurrentColumn = MyTZ.Columns[Act]; Bericht(CurrentColumn.Name); EndCycle;

Auf dem Bildschirm erhalten wir Folgendes

Vollständiger Name

Ich denke, dieses Beispiel war klar. Wir haben uns der Methode zugewandt Menge() Kolumnensammlungen“ MyTZ.Columns.Quantity()", hat die Anzahl der Spalten ermittelt und eine Schleife mit einem Zähler von gestartet null Vor Anzahl der Spalten minus eins. Innerhalb der Schleife rufen wir jede Spalte aus der Spaltensammlung ab und weisen das aktuelle Spaltenobjekt einer Variablen zu AktuelleSpalte Als nächstes die Variable AktuelleSpalte Wir betreten das Grundstück Name und zeigen Sie den Wert dieser Eigenschaft auf dem Bildschirm an: Bericht(CurrentColumn.Name);

Es ist wichtig, niemals die Eigenschaft eines Objekts und die Methode eines Objekts zu verwechseln.

Eine Eigenschaft ist ein bestimmter statischer Wert und der Zugriff darauf wird beispielsweise ohne Klammern geschrieben CurrentColumn.Name. Eine Methode ist im Wesentlichen eine Prozedur oder Funktion eines Objekts, und Aufrufe von Prozeduren und Funktionen werden immer in Klammern geschrieben (auch wenn keine Eingabeparameter vorhanden sind). Zum Beispiel: MyTZ.Columns.Quantity()

Wenn wir auf eine Methode zugreifen und vergessen, die Klammern zu schreiben, gibt uns der 1C-Interpreter eine Fehlermeldung und führt den Code nicht aus. Da der Interpreter davon ausgeht, dass wir nicht auf eine Methode, sondern auf eine Eigenschaft zugreifen – weil es keine Klammern gibt. Es können jedoch keine Eigenschaften mit diesem Namen gefunden werden (da es nur eine Methode mit diesem Namen gibt) – was in der Fehlermeldung angegeben wird.

Dies ist, was der Interpreter schreiben wird, wenn ich vergesse, in einem Methodenaufruf auf solch falsche Weise Klammern einzufügen MyTZ.Columns.Quantity(ohne Klammern nach „Quantity()“):

Objektfeld nicht gefunden (Menge)

In diesem Fall sind „Feld“ und „Eigenschaft“ als Synonyme oder als Ungenauigkeit in der Terminologie der 1C-Entwickler zu verstehen. Sie verwenden beide Wörter, um sich auf dasselbe Konzept zu beziehen. Obwohl diese Begriffe in anderen Programmiersprachen möglicherweise unterschiedliche Bedeutungen haben.

Abrufen von Daten aus einer Tabelle mit 1C-Werten mithilfe von Spaltennummern

Zunächst biete ich Ihnen ein einfaches Beispiel für das Abrufen von Daten aus der ersten Zeile unserer Tabelle. Bitte beachten Sie, dass wir die vorab ausgefüllte Tabelle vom Anfang des Artikels verwenden. Wir wissen mit Sicherheit, dass die Tabelle eine erste Zeile und mindestens eine Spalte hat. Wenn wir dieses Beispiel auf eine leere Tabelle anwenden, tritt ein Fehler auf. Also:

FirstLine = MyTK; // Erste Zeile abrufen (von Null an nummeriert) FirstColumnValue = FirstRow; // Den Wert der ersten Spalte abrufen (die Spaltennummerierung erfolgt ebenfalls von Grund auf) Report(Value of the FirstColumn); // den Wert der ersten Spalte in der ersten Zeile der Tabelle anzeigen

Auf dem Bildschirm wird Folgendes angezeigt:

Tschapajew

Zuerst haben wir ein Wertetabellenzeilenobjekt erhalten, indem wir mit dem Operator [...] auf die Wertetabelle zugegriffen haben. (Wenn Sie vergessen haben, wie das geht, können Sie sich frühere Artikel ansehen.) Wir haben das Argument „0“ innerhalb des Operators übergeben. Dies ist der Index der ersten Zeile der Wertetabelle. FirstLine = MyTK;

Darüber hinaus haben wir auch das Recht, mit dem Operator [...] auf ein String-Objekt zuzugreifen. Innerhalb dieses Operators haben wir die Spaltennummer der Wertetabelle übergeben, in diesem Fall auch „0“. Und so haben wir den Wert der Spalte mit der Nummer „0“ für die aktuelle Tabellenzeile mit der Nummer „0“ erhalten. Wir haben diesen Wert auf dem Bildschirm angezeigt und er stellt die Zeichenfolge „Chapaev“ dar.

Machen wir unser Beispiel etwas komplizierter:

FirstLine = MyTK; // die erste Zeile abrufen (von Null an nummeriert) Report(FirstLine); // den Wert der ersten Spalte in der ersten Zeile der Tabelle anzeigen Report(FirstRow); // den Wert der zweiten Spalte in der ersten Zeile der Tabelle anzeigen Report(FirstRow); // den Wert der dritten Spalte in der ersten Zeile der Tabelle anzeigen

Wir haben nun die Werte aus allen drei Spalten der ersten Zeile unserer Wertetabelle angezeigt:

Chapaev Wassili Iwanowitsch

Nun werde ich auch dieses Beispiel so modifizieren, dass wir auf die Variable verzichten können "Erste Linie"

Bericht(MyTZ); // den Wert der ersten Spalte in der ersten Zeile der Tabelle anzeigen Report(MyTZ); // den Wert der zweiten Spalte in der ersten Zeile der Tabelle anzeigen Report(MyTZ); // den Wert der dritten Spalte in der ersten Zeile der Tabelle anzeigen

Auf dem Bildschirm wird es dasselbe sein

Chapaev Wassili Iwanowitsch

Wir haben im obigen Beispiel gesehen, dass wir zum Zugriff auf einen Wert in einer bestimmten Zeile und einer bestimmten Spalte einer Wertetabelle einen sequentiellen Aufruf von zwei Operatoren verwenden können [...] in dieser Form: Wertetabelle[Zeilenindex][Spaltenindex]

Wir sind also bereit, eine Schleife zu erstellen und die Daten aller Zeilen und Spalten mithilfe von Zeilen- und Spaltenindizes abzurufen:

For RowCounter = 0 By MyTZ.Quantity() - 1 Loop // Durchlaufen der Zeilen For ColumnCounter = 0 By MyTZ.Columns.Quantity() - 1 Loop // verschachtelte Schleife durch Spalten // Zellwert abrufen (aus der aktuellen Zeile). und die aktuellen Spalten) CellValue = MyTK[RowCounter][ColumnCounter]; // Zeilennummer, Spaltennummer und Zellenwert anzeigen Report("Row No" + Row Count + "column No" + Column Count + " = " + CellValue); EndCycle; EndCycle;

Folgendes wird auf dem Bildschirm angezeigt:

Zeile Nr. 0 Spalte Nr. 0 = Chapaev Zeile Nr. 0 Spalte Nr. 1 = Wassili Zeile Nr. 0 Spalte Nr. 2 = Iwanowitsch Zeile Nr. 1 Spalte Nr. 0 = Dzerzhinsky Zeile Nr. 1 Spalte Nr. 1 = Felix Zeile Nr. 1 Spalte Nr. 2 = Edmundovich Zeile Nr. 2 Spalte Nr. 0 = Kotovsky Zeile Nr. 2 Spalte Nr. 1 = Grigory Zeile Nr. 2 Spalte Nr. 2 = Ivanovich

Mithilfe zweier Zyklen, von denen einer in den anderen verschachtelt ist, haben wir die Werte aller Spalten aus allen Zeilen der 1C-Wertetabelle angezeigt. In diesem Fall haben wir keine Spaltennamen verwendet, sondern über ihre Indizes auf Spalten und Zeilen zugegriffen. Beachten Sie zum besseren Verständnis die Kommentare im Beispiel.

Abschließend schlage ich vor, unser Beispiel leicht zu ändern, sodass anstelle der Spaltennummern deren Namen auf dem Bildschirm angezeigt werden. Darüber hinaus werde ich ein ansprechenderes Design für die Anzeige von Inhalten auf dem Bildschirm erstellen.

For LineCounter = 0 By MyTZ.Quantity() - 1 Loop // Schleife durch Zeilen Report(" ======= Line No. " + LineCounter + " ======="); Etwas melden(" "); // Zeilenvorschub (Einfügen einer leeren Zeile) For ColumnCounter = 0 By MyTZ.Columns.Quantity() - 1 Loop // verschachtelte Schleife durch Spalten // den Zellenwert abrufen (aus der aktuellen Zeile und der aktuellen Spalte) CellValue = MyTZ [RowCounter][ ColumnCounter]; // den Namen der Spalte abrufen ColumnName = MyTZ.Columns[ColumnCounter].Name; // Spaltennamen und Zellenwert anzeigen Report(ColumnName + ": " + CellValue); EndCycle; Etwas melden(" "); // Zeilenvorschub (Einfügen einer Leerzeile) EndCycle;

Jetzt sahen die Informationen auf unserem Bildschirm repräsentativer aus:

Zeile Nr. 0 ======= Nachname: Chapaev Vorname: Vasily Patronym: Ivanovich ======= Zeile Nr. 1 ======= Nachname: Dzerzhinsky Vorname: Felix Patronym: Edmundovich ===== == Zeile Nr. 2 ======= Nachname: Kotovsky Vorname: Grigory Patronym: Ivanovich

Ja, fast hätte ich es vergessen. Bei der Verwendung von zwei [...][...]-Operatoren in einer Zeile können wir anstelle eines Spaltenindex den Namen dieser Spalte übergeben: ValueTable[RowIndex][ColumnName]

Achten Sie auf die mit einem Pfeil markierte Zeile „. In dieser Zeile übergeben wir anstelle des Index der aktuellen Spalte den Namen der aktuellen Spalte in eckigen Klammern an das Argument [...] Das Ergebnis wird das gleiche sein.

Und jetzt das Letzte in diesem Artikel.

Korrektes Abrufen aller Daten aus der 1C-Wertetabelle mithilfe von Schleifen durch eine Sammlung von Zeilen und eine Sammlung von Spalten

For Each CurrentLine From MyTZ Loop // Schleife durch eine Sammlung von Strings Report(" ======= Line No. " + MyTZ.Index(CurrentLine) + " ======="); Etwas melden(" "); For Each CurrentColumn From MyTZ.Columns Loop // verschachtelte Schleife, die eine Sammlung von Spalten durchläuft ColumnName = CurrentColumn.Name; // den Spaltennamen abrufenCellValue = CurrentRow[ColumnName]; // Den Zellwert DURCH Spaltennamen abrufen Report(ColumnName + ": " + CellValue); // Spaltennamen und Zellenwert anzeigen End of Cycle; Etwas melden(" "); EndCycle;

Im Beispiel wurden zwei Schleifen verwendet. Eine Schleife zum Durchlaufen einer Sammlung von Spalten ist in einer Schleife zum Durchlaufen von Zeilen verschachtelt. Wenn Sie die obigen Beispiele durchgearbeitet und frühere Artikel gelesen haben, werden Sie keine Schwierigkeiten haben, die Funktionsweise dieses Beispiels zu verstehen.

Abschließend werde ich die Anzahl der Codezeilen in unserem letzten Beispiel so weit wie möglich reduzieren, indem ich auf die Verwendung von Zwischenvariablen verzichte. Wir erhalten ein Beispiel für „Industriecode“, der in realen Problemen verwendet wird.

Dies sollte nur dann erfolgen, wenn Sie genau wissen, was Sie tun. Wenn der Code sehr komplex ist, ist es akzeptabel, Zwischenvariablen zu belassen, um das spätere Verständnis des eigenen Codes zu erleichtern. Außerdem muss jeder Code zumindest minimal kommentiert werden, damit die Programmtexte nach einiger Zeit leichter verständlich sind.

Für jede aktuelle Zeile aus dem MyTZ-Zyklus // über Zeilen iterieren Report(" ======= Zeilennummer " + MyTZ.Index(CurrentLine) + " =======" + Symbols.PS); Für jede CurrentColumn From MyTZ.Columns-Schleife // über Spalten iterieren Report(CurrentColumn.Name + ": " + CurrentRow[CurrentColumn.Name]); EndCycle; Etwas melden(" "); EndCycle;

Die Ausgabe auf dem Bildschirm hat sich nicht verändert, sie bleibt die gleiche wie im vorherigen Beispiel:

2-WOCHEN-KURS

„PROGRAMMIERUNG IN 1C FÜR ANFÄNGER“

Der Kurs wird per E-Mail verschickt. Werden Sie Programmierer, indem Sie Schritt-für-Schritt-Aufgaben erledigen.

Zur Teilnahme benötigen Sie lediglich einen Computer und das Internet

Kostenloser Zugang zum Kurs:

Sp-force-hide ( display: none;).sp-form ( display: block; hintergrund: #eff2f4; padding: 5px; width: 270px; max-width: 100%; border-radius: 0px; -moz-border -radius: 0px; -webkit-border-radius: 0px; Schriftfamilie: Arial, „Helvetica Neue“, serifenlos; Hintergrundwiederholung: keine Wiederholung; Hintergrundposition: Mitte; Hintergrundgröße: automatisch;) .sp-form input ( display: inline-block; opazität: 1; sichtbarkeit: sichtbar;).sp-form .sp-form-fields-wrapper ( margin: 0 auto; width: 260px;).sp-form .sp -form-control ( Hintergrund: #ffffff; Randfarbe: #cccccc; Randstil: einfarbig; Randbreite: 1 Pixel; Schriftgröße: 15 Pixel; Innenabstand links: 8,75 Pixel; Innenabstand rechts: 8,75 Pixel; Rand -radius: 4px; -moz-border-radius: 4px; -webkit-border-radius: 4px; Höhe: 35px; Breite: 100%;).sp-form .sp-field label ( Farbe: #444444; Schriftart- Größe: 13px; Schriftstil: normal; Schriftstärke: fett;).sp-form .sp-button ( border-radius: 4px; -moz-border-radius: 4px; -webkit-border-radius: 4px; Hintergrundfarbe: #f4394c; Farbe: #ffffff; Breite: 100 %; Schriftstärke: 700; Schriftstil: normal; Schriftfamilie: Arial, „Helvetica Neue“, serifenlos; Kastenschatten: keiner; -moz-box-shadow: keine; -webkit-box-shadow: keine; Hintergrund: linear-gradient(to top, #e30d22 , #f77380);).sp-form .sp-button-container ( text-align: center; width: auto;)

(Dieser Artikel gehört zur Artikelserie 1C von Grund auf; Programmierung von 1C von Grund auf; Tabelle der 1C-Werte)

Eine virtuelle Datenspeicherstruktur in tabellarischer Form – das ist es

Die Wertetabelle ist kein permanentes Objekt der 1C-Datenbank und wird zwischen den Startsitzungen nicht gespeichert.

Wertetabelle 1C(TK) wird „on the fly“ mit Programmcode erstellt und anschließend mit ihm wie mit jedem anderen Programmobjekt der Programmiersprache 1C gearbeitet. Methodenaufrufe verwenden und auf die Eigenschaften eines Tabellenobjekts zugreifen.

Mit anderen Worten: Der Programmierer erstellt eine Tabelle im Speicher, füllt sie mit Daten, arbeitet damit, sortiert, gruppiert, berechnet Summen und so weiter. Erhält die notwendigen Daten zur weiteren Verwendung.

Lasst uns eine Wertetabelle erstellen und diese mit etwas füllen. Es muss daran erinnert werden, dass eine Tabelle mit 1C-Werten nicht nur manuell, sondern auch durch einen Anruf beim Bediener erstellt werden kann

NewValueTable;

Eine Wertetabelle ist häufig das Ergebnis eines Methodenaufrufs für ein anderes Objekt, beispielsweise kann das Ergebnis einer Abfrage in eine Wertetabelle usw. ausgegeben werden.

Lassen Sie mich Ihnen gleich ein einfaches Beispiel geben.

// MyTZ = New ValueTable; // eine neue Wertetabelle erstellen, die in der Variablen „MyTZ“ gespeichert ist MyTK. Säulen. Add("Nachname" ); // die Spalte „Nachname“ erstellen MyTK. Säulen. Add("Name"); // Erstelle die Spalte „Name“. Bericht (MyTZ); // den Wert der MyTZ-Variablen anzeigen //

Ich habe eine Tabelle mit 1C-Werten erstellt, mit zwei Spalten: „Nachname“, „Vorname“. Verfahren Bericht (MyTK) zeigt den Variablentyp im Nachrichtenfenster an MyTZ: Wertetabelle

Unsere Wertetabelle ist vorerst leer. Fügen wir ein paar Zeilen mit Vor- und Nachnamen hinzu.

// Wertetabelle füllen // füge die erste Zeile zu unserer Wertetabelle hinzu NewLine = MyTZ. Hinzufügen() ; Neue Zeile. Nachname = „Sidorov“ ; Neue Zeile. Name = „Vasya“ ; // füge unserer Wertetabelle eine zweite Zeile hinzu NewLine = MyTZ. Hinzufügen() ; Neue Zeile. Nachname = „Iwanow“ ; Neue Zeile. Name = „Peter“ ;

Wir haben einen Tisch wie diesen erhalten:

Denken Sie daran: Zeilennummern in der Wertetabelle beginnen bei Null

Warum brauchen wir überhaupt Zeilennummern? Und damit wir beispielsweise auf eine separate Zeile der Wertetabelle zugreifen können, nehmen Sie diese Zeile und zeigen Sie sie auf dem Bildschirm an.

// *** zeigt die Werte der Nulllinie auf dem Bildschirm an *** (im Alltag nummerieren wir normalerweise Dinge beginnend bei eins, aber hier - bei null) // Holen Sie sich die Nullzeile unserer Tabelle mithilfe des Zeilenindex in eckigen Klammern OurNullString = MyTZ[ 0] ; // jetzt ist der gesamte Nullstring in der Variablen „OurFirstLine“ enthalten Report(OurNullString.LastName) ; // den Wert der Spalte „Nachname“ anzeigen, die in Zeile Null gespeichert ist Bericht (OurNullString.Name) ; // den Wert der Spalte „Name“ aus derselben Zeile anzeigen

Als Ergebnis wird auf dem Bildschirm Folgendes angezeigt:

Sidorow Wasja

Für die ganz Schlauen und Prägnanten zeige ich nun ein Beispiel, das Ihnen den Zugriff auf den Wert einer Spalte in dieser und jener Zeile ermöglicht (Der Wert einer Spalte in dieser und jener Zeile ist eine Zelle der Wertetabelle . Ein inoffizieller, aber praktischer Begriff. Allerdings ohne die Verwendung einer Zwischenvariablen wie „OurZeroString“.

Um den Wert von Zellen aus der zweiten Zeile anzuzeigen (vergessen Sie nicht, dass die Zeile die zweite ist, der Index dieser Zeile jedoch eins ist, sodass die Nummerierung bei Null beginnt)

Zum Schluss noch der letzte Punkt in diesem Artikel. Ich habe Ihnen ein Beispiel für den Zugriff auf eine einzelne Zeile einer Wertetabelle anhand des Index (Zeilennummer) gezeigt. Die universelle Form zum Auslesen oder Zuweisen des Inhalts einer Zelle ist: „MyValueTable[RowNumber].ColumnName“

Jetzt gebe ich Ihnen einen Zyklus der vollständigen Ausgabe des Inhalts der Wertetabelle. Ohne ausführliche Erklärungen, damit Sie sich auch den Kopf zerbrechen können :)

// // Alle Zeilen unserer Wertetabelle durchlaufen und anzeigen// Für LineNumber = 0 Laut MyTZ. Quantity() - 1 Zyklusbericht (MyTZ[LineNumber] . LastName) ; // den Wert der Spalte „Nachname“ anzeigen Bericht (MyTK[LineNumber] . Name) ; // den Wert der Spalte „Name“ anzeigen EndCycle ;

Als Ergebnis der Ausführung dieser Schleife wird Folgendes auf dem Bildschirm angezeigt:

Sidorow Wasja Iwanow Petja

Hier habe ich Ihnen die Grundlagen der Arbeit mit der 1C-Wertetabelle erklärt. Diese Informationen gelten für 1C 8.0, 8.1, 8.2. Die interessanten Details zum Objekt „1C-Wertetabelle“ enden hier nicht. Dieses Objekt verfügt über enorme Möglichkeiten für die komfortable Arbeit mit Daten. Darüber werde ich in den folgenden Artikeln sprechen.

Degtyarev Roman.

Wie lerne ich das Programmieren in 1C von Grund auf?

Wie kann man als 1C-Programmierer arbeiten und bis zu 150.000 Rubel pro Monat verdienen?

MELDE DICH KOSTENLOS AN

2-WOCHEN-KURS

„PROGRAMMIERUNG IN 1C FÜR ANFÄNGER“

Der Kurs wird per E-Mail verschickt. Werden Sie Programmierer, indem Sie Schritt-für-Schritt-Aufgaben erledigen.

Zur Teilnahme benötigen Sie lediglich einen Computer und das Internet

Kostenloser Zugang zum Kurs:

Grüße an alle Leser von infostart. Dieser Artikel widmet sich der Frage der programmgesteuerten Erstellung einer beliebigen Wertetabelle in Form einer verwalteten Anwendung.

Merkmale der Aufgabe.

Wer in einer regulären Anwendung programmiert hat, stand schon oft vor der Aufgabe, eine beliebige Wertetabelle auf einem Formular zu erhalten. Eine beliebige Wertetabelle ist eine Tabelle, deren Anzahl und Art der Spalten nicht im Voraus bekannt sind. Das heißt, es könnten 3 Spalten vorhanden sein, oder vielleicht 6, oder vielleicht 8. In einer normalen Anwendung ist alles einfach: Sie könnten das Element „Wertetabelle“ auf dem Verarbeitungsformular platzieren und dann die erstellte Wertetabelle übertragen programmgesteuert zu diesem Element hinzufügen. Dann mit einem einfachen Befehl:

Form Elements.TableField.CreateColumns();

Holen Sie sich auf dem Formular eine vorgefertigte Wertetabelle. Es scheint, dass es einfacher sein könnte.

Dies alles war in der regulären Anwendung enthalten. In einer verwalteten Anwendung hat sich alles geändert. Es ist nicht so einfach, eine beliebige Tabelle zu erstellen. Jetzt müssen Sie die Wertetabelle im Formular entweder starr parametrisieren oder sie programmgesteuert erstellen (beschreiben Sie, nun ja, das ist tatsächlich die Essenz der verwalteten Anwendung selbst). Dies ist, was wir versuchen werden: Programmgesteuert eine beliebige Wertetabelle in einem kontrollierten Formular erstellen.

Die Lösung des Problems.

Als Erstes müssen wir festlegen, wie die Tabelle im Formular angezeigt wird. Die Hauptsache ist, dass Sie bei der Verarbeitung kein Formularelement erstellen müssen. Wir werden es wie die gesamte Tabelle programmgesteuert erstellen. Das heißt, die Tabelle wird im Moment des Öffnens des Formulars oder der Betätigung einer Schaltfläche beschrieben und erstellt – je nachdem, wer sie benötigt.

Die Erstellung einer Tabelle auf dem Formular erfolgt durch die Beschreibung der Wertetabelle als Attribut:
SelectionTypeArray = Neues Array; Array von SelectionType.Add(Type("Value Table")); ChoiceTypeDescription = New TypeDescription(ChoiceTypeArray); Array von Details = Neues Array; Array of Attributes.Add(New Form Attributes("Schedule Table", Beschreibung von SelectionType, "", "TZN")); Jetzt müssen wir eine programmatische Wertetabelle erstellen, die die Daten enthält. Wird die Wertetabelle aus einer Abfrage gewonnen, dann ist alles mehr oder weniger in Ordnung. Wenn die Tabelle manuell erstellt wird, kann die Bedeutung der Spalten, die Zahlen oder Datumsangaben enthalten, über die „Typenbeschreibung“ erstellt werden. Der Punkt ist, dass die Spalten in der Wertetabelle einen bestimmten Typ haben müssen. Wenn beispielsweise erwartet wird, dass der Benutzer diese Spalten interaktiv mit Daten ausfüllt, können Sie eine Spalte der Wertetabelle nicht einfach mit einem Namen hinzufügen; sie muss einen Typ haben. Denken Sie daran – das ist sehr wichtig, weil... Wir werden diese Typen in die Tabelle auf dem Formular übertragen.
Wir erstellen eine Tabelle, die mehrere Spalten enthält:
CD = NewDateQualifiers(DateParts.Time); ArrayKD = Neues Array; ArrayCD.Add(Type("Date")); DescriptionTypesTime = New DescriptionTypes(ArrayCD,CD); TZ = Neue Wertetabelle;
TK.Columns.Add("With", DescriptionTypesTime);
TK.Columns.Add("Before", DescriptionTypesTime);
TK.Columns.Add("Name");
TK.Columns.Add("Note"); // Vollständiger Name und Notiz - Zeilen Als nächstes füllen wir unsere TK-Programmtabelle mit den notwendigen Daten. Wir erhalten eine TK-Tabelle, die die notwendigen Werte enthält und zur Übertragung in das erstellte Formularattribut bereit ist. Für jede Spalte von TK. Spaltenzyklus

Array of Attributes.Add(New Form Attributes(Column.Name, Column.ValueType,"ScheduleTable"));

EndCycle;
ChangeDetails(ArrayDetails);
SelectionFieldsTable = Elements.Add("TZN", Type("FormTable"));
SelectionFieldsTable.DataPath = "ScheduleTable";
SelectionFieldTable.Display = TableDisplay.List;

Dies ist eine einfache Kombination und unser Tisch ist fertig.

Für jede Spalte von TK. Spaltenzyklus

NewElement = Elements.Add(Column.Name, Type("FormField"), SelectionFieldTable);
NewElement.View = FormFieldView.InputField;
NewElement.DataPath = „ScheduleTable.“ + Column.Name;
NewElement.Width = 10;

EndCycle;

Bedingtes Design, wenn wir es brauchen, schreiben wir es auch manuell, das Befehlsmenü - manuell. Tabellenhandler werden ebenfalls von Hand geschrieben. So fügen Sie beispielsweise einen Ereignishandler für die Tabelle „Auswahl“ hinzu:

Tabelle von SelectionFields.SetAction("Selection","TZNSelection");

Zur Bearbeitung dieses Ereignisses ist ein gesondertes Verfahren in Form eines Verfahrens vorgeschrieben:

&OnClient
Prozedur TKNSelection(TK, SelectedRow, Field, StandardProcessing)
//Handler-Befehle EndProcedure

Beachten Sie, dass Tabellenhandler auf dem Client ausgelöst werden und daher über einen Compiler-Zeigerbefehl verfügen müssen

&OnClient

Nun, das Letzte, was ich hinzufügen wollte, ist, dass Sie nach all diesen Schritten unbedingt daran denken sollten, die fertige Tabelle an das Formularattribut zu übergeben:

ValueFormAttributes(ToR, "ScheduleTable");

Folgendes haben wir als Ergebnis:

Und hier ist die Handhabung des Ereignisses „Auswahl“:

Nachwort.

Ich hoffe, dass der Artikel den 1C-Programmierern hilft, die beginnen, Tabellen auf einem Formular programmgesteuert zu erstellen.

Sie können eine Verarbeitung herunterladen, die programmgesteuert eine Wertetabelle erstellt und diese in einem überschaubaren Formular mit Kommentaren anzeigt, die Ihnen bei der Erstellung Ihrer eigenen Tabellen helfen.

Zur Abrechnung von Geld und Gütern werden in der Wirtschaft häufig verschiedene Tabellen verwendet. Fast jedes Dokument ist eine Tabelle.

Eine Tabelle listet die Waren auf, die aus dem Lager versendet werden sollen. Eine weitere Tabelle zeigt die Zahlungsverpflichtungen für diese Güter.

Daher nimmt in 1C die Arbeit mit Tabellen einen herausragenden Platz ein.

Tabellen in 1C werden auch „tabellarische Teile“ genannt. Verzeichnisse, Dokumente und andere haben sie.

Wenn die Abfrage ausgeführt wird, gibt sie eine Tabelle zurück, auf die auf zwei verschiedene Arten zugegriffen werden kann.

Die erste - schnellere - Auswahl, das Erhalten von Zeilen daraus ist nur der Reihe nach möglich. Die zweite besteht darin, das Abfrageergebnis in eine Wertetabelle hochzuladen und dann wahlfrei darauf zuzugreifen.

//Option 1 – sequenzieller Zugriff auf Abfrageergebnisse

//Hol dir den Tisch
Select = Query.Run().Select();
// Wir gehen alle Zeilen des Abfrageergebnisses der Reihe nach durch
While Select.Next()-Schleife
Bericht(Auswahl.Name);
EndCycle;

//Option 2 – Hochladen in eine Wertetabelle
Request = New Request("SELECT Name FROM Directory.Nomenclature");
//Hol dir den Tisch
Tabelle = Query.Run().Unload().
//weiterhin können wir auch alle Zeilen durchlaufen
Für jede Zeile aus dem Tabellenzyklus
Report(String.Name);
EndCycle;
//oder willkürlich auf Strings zugreifen
Row = Table.Find("Shovel", "Name");

Ein wichtiges Merkmal besteht darin, dass in der Tabelle, die aus dem Abfrageergebnis gewonnen wird, alle Spalten streng typisiert sind. Dies bedeutet, dass Sie durch die Anforderung des Felds „Name“ aus dem Nomenklaturverzeichnis eine Spalte vom Typ „String“ mit einer zulässigen Länge von nicht mehr als N Zeichen erhalten.

Tabelle auf dem Formular (Thick Client)

Der Benutzer arbeitet mit der Tabelle, wenn sie auf dem Formular platziert wird.

Die Grundprinzipien der Arbeit mit Formularen haben wir in der Lektion zu und in der Lektion zu besprochen

Platzieren wir also die Tabelle auf dem Formular. Dazu können Sie die Tabelle aus dem Steuerfeld ziehen. Ebenso können Sie im Menü die Option „Formular/Steuerelement einfügen“ auswählen.

Die Daten können in der Konfiguration gespeichert werden – dann müssen Sie den vorhandenen (zuvor hinzugefügten) tabellarischen Teil des Konfigurationsobjekts auswählen, dessen Formular Sie bearbeiten.

Klicken Sie in der Eigenschaft „Daten“ auf die Schaltfläche „…“. Um die Liste der tabellarischen Teile anzuzeigen, müssen Sie den Objektzweig erweitern.

Wenn Sie den tabellarischen Teil auswählen, fügt 1C selbst Spalten zur Tabelle im Formular hinzu. Vom Benutzer in eine solche Tabelle eingegebene Zeilen werden automatisch zusammen mit dem Nachschlagewerk/Dokument gespeichert.

In derselben Dateneigenschaft können Sie einen beliebigen Namen eingeben und den Typ Wertetabelle auswählen.

Dies bedeutet, dass eine beliebige Wertetabelle ausgewählt wurde. Es werden weder automatisch Spalten hinzugefügt noch automatisch gespeichert, aber Sie können damit machen, was Sie wollen.

Durch einen Rechtsklick auf die Tabelle können Sie eine Spalte hinzufügen. In den Eigenschaften einer Spalte können Sie ihren Namen (zur Referenz im 1C-Code), die Spaltenüberschrift im Formular, die Verbindung mit dem Attribut des tabellarischen Teils (letzteres – wenn keine beliebige Tabelle ausgewählt wird, sondern a tabellarischer Teil).

In den Tabelleneigenschaften des Formulars können Sie angeben, ob der Benutzer Zeilen hinzufügen/löschen kann. Eine erweiterte Form ist das Kontrollkästchen „Nur anzeigen“. Diese Eigenschaften eignen sich zum Organisieren von Tabellen, die zum Anzeigen von Informationen, aber nicht zum Bearbeiten vorgesehen sind.

Um die Tabelle zu verwalten, müssen Sie im Formular ein Befehlsfeld anzeigen. Wählen Sie den Menüpunkt Formular/Steuerelement einfügen/Befehlsleiste.

Aktivieren Sie in den Eigenschaften der Befehlsleiste das Kontrollkästchen „Autofill“, damit die Schaltflächen im Bedienfeld automatisch angezeigt werden.

Tabelle auf Formular (Thin/Managed Client)

Auf einem verwalteten Formular sehen diese Aktionen etwas anders aus. Wenn Sie einen tabellarischen Teil auf dem Formular platzieren müssen, erweitern Sie den Zweig „Objekt“ und ziehen Sie einen der tabellarischen Teile nach links. Und alle!

Wenn Sie eine Wertetabelle platzieren müssen, fügen Sie ein neues Formularattribut hinzu und geben Sie in seinen Eigenschaften den Typ an – Wertetabelle.

Um Spalten hinzuzufügen, verwenden Sie das Kontextmenü für dieses Formularattribut und wählen Sie Attributspalte hinzufügen aus.

Ziehen Sie dann auch die Tabelle nach links.

Damit eine Tabelle über eine Befehlsleiste verfügt, wählen Sie in den Tabelleneigenschaften die Werte im Abschnitt Verwendung – Position der Befehlsleiste aus.

Hochladen einer Tabelle nach Excel

Jede auf dem Formular befindliche 1C-Tabelle kann ausgedruckt oder in Excel hochgeladen werden.

Klicken Sie dazu mit der rechten Maustaste auf eine leere Stelle in der Tabelle und wählen Sie Liste.

In einem verwalteten (Thin) Client können ähnliche Aktionen über den Menüpunkt Alle Aktionen/Liste anzeigen durchgeführt werden.

Frage Erstellen einer Tabellenspalte mit Werten verschiedener Typen in 1C v8
Antwort Beim Erstellen einer Wertetabellenspalte können Sie übergeben Array von Typen, und vielleicht ein bestimmter Typ. Ein Array von Typen wird verwendet, wenn Sie mehrere verschiedene Typen für eine Spalte angeben müssen.

Wird zur Angabe von Typen verwendet „allgemeines Objekt“ – „Beschreibung der Typen“. Deshalb erklären wir zunächst, was „Beschreibung von Typen“ („Beschreibung von Werttypen“) ist.

„Beschreibung der Werttypen“. Um die akzeptablen Arten von Eigenschaftswerten verschiedener Objekte im System zu beschreiben, wird ein spezielles Objekt verwendet „Beschreibung der Typen“. Mit diesem Objekt können Sie die gültigen Wertetypen beschreiben, die Eigenschaften zugewiesen werden können. Um die möglichen Werte weiter einzuschränken, werden die primitiven Typen Number, String und Date bereitgestellt Qualifikanten. Qualifizierer beschreiben Parameter wie die Länge einer Zeichenfolge oder Zahl, gültige Teile eines Datums usw.

Syntax der Methode „Typbeschreibung“.

Neue Beschreibungstypen(<Исходное описание типов>, <Добавляемые типы>, <Вычитаемые типы>, <Квалификаторы числа>, <Квалификаторы строки>, <Квалификаторы даты>)
Optionen:
<Исходное описание типов> (Optional)
Typ: Beschreibungstypen. Die Erstbeschreibung der Typen, auf deren Grundlage ein neuer Typ erstellt wird.
<Добавляемые типы> (Optional)
Typ: Array, String. Ein Array von Typwerten. Ein Typ, der aus den Typen besteht, die im Objekt verwendet werden, oder eine Zeichenfolge, die die durch Kommas getrennten Namen der Typen enthält.
<Вычитаемые типы> (Optional)
Typ: Array, String. Ein Array von Typwerten (oder eine Zeichenfolge mit durch Kommas getrennten Typnamen), das aus den Typen besteht, die von der im ersten Parameter angegebenen Anfangsdeklaration ausgeschlossen werden.
<Квалификаторы числа> (Optional)
Typ: QualifiersNumbers. Zahlenqualifizierer, die gültige Werte eines numerischen Typs beschreiben.
<Квалификаторы строки> (Optional)
Typ: QualifiersStrings. String-Qualifizierer, die gültige Werte eines String-Typs beschreiben.
<Квалификаторы даты> (Optional)
Typ: QualifiersDates. Datumsqualifizierer, die gültige Werte vom Typ „Datum“ beschreiben.
Beschreibung:
Erstellt eine Typbeschreibung basierend auf einer anderen Typbeschreibung, indem einige Typen hinzugefügt und andere ausgeschlossen werden. Wenn kein neuer Qualifizierer angegeben wird, werden die Qualifizierer der ursprünglichen Typdeklaration beibehalten.
Ein Beispiel für die Verwendung des Objekts „Typbeschreibung“:

// Erweitern Sie die Beschreibung der gültigen Typen um neue Typen Array = Neues Array; Array. Hinzufügen(Typ( „Referenzlink. Methoden“)); Array. Add(Type("Number" )); Sign = ValidSign. Nicht negativ; QuNumbers = New QualifiersNumbers(10, 2, Sign); ValidTypes = NewTypeDescription(ValidTypes, Array, KvNumbers);

Nun tatsächlich Beispiele für die korrekte Erstellung von Spaltenwerten verschiedener Typen in einer Tabelle.

Im Allgemeinen reicht es aus, die Spaltentypen wie folgt zu definieren:

TK. Säulen. Hinzufügen( „Index sortieren“, Neue DescriptionTypes ( "Number" ) ); TK. Säulen. Add("SectionName", New TypeDescription("String" ) ); TK. Säulen. Add("DataCorr" , New TypeDescription("Date" ) ); TK. Säulen. Hinzufügen( „Unbedingte Löschung“, New TypeDescription("Boolean")); TK. Säulen. Add("Nomenclature" , New TypeDescription() ); TK. Säulen. Add("SectionData" , New TypeDescription("Structure" ) ) ; // Beispiel für die Erstellung der Spalten „Zahl“ und „Zeichenfolge“ mit Klärung der Parameter: TK. Säulen. Hinzufügen( "Prozent abgeschlossen", New DescriptionTypes („Number“, New QualifiersNumbers (18, 2))); TK. Säulen. Add("SectionName" , NewTypeDescription("String" , , NewStringQualifiers(200, AllowedLength. Variable) ) ); TK. Säulen. Add("DecommissionedDate" , NewTypeDescription("Date" , , , NewDateQualifiers(DateParts.DateTime) ) );

Im Allgemeinen wird jedoch ein Array als Spaltentyp übergeben. Ein Array wird verwendet, wenn einer Spalte mehrere Typen zugewiesen werden müssen. Dann sieht die Definition der Struktur etwa so aus (es werden Beispiele für verschiedene Spaltentypen angegeben, wenn der Typ ein Array ist, aber der Einfachheit halber wird die Zusammensetzung des Arrays vom gleichen Typ angegeben, um Verwirrung zu vermeiden )

////// Gestaltung der Struktur der technischen Spezifikationen (Erstellung von Spalten) //// Definieren Sie Qualifikationsmerkmale für die Substitution in den Qualifikationsfeldern der technischen Spezifikation CN = New QualifiersNumbers(18, 9); KS = NewStringQualifiers(200); CD = NewDateQualifiers(DataParts.DateTime) ; //// Definieren Sie Typbeschreibungen für zukünftige TK-Spalten // Ein Array ist die anfängliche Beschreibung von Typen, auf deren Grundlage ein neuer erstellt wird // Bitte beachten Sie, dass für TK-Spalten die anfängliche Typbeschreibung in diesem Beispiel ein Array ist Array = Neues Array; Array. Add(Type("String") ); TypeDescriptionString = New TypeDescription(Array, , KS) ; Array. Klar() ; Array. Add(Type("Number") ); TypeDescriptionNumber = New TypeDescription(Array, , , CN) ; Array. Klar() ; Array. Add(Type("Date") ); DescriptionTypesDate = New DescriptionTypes(Array, , , , CD) ; Array. Klar() ; Array. Hinzufügen(Typ( „DirectoryLink.Nomenclature“) ); TypbeschreibungNomenklatur = Neue Typbeschreibung (Array) ; Array. Klar() ; Array. Hinzufügen(Typ( „DirectoryLink.SeriesNomenclature“) ); TypeDescriptionSeries = New TypeDescription(Array) ; Array. Klar() ; Array. Hinzufügen(Typ( „DirectoryLink.Quality“) ); TypeDescriptionQuality = New TypeDescription(Array) ; Array. Klar() ; Array. Add(Type("Boolean") ); TypeDescriptionBoolean = New TypeDescription(Array) ; // tatsächlich Spalten zum TK hinzufügen (die Struktur des zukünftigen TK erstellen) TK. Säulen. Add("Nomenclature", DescriptionTypesNomenclature) ; TK. Säulen. Add("Code" , TypeDescriptionString) ; TK. Säulen. Hinzufügen( „SerienNomenklatur“, DescriptionTypesSeries); TK. Säulen. Add("AccountCode" , Type DescriptionString) ; TK. Säulen. Add("ActionDate" , TypeDescriptionDate) ; TK. Säulen. Add("Quality" , TypeDescriptionQuality); TK. Säulen. Add("NumberUS", DescriptionTypesNumber) ; TK. Säulen. Add("Write off" , TypeDescriptionBoolean) ; . . . //////// Gestaltung der Struktur der technischen Spezifikationen (Erstellung von Spalten) ////////////////////////////////////////////////////////

Informationen zum Hinzufügen einer Zeile zu einer Wertetabelle finden Sie unter