Domov redaktoři

1c vytvoření tabulky hodnot. Jaké metody existují a jak hledat několik hodnot současně

Publikováno 21. září 2011

Tabulka hodnot 1C – část 3. Metadata. Procházení sloupců tabulky hodnot

V tomto článku vám řeknu, jak pracovat s tabulkou hodnot „neznámé“ struktury, jak iterovat sloupce tabulky hodnot, jak extrahovat data ze sloupců a řádků bez použití názvů sloupců. (Tento článek patří do série článků 1C od nuly; programování 1C od nuly; tabulka hodnot 1C)

K vysvětlení materiálu a k tomu, abychom mohli naše příklady kódu spustit „naživo“, nějaké potřebujeme testovací tabulka hodnot 1C. Některé z našich příkladů budou extrahovat data z tabulky hodnot, takže vytvoříme tabulku se třemi sloupci „Příjmení“, „Jméno“, „Prostřední jméno“ a zadáme do ní malé množství dat – až 3 řádky :)

Vytvořme tedy testovací tabulku hodnot 1C a vyplňte ji:

MyTZ = New ValueTable; // vytvořte novou tabulku hodnot uloženou v proměnné "MyTZ" MyTZ.Columns.Add("Last Name"); // vytvořte sloupec "Příjmení" MyTZ.Columns.Add("Name"); // vytvořte sloupec "Name" MyTZ.Columns.Add("Patronymic"); // vytvořte sloupec "Middle name" // přidejte první řádek do naší tabulky hodnot NewLine = MyTZ.Add(); NewString.LastName = "Chapaev"; NewLine.Name = "Vasily"; NewString.Middle name = "Ivanovich"; // přidáme druhý řádek NewLine = MyTZ.Add(); NewString.LastName = "Dzeržinský"; NewRow.Name = "Felix"; NewString.Middle name = "Edmundovich"; // přidání třetího řádku NewLine = MyTZ.Add(); NewLine.LastName = "Kotovsky"; NewLine.Name = "Gregory"; NewString.Middle name = "Ivanovich";

Naše testovací tabulka se skládá ze tří sloupců: Jméno, Příjmení, Patronyma; a má tři plné řádky se jmény hrdinů občanské války.

První ukázka kódu je výčet sloupců tabulky hodnot 1C jako kolekce.

// zobrazení názvů všech sloupců TK For Each Column From MyTZ.Columns Cycle Report("Column name: " + Column.Name); EndCycle;

Náš cyklus zobrazí všechny názvy sloupců v okně zprávy 1C:

Název sloupce: Příjmení Název sloupce: Jméno Název sloupce: Prostřední jméno

Vidíme, že k iteraci po sloupcích se používá speciální iterační cyklus kolekce, podobný iteračnímu cyklu řádků (v předchozím článku). MyTZ.Columns- toto je kolekce sloupců tabulky hodnot 1C "MyTZ". Kolekce obsahuje objekty typu "Sloupec tabulky hodnot" Každý objekt tohoto typu je sloupcem tabulky hodnot a obsahuje vlastnosti a metody. Přístupem k těmto vlastnostem a metodám získáme potřebné informace o jednom sloupci nebo s ním provedeme nějaké další akce.

Například přístup k nemovitosti "Název" (Název sloupce) získáme název aktuálního sloupce.

Rád bych upozornil na název seriálu: „Pro každého Sloupec Z cyklu MyTZ.Column" Proměnná s názvem "Sloupec" námi vynalezené. Není nutné používat stejný název. Tuto proměnnou můžete například nazvat jakkoli chcete "MyCurrentColumn" Pak by výše uvedený příklad vypadal takto:

// zobrazení názvů všech sloupců TK For Each MyCurrentColumn From MyTK.Columns Cycle Report("Column name: " + MyCurrentColumn.Name); EndCycle;

Když prováděcí subsystém 1C narazí na cyklus tohoto typu, s každým průchodem cyklu přiřadí proměnné se zadaným názvem jeden prvek z naší kolekce, v tomto případě - jeden sbírkový prvek sloupce tabulky hodnot MyTZ.Columns A pak přistoupíme k proměnné, která obsahuje aktuální sloupec, a použijeme vlastnost "Název".

Navrhuji zobrazit vedle názvu sloupce číslo každého sloupce v kolekci sloupců:

// zobrazení počtu a názvů všech sloupců tabulky hodnot For Each Column From MyTZ.Columns Cycle ColumnNumber = MyTZ.Columns.Index(Column); // získání čísla sloupce Název_sloupce = Název_sloupce; // získání názvu sloupce Report("Column Number:" + Column Number + " Column Name: " + Column Name); EndCycle;

V okně zprávy 1C se zobrazí následující text:

Číslo sloupce:0 Název sloupce: Příjmení Číslo sloupce:1 Název sloupce: Jméno Číslo sloupce:2 Název sloupce: Prostřední jméno

Vezměte prosím na vědomí, že sloupce v tabulce hodnot 1C jsou číslovány od nuly, stejně jako řádky tabulky hodnot.

Počet sloupců v tabulce hodnot 1C

Ke zjištění počtu sloupců v tabulce hodnot používáme metodu "Count()" na kolekci sloupců.

