itthon Szerkesztők

1c értéktáblázat létrehozása. Milyen módszerek léteznek, és hogyan lehet egyszerre több értéket keresni

Közzétéve: 2011. szeptember 21

1C értéktáblázat – 3. rész. Metaadatok. Az értéktáblázat oszlopaiban való körözés

Ebben a cikkben elmondom, hogyan kell dolgozni egy „ismeretlen” szerkezetű értéktáblázattal, hogyan iterálhat át egy értéktáblázat oszlopait, hogyan nyerhet ki adatokat oszlopokból és sorokból oszlopnevek használata nélkül. (Ez a cikk az 1C a semmiből; az 1C programozás a semmiből; az 1C értékek táblázata cikksorozathoz tartozik)

Az anyag magyarázatához és kódpéldáink „élőben” futtatásához szükségünk van néhányra 1C értékek teszttáblázata. Példáink egy része egy értéktáblázatból kinyeri az adatokat, ezért készítünk egy táblázatot három oszlopból: „Vezetéknév”, „Keresztnév”, „Középső név” és beírunk egy kis mennyiségű adatot - akár 3-at. sorok :)

Tehát hozzunk létre egy teszttáblázatot az 1C értékekből, és töltsük ki:

MyTZ = új értéktábla; // hozzon létre egy új, a "MyTZ" változóban tárolt értékek táblázatát MyTZ.Columns.Add("Last Name"); // a "Vezetéknév" oszlop létrehozása MyTZ.Columns.Add("Name"); // a "Név" oszlop létrehozása MyTZ.Columns.Add("Patronymic"); // hozza létre a "Középső név" oszlopot // adja hozzá az első sort az értéktáblázatunkhoz.NewLine = MyTZ.Add(); NewString.LastName = "Chapaev"; NewLine.Name = "Vaszilij"; NewString.Middle name = "Ivanovich"; // a második sor hozzáadása NewLine = MyTZ.Add(); NewString.LastName = "Dzerzsinszkij"; NewRow.Name = "Félix"; NewString.Middle name = "Edmundovich"; // a harmadik sor hozzáadása NewLine = MyTZ.Add(); NewLine.LastName = "Kotovsky"; NewLine.Name = "Gregory"; NewString.Middle name = "Ivanovich";

Teszttáblázatunk három oszlopból áll: Keresztnév, Vezetéknév, Apanév; és három tele van benne a polgárháborús hősök neveivel.

Az első kódminta egy 1C értéktábla oszlopait gyűjti össze.

// megjeleníti a TK összes oszlopának nevét Minden oszlophoz From MyTZ.Columns Cycle Report("Oszlopnév: " + Oszlop.Név); EndCycle;

Ciklusunk az összes oszlopnevet megjeleníti az 1C üzenetablakban:

Oszlopnév: Vezetéknév Oszlopnév: Keresztnév Oszlopnév: Középső név

Látjuk, hogy az oszlopokon keresztüli iterációhoz egy speciális gyűjteményiterációs ciklust használnak, hasonlóan a soriterációs ciklushoz (az előző cikkben). MyTZ.Columns- ez az 1C értéktábla oszlopainak gyűjteménye "MyTZ". A gyűjtemény a következő típusú objektumokat tartalmazza "Értéktábla oszlop" Minden ilyen típusú objektum az értéktábla oszlopa, és tulajdonságokat és metódusokat tartalmaz. Ezekhez a tulajdonságokhoz és metódusokhoz való hozzáféréssel egy oszlopról megszerezzük a szükséges információkat, vagy más műveleteket hajtunk végre vele.

Például az ingatlanhoz való hozzáférés "Név" (Oszlop.Név) megkapjuk az aktuális oszlop nevét.

A sorozat címére szeretném felhívni a figyelmet: „Mindenkinek Oszlop MyTZ.Column Cycle-ből" Változó névvel "Oszlop" mi találtuk ki. Nem szükséges ugyanazt a nevet használni. Ezt a változót például bárminek hívhatja "Aktuális oszlopom" Akkor a fenti példa így nézne ki:

// megjeleníti a TK összes oszlopának nevét For Every CurrentColumn From MyTK.Columns Cycle Report("Oszlop neve: " + SajátCurrentColumn.Name); EndCycle;

Amikor az 1C végrehajtási alrendszer találkozik egy ilyen típusú ciklussal, a ciklus minden egyes lépésével hozzárendel egy adott nevű változóhoz egy elemet a gyűjteményünkből, ebben az esetben - egy gyűjtőelemértéktábla oszlopai MyTZ.Columns Ezután elérjük az aktuális oszlopot tartalmazó változót, és használjuk a tulajdonságot "Név".

Azt javaslom, hogy az oszlopnév mellett jelenítse meg az oszlopgyűjtemény egyes oszlopainak számát:

// megjeleníti az értéktáblázat összes oszlopának számát és nevét a MyTZ.Columns Cycle Oszlopszámból = MyTZ.Columns.Index(Column); // az oszlopszám lekérése ColumnName = Column.Name; // az oszlopnév lekérése Report("Oszlopszám:" + Oszlopszám + " Oszlopnév: " + Oszlopnév); EndCycle;

A következő szöveg jelenik meg az 1C üzenetablakban:

Oszlopszám:0 Oszlopnév: Vezetéknév Oszlopszám:1 Oszlopnév: Keresztnév Oszlopszám:2 Oszlopnév: Középső név

Kérjük, vegye figyelembe, hogy az 1C értéktáblázat oszlopai nullától kezdődően vannak számozva, ugyanúgy, mint az értéktáblázat sorai.

Az 1C értéktáblázat oszlopainak száma

