bahay Mga editor

1c paglikha ng isang talahanayan ng mga halaga. Anong mga pamamaraan ang umiiral at kung paano maghanap ng maraming mga halaga nang sabay-sabay

Na-publish noong Setyembre 21, 2011

Talaan ng mga halaga 1C - bahagi 3. Metadata. Pag-looping sa mga column ng talahanayan ng halaga

Sa artikulong ito sasabihin ko sa iyo kung paano magtrabaho sa isang talahanayan ng mga halaga ng isang "hindi kilalang" istraktura, kung paano umulit sa mga haligi ng isang talahanayan ng mga halaga, kung paano kunin ang data mula sa mga haligi at hilera nang hindi gumagamit ng mga pangalan ng haligi. (Ang artikulong ito ay kabilang sa serye ng mga artikulo 1C mula sa simula; programming 1C mula sa simula; talahanayan ng mga 1C na halaga)

Upang ipaliwanag ang materyal at upang mapatakbo ang aming mga halimbawa ng code na "live", kailangan namin ng ilan pagsubok ng talahanayan ng mga halaga 1C. Ang ilan sa aming mga halimbawa ay kukuha ng data mula sa isang talahanayan ng mga halaga, kaya gagawa kami ng isang talahanayan na may tatlong column na "Apelyido", "Unang pangalan", "Middle name" at maglalagay ng maliit na halaga ng data dito - kasing dami ng 3 mga hilera :)

Kaya, lumikha tayo ng isang talahanayan ng pagsubok ng mga halaga ng 1C at punan ito:

MyTZ = Bagong ValueTable; // lumikha ng isang bagong talahanayan ng mga halaga na nakaimbak sa variable na "MyTZ" MyTZ.Columns.Add("Last Name"); // create the column "Last Name" MyTK.Columns.Add("Name"); // create the column "Pangalan" MyTZ.Columns.Add("Patronymic"); // lumikha ng column na "Middle name" // idagdag ang unang hilera sa aming talahanayan ng mga halaga NewLine = MyTZ.Add(); NewString.LastName = "Chapaev"; NewLine.Name = "Vasily"; NewString.Middle name = "Ivanovich"; // idagdag ang pangalawang linya NewLine = MyTZ.Add(); NewString.LastName = "Dzerzhinsky"; NewRow.Name = "Felix"; NewString.Middle name = "Edmundovich"; // idagdag ang ikatlong linya NewLine = MyTZ.Add(); NewLine.LastName = "Kotovsky"; NewLine.Name = "Gregory"; NewString.Middle name = "Ivanovich";

Ang aming test table ay binubuo ng tatlong column: First Name, Last Name, Patronymic; at may tatlong punong linya na may mga pangalan ng mga bayani sa Digmaang Sibil.

Ang unang sample ng code ay binibilang ang mga column ng isang 1C value table bilang isang koleksyon.

// ipakita ang mga pangalan ng lahat ng column ng TK Para sa Bawat Column Mula sa MyTZ.Columns Cycle Report("Column name: " + Column.Name); EndCycle;

Ipapakita ng aming cycle ang lahat ng pangalan ng column sa 1C message window:

Pangalan ng column: Apelyido Pangalan ng column: Pangalan Pangalan ng column: Gitnang pangalan

Nakikita namin na para umulit sa mga column, ginagamit ang isang espesyal na ikot ng pag-ulit ng koleksyon, katulad ng ikot ng pag-ulit ng hilera (sa nakaraang artikulo). MyTK.Mga Hanay- ito ay isang koleksyon ng mga column ng 1C value table "MyTZ". Ang koleksyon ay naglalaman ng mga bagay ng uri "Haligi ng Talahanayan ng Halaga" Ang bawat bagay ng ganitong uri ay isang column ng talahanayan ng halaga at naglalaman ng mga katangian at pamamaraan. Sa pamamagitan ng pag-access sa mga katangian at pamamaraang ito, nakukuha namin ang kinakailangang impormasyon tungkol sa isang column o nagsasagawa kami ng ilang iba pang pagkilos dito.

Halimbawa, ang pag-access sa ari-arian "Pangalan" (Hanay.Pangalan) nakukuha natin ang pangalan ng kasalukuyang column.

Nais kong ituon ang iyong pansin sa pamagat ng serye: “Para sa Lahat Kolum Mula sa MyTZ.Column Cycle" Variable na may pangalan "Haligi" inimbento natin. Hindi kinakailangang gumamit ng parehong pangalan. Maaari mong tawagan ang variable na ito kahit anong gusto mo, halimbawa "MyCurrentColumn" Pagkatapos ang halimbawa sa itaas ay magiging ganito:

// ipakita ang mga pangalan ng lahat ng column ng TK Para sa Bawat MyCurrentColumn Mula sa MyTK.Columns Cycle Report("Column name: " + MyCurrentColumn.Name); EndCycle;

Kapag ang 1C execution subsystem ay nakatagpo ng isang cycle ng ganitong uri, sa bawat pass ng cycle ay itinatalaga nito sa isang variable na may tinukoy na pangalan isang elemento mula sa aming koleksyon, sa kasong ito - isang elemento ng koleksyon mga hanay ng talahanayan ng halaga MyTK.Mga Hanay At pagkatapos ay ina-access namin ang variable na naglalaman ng kasalukuyang column at ginagamit ang property "Pangalan".

Iminumungkahi kong ipakita sa tabi ng pangalan ng column ang numero ng bawat column sa koleksyon ng mga column:

// ipakita ang numero at pangalan ng lahat ng column ng table of values Para sa Bawat Column Mula sa MyTZ.Columns Cycle ColumnNumber = MyTZ.Columns.Index(Column); // kunin ang column number ColumnName = Column.Name; // get the column name Report("Column Number:" + Column Number + " Column Name: " + Column Name); EndCycle;

Ang sumusunod na teksto ay ipapakita sa 1C message window:

Numero ng column:0 Pangalan ng column: Apelyido Numero ng column:1 Pangalan ng column: Unang pangalan Numero ng column:2 Pangalan ng column: Middle name

Pakitandaan na ang mga column sa 1C value table ay binibilang simula sa zero, tulad ng mga row ng value table.