Počet sloupců = MyTZ.Columns.Quantity(); Zpráva (počet sloupců);

Na obrazovce se zobrazí číslo "3". Naše tabulka má skutečně tři sloupce: „Příjmení“, „Jméno“, „Patronymie“

Získání sloupcového objektu podle jeho čísla (indexu) a výčet sloupců pomocí indexu sloupce

Udělejme cyklus prohledávání všech sloupců tabulky hodnot pomocí sloupcových indexů (čísel). Pamatujte, že číslování sloupců začíná od nuly. Proto musíme zvýšit počítadlo cyklů „Sch“ z nuly na číslo rovné počtu sloupců mínus jedna.

Pro účet = 0 Podle MyTZ.Columns.Quantity() - 1 cyklus CurrentColumn = MyTZ.Columns[Act]; Sestava(AktuálníSloupec.Název); EndCycle;

Na obrazovce se nám zobrazí následující

Celé jméno

Myslím, že tento příklad byl jasný. Obrátili jsme se na metodu Množství() sloupcové kolekce" MyTZ.Columns.Quantity()“, získal počet sloupců a spustil smyčku s čítačem z nula před počet sloupců mínus jeden. Uvnitř smyčky získáme každý sloupec z kolekce sloupců a přiřadíme aktuální objekt sloupce k proměnné CurrentColumn Dále proměnná CurrentColumn vstoupíme do nemovitosti název a zobrazit hodnotu této vlastnosti na obrazovce: Sestava(AktuálníSloupec.Název);

Je důležité nikdy nezaměňovat vlastnost objektu a metodu objektu.

Vlastnost je určitá statická hodnota a přístup k ní se zapisuje například bez závorek CurrentColumn.Name. Metoda je v podstatě procedura nebo funkce objektu a volání procedur a funkcí se vždy zapisují se závorkami (i když neexistují žádné vstupní parametry). Například: MyTZ.Columns.Quantity()

Pokud přistoupíme k metodě a zapomeneme napsat závorky, interpret 1C nám vydá chybovou zprávu a nespustí kód. Protože interpret bude uvažovat, že nepřistupujeme k metodě, ale k vlastnosti – protože tam nejsou žádné závorky. Ale nebude moci najít vlastnosti s tímto názvem (protože existuje pouze metoda s tímto názvem) - což bude uvedeno v chybové zprávě.

To napíše interpret, když zapomenu dát závorky do volání metody tak nesprávným způsobem MyTZ.Columns.Množství(bez závorek za "Quantity()"):

Pole objektu nenalezeno (množství)

V tomto případě by „pole“ a „vlastnictví“ měly být chápány jako synonyma nebo nepřesnost v terminologii vývojářů 1C. Obě tato slova používají k označení stejného konceptu. I když v jiných programovacích jazycích mohou tyto pojmy znamenat různé věci.

Získání dat z tabulky hodnot 1C pomocí čísel sloupců

Pro začátek vám nabízím jednoduchý příklad získávání dat z prvního řádku naší tabulky. Upozorňujeme, že používáme předvyplněnou tabulku ze začátku článku. Víme jistě, že tabulka má první řádek a alespoň jeden sloupec. Pokud použijeme tento příklad na prázdnou tabulku, dojde k chybě. Tak:

První řádek = MyTK; // získání prvního řádku (číslovaného od nuly) FirstColumnValue = FirstRow; // získání hodnoty prvního sloupce (číslování sloupců je také od začátku) Report(Value of the FirstColumn); // zobrazení hodnoty prvního sloupce v prvním řádku tabulky

Na obrazovce se zobrazí:

Čapajev

Nejprve jsme získali objekt řádku tabulky hodnot přístupem k tabulce hodnot pomocí operátoru [...]. (pokud jste zapomněli, jak to udělat, můžete se podívat na předchozí články) Argument „0“ jsme předali uvnitř operátoru. Toto je index prvního řádku tabulky hodnot. První řádek = MyTK;

Dále máme také právo přistupovat k řetězcovému objektu pomocí operátoru [...]. Uvnitř tohoto operátoru jsme předali číslo sloupce tabulky hodnot, v tomto případě také „0“. A tak jsme obdrželi hodnotu sloupce s číslem "0" pro aktuální řádek tabulky s číslem "0". Tuto hodnotu jsme zobrazili na obrazovce a představuje řetězec „Chapaev“.

Pojďme si náš příklad trochu zkomplikovat:

První řádek = MyTK; // získání prvního řádku (číslovaného od nuly) Report(FirstLine); // zobrazení hodnoty prvního sloupce v prvním řádku tabulky Report(FirstRow); // zobrazení hodnoty druhého sloupce v prvním řádku tabulky Report(FirstRow); // zobrazení hodnoty třetího sloupce v prvním řádku tabulky

Nyní jsme zobrazili hodnoty ze všech tří sloupců prvního řádku naší tabulky hodnot:

Čapajev Vasilij Ivanovič

Nyní upravím i tento příklad, abychom se obešli bez proměnné "První řada"