Az oszlopok számának megállapításához az értéktáblázatban a "Count()" metódust használjuk az oszlopok gyűjteményénél.

Oszlopok száma = MyTZ.Columns.Quantity(); Jelentés(Oszlopok száma);

A "3" szám jelenik meg a képernyőn. Valójában a táblázatunk három oszlopból áll: „Vezetéknév”, „Utónév”, „Apanév”

Oszlopobjektum lekérése száma (index) alapján és oszlopok felsorolása az oszlopindex segítségével

Készítsünk egy ciklust az értéktábla összes oszlopában, oszlopindexek (számok) segítségével. Ne feledje, hogy az oszlopok számozása nullától kezdődik. Ezért az „Sch” ciklusszámlálót nulláról olyan számra kell növelnünk, amely egyenlő az oszlopok számával mínusz egy.

Számla esetén = 0 a SajátTZ.Oszlopok.Mennyiség() szerint - 1 Ciklus Aktuálisoszlop = Saját TZ.Oszlopok[Act]; Jelentés(Aktuális oszlop.Név); EndCycle;

A képernyőn a következőket fogjuk látni

Teljes név

Szerintem ez a példa egyértelmű volt. Rátértünk a módszerre Mennyiség() oszlopgyűjtemények" MyTZ.Columns.Quantity()", megkapta az oszlopok számát, és elindított egy ciklust egy számlálóval nulla előtt oszlopok száma mínusz egy. A cikluson belül minden oszlopot az oszlopok gyűjteményéből kapunk, és hozzárendeljük az aktuális oszlop objektumát egy változóhoz Aktuális oszlop Ezután a változó Aktuális oszlop bejutunk az ingatlanba Névés jelenítse meg ennek a tulajdonságnak az értékét a képernyőn: Jelentés(Aktuális oszlop.Név);

Fontos, hogy soha ne keverjük össze egy objektum tulajdonságát és az objektum metódusát.

A tulajdonság egy bizonyos statikus érték, és a hozzáférést például zárójelek nélkül írják le CurrentColumn.Name. A metódus lényegében egy objektum eljárása vagy függvénye, és az eljárások és függvények hívásait mindig zárójelben írjuk (még akkor is, ha nincsenek bemeneti paraméterek). Például: MyTZ.Columns.Quantity()

Ha elérünk egy metódust, és elfelejtjük beírni a zárójelet, az 1C interpreter hibaüzenetet ad nekünk, és nem futtatja le a kódot. Mivel az értelmező úgy fogja tekinteni, hogy nem metódushoz, hanem tulajdonsághoz férünk hozzá - mert nincsenek zárójelek. De az ilyen nevű tulajdonságokat nem fogja tudni megtalálni (mert csak ilyen nevű metódus van) - ami a hibaüzenetben fog megjelenni.

Ezt írja a tolmács, ha elfelejtem ilyen helytelenül zárójelet tenni a metódushívásba MyTZ.Oszlopok.Mennyiség(zárójelek nélkül a "Mennyiség()" után):

Az objektummező nem található (mennyiség)

Ebben az esetben a „mező” és a „tulajdonság” szinonimákként vagy az 1C fejlesztők terminológiájának pontatlanságaként értendő. Mindkét szót ugyanarra a fogalomra utalják. Bár más programozási nyelvekben ezek a kifejezések mást jelenthetnek.

Adatok beszerzése az 1C értékek táblázatából oszlopszámok segítségével

Először egy egyszerű példát mutatok be a táblázatunk első sorából származó adatok beszerzésére. Felhívjuk figyelmét, hogy a cikk elejétől előre kitöltött táblázatot használjuk. Biztosan tudjuk, hogy a táblázatnak van egy első sora és legalább egy oszlopa. Ha ezt a példát egy üres táblára alkalmazzuk, hiba lép fel. Így:

FirstLine = SajátTK; // az első sor lekérése (nullától számozva) FirstColumnValue = FirstRow; // az első oszlop értékének lekérése (az oszlopok számozása is a semmiből történik) Report(Value of the First Column); // az első oszlop értékének megjelenítése a táblázat első sorában

A képernyőn megjelenik:

Chapaev

Először egy értéktábla sorobjektumot kaptunk úgy, hogy elértük az értéktáblázatot a [...] operátor használatával. (ha elfelejtette, hogyan kell ezt megtenni, nézze meg a korábbi cikkeket) Az operátoron belül átadtuk a „0” argumentumot. Ez az értéktábla első sorának indexe. FirstLine = SajátTK;

Továbbá jogunk van hozzáférni egy karakterlánc objektumhoz a [...] operátor használatával. Ezen az operátoron belül adtuk át az értéktáblázat oszlopszámát, jelen esetben szintén „0”-t. Így megkaptuk a „0” sorszámú oszlop értékét az aktuális „0” sorszámú táblázathoz. Ezt az értéket megjelenítettük a képernyőn, és ez a „Chapaev” karakterláncot jelenti.

Bonyolítsuk egy kicsit a példánkat:

FirstLine = SajátTK; // az első sor lekérése (nullától számozva) Report(FirstLine); // az első oszlop értékének megjelenítése a tábla első sorában Report(FirstRow); // a második oszlop értékének megjelenítése a tábla első sorában Report(FirstRow); // a harmadik oszlop értékének megjelenítése a táblázat első sorában

Most megjelenítettük az értékeket az értéktáblázatunk első sorának mindhárom oszlopából:

Chapaev Vaszilij Ivanovics

Most ezt a példát is módosítom, hogy a változó nélkül is tudjunk lenni "Első sor"