Bilang ng mga column sa 1C value table

Upang malaman ang bilang ng mga column sa talahanayan ng mga halaga, ginagamit namin ang "Count()" na paraan sa koleksyon ng mga column.

Bilang ng Mga Haligi = MyTZ.Columns.Quantity(); Ulat(Bilang ng Mga Haligi);

Ang numerong "3" ay ipapakita sa screen. Sa katunayan, ang aming talahanayan ay may tatlong column: "Apelyido", "Unang pangalan", "Patronymic"

Pagkuha ng column object sa pamamagitan ng numero nito (index) at enumerating column gamit ang column index

Gumawa tayo ng cycle ng paghahanap sa lahat ng column ng value table gamit ang column index (numbers). Tandaan na ang column numbering ay nagsisimula sa zero. Samakatuwid, dapat nating taasan ang cycle counter na "Sch" mula sa zero hanggang sa isang numero na katumbas ng bilang ng mga column na minus one.

Para sa Account = 0 Ni MyTZ.Columns.Quantity() - 1 Cycle CurrentColumn = MyTZ.Columns[Act]; Ulat(CurrentColumn.Name); EndCycle;

Sa screen ay makukuha natin ang sumusunod

Buong pangalan

Sa tingin ko ang halimbawang ito ay malinaw. Bumaling kami sa pamamaraan Dami() mga koleksyon ng hanay" MyTZ.Columns.Quantity()", nakuha ang bilang ng mga column, at nagsimula ng loop na may counter mula sa sero dati bilang ng mga column minus one. Sa loob ng loop ay nakukuha namin ang bawat column mula sa koleksyon ng mga column at itinalaga ang kasalukuyang column object sa isang variable CurrentColumn Susunod, ang variable CurrentColumn ina-access namin ang property Pangalan at ipakita ang halaga ng property na ito sa screen: Ulat(CurrentColumn.Name);

Mahalagang huwag malito ang pag-aari ng isang bagay at pamamaraan ng isang bagay.

Ang isang property ay isang tiyak na static na halaga at ang pag-access dito ay nakasulat nang walang panaklong, halimbawa CurrentColumn.Pangalan. Ang isang pamamaraan ay mahalagang pamamaraan o function ng isang bagay, at ang mga tawag sa mga pamamaraan at function ay palaging isinusulat gamit ang mga panaklong (kahit na walang mga parameter ng input). Halimbawa: MyTZ.Columns.Quantity()

Kung nag-access kami ng isang paraan at nakalimutan naming isulat ang mga panaklong, bibigyan kami ng 1C interpreter ng mensahe ng error at hindi tatakbo ang code. Dahil isasaalang-alang ng interpreter na hindi namin ina-access ang isang paraan, ngunit isang pag-aari - dahil walang mga panaklong. Ngunit hindi ito makakahanap ng mga pag-aari na may ganoong pangalan (dahil mayroon lamang isang pamamaraan na may pangalang iyon) - na ilalahad sa mensahe ng error.

Ito ang isusulat ng interpreter kung nakalimutan kong maglagay ng mga panaklong sa isang method call sa hindi tamang paraan MyTZ.Columns.Quantity(walang panaklong pagkatapos ng "Dami()"):

Hindi nahanap ang field ng object (Dami)

Sa kasong ito, dapat na maunawaan ang "field" at "property" bilang mga kasingkahulugan, o isang kamalian sa terminolohiya ng mga developer ng 1C. Ginagamit nila ang parehong mga salitang ito upang sumangguni sa parehong konsepto. Bagaman sa iba pang mga programming language ang mga terminong ito ay maaaring mangahulugan ng iba't ibang mga bagay.

Pagkuha ng data mula sa isang talahanayan ng mga 1C na halaga gamit ang mga numero ng column

Upang magsimula, nag-aalok ako sa iyo ng isang simpleng halimbawa ng pagkuha ng data mula sa unang hilera ng aming talahanayan. Pakitandaan na ginagamit namin ang pre-populated na talahanayan mula sa simula ng artikulo. Alam nating sigurado na ang talahanayan ay may unang hilera at hindi bababa sa isang column. Kung ilalapat namin ang halimbawang ito sa isang walang laman na talahanayan, magkakaroon ng error. Kaya:

FirstLine = MyTK; // makuha ang unang hilera (numero mula sa zero) FirstColumnValue = FirstRow; // kunin ang halaga ng unang column (ang pagnunumero ng column ay mula rin sa simula) Report(Value ng FirstColumn); // ipakita ang halaga ng unang column sa unang hilera ng talahanayan

Ipapakita ng screen ang:

Chapaev

Una, nakakuha kami ng value table row object sa pamamagitan ng pag-access sa value table gamit ang [...] operator. (kung nakalimutan mo kung paano gawin ito, maaari mong tingnan ang mga nakaraang artikulo) Ipinasa namin ang argumentong "0" sa loob ng operator. Ito ang index ng unang hilera ng talahanayan ng halaga. FirstLine = MyTK;

Dagdag pa, mayroon din kaming karapatan na ma-access ang isang string object gamit ang [...] operator. Sa loob ng operator na ito ipinasa namin ang numero ng hanay ng talahanayan ng halaga, sa kasong ito ay "0" din. At sa gayon, natanggap namin ang halaga ng column na may bilang na "0" para sa kasalukuyang hilera ng talahanayan na may bilang na "0". Ipinakita namin ang halagang ito sa screen at kinakatawan nito ang string na "Chapaev".

Medyo gawing kumplikado ang ating halimbawa:

FirstLine = MyTK; // makuha ang unang linya (numbered mula sa zero) Report(FirstLine); // ipakita ang halaga ng unang column sa unang hilera ng table Report(FirstRow); // ipakita ang halaga ng pangalawang column sa unang hilera ng table Report(FirstRow); // ipakita ang halaga ng ikatlong hanay sa unang hilera ng talahanayan

Ipinakita na namin ngayon ang mga halaga mula sa lahat ng tatlong hanay ng unang hilera ng aming talahanayan ng halaga:

Chapaev Vasily Ivanovich

Ngayon ay babaguhin ko rin ang halimbawang ito upang magawa natin nang wala ang variable "Unang linya"

