Funkciónév, amely and absztrakciós szint nem megfelelő .

A addResponseIdToDB() felé hajlok, mert különben a „mellékhatás” teljes meglepetés. Azonban:

responseIds = addResponseIdToDB(); 

senkit sem lep meg.

A parancs lekérdezés felelősségi elkülönítésének elve azt állítja, hogy ez nem lehet az egyetlen módja a responseId objektum megszerzésének. Legyen olyan lekérdezés is, amely nem változtatja meg az objektumot megszerezni tudó DB-t.

A Bertrand Meyer -vel ellentétben nem hiszem, hogy ez azt jelenti, hogy az add-nak érvénytelennek kell lennie. Csak annyit jelent, hogy egyenértékű tiszta lekérdezésnek kell léteznie és könnyen megtalálható, így a DB-t nem használják feleslegesen az állapotváltozó lekérdezések.

_{Tekintettel arra, hogy getResponseIds() léteznie kell, és nem az adatbázissal kell beszélnie, akkor a metódus legjobb neve, amely mindkettőt elvégzi, valójában addToDB(getResponseId()). De ez csak akkor van, ha minden funkcionális összetételt meg akarsz szerezni róla.}

Megjegyzések

• Hozzáadva az elmondottakhoz, de hozzáadva egy olyan szót, amely még nem használt ‘ t, azt mondanám, hogy ” és ” akkor megfelelő, ha egy függvény valami olyasmit tesz, ami atomi . Ha előnye származhat abból, ha két dolog egyszerre atomikusan / együtt / egyszerre történik, akkor egyértelművé válik, hogy ez a két dolog mi van a függvényben a név jó. Tehát általában egyetértek az első állításoddal, de minősítés nélkül nem értek egyet.
• ” … nem hagy senkit meglepett. “. Nem értek egyet, én ‘ m meglepve távoztam, hogy egy logikai változót és ezután mentális váltást kell végeznem, hogy rájöjjek, hogy ez mindent összead és egyben kap. De nem értek egyet a @tintintong véleményével, hogy getAndAddResponseIdsToDB túl hosszú; Ez ‘ a függvényneveim nagyon sok felének kb. Ha egy függvény két dolgot végez, akkor mondja el a nevében.
• @Luaan OK, akkor mit fog átnevezni a getAndIncrement címre? otherIncrement?
• @Luaan Tehát melyik érték ad vissza Increment, az érték előre növekszik vagy növekszik? ‘ nem világos, hogy mi lenne az, ha nem merülne el a dokumentumokba.Szerintem a incrementAndGet és a getAndIncrement sokkal jobb metódusnevek, ami véleményem szerint jó eset a ” ÉS ” a metódusnevekben, legalábbis azoknak a speciális eseteknek, amelyeknek olyan mellékhatásai vannak, amelyek befolyásolhatják a visszatérési értéket.
• @Luaan Ha azt mondja, hogy ” A növekmény a növekményes értéket adja vissza “, akkor a növekedés előtti értékre gondol? Gotcha, először félreértettél. ami valójában remek példa arra, hogy miért getAndIncrement és incrementAndGet jobb név, mint csak increment, még akkor is, ha egyénileg vesszük figyelembe

Amint mások említették, az and használata a függvény nevében automatikusan azt jelenti, hogy egy függvény legalább két dolgot csinál, ami általában azt jelzi, hogy túl sokat vagy valamit csinál rossz helyen van.

A and záradék használata egy függvénynévben, tapasztalatom szerint azonban értelmes lehet, ha egy bizonyos folyamatban vannak olyan lépések, amelyek sorrendben kell végrehajtani, vagy amikor az egész számítás értelmessé válik.

A numerikus számítás során ennek sok értelme lehet:

normalizeAndInvert(Matrix m)

Úgy értem, ki tudja, igaz? Ha ki kell számolnia néhányat … mondjuk, a világítási pályákat a számítógépes grafikában és egy bizonyos a szakaszban normalizálnia és invertálnia kell egy bizonyos mátrixot, és azon kapja magát, hogy folyamatosan írja:

m = normalize(m), majd invert(m) csak egy egyszerű példa, amely bemutatja a normalizálás és az invertálás absztrakcióját, olvashatóság szempontjából jó lehet.

Szemantikailag beszélve például divideAndConquer() stb. valószínűleg nem ajánlott kifejezetten kiírni, de hát az ottani And alapvetően szükséges.

Megjegyzések