Jelentés (MyTZ); // az első oszlop értékének megjelenítése a tábla első sorában Report(MyTZ); // a második oszlop értékének megjelenítése a tábla első sorában Report(MyTZ); // a harmadik oszlop értékének megjelenítése a táblázat első sorában

Ugyanez lesz a képernyőn

Chapaev Vaszilij Ivanovics

A fenti példában láttuk, hogy egy értéktáblázat egy adott sorában és oszlopában található érték eléréséhez két operátor egymás utáni meghívását használhatjuk [...] ebben a formában: Értéktábla[Sorindex][Oszlopindex]

Tehát készen állunk egy hurok létrehozására, és megkapjuk az összes sor és oszlop adatait sor- és oszlopindexek segítségével:

For RowCounter = 0 By MyTZ.Quantity() - 1 Loop // ciklus a sorok között For ColumnCounter = 0 By MyTZ.Columns.Quantity() - 1 Loop // beágyazott hurok oszlopokon keresztül // a cellaérték lekérése (az aktuális sorból és az aktuális oszlopok) CellValue = SajátTK[Sorszámláló][Oszlopszámláló]; // megjeleníti a sorszámot, az oszlopszámot és a cellaértéket Report("Sorszám" + Sorszám + "oszlopszám" + Oszlopszám + " = " + CellValue); EndCycle; EndCycle;

A képernyőn a következők jelennek meg:

0. sor 0. oszlop = Csapajev 0. sor 1. számú oszlop = Vaszilij 0. sor 2. számú oszlop = Ivanovics 1. sor 0. sor = Dzerzsinszkij 1. sor 1. oszlop = Félix 1. sor 2. számú oszlop = Edmundovics 2. sor 0. oszlop = Kotovszkij 2. sor 1. oszlop = Grigorij 2. sor 2. oszlop = Ivanovics

Két ciklus segítségével, amelyek közül az egyik a másikba van ágyazva, megjelenítettük az 1C értéktáblázat összes sorából az összes oszlop értékét. Ebben az esetben nem oszlopneveket használtunk, hanem az oszlopokat és a sorokat indexeik alapján értük el. A jobb megértés érdekében ügyeljen a példán belüli megjegyzésekre.

Végezetül azt javaslom, hogy kissé módosítsuk a példánkat, hogy az oszlopszámok helyett a nevüket jelenítse meg a képernyőn. Ezen kívül pedig készítek egy reprezentatívabb dizájnt a tartalom képernyőn való megjelenítéséhez.

For LineCounter = 0 By MyTZ.Quantity() - 1 Loop // ciklus a sorok között Report(" ======= Sorszám " + Vonalszámláló + " ======="); Jelenteni(" "); // soremelés (üres sor beszúrása) For ColumnCounter = 0 By MyTZ.Columns.Quantity() - 1 Loop // beágyazott hurok oszlopokon keresztül // cellaérték lekérése (az aktuális sorból és az aktuális oszlopból) CellValue = MyTZ [RowCounter][ ColumnCounter]; // az oszlop nevének lekérése ColumnName = MyTZ.Columns[ColumnCounter].Name; // az oszlopnév és a cellaérték megjelenítése Report(ColumnName + ": " + CellValue); EndCycle; Jelenteni(" "); // soremelés (üres sor beszúrása) EndCycle;

Most a képernyőn az információ sokkal reprezentatívabbnak tűnt:

0. sor ======= Vezetéknév: Csapajev Keresztnév: Vaszilij Apanév: Ivanovics ======= 1. sor ======= Vezetéknév: Dzerzsinszkij Keresztnév: Felix Apanév: Edmundovics ===== == 2. sor ======= Vezetéknév: Kotovsky Keresztnév: Grigorij Apanév: Ivanovics

Igen, majdnem elfelejtettem. Ha két [...][...] operátort használunk egy sorban, oszlopindex helyett ennek az oszlopnak a nevét is átadhatjuk: Értéktábla[SorIndex][Oszlopnév]

Ügyeljen a nyíllal jelölt sorra ". Ebben a sorban az aktuális oszlop indexe helyett az aktuális oszlop nevét adjuk át a szögletes zárójelben lévő argumentumnak [...] Az eredmény ugyanaz lesz.

És most az utolsó dolog ebben a cikkben.

Minden adat HELYES beszerzése az 1C értéktáblázatból hurkok segítségével sorok és oszlopok gyűjteményén keresztül

A MyTZ Loop egyes aktuális soraihoz // ciklus sztringek gyűjteményén keresztül Report(" ======= Sorszám " + MyTZ.Index(CurrentLine) + " ======="); Jelenteni(" "); Minden egyes aktuális oszlophoz a MyTZ.Columns ciklusból // beágyazott ciklus, amely oszlopok gyűjteményén keresztül iterál ColumnName = CurrentColumn.Name; // az oszlopnévCellÉrték lekérése = AktuálisSor[Oszlopnév]; // a cella értékének lekérése BY oszlop NAME Report(ColumnName + ": " + CellValue); // az oszlopnév és a cellaérték megjelenítése Ciklus vége; Jelenteni(" "); EndCycle;

A példában két hurkot használtunk. Az oszlopok gyűjteményén keresztül történő hurkoláshoz egy hurok van beágyazva a sorokon való áthurkoláshoz. Ha végigdolgozta a fenti példákat, és elolvasta a korábbi cikkeket, akkor nem lesz nehéz megértenie a példa működését.

Végül az utolsó példánkban szereplő kódsorok számát a lehető legnagyobb mértékben csökkenteni fogom a közbenső változók használatának megszüntetésével. Kapunk egy mintát az "ipari kódból", amelyet valós problémák esetén használnak.