Ulat(MyTZ); // ipakita ang halaga ng unang column sa unang hilera ng table Report(MyTZ); // ipakita ang halaga ng pangalawang column sa unang hilera ng table Report(MyTZ); // ipakita ang halaga ng ikatlong hanay sa unang hilera ng talahanayan

Magiging pareho ito sa screen

Chapaev Vasily Ivanovich

Nakita namin sa halimbawa sa itaas na upang ma-access ang isang halaga na matatagpuan sa isang partikular na row at isang partikular na column ng isang talahanayan ng mga halaga, maaari kaming gumamit ng isang sequential na tawag ng dalawang operator [...] sa form na ito: Talahanayan ng Halaga[Row Index][Column Index]

Kaya, handa na kaming gumawa ng loop at kunin ang data ng lahat ng row at lahat ng column gamit ang row at column index:

Para sa RowCounter = 0 By MyTZ.Quantity() - 1 Loop // cycle through row Para sa ColumnCounter = 0 By MyTZ.Columns.Quantity() - 1 Loop // nested loop through columns // makuha ang cell value (mula sa kasalukuyang row at ang kasalukuyang mga column) CellValue = MyTK[RowCounter][ColumnCounter]; // ipakita ang row number, column number at cell value Report("Row No" + Row Count + "column No" + Column Count + " = " + CellValue); EndCycle; EndCycle;

Ang mga sumusunod ay ipapakita sa screen:

Line No. 0 column No. 0 = Chapaev Line No. 0 column No. 1 = Vasily Line No. 0 column No. 2 = Ivanovich Line No. 1 column No. 0 = Dzerzhinsky Line No. 1 column No. 1 = Felix Line No. 1 column No. 2 = Edmundovich Line No. 2 column No. 0 = Kotovsky Line No. 2 column No. 1 = Grigory Line No. 2 column No. 2 = Ivanovich

Gamit ang dalawang cycle, ang isa ay naka-nest sa loob ng isa pa, ipinakita namin ang mga value ng lahat ng column mula sa lahat ng row ng 1C value table. Sa kasong ito, hindi kami gumamit ng mga pangalan ng column, ngunit na-access ang mga column at row sa pamamagitan ng kanilang mga index. Para sa higit pang pag-unawa, bigyang-pansin ang mga komento sa loob ng halimbawa.

Sa konklusyon, iminumungkahi kong bahagyang baguhin ang aming halimbawa upang sa halip na mga numero ng hanay, ipinapakita nito ang kanilang mga pangalan sa screen. At bilang karagdagan, gagawa ako ng isang mas presentable na disenyo para sa pagpapakita ng nilalaman sa screen.

Para sa LineCounter = 0 By MyTZ.Quantity() - 1 Loop // loop through rows Report(" ======= Line No. " + LineCounter + " ======="); Mag-ulat(" "); // line feed (paglalagay ng walang laman na row) Para sa ColumnCounter = 0 By MyTZ.Columns.Quantity() - 1 Loop // nested loop through columns // makuha ang cell value (mula sa kasalukuyang row at sa kasalukuyang column) CellValue = MyTZ [RowCounter][ ColumnCounter]; // kunin ang pangalan ng column na ColumnName = MyTZ.Columns[ColumnCounter].Name; // ipakita ang column name at cell value Report(ColumnName + ": " + CellValue); EndCycle; Mag-ulat(" "); // line feed (paglalagay ng walang laman na linya) EndCycle;

Ngayon, sa aming screen ang impormasyon ay nagsimulang magmukhang mas kinatawan:

Linya No. 0 ======= Apelyido: Chapaev Unang pangalan: Vasily Patronymic: Ivanovich ======= Line No. 1 ======= Apelyido: Dzerzhinsky Unang pangalan: Felix Patronymic: Edmundovich ===== == Linya Blg. 2 ======= Apelyido: Kotovsky Unang pangalan: Grigory Patronymic: Ivanovich

Oo, muntik ko nang makalimutan. Kapag gumagamit ng dalawang [...][...] operator sa isang hilera, maaari naming ipasa ang pangalan ng column na ito sa halip na isang column index: ValueTable[RowIndex][ColumnName]

Bigyang-pansin ang linyang minarkahan ng arrow ". Sa linyang ito, sa halip na ang index ng kasalukuyang column, ipinapasa namin ang pangalan ng kasalukuyang column sa argument sa square bracket [...] Magiging pareho ang resulta.

At ngayon, ang huling bagay sa artikulong ito.

TAMA ang pagkuha ng lahat ng data mula sa 1C value table gamit ang mga loop sa pamamagitan ng isang koleksyon ng mga row at isang koleksyon ng mga column

Para sa Bawat CurrentLine Mula sa MyTZ Loop // loop through a collection of strings Report(" ======= Line No. " + MyTZ.Index(CurrentLine) + " ======="); Mag-ulat(" "); Para sa Bawat CurrentColumn Mula sa MyTZ.Columns Loop // nested loop na umuulit sa pamamagitan ng isang koleksyon ng mga column ColumnName = CurrentColumn.Name; // kunin ang column nameCellValue = CurrentRow[ColumnName]; // get the cell value BY column NAME Report(ColumnName + ": " + CellValue); // ipakita ang pangalan ng hanay at halaga ng cell End of Cycle; Mag-ulat(" "); EndCycle;

Sa halimbawa, dalawang loop ang ginamit. Ang isang loop para sa pag-loop sa isang koleksyon ng mga column ay naka-nest sa loob ng isang loop para sa pag-loop sa mga row. Kung nagawa mo na ang mga halimbawa sa itaas at nabasa mo ang mga nakaraang artikulo, hindi ka mahihirapang maunawaan kung paano gumagana ang halimbawang ito.

Sa wakas, babawasan ko ang bilang ng mga linya ng code sa aming huling halimbawa hangga't maaari sa pamamagitan ng pag-aalis ng paggamit ng mga intermediate variable. Makakakuha kami ng sample ng "industrial code" na ginagamit sa mga totoong problema.