Report(MyTZ); // zobrazení hodnoty prvního sloupce v prvním řádku tabulky Report(MyTZ); // zobrazení hodnoty druhého sloupce v prvním řádku tabulky Report(MyTZ); // zobrazení hodnoty třetího sloupce v prvním řádku tabulky

Na obrazovce to bude stejné

Čapajev Vasilij Ivanovič

Ve výše uvedeném příkladu jsme viděli, že pro přístup k hodnotě umístěné v konkrétním řádku a konkrétním sloupci tabulky hodnot můžeme použít sekvenční volání dvou operátorů [...] v tomto tvaru: Tabulka hodnot[Row Index][Column Index]

Takže jsme připraveni vytvořit smyčku a získat data všech řádků a všech sloupců pomocí řádkových a sloupcových indexů:

For RowCounter = 0 By MyTZ.Quantity() - 1 smyčka // procházet řádky For ColumnCounter = 0 Podle MyTZ.Columns.Quantity() - 1 smyčka // vnořená smyčka přes sloupce // získat hodnotu buňky (z aktuálního řádku a aktuální sloupce) CellValue = MyTK[RowCounter][ColumnCounter]; // zobrazení čísla řádku, sloupce a hodnoty buňky Report("Row No" + Row Count + "column No" + Column Count + " = " + CellValue); EndCycle; EndCycle;

Na obrazovce se zobrazí následující:

Řádek č. 0 sloupec č. 0 = Čapajev Řádek č. 0 sloupec č. 1 = Vasilij Řádek č. 0 sloupec č. 2 = Ivanovič Řádek č. 1 sloupec č. 0 = Dzeržinskij Řádek č. 1 sloupec č. 1 = Felix Řádek č. 1 sloupec č. 2 = Edmundovič Řádek č. 2 sloupec č. 0 = Kotovský Řádek č. 2 sloupec č. 1 = Grigorij Řádek č. 2 sloupec č. 2 = Ivanovič

Pomocí dvou cyklů, z nichž jeden je vnořený do druhého, jsme zobrazili hodnoty všech sloupců ze všech řádků tabulky hodnot 1C. V tomto případě jsme nepoužili názvy sloupců, ale přistupovali jsme ke sloupcům a řádkům podle jejich indexů. Pro lepší pochopení věnujte pozornost komentářům uvnitř příkladu.

Na závěr navrhuji mírně změnit náš příklad tak, aby místo čísel sloupců zobrazoval na obrazovce jejich názvy. A navíc udělám prezentovatelnější design pro zobrazování obsahu na obrazovce.

Pro LineCounter = 0 By MyTZ.Quantity() - 1 smyčka // smyčka po řádcích Report(" ======= Číslo řádku " + LineCounter + " ======="); Ohlásit(" "); // posun řádku (vložení prázdného řádku) For ColumnCounter = 0 By MyTZ.Columns.Quantity() - 1 smyčka // vnořená smyčka přes sloupce // získání hodnoty buňky (z aktuálního řádku a aktuálního sloupce) CellValue = MyTZ [RowCounter][ColumnCounter]; // získání názvu sloupce ColumnName = MyTZ.Columns[ColumnCounter].Name; // zobrazení názvu sloupce a hodnoty buňky Report(ColumnName + ": " + CellValue); EndCycle; Ohlásit(" "); // posun řádku (vložení prázdného řádku) EndCycle;

Nyní na naší obrazovce informace začaly vypadat reprezentativněji:

Řádek č. 0 ======= Příjmení: Čapajev Jméno: Vasilij Patronymus: Ivanovič ======= Řádek č. 1 ======= Příjmení: Dzeržinskij Jméno: Felix Patronymie: Edmundovich ===== == Řádek č. 2 ======= Příjmení: Kotovskij Jméno: Grigorij Patronymus: Ivanovič

Ano, málem bych zapomněl. Při použití dvou operátorů [...][...] v řadě můžeme místo indexu sloupce předat název tohoto sloupce: ValueTable[RowIndex][ColumnName]

Pozor na řádek označený šipkou ". V tomto řádku místo indexu aktuálního sloupce předáme argumentu v hranatých závorkách název aktuálního sloupce [...] Výsledek bude stejný.

A teď poslední věc v tomto článku.

SPRÁVNÉ získání všech dat z tabulky hodnot 1C pomocí smyček prostřednictvím kolekce řádků a kolekce sloupců

Pro každý CurrentLine From MyTZ Loop // smyčka přes kolekci řetězců Report(" ======= Číslo řádku " + MyTZ.Index(CurrentLine) + " ======="); Ohlásit(" "); For Each CurrentColumn From MyTZ.Columns Loop // vnořená smyčka iterující kolekcí sloupců ColumnName = CurrentColumn.Name; // získání sloupce nameCellValue = CurrentRow[ColumnName]; // získání hodnoty buňky BY sloupec NAME Report(ColumnName + ": " + CellValue); // zobrazení názvu sloupce a hodnoty buňky End of Cycle; Ohlásit(" "); EndCycle;

V příkladu byly použity dvě smyčky. Smyčka pro procházení kolekcí sloupců je vnořena do smyčky pro procházení řádků. Pokud jste si prošli výše uvedené příklady a přečetli jste si předchozí články, pak nebudete mít žádné potíže s pochopením toho, jak tento příklad funguje.