• A funkciók rendszeresen több dolgot is végeznek, de ezeknek apróságoknak kell lenniük egy nagy dologként, ami ‘ értelmesebbek magasabb szinten. normalizeAndInvert lehet computeLighting és divideAndConquer lehet applyMachiavelli
• Nyilvánvaló 🙂 Csak annyit mondok, hogy először létre kell hozni egy függvényt egy ” és ” névvel természetes kontextuson alapuló absztrakcióként jöhet. A ” Átnevezés módszerrel történő átdolgozás a ” módszerrel azonnal utána kell;)
• @BrunoOliveira Kivéve, ha néha a két lépés: önmaguk sok dolog alkotóelemeként, az átnevezés nem ‘ t a helyes megközelítés. És ennek ritkának kell lennie, de soha nem használja azt, hogy ‘ ismétli önmagát.

Valóban, ez a kérdés nehezen megválaszolható, mivel számos megjegyzés igazolhatja. Úgy tűnik, hogy az emberek ellentmondásos véleményekkel és tanácsokkal rendelkeznek mi a jó név.

Szeretném hozzáadni a 2 centemet ehhez a 2 hónapos szálhoz, mert úgy gondolom, hogy további színeket adhatok a már javasoltakhoz.

A névadás folyamat

Mindez a 6 lépéses kiváló útmutatóra emlékeztet: A névadás folyamatként .

A gyenge funkció neve meglepő, és rájössz, hogy nem bízhatsz meg. A jó névadás nehéz az első lövéskor. A tapasztalattal könnyebbé válik.

6 ismétlődő lépés a jó név felépítéséhez

1. A meglepő nevet cserélje ki nyilvánvaló hülyeségre mint appleSauce(). Ostobának hangzik, de ideiglenes, és nyilvánvalóvá teszi, hogy a névben nem lehet megbízni.
2. Becsületes névhez jutni , annak alapján, amit a függvény működéséből megért. Mondja, hogy még nem értette a DB részbe történő beszúrást, a getResponseIdsAndProbablyUseDb lehetőség lenne.
3. Get teljesen őszinte , tehát a függvény neve mindent elmond, amit a függvény (getAndAddResponseIdsToDB vagy getResponsesButAlsoAddCacheOfTheResponsesToTheDb a @Fattie-ből nagyszerű példák)
4. A “helyesen cselekszik” elérése, ami alapvetően az a rész, ahol a funkcióját az “AND” mentén osztja fel. Tehát valóban van getResponseIds és addResponseIdsToDb.
5. Eljut egy “szándék felfedő” névhez , amely megoldja a “Mindig meg akarom szerezni az I válaszazonosítót” pontot beillesztve a DB-be, miután ezt megtettem “. Ne gondolkozzon a megvalósítás részletein, és készítsen egy absztrakciót, amely a 2 legkisebb függvényt használja valami más felépítéséhez. Ez az a magasabb absztrakciós szint, amelyet @candied_orange említett. Az xample createResponseIds megteheti, és a getResponseIds és a addResponseIdsToDb összetétele lesz.
6. Lépjen be a domain absztrakciójába . Ez nehéz, a vállalkozásodtól függ. Időbe telik, amíg az üzleti nyelvét hallgatja, hogy helyreálljon. Végül a Response és az Response.createIds() értelmének lehet a vége. Vagy talán a ResponseId valami értékes dolog, és gyárad lenne sok létrehozására. A DB-be való beillesztés a Repository megvalósítási részlete lenne, stb. Igen, a tervezés elvontabb lenne. Gazdagabb lenne, és hagyná, hogy többet fejezzen ki. A csapatán kívül senki sem tudja megmondani, hogy mi legyen a megfelelő domain absztrakció az Ön helyzetében. Attól függ .

Esetedben már kitaláltad az 1-et és a 2-et, ezért valószínűleg legalább a 3-ra kell menned (használd az “ÉS” szót) vagy tovább. De a továbbjutás nem csak a megnevezés kérdése, hanem tulajdonképpen megosztaná a felelősséget.

Így az itt található különböző javaslatok érvényesek

Lényegében:

• Igen, a meglepő függvénynevek szörnyűek, és senki sem akar ezzel foglalkozni.
• Igen, az “ÉS” elfogadható egy függvénynévben, mert jobb, mint egy félrevezető név. / li>
• Igen, az absztrakció szintje összefüggő fogalom, és számít.

Nem kell azonnal a 6. szakaszra menni, jó, ha itt maradsz 2., 3. vagy 4. szakasz, amíg jobban nem tudod!

Remélem, hogy ez hasznos lehet, ha más perspektívát adunk az ellentmondásos tanácsoknak. Úgy gondolom, hogy mindenki ugyanarra a célra törekszik ( nem meglepő nevek), de a saját tapasztalataik alapján különböző szakaszokban állnak meg.

Örömmel válaszolok, ha bármilyen kérdése van 🙂

A funkciója két dolgot végez:

1. Azonosító készletet kap átalakítás útján, és visszaküldi őket a hívónak,
2. beírja az azonosítókészletet egy adatbázisba.