Ito ay dapat lamang gawin kapag mayroon kang mahusay na pag-unawa sa iyong ginagawa. Kung napakakumplikado ng code, katanggap-tanggap na mag-iwan ng mga intermediate na variable para mas madaling maunawaan ang sarili mong code sa ibang pagkakataon. Gayundin, ang anumang code ay dapat na magkomento ng hindi bababa sa minimal, upang pagkatapos ng ilang oras ay mas madaling maunawaan ang mga teksto ng programa.

Para sa Bawat CurrentLine Mula sa MyTZ Cycle // umulit sa mga row Report(" ======= Line No. " + MyTZ.Index(CurrentLine) + " =======" + Symbols.PS); Para sa Bawat CurrentColumn Mula sa MyTZ.Columns Loop // umulit sa mga column Report(CurrentColumn.Name + ": " + CurrentRow[CurrentColumn.Name]); EndCycle; Mag-ulat(" "); EndCycle;

Ang output sa screen ay hindi nagbago, nananatili itong pareho sa nakaraang halimbawa:

2 LINGGO NA KURSO

"PAG-PROGRAMMING SA 1C PARA SA MGA NAGSIMULA"

Ang kurso ay ipapadala sa pamamagitan ng email. Maging isang programmer sa pamamagitan ng pagkumpleto ng mga hakbang-hakbang na gawain.

Upang lumahok kailangan mo lamang ng isang computer at Internet

Libreng access sa kurso:

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", sans-serif; background-repeat: no-repeat; background-position: center; background-size: auto;) .sp-form input ( display: inline-block; opacity: 1; visibility: visible;).sp-form .sp-form-fields-wrapper ( margin: 0 auto; lapad: 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; taas: 35px; lapad: 100%;).sp-form .sp-field label ( kulay: #444444; font- laki: 13px; font-style: normal; font-weight: bold;).sp-form .sp-button ( border-radius: 4px; -moz-border-radius: 4px; -webkit-border-radius: 4px; kulay ng background: #f4394c; kulay: #ffffff; lapad: 100%; timbang ng font: 700; font-style: normal; font-family: Arial, "Helvetica Neue", sans-serif; box-shadow: wala; -moz-box-shadow: wala; -webkit-box-shadow: wala; background: linear-gradient(sa itaas, #e30d22 , #f77380);).sp-form .sp-button-container ( text-align: center; width: auto;)

(Ang artikulong ito ay kabilang sa serye ng mga artikulo 1C mula sa simula; programming 1C mula sa simula; talahanayan ng mga 1C na halaga)

Isang virtual na istraktura ng pag-iimbak ng data sa anyo ng tabular - kung ano ito

Ang talahanayan ng mga halaga ay hindi isang permanenteng bagay ng 1C database at hindi nai-save sa pagitan ng mga sesyon ng paglulunsad.

Talaan ng mga halaga 1C(TK) ay nilikha "on the fly" gamit ang code ng programa, at pagkatapos ay gumana dito ay isinasagawa sa parehong paraan tulad ng sa anumang iba pang bagay ng programa ng 1C programming language. Paggamit ng mga method call at pag-access sa mga katangian ng isang table-object.

Sa madaling salita, ang programmer ay lumilikha ng isang talahanayan sa memorya, pinupuno ito ng data, gumagana dito, nag-uuri, nagpangkat, nagkalkula ng mga kabuuan, at iba pa. Tumatanggap ng kinakailangang data para sa karagdagang paggamit.

Gumawa tayo ng talahanayan ng mga halaga at punan ito ng isang bagay. Dapat alalahanin na ang isang talahanayan ng mga halaga ng 1C ay maaaring malikha hindi lamang nang manu-mano, sa pamamagitan ng pagtawag sa operator

NewValueTable;

Ang isang talahanayan ng halaga ay kadalasang resulta ng isang tawag sa pamamaraan sa isa pang bagay, halimbawa ang resulta ng isang query ay maaaring itapon sa isang talahanayan ng halaga, at iba pa.

Hayaan akong bigyan ka kaagad ng isang simpleng halimbawa.

// MyTZ = Bagong ValueTable; // lumikha ng isang bagong talahanayan ng mga halaga na nakaimbak sa variable na "MyTZ" MyTK. Mga hanay. Add("LastName" ); // lumikha ng column na "Apelyido" MyTK. Mga hanay. Add("Pangalan"); // lumikha ng column na "Pangalan". Ulat (MyTZ); // ipakita ang halaga ng variable ng MyTZ //

Gumawa ako ng talahanayan ng mga halaga ng 1C, na may dalawang column: "Apelyido", "Unang pangalan". Pamamaraan Ulat(MyTK) ipapakita ang uri ng variable sa window ng mensahe MyTZ: Talaan ng mga Halaga

Ang aming talahanayan ng halaga ay walang laman sa ngayon. Magdagdag tayo ng ilang linya dito, na may una at apelyido.

// punan ang talahanayan ng mga halaga // idagdag ang unang row sa aming value table NewLine = MyTZ. Magdagdag (); Bagong linya. Apelyido = "Sidorov" ; Bagong linya. Pangalan = "Vasya" ; // magdagdag ng pangalawang row sa aming value table NewLine = MyTK. Magdagdag (); Bagong linya. Apelyido = "Ivanov" ; Bagong linya. Pangalan = "Pedro" ;

Nakatanggap kami ng isang talahanayan tulad nito:

Kailangang tandaan: Ang mga numero ng hilera sa talahanayan ng halaga ay nagsisimula sa zero

Bakit kailangan pa natin ng mga numero ng linya? At para ma-access natin ang isang hiwalay na hilera ng talahanayan ng mga halaga, halimbawa, kunin at ipakita ang row na ito sa screen.

// *** ipinapakita ang mga halaga ng zero line sa screen *** (sa pang-araw-araw na buhay namin ay karaniwang binibilang ang mga bagay simula sa isa, ngunit dito - mula sa zero) // kunin ang zero row ng aming table gamit ang row index sa mga square bracket OurNullString = MyTZ[ 0] ; // ngayon ang buong zero string ay nakapaloob sa variable na "OurFirstLine" Ulat(OurNullString.LastName) ; // ipakita ang halaga ng column na "Apelyido" na nakaimbak sa row zero Ulat (OurNullString.Name) ; // ipakita ang halaga ng column na "Pangalan" mula sa parehong linya

