Az 1C funkciók és eljárások az 1C-ben hasonlóan működnek, mint a többi nyelv- a függvény egy elnevezett alprogram, amelyet a programkód más helyeiről kell meghívni.
A modulban a függvények deklarálásának sorrendje tetszőleges (vagyis használhatja az eljárásokat a modul legelején található eljárás szövegében, amelynek szövege ebben a modulban alább található). Hasonlóképpen az 1C függvények is exportálhatók.
Ha ki szeretne lépni az 1C funkció és eljárás végrehajtásából, használja a "Return;" parancsot. Egy függvény (szemben az eljárással) "visszaadja" a számítások eredményét, vagyis be kell írni a "Return VALUE;" értéket. Az 1C függvények nincsenek gépelve, ami azt jelenti, hogy paraméterektől vagy feltételektől függően különböző típusú értékeket adhatnak vissza.
A függvény abban különbözik az eljárástól, hogy képes visszaadni a számítások eredményét, például:
1. funkció (paraméter)
Visszatérési paraméter * 2;
EndFunction
Változó1 = Funkció1 (10);
// Az 1. változó 20 lesz
Az 1C függvény és eljárás paraméterei a hívás helyén létező változókra való hivatkozások. A "Link" azt jelenti, hogy amikor az 1C függvény "belül" paraméterének értéke megváltozik, akkor "kívül" is megváltozik. Ennek elkerülése érdekében - a paraméter a VAR értékkel kerül átadásra. Ez azonban nem működik érték-objektumokkal (listák, táblázatok, adatbázis-objektumok), továbbra is hivatkozással kerülnek továbbításra.
Amikor egy paramétert átadunk egy eljárásnak / függvénynek, akkor "hivatkozással" adjuk át. Ez azt jelenti, hogy az eljáráson belüli módosításával megváltoztatja az értékét az 1C funkció befejezése után történő eléréskor. Így az előző példa így írható:
Eljárás 1. eljárás (paraméter)
Paraméter = Paraméter * 2;
Az eljárás vége
Változó1 = 10;
1. eljárás (változó1);
Jelentés (1. változó);
// Az eredmény 20 lesz
A változó értékének átadása az eljárásba, és nem maga a változó:
Eljárás 1. eljárás (VALUE paraméter)
// tettek ..
Az eljárás vége
Amikor objektumokkal (könyvtárakkal, dokumentumokkal) dolgozik, emlékeznie kell arra, hogy az 1C függvény / 1C eljáráson belül műveletek hajthatók végre rajtuk.
Ha az 1C függvény / 1C eljárásnak több paramétere van, akkor a szükségtelen kihagyható (vessző megadásával, ha a paraméter hiányzik a közepéből), míg a Nem definiált (lásd alább) vagy az alapértelmezett érték kerül átvitelre:
Funkció Funkció1 (Paraméter1, Paraméter2, Paraméter3 = "Karakterlánc értéke")
// Csinálj valamit
EndFunction
// A függvény meghívása bizonyos paraméterek nélkül
// a paraméter2 megegyezik a Nem definiált értékkel
// paraméter3 megegyezik a "String value" értékkel
Funkció1 (10);
// A függvény meghívása a második paraméter nélkül
Funkció1 (10, "Érték");
Amint korábban említettük, az 1C eljárásokat eseménykezelőként használják, amelyek akkor fordulnak elő, amikor a felhasználó űrlappal dolgozik (nyitás, zárás, gombok megnyomása stb.), Vagy amikor a platform működik (kezdés, befejezés stb.). Az űrlapkezelők vagy azok elemeinek lehetséges típusai láthatók a tulajdonságokban - a megfelelő űrlapelemre kattintva (és lefelé görgetve a tulajdonságok ablakban). Az objektummodul kezelőinek típusai a konfigurátor panelen található legördülő listából tekinthetők meg - ahol a még nem definiált és már meghatározott események listája jelenik meg. A különböző eseményeknek különböző paramétereik vannak, egy kezelő hozzáadásakor az 1C automatikusan előírja a paraméterek listáját.
A beépített 1C: Enterprise nyelv kétféle módon támogatja a paraméterek eljárásokhoz és funkciókhoz való továbbítását: a paraméterek hivatkozással történő továbbítását és a paraméterek érték szerinti átadását.
Alapértelmezés szerint a beépített 1C: Enterprise 8 nyelven a paraméterek hivatkozással kerülnek átadásra az eljárásoknak és funkcióknak. Ez azt jelenti, hogy egy eljárási vagy függvényen belüli formális paraméter megváltoztatása tükröződik az eljárás vagy függvény meghívásakor megadott tényleges paraméter értékében.
Eljárási eljárás1 (FormalParameter1)
FormalParameter1 = 2 * 3;
Az eljárás vége
Tényleges paraméter = 10;
1. eljárás (tényleges paraméter);
// a 6 érték jelenik meg - a formai változás
// az eljáráson belüli paraméter befolyásolta a változást
// eljáráshívás: alapértelmezés szerint a paraméterek átadásra kerülnek
// link!
A paraméterek átadása érték szerint
Amikor egy paramétert érték szerint továbbít egy meghívott eljárásnak vagy függvénynek, egy formális paraméter értékének megváltoztatása az eljáráson vagy függvényen belül semmilyen módon nem befolyásolja az eljárás vagy függvény meghívásakor átadott tényleges paramétert. Annak jelzése, hogy a paramétert érték szerint kell továbbítani, a Val kulcsszó segítségével történik.
Példa:
Eljárási eljárás2 (FormalParameter1)
FormalParameter1 = 2 * 3;
Az eljárás vége
Tényleges paraméter = 10;
Eljárás2 (tényleges paraméter);
// a 10 érték jelenik meg - a formai változás
// az eljáráson belüli paraméter NEM befolyásolta a változást
// a ténylegesen megadott paraméter értéke, amikor
// eljáráshívás: paraméter érték szerint átadva!
Jelentés (tényleges paraméter);
A különböző adattípusú változók érték szerinti átadásának jellemzői
A különböző adattípusok változóinak érték szerinti továbbításának sajátosságai vannak. Ezek abból állnak, hogy a formális paraméterek kontextusának módszereivel és tulajdonságaival dolgozva az eljárás vagy függvény meghívásakor átadott tényleges paraméter állapota megváltozhat.
Példaként tekintsünk egy olyan helyzetet, amikor az érték által átadott eljárásparaméter értékek táblázata. A ProcessTable () eljárásban meghívjuk az értéktábla új példányát, amelyhez három sor kerül. Ez semmilyen módon nem befolyásolja a ProcessTable () eljárás meghívásakor tényleges paraméterként átadott T3 értékek táblázatának állapotát:
Eljárási folyamat táblázat (Value TableValue)
TableValue = Új TableValue;
// Két oszlop hozzáadása az értékek táblázatához
TableValues.Columns.Add ("Oszlop1");
TableValues.Columns.Add ("Oszlop2");
N = 1 esetén 3 ciklus
NewRow = TabValue Add ();
NewStroka.Column1 = "Oszlop";
NewString.Column2 = n;
Ciklus vége;
Az eljárás vége
// Hozzon létre egy új értékrendet
Tz = Új értéktábla;
// Adjon hozzá néhány sort az értékek táblázatához
N = 1 esetén 10 ciklus
ÚjString = Tz.Add ();
Újsor.oszlop3 = n;
Ciklus vége;
// a 10 érték jelenik meg
Folyamat táblázat (Tz);
// a 10 érték jelenik meg: a ProcessTable eljárásban
// új érték táblázatot mentett a formális paraméterbe
Példaként tekintsünk egy olyan helyzetet, amikor az érték által átadott eljárásparaméter értékek táblázata. A CollapseTable () meghívott eljáráson belül az eljárás meghívásakor paraméterként átadott értékek táblája össze van csukva:
// Azt jelzi, hogy a TableValue paraméter átvitele érték szerint történik
Az eljárás összecsukási táblázata (táblázat értéke)
// Az értékek táblázatának összecsukása oszlopok 1 és 3 oszlopok szerint
TableValue minimalizálása ("Oszlop1", "Oszlop3");
Az eljárás vége
// Hozzon létre egy új értékrendet
Tz = Új értéktábla;
// Három oszlop hozzáadása az értékek táblázatához
Tz.Columns.Add ("Oszlop1");
Tz.Columns.Add ("2. oszlop");
Tz.Columns.Add ("3. oszlop");
// Adjon hozzá néhány sort az értékek táblázatához
N = 1 esetén 10 ciklus
ÚjString = Tz.Add ();
NewRow.Column1 = "Oszlop1";
NewStrok.Column2 = "Oszlop2";
Újsor.oszlop3 = n;
Ciklus vége;
// a 10 érték jelenik meg
Report ("Az elemek száma a TK -ban az összeomlás előtt:" + Tz.Number ());
// Hívja meg az eljárást, adja át a tényleges Tz paramétert érték szerint
A táblázat minimalizálása (Tz);
// Az értéktábla most összecsukva: az 1 érték jelenik meg
Report ("Az elemek száma a TK -ban hajtogatás után:" + Tz.Number ());
Így a tényleges paraméter érték szerinti átadása ebben az esetben nem eredményezte az értéktábla másolatát. Az értéktábla tulajdonságaival és metódusaival dolgozva a CollapseTable () eljárás meghívásakor használt értéktábla tulajdonságaival és metódusaival dolgozunk.
A különbség minden típus esetén, amikor egy eljárás vagy függvény paraméterét hivatkozás vagy érték adja át, abban nyilvánul meg, hogy új értéket rendelünk hozzá az eljárás vagy függvény tényleges paraméteréhez. A tényleges paraméterkontextus tulajdonságainak és módszereinek meghívása, ha van ilyen, befolyásolja a formális paramétert, függetlenül attól, hogy hivatkozás vagy érték alapján adja át.
1. Javasoljuk, hogy az eljárásokat és a funkciókat kommentár formájában írja le. Az eljárási és funkciókódex egyes szakaszainak megjegyzésének szükségességét a fejlesztőnek kell meghatároznia, a kód egyes szakaszainak összetettsége és nem szabványossága alapján.
2. A kötelező megjegyzések megkövetelik a modulok programfelületén szereplő eljárásokat és funkciókat - az ilyen eljárásokat és funkciókat más funkcionális alrendszerekben (vagy más alkalmazásokban) való használatra szánják, amelyekért más fejlesztők lehetnek felelősek, ezért ezeket jól dokumentálni kell.
Lásd még:Az exportálási eljárások és funkciók használatának korlátozásaés Export eljárások és függvények használata űrlapmodulokban
4. Kerülni kell azokat a megjegyzéseket, amelyek nem adnak további magyarázatot a kiviteli eljárás (funkció) működésére.
Például rosszul:
Ezekben a példákban a megjegyzések feleslegesek, mivel az eljárások neveiből nyilvánvaló, hogy ezek eseménykezelők. Leírásukkal és a paraméterek céljával megtalálható a szintaktikai asszisztensben.
// A függvény a dokumentum adatai szerint tér vissza FunkciócikkMoney (DocumentData)Ez a megjegyzés nem ad további információt a funkcióról.
5. A megjegyzést az eljárás (függvény) deklarációja elé kell helyezni, és a következő formájú.
5.1. "Leírás" szakasz szóbeli rövid leírást tartalmaz az eljárás (funkció) céljáról és / vagy elveiről. Ez lehet az egyetlen szakasz a paraméterek nélküli eljárásokhoz.
5.2. "Paraméterek" szakasz leírja az eljárás (függvény) paramétereit. Ha nem, akkor a szakasz kihagyásra kerül. Előtte a "Paraméterek:" sor szerepel , majd az összes paraméter leírása új sorba kerül.
5.2.1. A paraméter leírásaúj sorban kezdődik, majd a paraméter neve, majd kötőjel és típuslista (*), majd kötőjel és a paraméter szöveges leírása.
Például:
Továbbá minden paraméterhez megadhat egy vagy több további paramétertípus -leírást. Minden további leírás új sorban kezdődik, majd kötelező kötőjel, majd a paramétertípusok listája (*), majd kötőjel és szöveges leírás.
Például:
5.3. "Visszaadott érték" szakasz leírja a függvény visszatérési értékének típusát és tartalmát. Ez a szakasz hiányzik az eljárásokhoz. A "Visszaadott érték:" sor előzi meg. Ezután egy új sorban a típusok listája (*), majd kötőjel és szöveg.
Például:
5.4. "Példa" szakasz példát tartalmaz egy eljárás vagy függvény használatára. A "Példa:" sor előtagja. Ezután egy új vonalon, egy használati példa.
(*)Jegyzet:"típuslista" alatt a típusneveket vesszővel elválasztva értjük. A típusnév lehet egyszerű (egy szó) vagy összetett - két szó ponttal elválasztva.
Például: Vonal, Szerkezet, DirectoryRef. Alkalmazottak.
Az 1C: Enterprise 8.3 platformon történő fejlesztéskor a megjegyzés szövege az eljárások, funkciók és paramétereik kontextusában is megjelenik. További részletekért tekintse meg a platformdokumentáció 26. fejezetének „Fejlesztési eszközök” című fejezetének „Kontextus tippek modulszövegek beviteléhez” című szakaszát.
Példa a funkció leírására egy paraméterrel:
// Meghatározza a RoleNames szerepkörök elérhetőségét az aktuális felhasználó számára, // valamint az adminisztrátori jogok elérhetősége.// // Lehetőségek: // Szerepnevek - Karakterlánc - a rendelkezésre állást ellenőrző szerepek nevei, vesszővel elválasztva. // // Visszaadott érték: // Boolean - Igaz, ha az átadott szerepek közül legalább az egyik elérhető az aktuális felhasználó számára, // vagy adminisztrátori jogai vannak.// // Példa: // Ha a szerepkörök rendelkezésre állnak ("Jelentések küldése, e -mail"), akkor ...// FunkciószerepekAvailable (RoleNames) ExportPélda egy eljárás leírására paraméterek nélkül:
// Az eseménykezelőben az BeforeWrite dokumentum végrehajtása; // - a szolgáltatás táblázatos részének törlése, ha megbízási megbízottal van megállapodás; // - a UnitMeasurement tulajdonság kitöltésének ellenőrzése az áruk részei; // - szinkronizálás az "alárendelt" számlával; // - a raktár és a vevő megrendelésének kitöltése az Áruk és visszaküldhető csomagolás táblázatos rovatokban; // - a "Sorozatszámok" táblázatos rész nem használt sorainak törlése; // - a DeleteMotion objektum modulváltozójának kitöltése.// Eljárás BeforeWrite () EndProcedure6. Ha megjegyzést szeretne fűzni egy olyan eljáráshoz vagy függvényhez, amelyet egy fordítási irányelvvel együtt használ, először tegyen megjegyzést, majd -
összeállítási irányelv. Például:
A megjegyzés ilyen stílusa lehetővé teszi, hogy először is figyeljen a funkció meghatározására és az összeállítási irányelvre, majd a megjegyzésre, amely meglehetősen sok sort foglalhat el.
7. Az eljárások és funkciók kódját a modul szövegében üres sorokkal kell elválasztani.
Az eljárásokkal vagy funkciókkal kapcsolatos megjegyzések automatikus rendezése a fordítási irányelvekkel
A fordítási utasításokkal rendelkező eljárásokhoz vagy függvényekhez fűzött megjegyzések automatikus rendezéséhez használhatja a mellékelt feldolgozást Fordítási irányelvek formázása .epf... Ehhez szükség van:
- Konfigurációs modulok kiürítése (Configuration menü menüparancs -> Configuration files unload ...)
- Nyissa meg a feldolgozást módban 1C: Vállalatés adja meg azt a könyvtárat, amelybe a modulokat kirakták - majd kattintson a "Formátum" gombra
- Modulok betöltése a konfigurációba (konfigurációs menüparancs -> Konfigurációs fájlok betöltése ...)
Megtalálnak minket: példa az eljárás bejelentésére és leírására paraméterek nélkül, eljárás paraméterei BeforeWrite (), eljárás egy adott szerepkör használatára 1c, Hogyan lehet megnézni, hol használják az eljárást az 1c -ben, Milyen funkciók vagy eljárások neveit kell javítani? 1s, 1s dokumentumokban eljárások és funkciók
Előre is elnézést kérek a "pont elhelyezéssel" kapcsolatos igényes kommentárért, de valahogy be kell csábítanom a cikkbe)) A magam részéről megpróbálom elérni, hogy az annotáció továbbra is megfeleljen az elvárásainak.
Röviden, miről szól a beszéd
Ezt egyébként mindenki tudja, de az elején emlékeztetem, hogyan lehet a metódusparamétereket 1C -ben továbbítani. Átadhatók "hivatkozás" és "érték" szerint. Az első esetben ugyanazt az értéket adjuk át a módszernek, mint a hívás pillanatában, a másodikban pedig annak másolatát.
Alapértelmezés szerint az 1C -ben az argumentumok hivatkozás útján kerülnek továbbításra, és a metóduson belüli paraméter változása a metóduson kívülről is látható lesz. Itt a kérdés további megértése attól függ, hogy pontosan mit ért a "paraméterváltozás" szó alatt. Tehát az áthelyezésre gondolok, és semmi többre. Ezenkívül a hozzárendelés lehet implicit is, például egy platformmetódus meghívásával, amely visszaad valamit a kimeneti paraméterben.
De ha nem akarjuk, hogy a paraméterünk hivatkozásként kerüljön továbbításra, akkor megadhatjuk a kulcsszót a paraméter előtt Átlagos.
Eljárás érték szerint (Értékparaméter) Paraméter = 2; EndProcedure Parameter = 1; Érték szerint (paraméter); Jelentés (paraméter); // kimenet 1
Minden a megbeszéltek szerint működik - a paraméter értékének megváltoztatása (vagy inkább "cseréje") nem változtatja meg a módszeren kívüli értéket.
Nos, mi a fogás?
Az érdekes pillanatok akkor kezdődnek, amikor paraméterekként nem primitív típusokat (karakterláncok, számok, dátumok stb.), Hanem objektumokat kezdünk átadni. Itt merülnek fel olyan fogalmak, mint az objektum "sekély" és "mély" másolatai, valamint a mutatók (nem C ++ kifejezéssel, hanem absztrakt fogantyúként).
Amikor egy objektumot (például egy Értéktáblázatot) referenciaként adunk át, akkor átadjuk a mutató (egy fogantyú) értékét, amely "tartja" az objektumot a platform memóriájában. Ha érték szerint adja át, a keret másolatot készít erről a mutatóról.
Más szóval, ha az objektumot referenciaként átadva a módszerben az "Array" értéket rendeljük a paraméterhez, akkor a hívás helyén tömböt kapunk. A hivatkozás által átadott érték újbóli hozzárendelése a hívás helyéről látható.
Eljárás ProcessValue (Parameter) Parameter = New Array; EndProcedure Table = NewValuesTable; ProcessValue (táblázat); Jelentés (TypeZnch (táblázat)); // tömb megjelenítése
Ha azonban érték szerint adjuk át az objektumot, akkor a hívás pillanatában a ValueTable nem fog eltűnni.
Az objektum tartalma és állapota
Ha érték szerint adja át, nem a teljes objektum másolódik, hanem csak a mutatója. Az objektum példánya ugyanaz marad. Nem számít, hogyan adja át az objektumot, hivatkozás vagy érték alapján, az értéktábla törlésével maga a táblázat is törlődik. Ez a tisztítás mindenhol látható lesz, mert csak egy objektum volt, és nem mindegy, hogyan adták át a módszernek.
Eljárás ProcessValue (Parameter) Parameter.Clear (); EndProcedure Table = NewValuesTable; Table.Add (); ProcessValue (táblázat); Jelentés (táblázat. Mennyiség ()); // 0 lesz
Amikor objektumokat ad át módszereknek, a platform mutatókkal működik (feltételes, nem közvetlen analógok a C ++ - ból). Ha egy objektumot hivatkozás útján továbbítanak, akkor az 1C virtuális gép memóriacelláját, amely ezt az objektumot tartalmazza, egy másik objektum felülírhatja. Ha az objektum érték szerint kerül átadásra, akkor a mutató másolásra kerül, és az objektum felülírása nem írja felül a memória helyét az eredeti objektummal.
Ugyanakkor minden változás vagyon objektum (tisztítás, tulajdonságok hozzáadása stb.) megváltoztatja magát az objektumot, és általában semmi köze az objektum átadásának módjához és helyéhez. Egy objektumpéldány állapota megváltozott, lehet, hogy egy csomó "mellék-hivatkozás" és "mellékérték" van benne, de a példány mindig ugyanaz. Ha egy objektumot átadunk egy metódusnak, nem hozunk létre másolatot a teljes objektumról.
És ez mindig igaz, kivéve ...
Ügyfél-szerver interakció
A platform nagyon átláthatóan valósítja meg a szerverhívásokat. Csak hívjuk a metódust, és a motorháztető alatt a platform szerializálja (karakterlánccá alakítja) a metódus összes paraméterét, átviszi azokat a szerverre, majd visszaadja a kimeneti paramétereket a kliensnek, ahol deserializált és élő , mintha egyetlen szerverre sem utaztak volna.
Mint tudják, nem minden platformobjektum sorosítható. Itt nő az a korlátozás, hogy nem minden objektum adható át a szerver metódusnak az ügyféltől. Ha elhalad egy nem sorosítható objektum mellett, a platform rossz szavakkal káromkodni kezd.
- A programozó szándékának kifejezett nyilatkozata. A módszer aláírásával egyértelműen meg lehet határozni, hogy mely paraméterek kerülnek bemenetre, és melyek a kimenetek. Ez a kód könnyebben olvasható és karbantartható.
- Annak érdekében, hogy a szerverparaméter "hivatkozásból" történő változása látható legyen a kliens híváspontján, p A szerver által hivatkozás útján továbbított paramétereket a platform maga visszaküldi az ügyfélnek, hogy biztosítsa a cikk elején leírt viselkedést. Ha a paramétert nem kell visszaadni, akkor a forgalom túlterhelődik. Az adatcsere optimalizálása érdekében azokat a paramétereket, amelyek értékeire nincs szükségünk a kimeneten, meg kell jelölni a Val szóval.
A második pont itt említésre méltó. A forgalom optimalizálása érdekében a platform nem adja vissza a paraméter értékét az ügyfélnek, ha a paramétert a Val szó jelöli. Mindez nagyszerű, de érdekes hatása van.
Ahogy már mondtam, amikor az objektumot átviszik a szerverre, sorosodás következik be, azaz az objektum "mély" másolata folyamatban van. És ha van szó Jelentése az objektum nem utazik vissza a szerverről az ügyfélhez. Ezt a két tényt összeadva a következőket kapjuk:
& AtServer eljárás referencia (paraméter) Parameter.Clear (); EndProcedure & AtServer eljárás érték szerint (Value Parameter) Parameter.Clear (); EndProcedure & AtClient eljárás ValueClient szerint (Értékparaméter) Parameter.Clear (); EndProcedure & OnClient Procedúra CheckValue () List1 = NewList of Values; List1.Add ("hello"); List2 = List1.Copy (); List3 = List1.Copy (); // az objektum teljesen átmásolódik, // átkerül a szerverre, majd visszaadásra kerül. // a lista törlése látható a ByRef (List1) hívóponton; // az objektum teljesen másolva, // átadva a szervernek. Nem jön vissza. // A lista törlése NEM LÁTHATÓ a hívóponton ByValue (List2); // csak az objektummutató másolása // a lista törlése látható a hívóponton ByValueClient (List3); Jelentés (List1.Quantity ()); Jelentés (List2.Quantity ()); Jelentés (List3.Quantity ()); Az eljárás vége
Összefoglaló
Röviden a következőképpen foglalható össze:
- A hivatkozással történő átadás lehetővé teszi egy objektum "felülírását" egy teljesen más objektummal
- Az érték megadása nem teszi lehetővé az objektum "törlését", de az objektum belső állapotában bekövetkező változások láthatóak lesznek, mivel ugyanazzal az objektumpéldánnyal dolgozunk
- Szerverhíváskor a munka az objektum KÜLÖNBÖZŐ példányaival történik, mivel mély másolás folyamatban volt. Kulcsszó Jelentése megakadályozza, hogy a szerverpéldány vissza legyen másolva a klienspéldányba, és az objektum belső állapotának megváltoztatása a szerveren nem okoz hasonló változást a kliensen.
Remélem, hogy ez az egyszerű szabályok listája megkönnyíti a kollégákkal kapcsolatos viták megoldását a paraméterek "érték szerinti" és "hivatkozási" megadásával kapcsolatban.