Nakonec co nejvíce snížím počet řádků kódu v našem posledním příkladu tím, že odstraním použití meziproměnných. Získáme ukázku „průmyslového kódu“, který se používá v reálných problémech.

To by mělo být provedeno pouze tehdy, když dobře rozumíte tomu, co děláte. Pokud je kód velmi složitý, je přijatelné ponechat přechodné proměnné, aby bylo později snazší porozumět vlastnímu kódu. Také každý kód musí být alespoň minimálně okomentován, aby po nějaké době bylo snazší porozumět textům programu.

Pro každý aktuální řádek z cyklu MyTZ // iterace přes řádky Report(" ======= Číslo řádku " + MyTZ.Index(CurrentLine) + " =======" + Symbols.PS); Pro každý CurrentColumn From MyTZ.Columns Smyčka // iterace přes sloupce Report(CurrentColumn.Name + ": " + CurrentRow[CurrentColumn.Name]); EndCycle; Ohlásit(" "); EndCycle;

Výstup na obrazovce se nezměnil, zůstává stejný jako v předchozím příkladu:

2 TÝDENNÍ KURZ

"PROGRAMOVÁNÍ V 1C PRO ZAČÁTEČNÍKY"

Kurz bude zaslán emailem. Staňte se programátorem plněním úkolů krok za krokem.

K účasti potřebujete pouze počítač a internet

Volný vstup do kurzu:

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", bezpatkové; background-repeat: no-repeat; background-position: center; background-size: auto;) .sp-form input ( display: inline-block; neprůhlednost: 1; viditelnost: viditelná;).sp-form .sp-form-fields-wrapper ( margin: 0 auto; width: 260px;).sp-form .sp -form-control ( background: #ffffff; border-color: #cccccc; border-style: solid; border-width: 1px; font-size: 15px; padding-left: 8.75px; padding-right: 8.75px; border -radius: 4px; -moz-border-radius: 4px; -webkit-border-radius: 4px; výška: 35px; šířka: 100 %;).sp-form .sp-field label (color: #444444; font- size: 13px; font-style: normal; font-weight: bold;).sp-form .sp-button ( border-radius: 4px; -moz-border-radius: 4px; -webkit-border-radius: 4px; barva pozadí: #f4394c; barva: #ffffff; šířka: 100 %; váha písma: 700; styl písma: normální; rodina písem: Arial, "Helvetica Neue", bezpatkové; box-shadow: žádný; -moz-box-shadow: none; -webkit-box-shadow: none; background: linear-gradient(to top, #e30d22 , #f77380);).sp-form .sp-button-container (text-align: center; width: auto;)

(Tento článek patří do série článků 1C od nuly; programování 1C od nuly; tabulka hodnot 1C)

Struktura virtuálního úložiště dat v tabulkové formě - to je to, co to je

Tabulka hodnot není trvalým objektem databáze 1C a mezi spouštěcími relacemi se neukládá.

Tabulka hodnot 1C(TK) se vytváří „za běhu“ pomocí programového kódu a práce s ním se pak provádí stejným způsobem jako s jakýmkoli jiným programovým objektem programovacího jazyka 1C. Použití volání metod a přístup k vlastnostem objektu tabulky.

Jinými slovy, programátor vytvoří tabulku v paměti, naplní ji daty, pracuje s ní, třídí, seskupuje, počítá součty a tak dále. Získává potřebná data pro další použití.

Vytvořme tabulku hodnot a něčím ji vyplňte. Je třeba si uvědomit, že tabulku hodnot 1C lze vytvořit nejen ručně, zavoláním operátora

NewValueTable;

Tabulka hodnot je často výsledkem volání metody na jiný objekt, například výsledek dotazu může být uložen do tabulky hodnot a tak dále.

Dovolte mi hned uvést jednoduchý příklad.

// MyTZ = New ValueTable; // vytvořte novou tabulku hodnot uloženou v proměnné "MyTZ" MyTZ. Sloupce. Add("Příjmení" ) ; // vytvořte sloupec "Příjmení" MyTZ. Sloupce. Add("Jméno"); // vytvořte sloupec "Name". Zpráva (MyTZ); // zobrazí hodnotu proměnné MyTZ //

Vytvořil jsem tabulku hodnot 1C se dvěma sloupci: „Příjmení“, „Jméno“. Postup Zpráva (MyTZ) zobrazí typ proměnné v okně zprávy MyTZ: Tabulka hodnot

Naše tabulka hodnot je zatím prázdná. Přidejme k tomu pár řádků se jménem a příjmením.

// vyplňte tabulku hodnot // přidáme první řádek do naší tabulky hodnot NewLine = MyTZ. Add() ; Nový řádek. Příjmení = "Sidorov" ; Nový řádek. Jméno = "Vasya" ; // přidat druhý řádek do naší tabulky hodnot NewLine = MyTZ. Add() ; Nový řádek. Příjmení = "Ivanov" ; Nový řádek. Jméno = "Petr" ;

Dostali jsme takovou tabulku:

Je třeba si pamatovat: Čísla řádků v tabulce hodnot začínají od nuly

