Sammanhållning, koppling och separering av ansvar
Bemästra tre grundläggande egenskaper inom programvarudesign som avgör om kod förblir underhållbar: hög sammanhållning, låg koppling och tydlig separering av ansvar.
Sammanhållning, koppling och separering av ansvar är en gratis lektion i Clean Architecture och designmönster i praktiken på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Clean Architecture och designmönster i praktiken, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Clean Architecture och designmönster i praktiken innehåller totalt 4 lektioner.
Varför dessa egenskaper är viktiga
Under clean code och SOLID finns tre djupare design egenskaper: kohesion, koppling och separation av ansvarsområden. De förklarar varför reglerna fungerar.
Vad är kohesion
Kohesion mäter hur väl en moduls ansvarsområden hör ihop. Hög kohesion = en väldefinierad uppgift; låg kohesion = en samling orelaterade metoder.
Låg kontra hög kohesion
Jämför de två: klassen Util blandar orelaterade ansvarsområden, medan UserRepository är tydligt fokuserad. Det fokuset är hög kohesion.
// Low cohesion
class Util {
saveUser() {}
sendEmail() {}
formatDate() {}
}
// High cohesion
class UserRepository {
save() {}
findById() {}
}Vad är koppling
Koppling mäter hur mycket en modul är beroende av en annan moduls interna delar. Tät koppling sprider ändringar överallt; lös koppling håller interaktionerna begränsade.
Exempel på tät koppling
Här skapar OrderService sin egen SmtpMailer, vilket binder den till just den klassen. Att byta mailer kräver att tjänsten redigeras — tät koppling.
class OrderService {
constructor() {
this.mailer = new SmtpMailer();
}
}Minska kopplingen
Injicera i stället mailern. Nu beror OrderService på en abstraktion och kan ta emot valfri implementation. Det är lös koppling.
class OrderService {
constructor(mailer) {
this.mailer = mailer;
}
}Den ideala balansen
Den ideala balansen är hög kohesion och lös koppling tillsammans: fokuserade moduler som förblir oberoende, så att system är enkla att ändra, testa och förstå.
Separation av ansvarsområden
Separation av ansvarsområden innebär att dela upp ett program så att varje del ansvarar för ett tydligt avgränsat område — håll användargränssnitt, affärslogik och dataåtkomst i separata lager.
Blandade ansvarsområden
Den här funktionen blandar dataåtkomst, logik och presentation. Om ni ändrar ett ansvarsområde riskerar ni att de andra går sönder — blandade ansvarsområden.
function showTotal(id) {
const rows = db.query('SELECT * FROM orders WHERE id=' + id);
const total = rows.reduce((s, r) => s + r.price, 0);
document.body.innerHTML = 'Total: ' + total;
}Separerade ansvarsområden
Dela upp den i ett repository, en kalkylator och en vy. Nu kan varje ansvarsområde ändras och testas oberoende. Betydligt renare.
const order = repository.findById(id);
const total = calculator.total(order);
view.render(total);Hur de hänger samman med SOLID
Dessa egenskaper utgör grunden för SOLID: principen om ett enda ansvar driver kohesion, beroendeinversion driver lös koppling och lagerindelning uttrycker separation av ansvarsområden.
Snabb kontroll
Hög kohesion, lös koppling — kan ni skilja dem åt?
Sammanfattning
Ni har grunderna: kohesion håller samman relaterat arbete, lös koppling minimerar beroenden och separation av ansvarsområden delar upp koden efter syfte.
Lär dig Clean Architecture och designmönster i praktiken med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 12
- Lektioner
- 48
Vanliga frågor
Är lektionen ”Sammanhållning, koppling och separering av ansvar” gratis?
Ja – hela texten till ”Sammanhållning, koppling och separering av ansvar” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Clean Architecture och designmönster i praktiken, kan Ni uppgradera till CoddyKit PRO. Kursen i Clean Architecture och designmönster i praktiken innehåller totalt 4 lektioner.
Vad lär jag mig i ”Sammanhållning, koppling och separering av ansvar”?
Bemästra tre grundläggande egenskaper inom programvarudesign som avgör om kod förblir underhållbar: hög sammanhållning, låg koppling och tydlig separering av ansvar. Ni övar på Clean Architecture och designmönster i praktiken med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Clean Architecture och designmönster i praktiken?
Du behöver inga förkunskaper. Utbildningen i Clean Architecture och designmönster i praktiken på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.
Hur lång tid tar lektionen ”Sammanhållning, koppling och separering av ansvar”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Clean Architecture och designmönster i praktiken-lektionen?
Ja. Varje Clean Architecture och designmönster i praktiken-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Introduktion till Clean Code
- Översikt över SOLID-principerna
- Värdet av god design
- Sammanhållning, koppling och separering av ansvar