Bilang resulta, ipapakita ng screen ang:

Sidorov Vasya

Ngayon, para sa napakatalino at maigsi, magpapakita ako ng isang halimbawa na nagbibigay-daan sa iyo upang ma-access ang halaga ng isang column sa ganito at ganoong hilera (Ang halaga ng isang column sa ganito at ganoong hilera ay isang cell ng talahanayan ng mga halaga . Isang hindi opisyal na termino, ngunit isang maginhawa). Ngunit nang hindi gumagamit ng intermediate variable tulad ng "OurZeroString".

Upang ipakita ang mga halaga ng mga cell mula sa pangalawang hilera (huwag kalimutan na ang hilera ay ang pangalawa, ngunit ang index ng hilera na ito ay isa, kaya ang pagnunumero ay nagsisimula sa zero)

Panghuli, ang huling punto sa artikulong ito. Nagpakita ako sa iyo ng isang halimbawa ng pag-access sa isang solong hilera ng isang talahanayan ng halaga ayon sa index (numero ng hilera). Ang unibersal na anyo para sa pagbabasa o pagtatalaga ng mga nilalaman ng isang cell ay: "MyValueTable[RowNumber].ColumnName"

Ngayon ay bibigyan kita ng isang cycle ng kumpletong output ng mga nilalaman ng talahanayan ng mga halaga. Nang walang detalyadong mga paliwanag, para ma-rack mo rin ang iyong utak :)

// // loop through at ipakita ang lahat ng row ng aming table of values// Para sa LineNumber = 0 Ayon sa MyTK. Dami() - 1 Cycle Report (MyTZ[LineNumber] . LastName) ; // ipakita ang halaga ng column na "Apelyido". Ulat (MyTK[LineNumber] . Pangalan) ; // ipakita ang halaga ng column na "Pangalan". EndCycle ;

Bilang resulta ng pagpapatakbo ng loop na ito, ang mga sumusunod ay ipapakita sa screen:

Sidorov Vasya Ivanov Petya

Dito ko sinabi sa iyo ang mga pangunahing kaalaman sa pagtatrabaho sa 1C na talahanayan ng mga halaga. Nalalapat ang impormasyong ito sa 1C 8.0, 8.1, 8.2. Ang mga kawili-wiling detalye tungkol sa bagay na “1C value table” ay hindi nagtatapos doon. Ang bagay na ito ay may napakalaking kakayahan para sa maginhawang trabaho gamit ang data. Pag-uusapan ko ito sa mga susunod na artikulo.

Degtyarev Roman.

Paano matutong magprogram sa 1C mula sa simula?

Paano magtrabaho bilang isang 1C programmer at kumita ng hanggang 150,000 rubles bawat buwan?

MAG-SIGN UP NG LIBRE

2 LINGGO NA KURSO

"PAG-PROGRAMMING SA 1C PARA SA MGA NAGSIMULA"

Ang kurso ay ipapadala sa pamamagitan ng email. Maging isang programmer sa pamamagitan ng pagkumpleto ng mga hakbang-hakbang na gawain.

Upang lumahok kailangan mo lamang ng isang computer at Internet

Libreng access sa kurso:

Pagbati sa lahat ng nagbabasa ng infostart. Ang artikulong ito ay nakatuon sa isyu ng paglikha ng isang di-makatwirang talahanayan ng mga halaga sa anyo ng isang pinamamahalaang application sa programmatically.

Mga tampok ng gawain.

Ang sinumang nag-program sa isang regular na aplikasyon ay madalas na nahaharap sa gawain ng pagkuha ng isang di-makatwirang talahanayan ng mga halaga sa isang form. Ang isang arbitrary na talahanayan ng mga halaga ay isang talahanayan na ang bilang at uri ng mga hanay ay hindi alam nang maaga. Iyon ay, maaaring mayroong 3 mga haligi, o maaaring 6, o marahil 8. Sa isang normal na aplikasyon, ang lahat ay simple: maaari mong ilagay ang elemento ng "Talahanayan ng mga Halaga" sa form ng pagproseso, at pagkatapos ay ilipat ang nilikha na talahanayan ng mga halaga sa elementong ito sa pamamagitan ng program. Pagkatapos ay may isang simpleng utos:

Form Elements.TableField.CreateColumns();

kumuha ng handa na talahanayan ng mga halaga sa form. Mukhang mas simple ito.

Lahat ito ay nasa regular na aplikasyon. Sa isang pinamamahalaang application, nagbago ang lahat. Hindi ganoon kadali ang gumawa ng arbitrary table. Ngayon ay kailangan mong mahigpit na i-parameter ang talahanayan ng mga halaga sa form, o likhain ito sa programmatically (ilarawan, mabuti, ito, sa katunayan, ay ang kakanyahan ng pinamamahalaang application mismo). Ito ang susubukan naming gawin: gumawa ng programmatically ng isang arbitrary na talahanayan ng mga halaga sa isang kinokontrol na form.

Ang solusyon sa problema.

Ang unang bagay na kailangan nating gawin ay matukoy kung paano lilitaw ang talahanayan sa form. Ang pangunahing bagay ay hindi mo kailangang lumikha ng anumang elemento ng form sa pagproseso. Gagawin namin ito sa pamamagitan ng program, tulad ng buong talahanayan. Iyon ay, ang talahanayan ay ilalarawan at gagawin sa sandali ng pagbubukas ng form o paggamit ng isang pindutan - depende sa kung sino ang nangangailangan nito.