Ne feledje itt az egyetlen felelősség elvét: funkcióra kell törekednie. hogy egy felelősség legyen, ne kettő. Két feladata van, ezért két funkciója van:

getResponseIds – Átalakítással megszerzi az azonosítók készletét, és visszaadja azokat a hívónak
addResponseIdToDB – Fog egy azonosító készletet, és beírja őket egy adatbázisba.

És elmúlik az egész kérdés, hogy mit nevezhetünk egyetlen funkciónak, több felelősséggel, és megszűnik a kísértés, hogy a and -t a függvénynevekbe is beírjuk.

További bónuszként, mivel ugyanaz a függvény már nem felelős két, egymással nem összefüggő műveletért, a getResponseIds áthelyezhető a repo kódból (ahova nem tartozik) mivel nem végez semmilyen DB-vel kapcsolatos tevékenységet), külön üzleti szintű osztályba / modulba stb.

Megjegyzések

• Ez ‘ s bizonyára igaz, de azon kapod magad, hogy sokszor megismételsz egy részletet ezzel a két SRP módszerrel, akkor valószínűleg egy triviális metódust kell írnod ezzel, hogy SZÁRÍTS, nem kéne ‘ t vagy?
• @maaartinus, ha azt találod, hogy sok helyen hívod ezt a két módszert, akkor valószínűleg problémád van a kohézió hiányával a kódodban. A ” DRY ” függvény létrehozása csak elfedi az összetartás hiányát.

Az összetett függvénynév elfogadható, tehát melyik elnevezési séma függ a kontextustól. Vannak puristák, akik azt mondják, hogy bontsd szét, de én másként érvelek.

Két oka van annak, hogy megpróbáld elkerülni az ilyen dolgokat:

• Tisztaság – Egy funkció két dolgot két funkcióvá kell alakítani, amelyek egy-egy dolgot végeznek.
• Lexikai méret – egy bigUglyCompositeFunctionName nehezen olvasható.

A tisztasági érv általában az, amelyre összpontosít. Homályos általános heurisztikaként a funkciók szétbontása jó dolog. Segít szétosztani a történteket, megkönnyítve annak megértését. Kevésbé valószínű, hogy “okos” trükköket fog végrehajtani a változók megosztásával, amelyek a két viselkedés összekapcsolódásához vezetnek.

Tehát azt kell feltenned magadnak, hogy “tegyem-e mégis?” Azt mondom, hogy a dolgok szétbontása homályos heurisztikus, ezért valójában csak egy tisztességes érvre van szükséged, ha ellene akarsz állni. Ennek végső példája az atomi műveletekben található: compare_and_set. A compare_and_set az atomok sarokköve (amelyek többféle szálat is használhatnak zárak nélkül), amely elég sikeres ahhoz, hogy sokan hajlandók a nak gondolni sarokkövet. Van “és” ezen a néven. Ennek nagyon jó oka van. Ennek a műveletnek az a lényege, hogy az összehasonlítást és a beállítást oszthatatlan műveletként hajtja végre. Ha felosztotta a következőt: compare() és set(), akkor megdönti a függvény létezésének teljes okát, mert két compares() visszafelé fordulhat elő a set() s előtt.

Ezt a teljesítményben is látjuk. Kedvenc példám: fastInvSqrt . Ez a Quake egyik híres algoritmusa, amely 1 / sqrt (x) értéket számol. Kombináljuk az “inverz” és a “négyzetgyök” műveleteket, mert ezzel megadjuk hatalmas teljesítménynövekedést biztosítunk. Newton-közelítést végeznek, amely mindkét műveletet egyetlen lépésben hajtja végre (és történetesen egész matematika helyett lebegőpontos, ami a korszakban fontos volt). Ha a inverse(sqrt(x)) tenné, sokkal lassabban haladna!

Vannak esetek, amikor az eredmény egyértelműbb. Számos API-t írtam, amelyekben szálak vannak, ahol rettenetesen kell vigyázni az olyan dolgokra, mint a holtpontok. Nem akartam, hogy a felhasználóm tisztában legyen a belső megvalósítás részleteivel (főleg, hogy esetleg megváltoztatom őket), ezért az néhány “és” funkció, amelyek megakadályozták a felhasználót abban, hogy egynél több funkcióhíváshoz mindig zárat kelljen tartania. Ez azt jelenti, hogy soha nem kellett tudniuk, hogyan kezelem a többszálas szinkronizációt a motorháztető alatt. Valójában a legtöbb felhasználóm nem is tudta, hogy többszálas környezetben vannak!