Proč vůbec potřebujeme čísla řádků? A abychom měli například přístup k samostatnému řádku tabulky hodnot, vezměte a zobrazte tento řádek na obrazovce.

// *** zobrazí hodnoty nulového řádku na obrazovce *** (v každodenním životě obvykle číslujeme věci od jedné, ale zde - od nuly) // získáme nulový řádek naší tabulky pomocí indexu řádku v hranatých závorkách OurNullString = MyTZ[ 0] ; // nyní je celý nulový řetězec obsažen v proměnné "OurFirstLine" Report(NašeNullString.LastName) ; // zobrazení hodnoty sloupce "Příjmení" uloženého v řádku nula Zpráva (OurNullString.Name) ; // zobrazení hodnoty sloupce "Name" ze stejného řádku

V důsledku toho se na obrazovce zobrazí:

Sidorov Vasja

Nyní pro velmi chytré a stručné uvedu příklad, který umožňuje přistupovat k hodnotě sloupce v tom a takovém řádku (Hodnota sloupce v takovém a takovém řádku je buňka tabulky hodnot Neoficiální termín, ale pohodlný). Ale bez použití přechodné proměnné, jako je "OurZeroString".

Chcete-li zobrazit hodnotu buněk z druhého řádku (nezapomeňte, že řádek je druhý, ale index tohoto řádku je jedna, takže číslování začíná od nuly)

Konečně poslední bod v tomto článku. Ukázal jsem vám příklad přístupu k jednomu řádku tabulky hodnot podle indexu (čísla řádku). Univerzální formulář pro čtení nebo přiřazení obsahu buňky je: "MyValueTable[RowNumber].ColumnName"

Nyní vám dám cyklus kompletního výstupu obsahu tabulky hodnot. Bez podrobného vysvětlování, abyste si také mohli lámat hlavu :)

// // procházet a zobrazovat všechny řádky naší tabulky hodnot// Pro LineNumber = 0 Podle MyTK. Quantity() - Zpráva o 1 cyklu (MyTZ[LineNumber] . Příjmení) ; // zobrazení hodnoty sloupce "Příjmení". Report (MyTK[LineNumber] . Name) ; // zobrazení hodnoty sloupce "Name". EndCycle ;

V důsledku spuštění této smyčky se na obrazovce zobrazí následující:

Sidorov Vasja Ivanov Petya

Zde jsem vám řekl úplné základy práce s tabulkou hodnot 1C. Tyto informace platí pro 1C 8.0, 8.1, 8.2. Tím zajímavé podrobnosti o objektu „tabulka hodnot 1C“ nekončí. Tento objekt má obrovské možnosti pro pohodlnou práci s daty. O tom budu mluvit v následujících článcích.

Děgtyarev Roman.

Jak se naučit programovat v 1C od nuly?

Jak pracovat jako programátor 1C a vydělat až 150 000 rublů měsíčně?

ZAREGISTROVAT SE ZDARMA

2 TÝDENNÍ KURZ

"PROGRAMOVÁNÍ V 1C PRO ZAČÁTEČNÍKY"

Kurz bude zaslán emailem. Staňte se programátorem plněním úkolů krok za krokem.

K účasti potřebujete pouze počítač a internet

Volný vstup do kurzu:

Zdravím všechny čtenáře infostartu. Tento článek bude věnován problematice vytváření libovolné tabulky hodnot ve formě spravované aplikace programově.

Vlastnosti úkolu.

Každý, kdo programoval v běžné aplikaci, se často potýkal s úkolem získat na formuláři libovolnou tabulku hodnot. Libovolná tabulka hodnot je tabulka, jejíž počet a typ sloupců není předem znám. To znamená, že tam mohou být 3 sloupce nebo možná 6 nebo možná 8. V normální aplikaci je vše jednoduché: můžete umístit prvek „Tabulka hodnot“ na formulář pro zpracování a poté přenést vytvořenou tabulku hodnot k tomuto prvku programově. Poté pomocí jednoduchého příkazu:

Form Elements.TableField.CreateColumns();

získejte ve formuláři hotovou tabulku hodnot. Zdálo by se, že by to mohlo být jednodušší.

To vše bylo v běžné aplikaci. Ve spravované aplikaci se vše změnilo. Vytvořit libovolnou tabulku není tak snadné. Nyní musíte buď pevně parametrizovat tabulku hodnot ve formuláři, nebo ji vytvořit programově (popište, dobře, to je ve skutečnosti podstata samotné spravované aplikace). To je to, co se pokusíme udělat: programově vytvořit libovolnou tabulku hodnot na řízeném formuláři.

Řešení problému.

První věc, kterou musíme udělat, je určit, jak bude tabulka ve formuláři vypadat. Hlavní věc je, že při zpracování nemusíte vytvářet žádný formulářový prvek. Vytvoříme ji programově, jako celou tabulku. To znamená, že tabulka bude popsána a vytvořena v okamžiku otevření formuláře nebo pomocí tlačítka - podle toho, kdo to potřebuje.