Ang paglikha ng isang talahanayan sa form ay nangyayari sa pamamagitan ng paglalarawan ng talahanayan ng halaga bilang isang katangian:
SelectionTypeArray = Bagong Array; Array ng SelectionType.Add(Type("Value Table")); ChoiceTypeDescription = Bagong TypeDescription(ChoiceTypeArray); Array ng Mga Detalye = Bagong Array; Array ng Attributes.Add(New Form Attributes("Schedule Table", Description of SelectionType, "", "TZN")); Ngayon kailangan nating lumikha ng talahanayan ng halaga ng programa na naglalaman ng data. Kung ang talahanayan ng mga halaga ay nakuha mula sa isang query, kung gayon ang lahat ay higit pa o mas kaunti sa pagkakasunud-sunod. Kung ang talahanayan ay ginawa nang manu-mano, ang kahulugan ng mga column na maglalaman ng mga numero o petsa ay maaaring gawin sa pamamagitan ng "Paglalarawan ng Mga Uri". Ang punto ay ang mga haligi sa talahanayan ng mga halaga ay dapat na may ilang uri. Kung, halimbawa, inaasahang pupunan ng user ang data sa mga column na ito nang interactive, hindi ka maaaring magdagdag ng column ng value table na may pangalan lang; dapat ay may uri ito. Tandaan - ito ay napakahalaga dahil... Ililipat namin ang mga uri na ito sa talahanayan sa form.
Lumilikha kami ng isang talahanayan na naglalaman ng ilang mga haligi:
CD = NewDateQualifiers(DateParts.Time); ArrayKD = Bagong Array; ArrayCD.Add(Type("Petsa")); DescriptionTypesTime = Bagong Uri ng Paglalarawan(ArrayCD,CD); TZ = Bagong ValueTable;
TK.Columns.Add("With", DescriptionTypesTime);
TK.Columns.Add("Before", DescriptionTypesTime);
TK.Columns.Add("Pangalan");
TK.Columns.Add("Note"); // Buong pangalan at Tala - mga hilera Susunod, pupunuin namin ang aming talahanayan ng programa ng TK ng kinakailangang data. Nakatanggap kami ng isang talahanayan ng TK na naglalaman ng mga kinakailangang halaga at handa nang ilipat sa nilikha na katangian ng form. Para sa Bawat Column Mula sa TK. Column Cycle

Array ng 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;

Ito ay isang simpleng kumbinasyon at handa na ang aming mesa.

Para sa Bawat Column Mula sa TK. Column Cycle

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

EndCycle;

Kondisyon na disenyo, kung kailangan namin ito, isinusulat din namin ito nang manu-mano, ang command menu - nang manu-mano. Ang mga humahawak ng mesa ay nakasulat din sa pamamagitan ng kamay. Halimbawa, upang magdagdag ng tagapangasiwa ng kaganapan para sa talahanayang "Pagpipilian":

Talaan ng SelectionFields.SetAction("Selection","TZNSelection");

Upang iproseso ang kaganapang ito, ang isang hiwalay na pamamaraan ay inireseta sa anyo ng isang pamamaraan:

&OnClient
Pamamaraan TKNSelection(TK, SelectedRow, Field, StandardProcessing)
// iniuutos ng handler ang EndProcedure

Tandaan na ang mga tagapangasiwa ng talahanayan ay nagpapaputok sa kliyente at samakatuwid ay dapat magkaroon ng command ng compiler pointer

&OnClient

Well, ang huling bagay na gusto kong idagdag ay na pagkatapos ng lahat ng mga hakbang na ito, siguraduhing tandaan na ipasa ang tapos na talahanayan sa katangian ng form:

ValueВFormAttributes(ToR, "ScheduleTable");

Ito ang mayroon tayo bilang isang resulta:

At narito ang paghawak ng kaganapang "Selection":

Afterword.

Umaasa ako na ang artikulo ay makakatulong sa mga 1C programmer na nagsisimulang lumikha ng mga talahanayan sa isang form sa programmatically.

Maaari kang mag-download ng isang pagpoproseso na gumagawa ng isang talahanayan ng mga halaga sa pamamagitan ng program at ipinapakita ito sa isang mapapamahalaang form na may mga komento na makakatulong sa iyong lumikha ng iyong sariling mga talahanayan.

Upang makapag-account para sa pera at mga kalakal, ang iba't ibang mga talahanayan ay malawakang ginagamit sa negosyo. Halos bawat dokumento ay isang talahanayan.

Ang isang talahanayan ay naglilista ng mga kalakal na ipapadala mula sa bodega. Ang isa pang talahanayan ay nagpapakita ng mga obligasyon na magbayad para sa mga kalakal na ito.

Samakatuwid, sa 1C, ang pagtatrabaho sa mga talahanayan ay sumasakop sa isang kilalang lugar.

Ang mga talahanayan sa 1C ay tinatawag ding "mga bahagi ng tabular". Ang mga direktoryo, dokumento at iba pa ay mayroon nito.

Ang query, kapag naisakatuparan, ay nagbabalik ng isang talahanayan na maaaring ma-access sa dalawang magkaibang paraan.

Ang una - mas mabilis - pagpili, pagkuha ng mga hilera mula dito ay posible lamang sa pagkakasunud-sunod. Ang pangalawa ay ang pag-upload ng resulta ng query sa isang talahanayan ng mga halaga at pagkatapos ay random na pag-access dito.

//Pagpipilian 1 – sunud-sunod na pag-access sa mga resulta ng query

//kunin mo ang mesa
Piliin = Query.Run().Select();
// dumaan tayo sa lahat ng linya ng resulta ng query sa pagkakasunud-sunod
Habang Select.Next() Loop
Ulat(Selection.Pangalan);
EndCycle;

//Pagpipilian 2 – pag-upload sa isang talahanayan ng mga halaga
Kahilingan = Bagong Kahilingan("PUMILI NG Pangalan MULA SA Directory.Nomenclature");
//kunin mo ang mesa
Talahanayan = Query.Run().Unload().
//sa karagdagang maaari din nating umulit sa lahat ng mga linya
Para sa bawat Row mula sa Table Cycle
Ulat(String.Name);
EndCycle;
//o arbitraryong i-access ang mga string
Row = Table.Find("Shovel", "Pangalan");

Ang isang mahalagang tampok ay na sa talahanayan na nakuha mula sa resulta ng query, ang lahat ng mga column ay mahigpit na ita-type. Nangangahulugan ito na sa pamamagitan ng paghiling ng field na Pangalan mula sa direktoryo ng Nomenclature, makakatanggap ka ng column ng uri ng String na may pinapayagang haba na hindi hihigit sa N character.

Talahanayan sa form (makapal na kliyente)

Gumagana ang user sa talahanayan kapag inilagay ito sa form.

Tinalakay namin ang mga pangunahing prinsipyo ng paggawa sa mga form sa aralin sa at sa aralin sa