Tehát bár az általános szabály a dolgok szétbontása, mindig lehet oka összekapcsolni őket. Például , meg tudja-e bontani a felhasználó az architektúráját úgy, hogy többször is hozzáad egy adatbázishoz anélkül, hogy a “bejutás” bekerülne? Ha a DB-be bejelentkezett válaszok mindegyikének egyedi azonosítóval kell rendelkeznie, akkor bajba kerülhet, ha a felhasználónak ezt akarva kell megtennie sem. Hasonlóképpen, szeretnéd valaha is engedélyezni, hogy a felhasználó “beérjen” anélkül, hogy az eredményeket bejegyezné a DB-be? Ha a válasz “igen”, akkor bontsd szét őket, hogy a felhasználó hozzáférhessen a “get” funkcióhoz. Ha azonban a Az alkalmazás biztonsága megromlott, ha a felhasználó “be tud jutni” anélkül, hogy az eredményt be kellene jegyezni a DB-be, akkor valóban együtt kell tartania a függvényeket.

Ami a lexikális kérdéseket illeti, a függvény nevének leírnia kell, hogy mit a felhasználónak tudnia kell róla. Kezdjük a “get” résszel.Elég könnyű eltávolítani a “get” funkciót egy függvény nevéből, mert az összes példában megjelenik egy hozzárendelés: int id = addResponseIdToDB() “. Minden olyan helyen, ahol a függvényt használjuk, befejezzük dokumentálja azt a tényt, hogy a függvény értéket adott.

Hasonlóképpen az “add” opcionális is lehet. A “mellékhatás” kifejezést mindenre kiterjedő kifejezésként használjuk, de ennek különböző árnyalatai vannak. Ha a DB bejegyzések csupán naplók, akkor lehet, hogy nincs oka annak kiemelésére. Soha nem látunk olyan funkciókat, mint a playMusicAndSendPersonalInformationToOurCorporateServers. Csak playMusic, és ha szerencséje van, a dokumentáció említhet valamit az interneten keresztüli socket kapcsolatról. Másrészt, ha a felhasználók várhatóan meghívják ezt a függvényt a dolgok hozzáadása céljából a DB-hez, akkor az “add” elengedhetetlen. Ne vedd ki.

Most nagyon sok okot írtam arra, hogy minden lehetséges kombinációt elvégezzek, amit kérsz. Szándékosan nem válaszoltam a kérdésre, mert választani kell. Nem követendő szabály. Ön létrehoz egy API-t.

Ennek ellenére az az ösztönöm, hogy valószínűleg az addResponseIdToDB lesz a legjobb válasz. A legtöbb esetben a “get” rész elég nyilvánvaló mellékhatás, hogy nem éri el a plusz zajt, amelyet mindenhova beír. Azonban kevés olyan hely van, ahol fontosnak tarthatnám:

• Ha a “get” drága – Ha olyan “get” -et kell tennie, amely magában foglalja az interneten való letöltést, majd a helyi gyorsítótár-adatbázisba való felvételt, akkor mindenképpen fontos a “get”. Ez az a dolog, amelyet a felhasználó megpróbál.
• Ha világossá kell tennie, hogy a felhasználónak kell figyelnie az értékre. Ha a felhasználó használni akarja a változót, akkor rájön, hogy az API visszaadja, és felhasználja. Vigyázni kell azonban arra a felhasználóra, aki nem tudja, hogy szüksége van rá. Például, ha később memória felszabadítása érdekében ID-vel kell bezárnia ezt a műveletet, érdemes felhívnia a figyelmet arra, hogy “csinál valamit. Ezekben az esetekben érdemes a “get” -től eltérő igét keresni. A “get” gyakran idempotens függvényeket tartalmaz (ha újból felhívjuk, nem csinál semmit). Ha erőforrásokat ad vissza, akkor más igék, mint például a “create” vagy a “megszerzés”, jóak. Ez a bizonyos hibamechanizmus a C egyik fő problémája a kivételkezelés során . A C-ben nincs a C ++ elkapási / dobási mechanizmusa, ezért a visszatérési kódokra támaszkodik. A fejlesztők híresek arról, hogy egyszerűen nem ellenőrizték ezeket a visszatérési kódokat, és nagyon rossz helyzetekbe keveredtek, például a puffertúlcsordulás miatt.
• Szimmetria – Néha úgy tervez meg egy API-t, hogy legyen vele lexikai szimmetriája. Úgy állítja be a szavakat, hogy azok párban vagy más mintákban legyenek, és a parancsokat úgy alakítja ki, hogy vizuálisan könnyen azonosítható legyen. hogy a mintát követték-e vagy sem. Azt mondanám, hogy ez ritka, de nem hallatlan. Ezért az XML-címkék bezárása megismétli a címke nevét (például < foo > és < / foo >).

Megjegyzések

• Olyan emberek számára, akik nem div id = “6a2f57beef”>