Hier ist eine kleine Tatsache, um zu beginnen - einfache Beispiele Arbeite mit einer Wertetabelle:

1. Erstellen Sie eine Wertetabelle

Wertetabelle = Neue Wertetabelle;

2. Erstellen Sie Spalten der Wertetabelle:

ValueTable.Columns.Add("Name");
ValueTable.Columns.Add("Nachname");

3. Fügen Sie neue Zeilen mit Spaltennamen hinzu:

NewString.Name = "Vasily";
NewRow.LastName = "Pupkin";

4. So suchen Sie einen Wert in der Wertetabelle:
Es ist notwendig, eine Tabellenzeile zu finden, die den gewünschten Wert enthält.

FoundString = ValueTable.Find(LookupValue);

5. Suchen Sie das erste Vorkommen in bestimmten Spalten einer Wertetabelle

FoundString = ValueTable.Find(LookupValue, "Lieferant, Käufer");

6. Wenn Sie alle Vorkommen in der Wertetabelle suchen müssen:
Wir verwenden die Suchstruktur.

SearchStructure = Structure("Mitarbeiter", LookupValue);
ArrayFoundStrings = ValueTable.FindStrings(SearchStructure);

Lassen Sie uns eine Suchstruktur erstellen, deren jedes Element den Namen der Spalte als Schlüssel und den gesuchten Wert in dieser Spalte als Wert enthält. Wir übergeben die Suchstruktur als Parameter an die Methode FindStrings(). Als Ergebnis erhalten wir die Zeilen der Tabelle.
Wenn wir die Suche nach dem gewünschten Wert beispielsweise auch in der Spalte Responsible in die Suchstruktur einfügen, erhalten wir als Ergebnis der Anwendung der Methode FindRows() alle Zeilen, in denen sowohl Employee als auch Responsible gleich dem gewünschten Wert sind Wert.

7. Wie man eine Wertetabelle in zufälliger Reihenfolge durchläuft

Für jede CurrentRow aus der ValueTable-Schleife
Report(CurrentLine.Name);
EndCycle;

Machen Sie dasselbe mit Indizes:

SeniorIndex = ValueTable.Count() - 1;
Für MF = 0 nach SeniorIndex-Zyklus
Report(ValueTable[Count].Name);
EndCycle;

8. Löschen einer vorhandenen Wertetabellenzeile

ValueTable.Delete(RemoveRow);

nach Index

ValueTable.Delete(0);

9. Löschen einer bestehenden Spalte der Wertetabelle

ValueTable.Columns.Delete(RemoveColumn);

nach Index

ValueTable.Columns.Delete(0);

Es muss berücksichtigt werden, dass das Löschen einer Zeile (oder Spalte) „aus der Mitte“ der Wertetabelle zu einer Verringerung um einen der Indizes der Zeilen führt, die „nach“ dem Löschen waren

10. Wie fülle ich die Wertetabelle aus, wenn die Spaltennamen in Variablen enthalten sind?

NewRow = ValueTable.Add();
NewRow[ColumnName] = Wert;

11. Wie füllt man die gesamte Spalte der Wertetabelle mit dem gewünschten Wert?
Die Spalte FiscalAccounting Flag in der Wertetabelle der Wertetabelle muss mit dem Wert False gefüllt werden

ValueTable.FillValue(False, „Flagge Steuerbuchhaltung“);

Wir verwenden die Methode FillValues() für die Wertetabelle. Der erste Parameter ist der zu füllende Wert. Der zweite Parameter ist der Name der gefüllten Spalte.

12. Wie füllt man die Wertetabelle „TableRecipient“ mit den Daten der Wertetabelle „SourceTable“?

Wenn die Empfängertabelle zum Zeitpunkt der Operation noch nicht vorhanden ist oder Sie ihre vorherigen Spalten nicht speichern müssen, können Sie sie als erstellen vollständige Kopie Initial

TableReceiver = TableOriginal.Copy();

Option zwei: Die Tabelle TableReceiver existiert, und es ist schade, ihre Spalten und Einschränkungen für Spaltendatentypen zu verlieren. Aber Sie müssen die Daten für die Spalten ausfüllen, deren Namen mit den Namen der Quelltabelle übereinstimmen.

Partielle Datenübertragung für Spalten mit übereinstimmenden Namen:

Für jede Zeile der SourceTable aus der SourceTable-Schleife
FillPropertyValues(NewString, SourceTableString);
EndCycle