Kaya, ilagay natin ang talahanayan sa form. Upang gawin ito, maaari mong i-drag ang talahanayan mula sa Controls panel. Katulad nito, maaari mong piliin ang Form/Insert Control mula sa menu.

Ang data ay maaaring maimbak sa pagsasaayos - pagkatapos ay kailangan mong piliin ang umiiral na (dating idinagdag) na bahagi ng tabular ng object ng pagsasaayos na ang anyo ay iyong ini-edit.

I-click ang "..." na button sa Data property. Upang makita ang listahan ng mga bahagi ng tabular, kailangan mong palawakin ang sangay ng Bagay.

Kapag pinili mo ang tabular na bahagi, ang 1C mismo ay magdaragdag ng mga column sa talahanayan sa form. Ang mga row na ipinasok ng user sa naturang talahanayan ay awtomatikong mase-save kasama ng reference na libro/dokumento.

Sa parehong Data property, maaari kang maglagay ng arbitrary na pangalan at piliin ang uri ng Talaan ng Halaga.

Nangangahulugan ito na ang isang arbitrary na talahanayan ng mga halaga ay napili. Hindi ito awtomatikong magdagdag ng mga column, at hindi rin ito awtomatikong mase-save, ngunit magagawa mo ang anumang gusto mo dito.

Sa pamamagitan ng pag-right click sa talahanayan maaari kang magdagdag ng column. Sa mga katangian ng isang column, maaari mong tukuyin ang pangalan nito (para sa sanggunian sa 1C code), ang heading ng column sa form, ang koneksyon sa katangian ng tabular na bahagi (ang huli - kung hindi isang arbitrary na talahanayan ang pipiliin, ngunit isang tabular na bahagi).

Sa mga katangian ng talahanayan sa form, maaari mong tukuyin kung ang user ay maaaring magdagdag/magtanggal ng mga row. Ang isang mas advanced na form ay ang View Only checkbox. Ang mga katangiang ito ay maginhawang gamitin para sa pag-aayos ng mga talahanayan na nilayon para sa pagpapakita ng impormasyon, ngunit hindi sa pag-edit.

Upang pamahalaan ang talahanayan, kailangan mong magpakita ng command panel sa form. Piliin ang menu item na Form/Insert Control/Command Bar.

Sa mga property ng command bar, piliin ang checkbox ng Autofill para awtomatikong lumabas ang mga button sa panel.

Talahanayan sa form (manipis/pinamamahalaang kliyente)

Sa isang pinamamahalaang form, ang mga pagkilos na ito ay medyo naiiba. Kung kailangan mong maglagay ng tabular na bahagi sa form, palawakin ang Object branch at i-drag ang isa sa mga tabular na bahagi sa kaliwa. Iyon lang!

Kung kailangan mong maglagay ng talahanayan ng mga halaga, magdagdag ng bagong katangian ng form at sa mga katangian nito tukuyin ang uri - talahanayan ng mga halaga.

Upang magdagdag ng mga column, gamitin ang right-click na menu sa attribute ng form na ito, piliin ang Add attribute column.

Pagkatapos ay i-drag din ang talahanayan sa kaliwa.

Upang ang isang talahanayan ay magkaroon ng isang command bar, sa mga katangian ng talahanayan, piliin ang mga halaga sa seksyon ng Usage - Command bar na posisyon.

Pag-upload ng talahanayan sa Excel

Anumang 1C table na matatagpuan sa form ay maaaring i-print o i-upload sa Excel.

Upang gawin ito, mag-right-click sa isang walang laman na espasyo sa talahanayan at piliin ang Listahan.

Sa isang pinamamahalaang (manipis) na kliyente, maaaring isagawa ang mga katulad na pagkilos gamit ang item sa menu na Lahat ng aksyon/listahan ng Display.

Tanong Paglikha ng isang haligi ng talahanayan ng mga halaga ng iba't ibang uri sa 1C v8
Sagot Kapag gumagawa ng column ng value table, maaari kang pumasa hanay ng mga uri, at maaaring isang partikular na uri. Isang hanay ng mga uri ang ginagamit kapag kailangan mong tumukoy ng ilang iba't ibang uri para sa isang column.

Ginagamit upang ipahiwatig ang mga uri "pangkalahatang bagay" - "Paglalarawan ng mga uri". Samakatuwid, ipapaliwanag muna namin kung ano ang "Paglalarawan ng mga uri" ("Paglalarawan ng mga uri ng halaga").

"Paglalarawan ng mga uri ng halaga". Upang ilarawan ang mga katanggap-tanggap na uri ng mga halaga ng ari-arian ng iba't ibang mga bagay sa system, isang espesyal na bagay ang ginagamit "Paglalarawan ng mga Uri". Gamit ang bagay na ito, maaari mong ilarawan ang mga wastong uri ng mga halaga na maaaring italaga sa mga katangian. Upang higit pang limitahan ang mga posibleng halaga ng mga primitive na uri Ang Numero, String at Petsa ay ibinigay mga kwalipikasyon. Inilalarawan ng mga qualifier ang mga parameter gaya ng haba ng isang string o numero, mga wastong bahagi ng isang petsa, atbp.

Syntax ng pamamaraang "Uri ng Paglalarawan".