Ezt csak akkor szabad megtenni, ha jól érti, mit csinál. Ha a kód nagyon összetett, akkor elfogadható a közbenső változók meghagyása, hogy később könnyebben megértse a saját kódját. Valamint minden kódot legalább minimálisan kommentálni kell, hogy egy idő után könnyebben érthető legyen a programszöveg.

Minden egyes aktuális sorhoz a MyTZ ciklusból // sorok közötti iteráció Report(" ======= Sorszám " + MyTZ.Index(CurrentLine) + " =======" + Symbols.PS); Minden aktuális oszlophoz a MyTZ.Columns ciklusból // iterálás oszlopok között Report(AktuálisOszlop.Név + ": " + AktuálisSor[AktuálisOszlop.Név]); EndCycle; Jelenteni(" "); EndCycle;

A képernyőn megjelenő kimenet nem változott, ugyanaz marad, mint az előző példában:

2 HETES TANFOLYAM

"PROGRAMOZÁS 1C-BEN KEZDŐKNEK"

A tanfolyamot e-mailben küldjük el. Legyen programozó lépésről lépésre végrehajtott feladatok végrehajtásával.

A részvételhez csak számítógép és internet szükséges

Ingyenes belépés a tanfolyamra:

Sp-force-hide ( display: none;).sp-form ( display: block; background: #eff2f4; padding: 5px; szélesség: 270px; max-width: 100%; border-radius: 0px; -moz-border -radius: 0px; -webkit-border-radius: 0px; font-family: Arial, "Helvetica Neue", sans-serif; background-repeat: no-repeat; background-position: center; background-size: auto;) .sp-form bemenet ( kijelző: inline-block; átlátszatlanság: 1; láthatóság: látható;).sp-form .sp-form-fields-wrapper ( margó: 0 auto; szélesség: 260px;).sp-form .sp -form-control ( háttér: #ffffff; keretszín: #cccccc; keret stílusa: tömör; keret szélessége: 1 képpont; betűméret: 15 képpont; bal oldali padding: 8,75 képpont; jobb oldali padding: 8,75 képpont; szegély -sugár: 4px; -moz-border-radius: 4px; -webkit-border-radius: 4px; magasság: 35px; szélesség: 100%;).sp-form .sp-field label ( szín: #444444; font- méret: 13px; betűstílus: normál; font súlya: félkövér;).sp-form .sp-button ( border-radius: 4px; -moz-border-radius: 4px; -webkit-border-radius: 4px; háttérszín: #f4394c; szín: #ffffff; szélesség: 100%; betűsúly: 700; betűstílus: normál; font-család: Arial, "Helvetica Neue", sans-serif; doboz-árnyék: nincs; -moz-box-shadow: nincs; -webkit-box-shadow: nincs; háttér: linear-gradient(to top, #e30d22 , #f77380);).sp-form .sp-button-container ( szövegigazítás: középre; szélesség: automatikus;)

(Ez a cikk az 1C a semmiből; az 1C programozás a semmiből; az 1C értékek táblázata cikksorozathoz tartozik)

Virtuális adattárolási struktúra táblázatos formában – ez az

Az értéktáblázat nem az 1C adatbázis állandó objektuma, és nem kerül mentésre az indítási munkamenetek között.

Értéktáblázat 1C(TK) „menet közben” jön létre programkód segítségével, majd a vele végzett munka ugyanúgy történik, mint az 1C programozási nyelv bármely más programobjektumával. Metódushívások használata és egy táblaobjektum tulajdonságainak elérése.

Vagyis a programozó létrehoz egy táblázatot a memóriában, kitölti adatokkal, dolgozik vele, rendez, csoportosít, összesítést számol stb. Megkapja a további felhasználáshoz szükséges adatokat.

Készítsünk egy értéktáblázatot, és töltsük fel valamivel. Emlékeztetni kell arra, hogy az 1C értékek táblázata nem csak manuálisan, az operátor hívásával hozható létre

NewValueTable;

Az értéktáblázat gyakran egy másik objektum metódushívásának eredménye, például előfordulhat, hogy egy lekérdezés eredménye egy értéktáblázatba kerül, és így tovább.

Hadd mondjak rögtön egy egyszerű példát.

// MyTZ = Új értéktábla; // hozzon létre egy új, a "MyTZ" változóban tárolt értéktáblázatot MyTK. Oszlopok. Add("Vezetéknév" ) ; // hozza létre a "Vezetéknév" oszlopot MyTZ. Oszlopok. Add("Név"); // hozza létre a "Név" oszlopot Jelentés (MyTZ); // megjeleníti a MyTZ változó értékét //

Létrehoztam egy táblázatot az 1C értékekből, két oszloppal: „Vezetéknév”, „Keresztnév”. Eljárás Jelentés (MyTK) megjeleníti a változó típusát az üzenetablakban MyTZ: Értéktáblázat

Értéktáblázatunk egyelőre üres. Adjunk hozzá pár sort, kereszt- és vezetéknévvel.

// töltse ki az értéktáblázatot // hozzáadjuk az első sort az értéktáblázatunkhoz NewLine = MyTZ. Add() ; Új sor. Vezetéknév = "Sidorov" ; Új sor. Név = "Vasya" ; // adjunk hozzá egy második sort az értéktáblázatunkhoz NewLine = MyTZ. Add() ; Új sor. Vezetéknév = "Ivanov" ; Új sor. Név = "Péter" ;

Ilyen táblázatot kaptunk:

Emlékezni kell: A sorszámok az értéktáblázatban nullától kezdődnek

Miért van szükségünk sorszámokra? És hogy például az értéktáblázat egy külön sorát elérhessük, vegyük és jelenítsük meg ezt a sort a képernyőn.

// *** a nulla vonal értékeinek megjelenítése a képernyőn *** (a mindennapi életben általában egytől kezdődően számozzuk a dolgokat, de itt - nullától) // a szögletes zárójelben lévő sorindex segítségével kapjuk meg a táblázatunk nulla sorát OurNullString = MyTZ[ 0] ; // most a teljes nulla karakterlánc az "OurFirstLine" változóban van Jelentés(OurNullString.LastName) ; // a nulladik sorban tárolt "Vezetéknév" oszlop értékének megjelenítése Jelentés (OurNullString.Name) ; // a "Név" oszlop értékének megjelenítése ugyanabból a sorból

Ennek eredményeként a képernyőn megjelenik:

Sidorov Vasya

Most a nagyon okosak és tömörek kedvéért mutatok egy példát, amely lehetővé teszi egy ilyen és egy sorban lévő oszlop értékének elérését (Az ilyen és ilyen sorban lévő oszlop értéke az értéktáblázat egyik cellája Nem hivatalos kifejezés, de kényelmes). De anélkül, hogy olyan köztes változót használnánk, mint az "OurZeroString".

A cellák értékeinek megjelenítése a második sorból (ne felejtse el, hogy a sor a második, de ennek a sornak az indexe egy, tehát a számozás nulláról kezdődik)

Végül az utolsó pont ebben a cikkben. Mutattam egy példát egy értéktábla egyetlen sorának index (sorszám) alapján történő elérésére. A cella tartalmának beolvasásának vagy hozzárendelésének univerzális formája a következő: "SajátÉrtéktáblázat[Sorszám].Oszlopnév"

Most adok egy ciklust az értéktáblázat tartalmának teljes kimenetére. Részletes magyarázatok nélkül, hogy te is törhesd az agyad :)