K vytvoření tabulky ve formuláři dochází prostřednictvím popisu tabulky hodnot jako atributu:
SelectionTypeArray = Nové pole; Pole SelectionType.Add(Type("Tabulka hodnot")); ChoiceTypeDescription = New TypeDescription(ChoiceTypeArray); Pole detailů = Nové pole; Array of Attributes.Add(New Form Attributes("Schedule Table", Description of SelectionType, "", "TZN")); Nyní musíme vytvořit tabulku hodnot programu, která obsahuje data. Pokud je tabulka hodnot získána z dotazu, pak je vše víceméně v pořádku. Pokud je tabulka vytvořena ručně, pak význam sloupců, které budou obsahovat čísla nebo data, lze vytvořit pomocí „Popis typů“. Jde o to, že sloupce v tabulce hodnot musí mít nějaký typ. Pokud se například očekává, že uživatel bude data v těchto sloupcích vyplňovat interaktivně, pak nelze přidat sloupec tabulky hodnot pouze názvem, musí mít typ. Mějte na paměti - je to velmi důležité, protože... Tyto typy přeneseme do tabulky na formuláři.
Vytvoříme tabulku, která obsahuje několik sloupců:
CD = NewDateQualifiers(DateParts.Time); ArrayKD = Nové pole; ArrayCD.Add(Type("Datum")); DescriptionTypesTime = Nový DescriptionTypes(ArrayCD,CD); TZ = Nová tabulka hodnot;
TK.Columns.Add("S", DescriptionTypesTime);
TK.Columns.Add("Před", DescriptionTypesTime);
TK.Columns.Add("Jméno");
TK.Columns.Add("Note"); // Celé jméno a Poznámka - řádky Dále naplníme naši tabulku programu TK potřebnými údaji. Obdržíme tabulku TK, která obsahuje potřebné hodnoty a je připravena k přenosu do vytvořeného atributu formuláře. Pro každý sloupec z TK. Cyklus sloupců

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;

Toto je jednoduchá kombinace a náš stůl je připraven.

Pro každý sloupec z TK. Cyklus sloupců

NewElement = Elements.Add(Column.Name, Type("FormField"), SelectionFieldTable);
NewElement.View = FormFieldView.InputField;
NewElement.DataPath = "ScheduleTable." + Název sloupce;
NewElement.Width = 10;

EndCycle;

Podmíněný design, pokud jej potřebujeme, napíšeme jej také ručně, příkazové menu - ručně. Ručně jsou psány i stolní manipulátory. Chcete-li například přidat obslužnou rutinu události pro tabulku „Výběr“:

Table of SelectionFields.SetAction("Selection","TZNSelection");

Pro zpracování této události je předepsán samostatný postup ve formě postupu:

&OnClient
Postup TKNSelection(TK, SelectedRow, Field, StandardProcessing)
//příkazy obsluhy EndProcedure

Všimněte si, že obslužné rutiny tabulky spouštějí klienta, a proto musí mít příkaz ukazatele kompilátoru

&OnClient

No, poslední věc, kterou jsem chtěl dodat, je, že po všech těchto krocích nezapomeňte předat hotovou tabulku do atributu formuláře:

ValueВFormAttributes(ToR, "ScheduleTable");

Toto máme jako výsledek:

A zde je zpracování události "Výběr":

Doslov.

Doufám, že článek pomůže těm 1C programátorům, kteří začínají programově vytvářet tabulky na formuláři.

Můžete si stáhnout zpracování, které programově vytvoří tabulku hodnot a zobrazí ji ve spravovatelném formuláři s komentáři, které vám pomohou vytvořit si vlastní tabulky.

Za účelem účtování peněz a zboží se v podnikání široce používají různé tabulky. Téměř každý dokument je tabulka.

V jedné tabulce je uvedeno zboží k odeslání ze skladu. Další tabulka uvádí povinnosti platit za toto zboží.

Proto v 1C zaujímá práce s tabulkami přední místo.

Tabulky v 1C se také nazývají „tabulkové části“. Adresáře, dokumenty a další je mají.

Dotaz po provedení vrátí tabulku, ke které lze přistupovat dvěma různými způsoby.

První - rychlejší - výběr, získávání řádků z něj je možné pouze v pořádku. Druhým je nahrání výsledku dotazu do tabulky hodnot a poté k němu náhodný přístup.

//Možnost 1 – sekvenční přístup k výsledkům dotazu

//získejte stůl
Select = Query.Run().Select();
// projdeme všechny řádky výsledku dotazu v pořadí
Zatímco Select.Next() Loop
Zpráva(Výběr.Název);
EndCycle;

//Možnost 2 – nahrání do tabulky hodnot
Request = New Request("SELECT Name FROM Directory.Nomenclature");
//získejte stůl
Tabulka = Query.Run().Unload().
//dále můžeme také iterovat všechny řádky
Pro každý řádek z cyklu tabulky
Report(String.Name);
EndCycle;
//nebo libovolně přistupovat k řetězcům
Řádek = Stůl.Find("Lopata", "Jméno");

Důležitou vlastností je, že v tabulce, která je získána z výsledku dotazu, budou všechny sloupce striktně zadány. To znamená, že vyžádáním pole Název z adresáře Nomenclature obdržíte sloupec typu String s povolenou délkou maximálně N znaků.

Tabulka na formuláři (tlustý klient)

Uživatel pracuje s tabulkou při jejím umístění na formulář.

Základní principy práce s formuláři jsme probrali v hodině na a v hodině na

Položme tedy tabulku na formulář. Chcete-li to provést, můžete tabulku přetáhnout z panelu Ovládací prvky. Podobně můžete z nabídky vybrat Form/Insert Control.

Data je možné uložit do konfigurace – pak je potřeba vybrat stávající (dříve přidanou) tabulkovou část konfiguračního objektu, jehož podobu upravujete.

Klikněte na tlačítko "..." ve vlastnosti Data. Chcete-li zobrazit seznam tabulkových částí, musíte rozbalit větev Objekt.

Když vyberete tabulkovou část, 1C sám přidá sloupce do tabulky ve formuláři. Řádky zadané uživatelem do takové tabulky se automaticky uloží spolu s referenční knihou/dokumentem.

Ve stejné vlastnosti Data můžete zadat libovolný název a vybrat typ Tabulka hodnot.

To znamená, že byla vybrána libovolná tabulka hodnot. Nebude automaticky přidávat sloupce, ani se automaticky neukládá, ale můžete si s ním dělat, co chcete.

Kliknutím pravým tlačítkem na tabulku můžete přidat sloupec. Ve vlastnostech sloupce můžete zadat jeho název (pro referenci v kódu 1C), záhlaví sloupce ve formuláři, spojení s atributem tabulkové části (druhé - pokud není vybrána libovolná tabulka, ale tabulková část).

Ve vlastnostech tabulky ve formuláři můžete určit, zda uživatel může přidávat/odstraňovat řádky. Pokročilejším formulářem je zaškrtávací políčko Pouze zobrazení. Tyto vlastnosti je vhodné použít pro organizaci tabulek určených k zobrazování informací, ale ne k úpravám.

Chcete-li tabulku spravovat, musíte ve formuláři zobrazit panel příkazů. Vyberte položku nabídky Formulář/Vložit ovládací/Příkazový řádek.

Ve vlastnostech panelu příkazů zaškrtněte políčko Automatické vyplňování, aby se tlačítka na panelu zobrazovala automaticky.

Tabulka na formuláři (tenký/spravovaný klient)

Na spravovaném formuláři vypadají tyto akce trochu jinak. Pokud potřebujete umístit tabulkovou část na formulář, rozbalte větev Objekt a přetáhněte jednu z tabulkových částí doleva. To je vše!

Pokud potřebujete umístit tabulku hodnot, přidejte nový atribut formuláře a v jeho vlastnostech určete typ – tabulka hodnot.

Chcete-li přidat sloupce, použijte nabídku pravým tlačítkem myši na tento atribut formuláře, vyberte Přidat sloupec atributu.

Potom také přetáhněte tabulku doleva.

Aby tabulka měla panel příkazů, ve vlastnostech tabulky vyberte hodnoty v části Použití – Umístění panelu příkazů.

Nahrání tabulky do Excelu

Jakoukoli tabulku 1C umístěnou ve formuláři lze vytisknout nebo nahrát do Excelu.

Chcete-li to provést, klepněte pravým tlačítkem myši na prázdné místo v tabulce a vyberte Seznam.

Ve spravovaném (tenkém) klientovi lze podobné akce provádět pomocí položky nabídky Všechny akce/Zobrazit seznam.

Otázka Vytvoření sloupce tabulky hodnot různých typů v 1C v8
Odpovědět Při vytváření sloupce tabulky hodnot můžete projít řada typů a možná i konkrétní typ. Pole typů se používá, když potřebujete zadat několik různých typů pro jeden sloupec.

Používá se k označení typů "obecný objekt" - "Popis typů". Nejprve si proto vysvětlíme, co je to „Popis typů“ („Popis typů hodnot“).

"Popis typů hodnot". K popisu přijatelných typů hodnot vlastností různých objektů v systému se používá speciální objekt "Popis typů". Pomocí tohoto objektu můžete popsat platné typy hodnot, které lze vlastnostem přiřadit. Pro další omezení možných hodnot primitivních typů Number, String a Date kvalifikátory. Kvalifikátory popisují parametry, jako je délka řetězce nebo čísla, platné části data atd.

Syntaxe metody „Popis typu“.

Nové typy popisů(<Исходное описание типов>, <Добавляемые типы>, <Вычитаемые типы>, <Квалификаторы числа>, <Квалификаторы строки>, <Квалификаторы даты>)
Možnosti:
<Исходное описание типов> (volitelný)
Typ: PopisTypy. Prvotní popis typů, na základě kterých bude postaven nový.
<Добавляемые типы> (volitelný)
Typ: Array, String. Pole hodnot typu Typ skládající se z typů, které budou použity v objektu, nebo řetězec obsahující názvy typů oddělené čárkami.
<Вычитаемые типы> (volitelný)
Typ: Array, String. Pole hodnot typu (nebo řetězec obsahující názvy typů oddělené čárkami) skládající se z typů, které budou vyloučeny z počáteční deklarace zadané v prvním parametru.
<Квалификаторы числа> (volitelný)
Typ: QualifiersNumbers. Číselné kvalifikátory, které popisují platné hodnoty číselného typu.
<Квалификаторы строки> (volitelný)
Typ: QualifiersStrings. Kvalifikátory řetězce, které popisují platné hodnoty typu řetězce.
<Квалификаторы даты> (volitelný)
Typ: QualifiersDates. Kvalifikátory data, které popisují platné hodnoty typu Datum.
Popis:
Vytvoří popis typu na základě jiného popisu typu přidáním některých typů a vyloučením jiných. Pokud není zadán nový kvalifikátor, budou zachovány kvalifikátory původní deklarace typu.
Příklad použití objektu „Popis typu“:

// rozšíří popis Platných typů o nové typy Pole = Nové pole; Pole. Přidat(Typ( "Referenční odkaz. Metody")); Pole. Add(Type("Číslo" )); Sign = ValidSign. Nenegativní; QuNumbers = New QualifiersNumbers(10, 2, Sign); ValidTypes = NewTypeDescription(ValidTypes, Array, QNumbers);

Nyní ve skutečnosti příklady správného vytváření hodnot sloupců různých typů v tabulce.

Obecně stačí definovat typy sloupců takto:

TK. Sloupce. Přidat( "Index řazení", Nové typy popisů ( "Číslo" ) ); TK. Sloupce. Add("SectionName", New TypeDescription("String" ) ) ; TK. Sloupce. Add("DataCorr" , New TypeDescription("Date" ) ); TK. Sloupce. Přidat( "Bezpodmínečné odstranění", Nový TypeDescription("Boolean")); TK. Sloupce. Add("Nomenklatura" , New TypeDescription() ) ; TK. Sloupce. Add("SectionData" , New TypeDescription("Structure" ) ); // příklad vytvoření sloupců "číslo" a "řetězec" s upřesněním parametrů: TK. Sloupce. Přidat( "Dokončeno v procentech", New DescriptionTypes ( "Number" , New QualifiersNumbers ( 18 , 2 ) ) ); TK. Sloupce. Add("SectionName" , NewTypeDescription("String" , , NewStringQualifiers(200, AllowedLength. Variable) ) ); TK. Sloupce. Add("DecommissionedDate" , NewTypeDescription("Date" , , , NewDateQualifiers(DateParts.DateTime) ) );

Obecněji se však jako typ sloupce předává pole. Pole se používá, když je třeba jednomu sloupci přiřadit několik typů. Pak bude definice struktury asi tato (příklady jsou uvedeny pro různé typy sloupců, kdy typem je pole, ale pro zjednodušení je složení pole uvedeno stejného typu, aby nedošlo k záměně )

////// tvorba struktury technických specifikací (vytváření sloupců) //// definuje kvalifikátory pro substituci v polích kvalifikátorů technické specifikace CN = New QualifiersNumbers(18, 9); KS = NewStringQualifiers(200); CD = NewDateQualifiers(DataParts.DateTime) ; //// definuje popis typů pro budoucí sloupce TK // Pole je počáteční popis typů, na základě kterých bude postaveno nové // Upozorňujeme, že pro sloupce TK je v tomto příkladu počáteční popis typu pole Pole = Nové pole; Pole. Add(Type("String") ) ; TypeDescriptionString = New TypeDescription(Array, , KS) ; Pole. Průhledná() ; Pole. Add(Type("Číslo") ); TypeDescriptionNumber = Nový TypeDescription(Array, , , CN) ; Pole. Průhledná() ; Pole. Add(Type("Datum") ); DescriptionTypesDate = New DescriptionTypes(Array, , , , CD) ; Pole. Průhledná() ; Pole. Přidat(Typ( "DirectoryLink.Nomenclature")); Typ PopisNomenklatura = Nový Popis typu (Array) ; Pole. Průhledná() ; Pole. Přidat(Typ( "DirectoryLink.SeriesNomenclature")); TypeDescriptionSeries = New TypeDescription(Array) ; Pole. Průhledná() ; Pole. Přidat(Typ( "DirectoryLink.Quality")); TypeDescriptionQuality = New TypeDescription(Array) ; Pole. Průhledná() ; Pole. Add(Type("Boolean") ); TypeDescriptionBoolean = New TypeDescription(Array) ; // skutečné přidání sloupců do TK (vytvoření struktury budoucí TK) TK. Sloupce. Add("Nomenklatura", PopisTypyNomenklatura) ; TK. Sloupce. Add("Kód" , TypeDescriptionString) ; TK. Sloupce. Přidat( "Nomenklatura řady", PopisTypySeries); TK. Sloupce. Add("Kód účtu" , Typ PopisString) ; TK. Sloupce. Add("ActionDate" , TypeDescriptionDate) ; TK. Sloupce. Add("Kvalita" , TypPopisKvalita) ; TK. Sloupce. Add("NumberUS", DescriptionTypesNumber) ; TK. Sloupce. Add("Odepsat" , TypeDescriptionBoolean) ; . . . //////// tvorba struktury technické specifikace (vytváření sloupců) ////////////////////////////////////////////////////////

Chcete-li přidat řádek do tabulky hodnot, viz