Mga Bagong Uri ng Paglalarawan(<Исходное описание типов>, <Добавляемые типы>, <Вычитаемые типы>, <Квалификаторы числа>, <Квалификаторы строки>, <Квалификаторы даты>)
Mga Pagpipilian:
<Исходное описание типов> (opsyonal)
Uri: Mga Uri ng Paglalarawan. Ang paunang paglalarawan ng mga uri, batay sa kung saan itatayo ang isang bago.
<Добавляемые типы> (opsyonal)
Uri: Array, String. Isang hanay ng mga halaga ng uri Isang Uri na binubuo ng mga uri na gagamitin sa bagay, o isang string na naglalaman ng mga pangalan ng mga uri na pinaghihiwalay ng mga kuwit.
<Вычитаемые типы> (opsyonal)
Uri: Array, String. Isang hanay ng mga halaga ng Uri (o isang string na naglalaman ng mga pangalan ng uri na pinaghihiwalay ng kuwit) na binubuo ng mga uri na ibubukod mula sa unang deklarasyon na tinukoy sa unang parameter.
<Квалификаторы числа> (opsyonal)
Uri: QualifiersNumbers. Mga kwalipikasyon ng numero na naglalarawan ng mga wastong halaga ng isang uri ng numero.
<Квалификаторы строки> (opsyonal)
Uri: QualifiersStrings. Mga string qualifier na naglalarawan ng mga wastong halaga ng isang uri ng string.
<Квалификаторы даты> (opsyonal)
Uri: QualifiersDates. Mga qualifier ng petsa na naglalarawan ng mga wastong halaga ng uri ng Petsa.
Paglalarawan:
Lumilikha ng paglalarawan ng uri batay sa isa pang uri ng paglalarawan, sa pamamagitan ng pagdaragdag ng ilang uri at pagbubukod ng iba. Kung hindi tinukoy ang isang bagong qualifier, ang mga qualifier ng orihinal na uri ng deklarasyon ay pananatilihin.
Isang halimbawa ng paggamit ng object na "Uri ng Paglalarawan":

// palawakin ang paglalarawan ng Mga Wastong Uri gamit ang mga bagong uri Array = Bagong Array; Array. Magdagdag(Uri( "Reference Link. Mga Paraan")); Array. Add(Type("Number")); Sign = ValidSign. Di-negatibo; QuNumbers = Bagong QualifiersNumbers(10, 2, Sign); ValidTypes = NewTypeDescription(ValidTypes, Array, KvNumbers);

Ngayon, sa katunayan, mga halimbawa ng tamang paglikha ng mga halaga ng hanay ng iba't ibang uri sa isang talahanayan.

Sa pangkalahatan, sapat na upang tukuyin ang mga uri ng hanay tulad ng sumusunod:

TK. Mga hanay. Idagdag( "Pag-uri-uriin ang Index", Bagong Uri ng Paglalarawan ( "Number" ) ); TK. Mga hanay. Add("SectionName", New TypeDescription("String" ) ); TK. Mga hanay. Add("DataCorr" , New TypeDescription("Date" ) ); TK. Mga hanay. Idagdag( "UnconditionalDeletion", New TypeDescription("Boolean")); TK. Mga hanay. Add("Nomenclature" , New TypeDescription() ); TK. Mga hanay. Add("SectionData" , New TypeDescription("Structure") ); // halimbawa ng paglikha ng mga column na "number" at "string" na may paglilinaw ng mga parameter: TK. Mga hanay. Idagdag( "Porsyento Kumpleto", Bagong Uri ng Paglalarawan ( "Number" , Bagong QualifiersNumbers ( 18 , 2 ) )); TK. Mga hanay. Add("SectionName" , NewTypeDescription("String" , , NewStringQualifiers(200, AllowedLength. Variable) ) ); TK. Mga hanay. Add("DecommissionedDate" , NewTypeDescription("Date" , , , NewDateQualifiers(DateParts.DateTime) ) ) ;

Gayunpaman, sa pangkalahatan, ang isang array ay ipinapasa bilang uri ng column. Ginagamit ang array kapag kailangang italaga ang ilang uri sa isang column. Kung gayon ang kahulugan ng istraktura ay magiging katulad nito (ibinibigay ang mga halimbawa para sa iba't ibang uri ng mga haligi, kapag ang uri ay isang array, ngunit para sa pagiging simple, ang komposisyon ng array ay ibinigay ng parehong uri, upang hindi malito )

////// pagbuo ng istraktura ng mga teknikal na pagtutukoy (paglikha ng mga haligi) //// tukuyin ang mga qualifier para sa pagpapalit sa mga qualifier field ng teknikal na detalye CN = Bagong QualifiersNumbers(18, 9); KS = NewStringQualifiers(200); CD = NewDateQualifiers(DataParts.DateTime) ; //// tukuyin ang mga uri ng paglalarawan para sa hinaharap na TK column // Ang array ay ang unang paglalarawan ng mga uri, batay sa kung saan bubuo ang isang bago // Pakitandaan na para sa mga TK column ang unang uri ng paglalarawan sa halimbawang ito ay isang array Array = Bagong Array; Array. Add(Type("String") ); TypeDescriptionString = New TypeDescription(Array, , KS) ; Array. Clear(); Array. Add(Type("Number") ); TypeDescriptionNumber = New TypeDescription(Array, , , CN) ; Array. Clear(); Array. Add(Type("Date") ); DescriptionTypesDate = Bagong Uri ng Paglalarawan(Array, , , , CD) ; Array. Clear(); Array. Magdagdag(Uri( "DirectoryLink.Nomenclature")); Uri ng PaglalarawanNomenclature = Bagong Uri ng Paglalarawan (Array) ; Array. Clear(); Array. Magdagdag(Uri( "DirectoryLink.SeriesNomenclature")); TypeDescriptionSeries = Bagong TypeDescription(Array) ; Array. Clear(); Array. Magdagdag(Uri( "DirectoryLink.Quality")); TypeDescriptionQuality = Bagong TypeDescription(Array) ; Array. Clear(); Array. Add(Type("Boolean") ); TypeDescriptionBoolean = New TypeDescription(Array) ; // aktwal na pagdaragdag ng mga haligi sa TK (lumilikha ng istraktura ng hinaharap na TK) TK. Mga hanay. Add("Nomenclature", DescriptionTypesNomenclature) ; TK. Mga hanay. Add("Code" , TypeDescriptionString); TK. Mga hanay. Idagdag( "SeriesNomenclature", DescriptionTypesSeries); TK. Mga hanay. Add("AccountCode" , Type DescriptionString) ; TK. Mga hanay. Add("ActionDate" , TypeDescriptionDate); TK. Mga hanay. Add("Quality" , TypeDescriptionQuality); TK. Mga hanay. Add("NumberUS", DescriptionTypesNumber) ; TK. Mga hanay. Add("Write off" , TypeDescriptionBoolean); . . . //////// pagbuo ng istraktura ng mga teknikal na pagtutukoy (paglikha ng mga haligi) ////////////////////////////////////////////////////////

Upang magdagdag ng row sa isang value table, tingnan