Für jede Zeile der Quelltabelle wird der Zieltabelle eine neue Zeile hinzugefügt und die Werte in die Spalten der neuen Tabelle gefüllt, deren Namen mit den Namen der Spalten in der Quelltabelle übereinstimmen

Wenn die Tabellen keine gleichnamigen Spalten haben, enthält die Zieltabelle am Ende so viele Zeilen mit Nullwerten, wie Zeilen in der Quelltabelle vorhanden waren.
Wenn für einige gleichnamige Spalten der Datenwerttyp aus der Quelltabelle nicht in das Array der zulässigen Typen der Spalte der Zieltabelle fällt, erhalten wir in solchen Feldern leere Werte.
Betrachten wir den dritten Fall. Bei gleichnamigen Spalten muss die Spalte der Zieltabelle vollständig mit der Spalte der Quelltabelle in Übereinstimmung gebracht werden.

Vollständige Datenkopie für Spalten mit übereinstimmenden Namen

ÄhnlicheSpalten = Neues Array();

Für jede Spalte aus SourceTable.Columns Loop
MatchingColumn = TableReceiver.Columns.Find(Column.Name);

Wenn MatchedColumn<>Undefiniert damals

// Spalteneigenschaften abrufen.
Name = Spalte.Name;
Werttyp = Spalte.Werttyp;
Titel = Spalte.Titel;
Breite = Spalte.Breite;

// Spalten in der Zieltabelle ersetzen.
Index = TableReceiver.Columns.Index(CoincidentColumn);

TableReceiver.Columns.Delete(Index);
TableReceiver.Columns.Insert(Index, Name, ValueType, Titel, Breite);

// Den nächsten Namen der übereinstimmenden Spalten zum Array hinzufügen.
Same-nameColumns.Add(Column.Name);

EndIf;

EndCycle;

// Schleife durch die Zeilen der Quelltabelle.
Für jede Zeile von SourceTable From SourceTable Loop

// Eine neue Zeile zur Zieltabelle hinzufügen.
NewString = TableReceiver.Add();

// Füllen Sie Werte in übereinstimmende Zellen ein.
Für jede NameColumns Of Same NameColumns-Schleife
NewString[Spaltenname] = SourceTableString[Spaltenname];

EndCycle;

EndCycle;

Wir müssen die Spalte in der Zieltabelle durch eine neue ersetzen, deren Eigenschaften vollständig mit der Spalte der Quelltabelle übereinstimmen.
Wenn also eine gleichnamige Spalte in der Empfängertabelle gefunden wird, sammeln wir in Variablen alle Eigenschaften für die neue Spalte. Als nächstes löschen Sie die alte und erstellen eine neue Spalte. Dann durchlaufen wir die Zeilen der Quelltabelle.
In der Schleife fügen wir der Empfängertabelle eine neue Zeile hinzu und öffnen eine Schleife durch die Namen der Spalten im Array der übereinstimmenden Spalten.
Innerhalb dieser verschachtelten Schleife füllen wir die Zellen der Empfängertabelle mit den Daten der Zelle der Quelltabelle.

13. Wie füge ich Spalten zur Wertetabelle "Wertetabelle" mit Typbeschränkungen hinzu?

Beim Hinzufügen einer Spalte können Sie einfach ihren Namen angeben und den zweiten Parameter der Methode Add() nicht berühren. In diesem Fall ist der Datentyp der Spalte beliebig.

Hinzufügen einer Spalte ohne Angabe eines Datentyps

// Eine Spalte ohne Typbeschränkungen hinzufügen.
ValueTable.Columns.Add("Object");

Sie können den Wert des zweiten Parameters eingeben. Dort muss eine Beschreibung des zulässigen Typs der Spalte übergeben werden. Die Beschreibung selbst kann mit dem Konstruktor abgerufen werden, indem der Stringtypname als Parameter an letzteren übergeben wird (wenn es viele Typen gibt, dann durch Kommas getrennt) oder ein Array gültiger Typen.

Hinzufügen einer Spalte, die den Datentyp angibt

// Einschränkungen für Spaltendatentypen:
// Nur Elemente des Verzeichnisses "Contractors".
ValueTable.Columns.Add("Account", New TypeDescription("ReferenceReference.Accounts"));

Wenn unter den zulässigen Typen zum Ausfüllen der Spaltendaten eine Zeichenfolge vorhanden ist, können Sie ihre Bittiefe (Länge) begrenzen und die Verwendung einer variablen oder festen Länge festlegen. All dies wird bereitgestellt, indem ein Objekt mit dem StringQualifiers-Konstruktor erstellt wird. Außerdem wird dieses Objekt als einer der Parameter des TypeDescription-Konstruktors verwendet.

Verwenden von Qualifizierern zum Angeben des Datentyps einer Wertetabellenspalte

// Grenzen für Daten vom Typ String vorbereiten und festlegen.
String Qualifiers = New String Qualifiers(20, ValidLength.Variable);
AllowedTypes = NewTypeDescription("String",StringQualifiers);
ValueTable.Columns.Add("NoteStringShort", ValidTypes);

Sie können dasselbe für Zahlen- und Datumsqualifizierer tun.
Bitte beachten Sie: Die Typbeschreibung kann vom Konstrukteur sowohl "von Grund auf neu" erstellt werden, als auch eine vorhandene Typbeschreibung als Grundlage verwenden

Verwenden vorhandener Typdeklarationen zum Angeben des Datentyps einer Wertetabellenspalte

// Erweiterung der bisher verwendeten Typenbeschreibung.
Nummernqualifizierer = Neue Nummernqualifizierer (10, 2, ValidSign.Non-negativ);
DateQualifiers = New DateQualifiers(DateParts.Date);
ExtendedValidTypes = NewTypeDescription(ValidTypes, "Number, Date",NumberQualifiers,DateQualifiers);

ValueTable.Columns.Add("Hinweis", ExtendedAllowedTypes);

Um Geld und Waren zu berücksichtigen, sind im Geschäftsleben unterschiedliche Tabellen weit verbreitet. Fast jedes Dokument ist eine Tabelle.

Eine Tabelle listet die aus dem Lager zu versendenden Waren auf. In einer anderen Tabelle - die Zahlungsverpflichtung für diese Waren.

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

Tabellen in 1C werden auch "Tabellenteile" genannt. Nachschlagewerke, Dokumente und andere haben sie.

Die Abfrage gibt als Ergebnis ihrer Ausführung eine Tabelle zurück, auf die auf zwei verschiedene Arten zugegriffen werden kann.

Die erste - schnellere - Auswahl, das Abrufen von Zeilen ist nur der Reihe nach möglich. Die zweite ist das Entladen des Abfrageergebnisses in eine Wertetabelle und dann der wahlfreie Zugriff darauf.

//Option 1 - sequenzieller Zugriff auf Abfrageergebnisse

// Tabelle abrufen
Auswahl = Abfrage.Ausführen().Auswählen();
// Alle Zeilen des Abfrageergebnisses der Reihe nach umgehen
While Selection.Next()-Schleife
Bericht(Auswahl.Name);
EndCycle;

//Option 2 - Hochladen in die Wertetabelle
Abfrage = Neue Abfrage ("SELECT Name FROM Directory.Nomenclature");
// Tabelle abrufen
Tabelle = Abfrage.Ausführen().Hochladen().
// dann können wir auch alle Zeilen umgehen
Für jede Zeile aus der Tabellenschleife
Bericht (String.Name);
EndCycle;
//oder willkürlich auf Strings zugreifen
String = Table.Find("Schaufel", "Name");

Ein wichtiges Feature ist, dass in der Tabelle, die aus dem Ergebnis der Abfrage gewonnen wird, alle Spalten stark typisiert werden. Das heißt, wenn Sie das Namensfeld aus der Nomenklatursuche anfordern, erhalten Sie eine Spalte vom Typ Zeichenfolge mit einer zulässigen Länge von nicht mehr als N Zeichen.

Tabelle auf dem Formular (Thick Client)

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

Wir haben die Grundprinzipien der Arbeit mit Formularen 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 Bedienfeld ziehen. Ebenso können Sie das Steuerelement Formular/Einfügen aus dem Menü auswählen.

Daten können in einer Konfiguration gespeichert werden - dann müssen Sie einen 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.

Bei der Auswahl eines tabellarischen Teils fügt 1C selbst Spalten zur Tabelle im Formular hinzu. Die vom Benutzer in eine solche Tabelle eingegebenen Zeichenfolgen werden automatisch zusammen mit dem Verzeichnis/Dokument gespeichert.