// // átfutja és megjeleníti az értéktáblázatunk összes sorát// For LineNumber = 0 a MyTZ szerint. Mennyiség() - 1 Ciklusjelentés (MyTZ[Sorszám] . Vezetéknév) ; // megjeleníti a "Vezetéknév" oszlop értékét Jelentés (SajátTK[Vonalszám] . Név) ; // megjeleníti a "Név" oszlop értékét EndCycle ;

A ciklus futtatásának eredményeként a következő jelenik meg a képernyőn:

Sidorov Vasya Ivanov Petya

Itt elmondtam az 1C értéktáblázattal való munka alapjait. Ez az információ az 1C 8.0, 8.1, 8.2 verziókra vonatkozik. Az „1C value table” objektum érdekes részletei ezzel nem érnek véget. Ez az objektum hatalmas képességekkel rendelkezik az adatok kényelmes használatához. Erről fogok beszélni a következő cikkekben.

Degtyarev római.

Hogyan lehet megtanulni a nulláról programozni 1C-ben?

Hogyan dolgozhat 1C programozóként és kereshet akár 150 000 rubelt havonta?

REGISZTRÁLJ INGYEN

2 HETES TANFOLYAM

"PROGRAMOZÁS 1C-BEN KEZDŐKNEK"

A tanfolyamot e-mailben küldjük el. Legyen programozó lépésről lépésre végrehajtott feladatok végrehajtásával.

A részvételhez csak számítógép és internet szükséges

Ingyenes belépés a tanfolyamra:

Üdvözlöm az infostart minden olvasóját. Ez a cikk egy tetszőleges értéktáblázat létrehozásának kérdésével foglalkozik egy felügyelt alkalmazás formájában, programozottan.

A feladat jellemzői.

Bárki, aki egy normál alkalmazásban programozott, gyakran szembesült azzal a feladattal, hogy tetszőleges értéktáblázatot kapjon egy űrlapon. A tetszőleges értéktáblázat olyan táblázat, amelynek oszlopainak száma és típusa nem ismert előre. Vagyis lehet 3 oszlop, esetleg 6, esetleg 8. Egy normál alkalmazásban minden egyszerű: elhelyezheti az „Értéktáblázat” elemet a feldolgozó űrlapon, majd átviheti a létrehozott értéktáblázatot ehhez az elemhez programozottan. Ezután egy egyszerű paranccsal:

Form Elements.TableField.CreateColumns();

kap egy kész értéktáblázatot az űrlapon. Úgy tűnik, lehetne egyszerűbb is.

Ez mind benne volt a normál alkalmazásban. Egy felügyelt alkalmazásban minden megváltozott. Nem olyan egyszerű tetszőleges táblázatot létrehozni. Most vagy mereven paramétereznie kell az értéktáblázatot az űrlapon, vagy programozottan létre kell hoznia (leírja, nos, ez valójában magának a felügyelt alkalmazásnak a lényege). Ezt próbáljuk megtenni: programozottan létrehozni egy tetszőleges értéktáblázatot egy ellenőrzött űrlapon.

A probléma megoldása.

Az első dolog, amit meg kell tennünk, hogy meghatározzuk, hogyan fog megjelenni a táblázat az űrlapon. A lényeg az, hogy a feldolgozás során ne kelljen űrlapelemet létrehoznia. A teljes táblázathoz hasonlóan programozottan hozzuk létre. Vagyis a táblázat leírása és létrehozása az űrlap megnyitásának pillanatában vagy egy gomb segítségével történik - attól függően, hogy kinek van rá szüksége.

