az implicit és explicit kifejezések megszokják, amikor először hallod őket. Amikor meghallja őket a programozás szempontjából, mit jelent ez pontosan az Ön számára? Az egyik út jobb, mint a másik? Itt megyünk át minden ezeket az ötleteket, és példákat néhány tervezési minta előnyeit, hogy származhat tőlük.
A
kifejezések a programozásban, az implicit gyakran arra utalnak, hogy valami más kóddal történik az Ön számára a színfalak mögött., Explicit a kézi megközelítés a kívánt változás végrehajtásához, ha kifejezetten megírja a végrehajtandó utasításokat. A kisebb képen, implicit és explicit gyakran használt kifejezések casting típusok a típus lenne, hogy legyen. A nagyobb képen, akkor lehet beszélni egyezmény felett konfiguráció, ahol egyezmény az, amit implicit módon történik az Ön számára egy kódbázis vagy keretrendszer konfiguráció egyszerűen explicit beállításokat.,
a szóban forgó programozási nyelvtől, valamint attól függően, hogy a nyelvet statikusan gépelték-e vagy dinamikusan gépelték-e, vannak különbségek a megfelelőség vagy előny szempontjából. Attól is függ, hogy a dolgok levonhatók-e futási időből vagy összeállítás közben. Ezen tényezők miatt az állítás, hogy az egyik módszer jobb, mint a másik, csak szűk kontextusokban lehet igaz, mivel figyelembe kell vennie a szóban forgó programozási nyelvek és programok tervezését.,
A C-ben implicit és explicit típusú öntés példája a következő:
int implicit;implicit = 4.5;int explicit;explicit = (int)4.5;
itt a implicit és explicit iv id=”int. Egyszer adott érték 4.5 az implicit változat a fordító konvertálja azt, ami általában úszó vagy kettős típus egész számra, míg az explicit változat kifejezetten egész számra adta a (int) használatával.,
statikusan gépelt nyelvek
statikusan gépelt nyelveken, mint például a Rust, az értékteremtés és a hozzárendelés túlnyomó többsége explicit típusú annotációs követelményekkel rendelkezik, kivéve, ha a fordító képes a típusra következtetni. A következő példa a Rust explicit és implicit típusait mutatja be.
fn add_one(input: u8) -> u8 { input + 1}let four = add_one(3);
itt a add_one módszer explicit a bemeneti típusról és a kimeneti típusról., A szám 1 hogy ki itt az implicit egy u8 száma a fordítási idő, mint a szövegkörnyezet segít következtetni a típusát, továbbá, hogy az u8 csak végre dolgozni u8 számok. Az utolsó sort implicit módon írja be u8, mivel maga a módszer határozza meg a visszaküldendő típust.
amit a Rozsdában lehet következtetni, elég lenyűgöző a generikumok alkalmazásával. De a következtetés használata a fordításkor ismert dolgokra korlátozódik., Ha fordításkor nem ismert, akkor a hozzárendelés bármely pontján kifejezetten meg kell határoznia a típust. Vegyük a következő módszer meghatározása:
use std::ops::Add;fn add_both<T: Add>(a: T, b: T) -> T::Output { a + b}
itt T lehet bármilyen típusú, amely megvalósítja a tulajdonság Add. A T::Outputtípus akkor kerül meghatározásra, amikor az Add tulajdonság az adott típusra van definiálva, és általában ugyanaz a típus, mint a T önmagában ebben az esetben. Most, ha két számot adunk meg paraméterként, a fordító a típust rá fogja következtetni.,
let x = add_both(3 , 4 ); // implicit typelet y: u8 = add_both(3u8 , 4u8 ); // explicit typelet z: u32 = add_both(3u32, 4u32); // explicit type
a fenti kód futtatásakor x
i32 típusnak kell lennie. Ay ész példák megkövetelik, hogy a bemeneti paramétertípusok ismertek legyenek, ha a függvénynek aT::Output következtetésként adják meg, nem feltétlenül ugyanaz, mint amire a t lehet következtetni. Alapértelmezés szerint i32, majd hozzárendel egy i32u8vagy u32 egyszerűen rossz.,
dinamikusan gépelt nyelvek
most dinamikusan gépelt nyelvekkel kevésbé kell aggódnia a típusok, önmagában, és inkább az implicit vagy explicit objektumok vagy viselkedés miatt. Modellezés kód körül tárgyak, amelyek ugyanazt a viselkedést az úgynevezett duck gépelés, amely egy magasabb tartomány a gondolkodás objektum-orientált programozás, ahol kezelése ezeket az objektumokat implicit. Mivel a kód modellezése bizonyos objektumosztályok körül nagyon hasonlít az explicit vagy implicit gépeléshez., De ha bármilyen objektumot bemenetként fogad el, akkor az abban a szakaszban szereplő kódnak vagy explicit módon kell kezelnie a különböző objektumokat, vagy máshol kell átadnia ezt a felelősséget.
a tisztázáshoz, amikor kódot ír a különféle dolgok kezelésére, akkor explicit kódot ír. Ha azonban ugyanazt a kódot már megírtuk, és egy egyszerű metódushívással újra felhasználjuk,akkor a viselkedés ebben az új kontextusban implicit. Implicit lenni dolgokat tenni, mintha automatikusan kezeli kívül a jelenlegi hatálya.,
A Ruby-ban a legtöbb típusnak van egy explicit vagy implicit konverziós terve. Az ötlet az, hogy az implicit konverziós módszereket implicit kontextusokban kell használni, az explicit konverziókat pedig a fejlesztők számára sokkal több kontextusban kell írni. Hadd mutassam be ezt példával.
# explicit"4".to_i + "5".to_i# => 9# implicitclass Seven def to_int 7 endendArray.new(Seven.new)# =>
itt az explicit példa nagyon nyilvánvalóvá teszi az olvasó számára, hogy a String objektumokat egy Integer objektumra konvertáljuk, és a kettő között kiegészítést végzünk., Az implicit példa nem annyira nyilvánvaló az olvasó számára, mint aArray.new metódus implicit módon hívja a to_int metódust bármilyen paraméterre. Az Integer osztály a módszer to_int meghatározott minden egyes példánya, hogy egyszerűen vissza önálló. Ha írsz 42.to_integyszerűen kap vissza 42. Ez az implicit konverzió használata bemeneti védőként a módszerhívásokhoz nagyszerű kialakítás a típusbiztonság szempontjából. Itt van, mi történik, ha rossz típusú objektumot ad meg bemenetként, amely nem határozza meg a to_intértéket.,
Array.new("32")# TypeError (no implicit conversion of String into Integer)
nem csak nem sikerül, de hasznos üzenetet ad nekünk, hogy implicit konverziót kíséreltek meg, és megmondja az adott objektum osztályát és az elvárható objektumosztályt. Implicit konverziós módszerek Ruby egy módja annak, hogy ez az objektum valóban az, amit vársz. Az explicit konverzió pedig egyszerűen a várt típusra történő átváltást teszi lehetővé.
A Ruby implicit és explicit opciókkal rendelkezik számos alapvető objektumához.,
A Ruby-nak is van néhány osztálya osztálymódszerekkel, amelyek implicit konverziót vagy nulla visszatérést végeznek, és ez a módszer neve try_convert.
követhetjük Ruby példa a Array.new egy jó őr a fajta bemeneti paraméterek vagyunk által megadott tervezése implicit konverzió a saját egyéni típusú. Ebben a példában, mivel ato_f explicit konverzió egy Float számra a Ruby-ban aas_ előtagként használjuk ato_helyett., Íme egy alapvető példa az implicitségre, mint a biztonság mintájára.
most ez segít más fejlesztőknek, akik a Bar osztályt használják, hogy ne adják át inkompatibilis paraméterként. Ez a Ruby nyelven belüli egyezményt követi, és a fejlesztőknek sokkal könnyebben meg kell érteniük a hasznos hibákat. Ha van más objektum, amelyet Foo objektummá szeretne konvertálni, akkor megadhat egy as_f módszert egy explicit konverzióhoz, és az új objektumot használó Fejlesztő explicit lesz a használatában Bar.new(Baz.new.as_f)., Ez biztosítja, hogy a kód úgy működjön, hogy a Barés a Foo már működik.
összefoglaló
az implicit és explicit kódolás, valamint implicit és explicit kódját a további viselkedés vagy típusbeállítás/öntés végrehajtásának kontextusa határozza meg. Pontosabban, az implicit vagy explicit módszereket azok a kontextusok határozzák meg, amelyekben ezeket használni kell. Implicit kód lehet egy nagyon szép élmény, ha a dolgok jól elemzi, mert tartja a dolgokat egyszerű.,
azonban implicit kód, Kód csinál dolgokat a színfalak mögött az Ön számára, is lehet egy nehéz kérdés, hogy megoldja, ha rosszul. Explicit kód teszi a kódot egyértelmű, ha megnézzük, hogy a sajátosságait, hogy mi történik már lefektetett, mielőtt, és nem kell nyomon követni a kérdéseket máshol, de általában azt jelenti, sokkal több munkát írásban is. Önmagában is elsöprő, így megtalálni a megfelelő egyensúlyt a kettő között gyakran a legjobb megoldás. Legyen explicit, ha kell, és implicit, ha a tervezési és elnevezési fogalmak könnyen érthető., Ez egy kényelmesebb fejlesztési élményt nyújt.