In derselben Data-Eigenschaft können Sie einen beliebigen Namen eingeben und den ValueTable-Typ auswählen.

Das bedeutet, dass eine beliebige Wertetabelle ausgewählt wurde. Es werden keine Spalten automatisch hinzugefügt, es wird nicht 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 der Spalte können Sie ihren Namen (als Referenz im 1C-Code), die Spaltenüberschrift im Formular und die Verbindung mit dem Attribut des tabellarischen Teils (letzteres - wenn es sich nicht um eine beliebige Tabelle, sondern um eine Tabelle handelt) angeben Teil ausgewählt ist).

In den Tabelleneigenschaften des Formulars können Sie festlegen, ob der Benutzer Zeilen hinzufügen/löschen kann. Eine fortgeschrittenere Form ist das Kontrollkästchen ViewOnly. Diese Eigenschaften sind nützlich, um Tabellen zu organisieren, die zum Anzeigen von Informationen, aber nicht zum Bearbeiten bestimmt sind.

Um die Tabelle zu verwalten, müssen Sie das Befehlsfeld auf dem Formular anzeigen. Wählen Sie den Menüpunkt Form/Insert Control/Command Panel.

Aktivieren Sie in den Eigenschaften der Befehlsleiste das Kontrollkästchen Autovervollständigung, damit die Schaltflächen in der Symbolleiste automatisch angezeigt werden.

Tabelle auf Formular (Thin/Managed Client)

Auf einem verwalteten Formular sehen diese Aktionen etwas anders aus. Wenn Sie einen tabellarischen Abschnitt auf dem Formular platzieren müssen, erweitern Sie die Verzweigung Objekt und ziehen Sie einen der tabellarischen Abschnitte nach links. Und alle!

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

Um Spalten hinzuzufügen, verwenden Sie das Menü der rechten Maustaste auf diesem Formularattribut, Element Attributspalte hinzufügen.

Ziehen Sie dann auch die Tabelle nach links.

Damit die Tabelle eine Befehlsleiste hat, wählen Sie in den Tabelleneigenschaften die Werte im Abschnitt Verwendung - Position der Befehlsleiste aus.

Exportieren einer Tabelle nach Excel

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

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

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

Die Wertetabelle in der 1C 8.3-Plattform (8.2) ist eine universelle Sammlung von Werten, die ein Entwickler in der Softwareentwicklung verwenden kann, um seine Algorithmen zu implementieren. Tatsächlich ist die 1C-Wertetabelle ein dynamischer Satz von Werten mit Spalten und Spalten.

Artikel über andere universelle Wertesammlungen in 1C

Lernen Sie das Programmieren in 1C an einem Ort aus meinem Buch "Programmieren in 1C in 11 Schritten"

1. Das Buch ist in einer klaren und einfachen Sprache geschrieben - für einen Anfänger.
2. Lernen Sie, die 1C-Architektur zu verstehen;
3. Sie werden beginnen, Code in 1C-Sprache zu schreiben;
4. Beherrschen Sie die grundlegenden Programmiertechniken;
5. Erlerntes Wissen mit Hilfe eines Aufgabenheftes festigen;

Ein ausgezeichneter Leitfaden für die Entwicklung in einer verwalteten 1C-Anwendung, sowohl für unerfahrene Entwickler als auch für erfahrene Programmierer.

1. Sehr zugängliche und verständliche Sprache
2. Das Buch wird verschickt Email im PDF-Format. Kann auf jedem Gerät geöffnet werden!
3. Verstehen Sie die Ideologie einer verwalteten 1C-Anwendung
4. Erfahren Sie, wie Sie eine verwaltete Anwendung entwickeln;
5. Gestalten lernen verwaltete Formulare 1C;
6. Sie können mit den grundlegenden und notwendigen Elementen verwalteter Formulare arbeiten
7. Das Programmieren unter einer verwalteten Anwendung wird deutlich

Aktionscode für 15 % Rabatt - 48PVXHeYu

Wenn Ihnen diese Lektion bei der Lösung eines Problems geholfen hat, sie Ihnen gefallen hat oder nützlich war, können Sie mein Projekt unterstützen, indem Sie einen beliebigen Betrag überweisen:

kann manuell bezahlt werden:

Yandex.Geld — 410012882996301
Web Money - R955262494655

Tritt meinen Gruppen bei.

Gepostet am 21. September 2011

Wertetabelle 1C - Teil 3. Metadaten. Iteration über die Spalten der Wertetabelle

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 bezieht sich auf eine Artikelserie 1C von Grund auf neu; Programmierung 1c von Grund auf neu; Wertetabelle 1c)

Um das Material zu erklären und um unsere Beispiel-Programmcodes "live" ausführen zu können, benötigen wir welche Testwertetabelle 1C. Ein Teil unserer Beispiele extrahiert Daten aus einer Wertetabelle, also erstellen wir eine Tabelle mit drei Spalten „Nachname“, „Vorname“, „Patronym“ und geben eine kleine Datenmenge ein – bis zu 3 Zeilen :)

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

MyTR = Neue Wertetabelle; // Erstellen Sie eine neue Wertetabelle, die in der Variablen "MyTR" gespeichert ist MyTR.Columns.Add ("Nachname"); // die Spalte "Nachname" erstellen MyTR.Columns.Add("Vorname"); // die Spalte "Name" erstellen MyTM.Columns.Add("Patronymic"); // erstelle die Spalte "Zweiter Vorname" // füge die erste Zeile zu unserer Wertetabelle hinzu NewRow = MyТЗ.Add(); NewLine.Surname = "Chapaev"; NewString.Name = "Vasily"; NewString.Patronymic = "Iwanowitsch"; // zweite Zeile hinzufügen NewLine = MyТЗ.Add(); NewLine.Lastname = "Dserschinski"; NewString.Name = "Felix"; NewLine.Patronymic = "Edmundovich"; // dritte Zeile hinzufügen NewLine = MyTR.Add(); NewRow.LastName = "Kotovsky"; NewString.Name = "Gregory"; NewString.Patronymic = "Iwanowitsch";

Unsere Testtabelle besteht aus drei Spalten: Vorname, Nachname, Patronym; und hat drei vollständige Zeilen mit den Namen der Helden des Bürgerkriegs.

Das erste Codebeispiel durchläuft die Spalten der 1C-Wertetabelle als Auflistung.

// Anzeige der Namen aller Spalten des TK für jede Spalte von My TK.Columns Notify loop("Column name: " + Column.Name); EndCycle;

Unsere Schleife zeigt alle Spaltennamen im 1C-Meldungsfeld an:

Spaltenname: Nachname Spaltenname: Vorname Spaltenname: Zweiter Vorname

Wir sehen, dass eine spezielle Sammlungsschleife verwendet wird, um durch die Spalten zu iterieren, ähnlich der Zeilen-Iterationsschleife (im letzten Artikel). MeineTM.Spalten- Dies ist eine Sammlung von Spalten der Wertetabelle 1C "MoyaTZ". Die Sammlung enthält Objekte vom Typ "Spaltenwerttabelle" Jedes Objekt dieses Typs ist eine Spalte der Wertetabelle und enthält Eigenschaften und Methoden. Unter Bezugnahme auf diese Eigenschaften und Methoden erhalten wir die erforderlichen Informationen zu einer Spalte oder führen einige andere Aktionen damit aus.

Zum Beispiel Zugriff auf die Eigenschaft "Name" (Spaltenname) erhalten wir den Namen der aktuellen Spalte.

Ich möchte Ihre Aufmerksamkeit auf den Titel des Zyklus lenken: „Für jeden Spalte From MyTR.Columns Loop" Variable benannt "Spalte" von uns erfunden. Es ist nicht notwendig, denselben Namen zu verwenden. Sie können diese Variable zum Beispiel beliebig benennen "MeineAktuelleSpalte" Dann würde das obige Beispiel so aussehen:

// drucke die Namen aller Spalten des TK For Each MyCurrentColumn From MyTK.Columns Notify Loop("Spaltenname: " + MyCurrentColumn.Name); EndCycle;

Wenn das 1C-Ausführungssubsystem auf einen solchen Zyklus trifft, weist es bei jedem Durchlauf des Zyklus ein Element aus unserer Sammlung der Variablen mit dem angegebenen Namen in zu dieser Fall - ein Element der Sammlung Wertetabellenspalten MeineTM.Spalten Und dann verweisen wir auf die Variable, die die aktuelle Spalte enthält, und verwenden die Eigenschaft "Name".

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

// Anzahl und Namen aller Spalten der Wertetabelle anzeigen For Each Column From MyTR.Columns LoopColumnNumber = MyTR.Columns.Index(Column); // Spaltennummer abrufen ColumnName = Column.Name; // den Spaltennamen abrufen Report("Spaltennummer:" + Spaltennummer + " Spaltenname: " + Spaltenname); EndCycle;

Der Text wird im Meldungsfeld 1C angezeigt:

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

Achten wir darauf, dass die Spalten in der Wertetabelle 1C genauso wie die Zeilen der Wertetabelle von Null beginnend nummeriert sind.

Die Anzahl der Spalten in der Wertetabelle 1C

Um die Anzahl der Spalten in der Wertetabelle herauszufinden, verwenden wir die Methode "Number()" für die Spaltensammlung.

Anzahl der Spalten = MyTM.Columns.Number(); Bericht (Anzahl der Spalten);

Auf dem Bildschirm wird die Zahl „3“ angezeigt. Tatsächlich gibt es in unserer Tabelle drei Spalten: "Nachname", "Vorname", "Patronym".

Abrufen eines Spaltenobjekts anhand seiner Nummer (Index) und Iterieren über Spalten mithilfe des Spaltenindex

Machen wir eine Schleife durch alle Spalten der Wertetabelle, indem wir die Spaltenindizes (Zahlen) verwenden. Denken Sie daran, dass die Spaltennummerierung bei Null beginnt. Daher müssen wir den Zähler des Zyklus "Sh" von Null auf eine Zahl erhöhen, die der Anzahl der Spalten minus eins entspricht.

Für SC = 0 By MyTM.Columns.Quantity() - 1 Loop CurrentColumn = MyTM.Columns[SC]; Notify(CurrentColumn.Name); EndCycle;

Auf dem Bildschirm erhalten wir Folgendes

Vollständiger Name

Ich denke, dass dieses Beispiel klar war. Wir wandten uns der Methode zu Menge() Spaltensammlungen" MeineTM.Spalten.Menge()", bekam die Anzahl der Spalten und startete eine Schleife mit einem Zähler von Null Vor Anzahl der Spalten minus eins. Innerhalb der Schleife holen wir jede Spalte aus der Spaltensammlung 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: Notify(CurrentColumn.Name);

Es ist wichtig, niemals eine Objekteigenschaft mit einer Objektmethode zu verwechseln.

Eine Eigenschaft ist eine Art statischer Wert und der Zugriff darauf wird beispielsweise ohne Klammern geschrieben AktuelleSpalte.Name. Eine Methode ist im Wesentlichen eine Prozedur oder Funktion eines Objekts, und Aufrufe von Prozeduren und Funktionen werden immer in Klammern geschrieben (selbst wenn es keine Eingabeparameter gibt). Zum Beispiel: MeineTM.Spalten.Menge()

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

Das schreibt der Interpreter, wenn ich vergesse, Klammern so falsch in einen Methodenaufruf zu setzen MeineTM.Spalten.Menge(keine Klammern nach "Quantity()"):

Objektfeld nicht gefunden (Anzahl)

In diesem Fall sollten "Feld" und "Eigenschaft" als Synonyme oder als Ungenauigkeit in der Terminologie von 1C-Entwicklern verstanden werden. Sie verwenden beide Wörter, um sich auf dasselbe Konzept zu beziehen. In anderen Programmiersprachen können diese Begriffe jedoch unterschiedliche Konzepte bedeuten.

Abrufen von Daten aus der 1C-Wertetabelle mithilfe von Spaltennummern

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

FirstLine = MeinTR; // die erste Zeile erhalten (Nummerierung von Null) ColumnFirstValue = RowFirst; // erhalte den Wert der ersten Spalte (Spaltennummerierung ist auch von Null) Report(FirstColumnValue); // Den Wert der ersten Spalte in der ersten Zeile der Tabelle anzeigen

Der Bildschirm zeigt Folgendes an:

Chapajew

Wir haben zuerst das Wertetabellen-Zeilenobjekt 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.) Innerhalb des Operators haben wir das Argument "0" übergeben. Dies ist der Index der ersten Zeile der Wertetabelle. FirstLine = MeinTR;

Außerdem haben wir das Recht, mit dem Operator [...] auf das String-Objekt zu verweisen. Innerhalb dieser Anweisung haben wir die Spaltennummer der Wertetabelle übergeben, in diesem Fall also auch „0“. Und so haben wir den Wert der Spalte mit der Nummer „0“ für bekommen aktuelle Zeile Tische mit der Nummer „0“. Wir haben diesen Wert auf dem Bildschirm angezeigt und er repräsentiert die Zeichenfolge "Chapaev".

Machen wir unser Beispiel etwas komplizierter:

FirstLine = MeinTR; // erhalte die erste Zeile (nummeriert von Null) 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

Nun haben wir die Werte aus allen drei Spalten der ersten Zeile unserer Wertetabelle angezeigt:

Chapaev Wassili Iwanowitsch

Nun modifiziere ich dieses Beispiel weiter, sodass wir auf eine Variable verzichten können "Erste Linie"

Benachrichtigen (MyTM); // den Wert der ersten Spalte in der ersten Zeile der Tabelle anzeigen Report(MyTR); // den Wert der zweiten Spalte in der ersten Zeile der Tabelle anzeigen Report(MyTR); // Den Wert der dritten Spalte in der ersten Zeile der Tabelle anzeigen

Der Bildschirm wird derselbe sein.

Chapaev Wassili Iwanowitsch

Wir haben im obigen Beispiel gesehen, dass wir für den Zugriff auf einen Wert, der sich in einer bestimmten Zeile und bestimmten Spalte einer Wertetabelle befindet, den aufeinanderfolgenden Aufruf von zwei Operatoren [...] in dieser Form verwenden können: ValueTable[IndexRows][IndexColumns]

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

For RowCount = 0 By MyTM.Quantity() - 1 Schleife // Zeilen durchlaufen For ColumnCount = 0 By MyTM.Columns.Quantity() - 1 Schleife // verschachtelte Schleife durch Spalten // Abrufen des Zellenwerts (aus der aktuellen Zeile und die aktuellen Spalten) CellValue = MyTR[RowCount][ColumnCount]; // Zeilennummer, Spaltennummer und Zellenwert anzeigen Report("Line #" + RowCount + "column #" + ColumnCount + " = " + CellValue); EndCycle; EndCycle;

Folgendes wird auf dem Bildschirm angezeigt:

Zeile #0 Spalte #0 = Chapaev Zeile #0 Spalte #1 = Vasily Zeile #0 Spalte #2 = Ivanovich Zeile #1 Spalte #0 = Dzerzhinsky Zeile #1 Spalte #1 = Felix Zeile #1 Spalte #2 = Edmundovich Zeile # 2. Spalte Nr. 0 = Kotovsky-Linie Nr. 2. Spalte Nr. 1 = Grigory-Linie Nr. 2. Spalte Nr. 2 = Iwanowitsch

Mit Hilfe von zwei Schleifen, von denen eine in der anderen verschachtelt ist, haben wir die Werte aller Spalten aus allen Zeilen der 1C-Wertetabelle angezeigt. In diesem Fall haben wir nicht die Namen der Spalten verwendet, sondern über ihre Indizes auf die Spalten und Zeilen verwiesen. Beachten Sie zum besseren Verständnis die Kommentare innerhalb des Beispiels.

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

For RowCount = 0 By MyTR.Quantity() - 1 Loop // Zeilen durchlaufen Report(" ======= Row # " + RowCount + " ======="); Etwas melden(" "); // Zeilenvorschub (Leerzeile einfügen) For ColumnCount = 0 By MyTR.Columns.Quantity() - 1 Schleife // Verschachtelte Schleife durch Spalten // Holen Sie sich den Zellenwert (aus der aktuellen Zeile und aktuellen Spalte) CellValue = MyTR[RowCount ][ Spaltenanzahl]; // Holen Sie sich den Namen der Spalte ColumnName = MyTR.Columns[ColumnCount].Name; // Spaltennamen und Zellenwert anzeigen Report(ColumnName + ": " + CellValue); EndCycle; Etwas melden(" "); // Zeilenumbruch (Leerzeile einfügen) EndCycle;

Jetzt begannen die Informationen auf unserem Bildschirm repräsentativer auszusehen:

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

Ja, fast hätte ich es vergessen. Wenn wir zwei Operatoren [...][...] hintereinander verwenden, können wir den Namen dieser Spalte anstelle des Spaltenindex übergeben: Wertetabelle[Zeilenindex][Spaltenname]

For RowCount = 0 By MyTR.Quantity() - 1 Loop // Zeilen durchlaufen Report(" ======= Row # " + RowCount + " ======="); Etwas melden(" "); // Zeilenvorschub (Einfügen einer leeren Zeile) For ColumnCount = 0 By MyTR.Columns.Quantity() - 1 Schleife // Verschachtelte Schleife durch die Spalten ColumnName = MyTR.Columns[ColumnCount].Name; // Holen Sie sich den SpaltennamenCellValue = MyTR[RowCount][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 an das Argument in eckige Klammern[...] Das Ergebnis wird dasselbe sein.

Und jetzt das letzte in diesem Artikel.

KORREKTER Empfang aller Daten der 1C-Wertetabelle, wobei Schleifen verwendet werden, um über die Sammlung von Zeilen und die Sammlung von Spalten zu iterieren

For Each CurrentRow From MyTR Loop // zyklisch durch die Sammlung von Strings Report(" ======= Line # " + MyTR.Index(CurrentRow) + " ======="); Etwas melden(" "); For Each CurrentColumn From MyTR.Columns Loop // verschachtelte Schleife durch die Sammlung von Spalten ColumnName = CurrentColumn.Name; // Holen Sie sich den SpaltennamenCellValue = CurrentRow[ColumnName]; // Zellenwert NACH SpaltenNAME abrufen Report(ColumnName + ": " + CellValue); // den Spaltennamen und Zellenwert anzeigen EndCycle; Etwas melden(" "); EndCycle;

Im Beispiel wurden zwei Schleifen verwendet. Die Spaltensammlungsschleife ist innerhalb der Zeilenschleife verschachtelt. Wenn Sie sich mit den obigen Beispielen auseinandergesetzt und die vorherigen Artikel gelesen haben, dann werden Sie keine Schwierigkeiten haben, die Funktionsweise dieses Beispiels zu verstehen.

Schließlich werde ich die Anzahl der Codezeilen in unserem letzten Beispiel so kurz wie möglich halten, indem ich die Verwendung von Zwischenvariablen eliminiere. Wir erhalten ein Muster von "industriellem Code", der in realen Anwendungen verwendet wird.

Dies sollte nur getan werden, wenn Sie ein gutes Verständnis dafür haben, 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 es nach einiger Zeit einfacher wird, die Texte des Programms zu verstehen.

For Each CurrentRow From MyTR Loop // Schleife durch die Zeilen Report(" ======= Line # " + MyTR.Index(CurrentRow) + " =======" + Symbols.PS); For Each CurrentColumn From MyTr.Columns Loop // über Spalten iterieren Report(CurrentColumn.Name + ": " + CurrentRow[CurrentColumn.Name]); EndCycle; Etwas melden(" "); EndCycle;

Die Ausgabe auf dem Bildschirm hat sich nicht geändert, sie bleibt gleich wie im vorigen Beispiel:

2-WOCHEN-KURS

"PROGRAMMIEREN in 1C FÜR EINSTEIGER"

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

Alles, was Sie für die Teilnahme benötigen, ist ein Computer und Internet.

Kostenloser Zugang zum Kurs:

sp-force-hide ( display: none;).sp-form ( display: block; background: #eff2f4; padding: 5px; width: 270px; max-width: 100%; border-radius: 0px; -moz-border -radius: 0px; -webkit-border-radius: 0px; font-family: Arial, "Helvetica Neue", serifenlos; background-repeat: no-repeat; background-position: center; background-size: auto;) .sp-Formulareingabe ( Anzeige: Inline-Block; Deckkraft: 1; Sichtbarkeit: sichtbar;).sp-Formular .sp-Formularfeld-Wrapper ( Rand: 0 Auto; Breite: 260px;).sp-Formular .sp -form-control ( Hintergrund: #ffffff; Randfarbe: #cccccc; Randstil: fest; Randbreite: 1px; Schriftgröße: 15px; Polsterung links: 8,75px; Polsterung rechts: 8,75px; Rand -radius: 4px; -moz-border-radius: 4px; -webkit-border-radius: 4px; height: 35px; width: 100%;).sp-form .sp-field label ( color: #444444; font- 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 %; Schriftgewicht Höhe: 700; Schriftstil: normal Schriftfamilie: Arial, "Helvetica Neue", serifenlos; Box-Schatten: keine -moz-box-shadow: keine; -webkit-box-shadow: keine; background: linear-gradient(to top, #e30d22 , #f77380);).sp-form .sp-button-container ( text-align: center; width: auto;)