A táblázat létrehozása az űrlapon az értéktábla attribútumként való leírásán keresztül történik:
SelectionTypeArray = Új tömb; SelectionType tömbje.Add(Type("Értéktábla")); ChoiceTypeDescription = Új típusleírás(ChoiceTypeArray); Részletek tömbje = New Array; Attribútumok tömbje.Add(New Form Attributes("Ütemezési táblázat", SelectionType leírása, "", "TZN")); Most létre kell hoznunk egy programérték táblát, amely tartalmazza az adatokat. Ha az értéktáblázatot egy lekérdezésből kapjuk, akkor többé-kevésbé minden rendben van. Ha a táblázatot manuálisan hozzuk létre, akkor a „Típusok leírása” segítségével létrehozható a számokat vagy dátumokat tartalmazó oszlopok jelentése. A lényeg az, hogy az értéktáblázat oszlopainak valamilyen típusúnak kell lenniük. Ha például elvárható, hogy a felhasználó interaktív módon töltse ki az adatokat ezekbe az oszlopokba, akkor az értéktáblázat oszlopát nem lehet egyszerűen névvel hozzáadni, annak típusnak kell lennie. Ne feledje – ez nagyon fontos, mert... Ezeket a típusokat átvisszük az űrlapon lévő táblázatba.
Létrehozunk egy táblázatot, amely több oszlopot tartalmaz:
CD = NewDateQalifiers(DateParts.Time); ArrayKD = új tömb; ArrayCD.Add(Típus("Dátum")); DescriptionTypesTime = Új leírástípusok(ArrayCD,CD); TZ = Új értéktábla;
TK.Columns.Add("With", DescriptionTypesTime);
TK.Columns.Add("Before", DescriptionTypesTime);
TK.Columns.Add("Név");
TK.Columns.Add("Note"); // Teljes név és Megjegyzés - sorok Ezután a TK programtáblázatunkat töltjük ki a szükséges adatokkal. Kapunk egy TK táblát, amely tartalmazza a szükséges értékeket, és készen áll a létrehozott form attribútumba való átvitelre. A TK minden oszlopához. Oszlopok ciklusa

Attribútumok tömbje.Add(New Form Attributes(Oszlop.Név, Oszlop.Értéktípus,"Ütemezési táblázat"));

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

Ez egy egyszerű kombináció, és kész is az asztalunk.

A TK minden oszlopához. Oszlopok ciklusa

NewElement = Elemek.Hozzáadás(Oszlop.Név, Típus("Űrlapmező"), SelectionFieldTable);
NewElement.View = FormFieldView.InputField;
NewElement.DataPath = "Ütemezési táblázat." + Oszlopnév;
ÚjElem.Szélesség = 10;

EndCycle;

Feltételes kialakítás, ha kell, manuálisan is írjuk, a parancsmenü - manuálisan. A táblázatkezelőket is kézzel írják. Például eseménykezelő hozzáadásához a „Kiválasztás” táblázathoz:

SelectionFields táblázat.SetAction("Kiválasztás","TZNSelection");

Ennek az eseménynek a feldolgozásához külön eljárást írnak elő eljárás formájában:

&OnClient
Eljárás TKNSelection (TK, Selected Row, Field, Standard Processing)
//kezelő parancsok EndProcedure

Ne feledje, hogy a táblakezelők aktiválják a klienst, ezért rendelkezniük kell egy fordítómutató-parancskal

&OnClient

Nos, az utolsó dolog, amit hozzá akartam tenni, az az, hogy mindezen lépések után ne felejtse el átadni a kész táblázatot a form attribútumnak:

ValueВFormAttributes(ToR, "ScheduleTable");

Eredményünk a következő:

És itt van a "Kiválasztás" esemény kezelése:

Utószó.

Remélem, hogy a cikk segít azoknak az 1C programozóknak, akik elkezdenek programozottan táblákat létrehozni egy űrlapon.

Letölthet egy feldolgozást, amely programozottan létrehoz egy értéktáblázatot, és megjeleníti azt egy kezelhető űrlapon megjegyzésekkel, amelyek segítenek a saját táblázatok létrehozásában.

A pénz és az áruk elszámolására különféle táblázatokat széles körben használnak az üzleti életben. Szinte minden dokumentum egy táblázat.

Az egyik táblázat felsorolja a raktárból kiszállítandó árukat. Egy másik táblázat az ezen áruk fizetési kötelezettségeit mutatja.

Ezért az 1C-ben az asztalokkal való munka előkelő helyet foglal el.

Az 1C táblázatait „táblázatos részeknek” is nevezik. A címtárak, dokumentumok és egyebek rendelkeznek velük.

A lekérdezés végrehajtásakor egy táblát ad vissza, amely két különböző módon érhető el.

Az első - gyorsabb - kijelölés, sorok beszerzése belőle csak sorrendben lehetséges. A második a lekérdezés eredményének feltöltése egy értéktáblázatba, majd véletlenszerű hozzáférés hozzá.

//1. lehetőség – szekvenciális hozzáférés a lekérdezések eredményeihez

//szerezd meg az asztalt
Select = Query.Run().Select();
// sorrendben végigmegyünk a lekérdezés eredményének minden során
Míg Select.Next() Loop
Jelentés(Kiválasztás.Név);
EndCycle;

//2. lehetőség – feltöltés értéktáblázatba
Request = New Request("SELECT Name FROM Directory.Nomenclature");
//szerezd meg az asztalt
Table = Query.Run().Unload().
//továbbá az összes sort is iterálhatjuk
A táblázatciklus minden sorához
Report(String.Name);
EndCycle;
//vagy tetszőlegesen hozzáférhet a karakterláncokhoz
Row = Table.Find("Shovel", "Name");

Fontos jellemzője, hogy a lekérdezés eredményeként kapott táblázatban minden oszlop szigorúan be van írva. Ez azt jelenti, hogy a Név mező lekérésével a Nomenclature könyvtárból egy String típusú oszlopot kap, amelynek megengedett hossza legfeljebb N karakter.

Táblázat az űrlapon (vastag kliens)

A felhasználó akkor dolgozik a táblázattal, amikor az az űrlapon van.

A leckében és a leckében megbeszéltük a formákkal való munka alapelveit

Tehát helyezzük el a táblázatot az űrlapon. Ehhez húzza a táblázatot a Vezérlőpultról. Hasonlóképpen kiválaszthatja a Form/Insert Control menüpontot a menüből.

Az adatok a konfigurációban tárolhatók - ekkor ki kell választani a konfigurációs objektum meglévő (korábban hozzáadott) táblázatos részét, amelynek űrlapját szerkeszti.

Kattintson a "..." gombra az Adat tulajdonságban. A táblázatos részek listájának megtekintéséhez ki kell bontani az Objektum ágat.

Amikor kiválasztja a táblázatos részt, az 1C maga is hozzáad oszlopokat az űrlapon lévő táblázathoz. A felhasználó által egy ilyen táblázatba beírt sorok automatikusan mentésre kerülnek a referenciakönyvvel/dokumentummal együtt.

Ugyanabban az Adat tulajdonságban megadhat egy tetszőleges nevet, és kiválaszthatja az Értéktábla típusát.

Ez azt jelenti, hogy egy tetszőleges értéktáblázat került kiválasztásra. Nem ad hozzá automatikusan oszlopokat, és nem is menti automatikusan, de bármit megtehetsz vele.

A táblázatra jobb gombbal kattintva hozzáadhat egy oszlopot. Egy oszlop tulajdonságainál megadhatjuk a nevét (az 1C kódban való hivatkozáshoz), az űrlapon lévő oszlopfejlécet, a kapcsolatot a táblázatos rész attribútumával (utóbbi - ha nem tetszőleges táblázat van kiválasztva, hanem egy táblázatos rész).

Az űrlapon a táblázat tulajdonságainál megadhatja, hogy a felhasználó hozzáadhat-e/törölhet-e sorokat. Egy fejlettebb űrlap a Csak megtekintése jelölőnégyzet. Ezek a tulajdonságok kényelmesek az információk megjelenítésére, de nem szerkesztésére szolgáló táblázatok rendszerezésére.

A táblázat kezeléséhez meg kell jelenítenie egy parancspanelt az űrlapon. Válassza ki a Form/Insert Control/Command Bar menüpontot.

A parancssor tulajdonságainál jelölje be az Automatikus kitöltés jelölőnégyzetet, hogy a panelen lévő gombok automatikusan megjelenjenek.

Táblázat az űrlapon (vékony/felügyelt kliens)

A kezelt űrlapon ezek a műveletek kicsit másképp néznek ki. Ha táblázatos részt kell elhelyeznie az űrlapon, bontsa ki az Objektum ágat, és húzza balra az egyik táblázatos részt. Ez minden!

Ha értéktáblázatot kell elhelyeznie, adjon hozzá egy új űrlapattribútumot, és annak tulajdonságaiban adja meg a típust – értéktábla.

Oszlopok hozzáadásához kattintson a jobb gombbal az űrlapattribútumra, és válassza az Attribútumoszlop hozzáadása lehetőséget.

Ezután húzza a táblázatot is balra.

Annak érdekében, hogy egy táblának legyen parancssora, a táblázat tulajdonságainál válassza ki az értékeket a Használat – Parancssor pozíció szakaszban.

Táblázat feltöltése Excelbe

Az űrlapon található bármely 1C táblázat kinyomtatható vagy feltölthető Excelbe.

Ehhez kattintson a jobb gombbal egy üres helyre a táblázatban, és válassza a Lista menüpontot.

Felügyelt (vékony) kliensben a Minden művelet/Megjelenítési lista menüpont segítségével hasonló műveletek hajthatók végre.

Kérdés Különféle típusú értékek táblázatoszlopának létrehozása az 1C v8-ban
VálaszÉrtéktábla oszlopának létrehozásakor átadhatja típusok tömbje, és talán egy adott típus. Típustömböt használunk, ha egy oszlophoz több különböző típust kell megadni.

A típusok jelzésére szolgál "általános objektum" - "Típusok leírása". Ezért először elmagyarázzuk, mi az a „Típusok leírása” („Értéktípusok leírása”).

"Értéktípusok leírása". A rendszerben lévő különféle objektumok tulajdonságértékeinek elfogadható típusainak leírására egy speciális objektumot használnak "Típusok leírása". Ezzel az objektummal leírhatja az érvényes értéktípusokat, amelyek a tulajdonságokhoz rendelhetők. A Number, String és Date primitív típusok lehetséges értékeinek további korlátozása érdekében rendelkezésre állnak minősítők. A minősítők olyan paramétereket írnak le, mint például egy karakterlánc vagy szám hossza, egy dátum érvényes részei stb.

A „Típusleírás” metódus szintaxisa

New DescriptionTypes(<Исходное описание типов>, <Добавляемые типы>, <Вычитаемые типы>, <Квалификаторы числа>, <Квалификаторы строки>, <Квалификаторы даты>)
Lehetőségek:
<Исходное описание типов> (választható)
Típus: LeírásTípusok. A típusok kezdeti leírása, amely alapján újat építenek.
<Добавляемые типы> (választható)
Típus: Array, String. Típusértékek tömbje A Típus, amely az objektumban használt típusokból áll, vagy egy karakterlánc, amely a típusok neveit vesszővel elválasztva tartalmazza.
<Вычитаемые типы> (választható)
Típus: Array, String. Típusértékek tömbje (vagy vesszővel elválasztott típusneveket tartalmazó karakterlánc), amely az első paraméterben megadott kezdeti deklarációból kizárt típusokból áll.
<Квалификаторы числа> (választható)
Típus: QualifiersNumbs. Számminősítők, amelyek egy numerikus típusú érvényes értékeket írnak le.
<Квалификаторы строки> (választható)
Típus: QualifiersStrings. Karakterlánc-minősítők, amelyek egy karakterlánctípus érvényes értékeit írják le.
<Квалификаторы даты> (választható)
Típus: QualifiersDates. Dátumminősítők, amelyek a Dátum típus érvényes értékeit írják le.
Leírás:
Típusleírást hoz létre egy másik típusleírás alapján, egyes típusok hozzáadásával és mások kizárásával. Ha nem adunk meg új minősítőt, akkor az eredeti típusnyilatkozat minősítői megmaradnak.
Példa a „Típusleírás” objektum használatára:

// bővítse ki az Érvényes típusok leírását új típusokkal Array = Új tömb; Sor. Add(Típus( "Referencia hivatkozás. Módszerek")); Sor. Add(Típus("Szám" )); Sign = ValidSign. Nem negatív; QuSzámok = Új minősítőkSzámok(10, 2, jel); ValidTypes = ÚjTípusLeírás(ÉrvényesTípusok, Tömb, KvSzámok);

Valójában példák a különböző típusú oszlopértékek helyes létrehozására egy táblázatban.

Általában elegendő az oszloptípusokat a következőképpen meghatározni:

TK. Oszlopok. Add( "Rendezési index", Új leírásTípusok ( "Szám" ) ); TK. Oszlopok. Add("Szakasznév", New TypeDescription("String" ) ) ; TK. Oszlopok. Add("DataCorr" , New TypeDescription("Dátum" ) ) ; TK. Oszlopok. Add( "Feltétel nélküli törlés", New TypeDescription("Logiai")); TK. Oszlopok. Add("Nómenklatúra" , New TypeDescription() ) ; TK. Oszlopok. Add("SectionData" , New TypeDescription("Struktúra")) ; // példa a "szám" és "karakterlánc" oszlopok létrehozására a paraméterek pontosításával: TK. Oszlopok. Add( "Teljesített százalék", Új leírástípusok ( "Szám" , Új minősítőszámok ( 18 , 2 ) ) ); TK. Oszlopok. Add("Szakasznév" , NewTypeDescription("String" , , NewStringQualifers(200, AllowedLength. Variable) ) ); TK. Oszlopok. Add("DecommissionedDate" , NewTypeDescription("Dátum" , , , NewDateQualifers(DateParts.DateTime) ) );

Általánosságban azonban egy tömb kerül átadásra oszloptípusként. Tömböt használunk, ha több típust kell hozzárendelni egy oszlophoz. Ekkor a szerkezet definíciója valami ilyesmi lesz (példákat adunk különböző típusú oszlopokra, amikor a típus egy tömb, de az egyszerűség kedvéért a tömb összetétele azonos típusú, hogy ne keveredjünk össze )

////// a műszaki leírás szerkezetének kialakítása (oszlopok létrehozása) //// helyettesíthető minősítők meghatározása a műszaki specifikáció minősítő mezőiben CN = Új minősítőszámok(18, 9); KS = NewStringQalifiers(200); CD = NewDateQalifiers(DataParts.DateTime) ; //// típusleírások meghatározása a jövőbeli TK oszlopokhoz // A tömb a típusok kezdeti leírása, amely alapján újat építenek // Kérjük, vegye figyelembe, hogy a TK oszlopok esetében a kezdeti típusleírás ebben a példában egy tömb Array = Új tömb; Sor. Add(Típus("String") ) ; TypeDescriptionString = Új típusleírás(Array, , KS) ; Sor. Egyértelmű() ; Sor. Add(Típus("Szám") ) ; TypeDescriptionNumber = Új típusleírás(Tömb, , , CN) ; Sor. Egyértelmű() ; Sor. Add(Típus("Dátum") ) ; DescriptionTypesDate = Új leírásTípusok(Array, , , , CD) ; Sor. Egyértelmű() ; Sor. Add(Típus( "DirectoryLink.Nómenklatúra") ) ; Type DescriptionNomenclature = Új típusleírás (Tömb) ; Sor. Egyértelmű() ; Sor. Add(Típus( "DirectoryLink.SeriesNomenclature") ) ; TypeDescriptionSeries = Új TypeDescription(Array) ; Sor. Egyértelmű() ; Sor. Add(Típus( "DirectoryLink.Quality") ) ; TypeDescriptionQuality = Új TypeDescription(Array) ; Sor. Egyértelmű() ; Sor. Add(Típus("Logiai") ) ; TypeDescriptionBoolean = Új TypeDescription(Array) ; // ténylegesen oszlopok hozzáadása a TK-hoz (a jövőbeli TK szerkezetének létrehozása) TK. Oszlopok. Add("Nómenklatúra", LeírásTípusokNómenklatúra) ; TK. Oszlopok. Add("Kód" , TypeDescriptionString) ; TK. Oszlopok. Add( "Sorozatnómenklatúra", DescriptionTypesSeries); TK. Oszlopok. Add("AccountCode" , Type DescriptionString) ; TK. Oszlopok. Add("ActionDate" , TypeDescriptionDate) ; TK. Oszlopok. Add("Minőség" , TypeDescriptionQuality) ; TK. Oszlopok. Add("SzámUS", LeírásTípusokSzám) ; TK. Oszlopok. Add("Leírás" , TypeDescriptionBoolean) ; . . . //////// a műszaki leírás szerkezetének kialakítása (oszlopok létrehozása) ////////////////////////////////////////////////////////

Egy sor értéktáblázathoz való hozzáadásához lásd: