SOLID ஐப் பயன்படுத்தி நெகிழ்வான குறியீட்டை எழுதுதல்

மொழிபெயர்ப்பாளரிடமிருந்து: உங்களுக்காக வெளியிடப்பட்டது செவெரின் பெரெஸின் கட்டுரை நிரலாக்கத்தில் SOLID கொள்கைகளைப் பயன்படுத்துவது பற்றி. கட்டுரையில் உள்ள தகவல்கள் ஆரம்ப மற்றும் அனுபவம் வாய்ந்த புரோகிராமர்களுக்கு பயனுள்ளதாக இருக்கும்.

நீங்கள் வளர்ச்சியில் இருந்தால், SOLID கொள்கைகளைப் பற்றி நீங்கள் கேள்விப்பட்டிருக்கலாம். அவை புரோகிராமருக்கு சுத்தமான, நன்கு கட்டமைக்கப்பட்ட மற்றும் எளிதில் பராமரிக்கக்கூடிய குறியீட்டை எழுத உதவுகின்றன. நிரலாக்கத்தில் ஒரு குறிப்பிட்ட வேலையை எவ்வாறு சரியாகச் செய்வது என்பதற்கு பல அணுகுமுறைகள் உள்ளன என்பது கவனிக்கத்தக்கது. வெவ்வேறு நிபுணர்களுக்கு வெவ்வேறு யோசனைகள் மற்றும் "சரியான பாதை" பற்றிய புரிதல் உள்ளது; இவை அனைத்தும் ஒவ்வொரு நபரின் அனுபவத்தைப் பொறுத்தது. இருப்பினும், SOLID இல் அறிவிக்கப்பட்ட யோசனைகள் IT சமூகத்தின் கிட்டத்தட்ட அனைத்து பிரதிநிதிகளாலும் ஏற்றுக்கொள்ளப்படுகின்றன. அவை பல நல்ல வளர்ச்சி மேலாண்மை நடைமுறைகளின் தோற்றம் மற்றும் வளர்ச்சிக்கான தொடக்க புள்ளியாக அமைந்தன.

SOLID கொள்கைகள் என்ன, அவை நமக்கு எவ்வாறு உதவுகின்றன என்பதைப் புரிந்துகொள்வோம்.

Skillbox பரிந்துரைக்கிறது: நடைமுறை படிப்பு "மொபைல் டெவலப்பர் புரோ".

நாங்கள் நினைவூட்டுகிறோம்: "Habr" இன் அனைத்து வாசகர்களுக்கும் - "Habr" விளம்பரக் குறியீட்டைப் பயன்படுத்தி எந்த Skillbox படிப்பிலும் சேரும்போது 10 ரூபிள் தள்ளுபடி.

SOLID என்றால் என்ன?

இந்த சொல் ஒரு சுருக்கமாகும், இந்த வார்த்தையின் ஒவ்வொரு எழுத்தும் ஒரு குறிப்பிட்ட கொள்கையின் பெயரின் தொடக்கமாகும்:

• Sஒற்றை பொறுப்புக் கொள்கை. ஒரு தொகுதி மாற்றத்திற்கு ஒரே ஒரு காரணத்தைக் கொண்டிருக்கலாம்.
• தி Oபேனா / மூடிய கொள்கை (திறந்த/மூடிய கொள்கை). வகுப்புகள் மற்றும் பிற கூறுகள் நீட்டிப்புக்காக திறந்திருக்க வேண்டும், ஆனால் மாற்றத்திற்காக மூடப்பட்டிருக்க வேண்டும்.
•  தி Liskov மாற்றுக் கொள்கை (லிஸ்கோவ் மாற்றுக் கொள்கை). அடிப்படை வகையைப் பயன்படுத்தும் செயல்பாடுகள், அடிப்படை வகையின் துணை வகைகளைத் தெரியாமல் பயன்படுத்த முடியும்.
• தி Iஇடைமுகம் பிரித்தல் கோட்பாடு  (இடைமுகம் பிரிக்கும் கொள்கை). மென்பொருள் நிறுவனங்கள் அவர்கள் பயன்படுத்தாத முறைகளை சார்ந்து இருக்கக்கூடாது.
• தி Dependency inversion Principle (சார்பு தலைகீழ் கொள்கை). உயர் மட்டங்களில் உள்ள தொகுதிகள் கீழ் மட்டங்களில் உள்ள தொகுதிகளைச் சார்ந்து இருக்கக்கூடாது.

ஒற்றைப் பொறுப்புக் கொள்கை

 
ஒற்றைப் பொறுப்புக் கோட்பாடு (SRP) ஒரு நிரலில் உள்ள ஒவ்வொரு வகுப்பும் அல்லது தொகுதியும் அந்த நிரலின் செயல்பாட்டின் ஒரு பகுதிக்கு மட்டுமே பொறுப்பாக இருக்க வேண்டும் என்று கூறுகிறது. கூடுதலாக, இந்தப் பொறுப்பின் கூறுகள் தொடர்பில்லாத வகுப்புகளில் சிதறாமல், அவர்களின் சொந்த வகுப்பிற்கு ஒதுக்கப்பட வேண்டும். SRP இன் டெவலப்பர் மற்றும் தலைமை சுவிசேஷகர், ராபர்ட் எஸ். மார்ட்டின், பொறுப்புக்கூறல் மாற்றத்திற்கான காரணம் என்று விவரிக்கிறார். அவர் முதலில் இந்த சொல்லை அவரது படைப்பின் கூறுகளில் ஒன்றாக "பொருள் சார்ந்த வடிவமைப்பின் கொள்கைகள்" என்று முன்மொழிந்தார். டாம் டிமார்கோவால் முன்னர் வரையறுக்கப்பட்ட இணைப்பு முறையின் பெரும்பகுதியை இந்த கருத்து ஒருங்கிணைக்கிறது.

டேவிட் பர்னாஸ் வடிவமைத்த பல கருத்துருக்களையும் உள்ளடக்கியது. இரண்டு முக்கியமானவை இணைத்தல் மற்றும் தகவல்களை மறைத்தல். ஒரு கணினியை தனி தொகுதிகளாகப் பிரிப்பது, தொகுதி வரைபடங்கள் அல்லது செயல்படுத்தல் ஓட்டங்களின் பகுப்பாய்வு அடிப்படையில் இருக்கக்கூடாது என்று பர்னாஸ் வாதிட்டார். எந்தவொரு தொகுதியிலும் வாடிக்கையாளர்களுக்கு குறைந்தபட்ச தகவலை வழங்கும் ஒரு குறிப்பிட்ட தீர்வு இருக்க வேண்டும்.

மூலம், மார்ட்டின் ஒரு நிறுவனத்தின் மூத்த மேலாளர்களுடன் (COO, CTO, CFO) ஒரு சுவாரஸ்யமான உதாரணத்தைக் கொடுத்தார், அவர்கள் ஒவ்வொருவரும் வெவ்வேறு நோக்கங்களுக்காக குறிப்பிட்ட வணிக மென்பொருளைப் பயன்படுத்துகின்றனர். இதன் விளைவாக, அவர்களில் எவரும் மற்ற மேலாளர்களின் நலன்களைப் பாதிக்காமல் மென்பொருளில் மாற்றங்களைச் செயல்படுத்த முடியும்.

தெய்வீக பொருள்

எப்பொழுதும் போல, எஸ்ஆர்பியை கற்றுக்கொள்வதற்கான சிறந்த வழி, அதை செயலில் பார்ப்பதுதான். ஒற்றைப் பொறுப்புக் கொள்கையைப் பின்பற்றாத திட்டத்தின் ஒரு பகுதியைப் பார்ப்போம். இது ரூபி குறியீடு ஆகும், இது விண்வெளி நிலையத்தின் நடத்தை மற்றும் பண்புகளை விவரிக்கிறது.

உதாரணத்தை மதிப்பாய்வு செய்து பின்வருவனவற்றை தீர்மானிக்க முயற்சிக்கவும்:
விண்வெளி நிலைய வகுப்பில் அறிவிக்கப்பட்ட பொருட்களின் பொறுப்புகள்.
விண்வெளி நிலையத்தின் செயல்பாட்டில் ஆர்வம் உள்ளவர்கள்.

class SpaceStation
  def initialize
    @supplies = {}
    @fuel = 0
  end
 
  def run_sensors
    puts "----- Sensor Action -----"
    puts "Running sensors!"
  end
 
  def load_supplies(type, quantity)
    puts "----- Supply Action -----"
    puts "Loading #{quantity} units of #{type} in the supply hold."
    
    if @supplies[type]
      @supplies[type] += quantity
    else
      @supplies[type] = quantity
    end
  end
 
  def use_supplies(type, quantity)
    puts "----- Supply Action -----"
    if @supplies[type] != nil && @supplies[type] > quantity
      puts "Using #{quantity} of #{type} from the supply hold."
      @supplies[type] -= quantity
    else
      puts "Supply Error: Insufficient #{type} in the supply hold."
    end
  end
 
  def report_supplies
    puts "----- Supply Report -----"
    if @supplies.keys.length > 0
      @supplies.each do |type, quantity|
        puts "#{type} avalilable: #{quantity} units"
      end
    else
      puts "Supply hold is empty."
    end
  end
 
  def load_fuel(quantity)
    puts "----- Fuel Action -----"
    puts "Loading #{quantity} units of fuel in the tank."
    @fuel += quantity
  end
 
  def report_fuel
    puts "----- Fuel Report -----"
    puts "#{@fuel} units of fuel available."
  end
 
  def activate_thrusters
    puts "----- Thruster Action -----"
    if @fuel >= 10
      puts "Thrusting action successful."
      @fuel -= 10
    else
      puts "Thruster Error: Insufficient fuel available."
    end
  end
end

உண்மையில், எங்கள் விண்வெளி நிலையம் செயலிழந்துள்ளது (எப்போது வேண்டுமானாலும் நாசாவிடமிருந்து எனக்கு அழைப்பு வரும் என்று நான் நினைக்கவில்லை), ஆனால் இங்கே பகுப்பாய்வு செய்ய ஏதாவது உள்ளது.

எனவே, ஸ்பேஸ்ஸ்டேஷன் வகுப்பிற்கு பல்வேறு பொறுப்புகள் (அல்லது பணிகள்) உள்ளன. அவை அனைத்தையும் வகைகளாகப் பிரிக்கலாம்:

• உணரிகள்;
• பொருட்கள் (நுகர்பொருட்கள்);
• எரிபொருள்;
• முடுக்கிகள்.

நிலையத்தின் ஊழியர்கள் யாருக்கும் வகுப்பு ஒதுக்கப்படவில்லை என்றாலும், எதற்கு யார் பொறுப்பு என்பதை நாம் எளிதாக கற்பனை செய்து கொள்ளலாம். பெரும்பாலும், விஞ்ஞானி சென்சார்களைக் கட்டுப்படுத்துகிறார், தளவாட நிபுணர் வளங்களை வழங்குகிறார், பொறியாளர் எரிபொருள் விநியோகத்திற்கு பொறுப்பு, மற்றும் பைலட் பூஸ்டர்களைக் கட்டுப்படுத்துகிறார்.

இந்த திட்டம் SRP இணக்கமானது அல்ல என்று சொல்ல முடியுமா? ஆம், கண்டிப்பாக. ஆனால் ஸ்பேஸ் ஸ்டேஷன் வகுப்பு என்பது ஒரு பொதுவான "கடவுள் பொருள்" ஆகும், அது எல்லாவற்றையும் அறிந்திருக்கிறது மற்றும் எல்லாவற்றையும் செய்கிறது. பொருள் சார்ந்த நிரலாக்கத்தில் இது ஒரு முக்கிய எதிர்ப்பு வடிவமாகும். ஒரு தொடக்கக்காரருக்கு, அத்தகைய பொருட்களை பராமரிப்பது மிகவும் கடினம். இதுவரை நிரல் மிகவும் எளிமையானது, ஆம், ஆனால் புதிய அம்சங்களைச் சேர்த்தால் என்ன நடக்கும் என்று கற்பனை செய்து பாருங்கள். ஒருவேளை நமது விண்வெளி நிலையத்திற்கு மருத்துவ நிலையம் அல்லது சந்திப்பு அறை தேவைப்படலாம். மேலும் செயல்பாடுகள் அதிகமாக இருந்தால், அதிக விண்வெளி நிலையம் வளரும். சரி, இந்த வசதி மற்றவர்களுடன் இணைக்கப்படுவதால், முழு வளாகத்திற்கும் சேவை செய்வது இன்னும் கடினமாகிவிடும். இதன் விளைவாக, எடுத்துக்காட்டாக, முடுக்கிகளின் செயல்பாட்டை நாம் சீர்குலைக்கலாம். ஒரு ஆராய்ச்சியாளர் சென்சார்களில் மாற்றங்களைக் கோரினால், இது நிலையத்தின் தகவல் தொடர்பு அமைப்புகளை நன்றாகப் பாதிக்கும்.

SRP கொள்கையை மீறுவது ஒரு குறுகிய கால தந்திரோபாய வெற்றியைக் கொடுக்கலாம், ஆனால் இறுதியில் நாம் "போரை இழப்போம்", மேலும் எதிர்காலத்தில் அத்தகைய அரக்கனை பராமரிப்பது மிகவும் கடினமாகிவிடும். நிரலை குறியீட்டின் தனி பிரிவுகளாகப் பிரிப்பது சிறந்தது, ஒவ்வொன்றும் ஒரு குறிப்பிட்ட செயல்பாட்டைச் செய்வதற்கு பொறுப்பாகும். இதைப் புரிந்துகொண்டு, ஸ்பேஸ்ஸ்டேஷன் வகுப்பை மாற்றுவோம்.

பொறுப்பை பகிர்ந்தளிப்போம்

மேலே ஸ்பேஸ்ஸ்டேஷன் வகுப்பினால் கட்டுப்படுத்தப்படும் நான்கு வகையான செயல்பாடுகளை நாங்கள் வரையறுத்துள்ளோம். மறுசீரமைக்கும்போது அவற்றை மனதில் வைத்திருப்போம். புதுப்பிக்கப்பட்ட குறியீடு SRP உடன் நன்றாகப் பொருந்துகிறது.

class SpaceStation
  attr_reader :sensors, :supply_hold, :fuel_tank, :thrusters
 
  def initialize
    @supply_hold = SupplyHold.new
    @sensors = Sensors.new
    @fuel_tank = FuelTank.new
    @thrusters = Thrusters.new(@fuel_tank)
  end
end
 
class Sensors
  def run_sensors
    puts "----- Sensor Action -----"
    puts "Running sensors!"
  end
end
 
class SupplyHold
  attr_accessor :supplies
 
  def initialize
    @supplies = {}
  end
 
  def load_supplies(type, quantity)
    puts "----- Supply Action -----"
    puts "Loading #{quantity} units of #{type} in the supply hold."
    
    if @supplies[type]
      @supplies[type] += quantity
    else
      @supplies[type] = quantity
    end
  end
 
  def use_supplies(type, quantity)
    puts "----- Supply Action -----"
    if @supplies[type] != nil && @supplies[type] > quantity
      puts "Using #{quantity} of #{type} from the supply hold."
      @supplies[type] -= quantity
    else
      puts "Supply Error: Insufficient #{type} in the supply hold."
    end
  end
 
  def report_supplies
    puts "----- Supply Report -----"
    if @supplies.keys.length > 0
      @supplies.each do |type, quantity|
        puts "#{type} avalilable: #{quantity} units"
      end
    else
      puts "Supply hold is empty."
    end
  end
end
 
class FuelTank
  attr_accessor :fuel
 
  def initialize
    @fuel = 0
  end
 
  def get_fuel_levels
    @fuel
  end
 
  def load_fuel(quantity)
    puts "----- Fuel Action -----"
    puts "Loading #{quantity} units of fuel in the tank."
    @fuel += quantity
  end
 
  def use_fuel(quantity)
    puts "----- Fuel Action -----"
    puts "Using #{quantity} units of fuel from the tank."
    @fuel -= quantity
  end
 
  def report_fuel
    puts "----- Fuel Report -----"
    puts "#{@fuel} units of fuel available."
  end
end
 
class Thrusters
  def initialize(fuel_tank)
    @linked_fuel_tank = fuel_tank
  end
 
  def activate_thrusters
    puts "----- Thruster Action -----"
    if @linked_fuel_tank.get_fuel_levels >= 10
      puts "Thrusting action successful."
      @linked_fuel_tank.use_fuel(10)
    else
      puts "Thruster Error: Insufficient fuel available."
    end
  end
end

நிறைய மாற்றங்கள் உள்ளன, நிரல் நிச்சயமாக இப்போது நன்றாக இருக்கிறது. இப்போது எங்கள் ஸ்பேஸ் ஸ்டேஷன் கிளாஸ், சென்சார்கள், நுகர்வு விநியோக அமைப்பு, எரிபொருள் தொட்டி மற்றும் பூஸ்டர்கள் உள்ளிட்ட சார்பு பாகங்களுக்கான செயல்பாடுகள் தொடங்கப்படும் ஒரு கொள்கலனாக மாறிவிட்டது.

எந்த மாறிகளுக்கும் இப்போது தொடர்புடைய வகுப்பு உள்ளது: சென்சார்கள்; சப்ளைஹோல்ட்; எரிபொருள் தொட்டி; த்ரஸ்டர்கள்.

குறியீட்டின் இந்தப் பதிப்பில் பல முக்கியமான மாற்றங்கள் உள்ளன. தனிப்பட்ட செயல்பாடுகள் அவற்றின் சொந்த வகுப்புகளில் மட்டும் இணைக்கப்படவில்லை, அவை யூகிக்கக்கூடிய மற்றும் நிலையானதாக இருக்கும் வகையில் ஒழுங்கமைக்கப்பட்டுள்ளன. ஒத்திசைவுக் கொள்கையைப் பின்பற்ற, ஒத்த செயல்பாடுகளைக் கொண்ட கூறுகளை நாங்கள் குழுவாக்குகிறோம். இப்போது, ​​கணினி செயல்படும் முறையை மாற்ற வேண்டும் என்றால், ஒரு ஹாஷ் கட்டமைப்பிலிருந்து ஒரு அணிக்கு நகரும் போது, ​​சப்ளைஹோல்ட் வகுப்பைப் பயன்படுத்தவும்; மற்ற தொகுதிகளை நாம் தொட வேண்டியதில்லை. இந்த வழியில், தளவாட அதிகாரி தனது பிரிவில் ஏதாவது மாற்றினால், மீதமுள்ள நிலையங்கள் அப்படியே இருக்கும். இந்த வழக்கில், ஸ்பேஸ் ஸ்டேஷன் வகுப்பிற்கு மாற்றங்கள் கூட தெரியாது.

விண்வெளி நிலையத்தில் பணிபுரியும் எங்கள் அதிகாரிகள் மாற்றங்களைப் பற்றி மகிழ்ச்சியடைகிறார்கள், ஏனெனில் அவர்கள் தங்களுக்குத் தேவையானவற்றைக் கோரலாம். சப்ளைஹோல்ட் மற்றும் ஃப்யூல்டேங்க் வகுப்புகளில் உள்ள ரிப்போர்ட்_சப்ளைகள் மற்றும் ரிப்போர்ட்_எரிபொருள் போன்ற முறைகள் குறியீட்டில் இருப்பதைக் கவனிக்கவும். பூமி அறிக்கை செய்யும் முறையை மாற்றச் சொன்னால் என்ன நடக்கும்? சப்ளை ஹோல்ட் மற்றும் ஃப்யூல் டேங்க் ஆகிய இரண்டு வகுப்புகளும் மாற்றப்பட வேண்டும். எரிபொருள் மற்றும் நுகர்பொருட்கள் விநியோகிக்கப்படும் முறையை நீங்கள் மாற்ற வேண்டும் என்றால் என்ன செய்வது? ஒருவேளை நீங்கள் மீண்டும் அதே வகுப்புகளை மாற்ற வேண்டியிருக்கும். இது ஏற்கனவே SRP கொள்கையை மீறுவதாகும். இதை சரி செய்வோம்.

class SpaceStation
  attr_reader :sensors, :supply_hold, :supply_reporter,
              :fuel_tank, :fuel_reporter, :thrusters
 
  def initialize
    @sensors = Sensors.new
    @supply_hold = SupplyHold.new
    @supply_reporter = SupplyReporter.new(@supply_hold)
    @fuel_tank = FuelTank.new
    @fuel_reporter = FuelReporter.new(@fuel_tank)
    @thrusters = Thrusters.new(@fuel_tank)
  end
end
 
class Sensors
  def run_sensors
    puts "----- Sensor Action -----"
    puts "Running sensors!"
  end
end
 
class SupplyHold
  attr_accessor :supplies
  attr_reader :reporter
 
  def initialize
    @supplies = {}
  end
 
  def get_supplies
    @supplies
  end
 
  def load_supplies(type, quantity)
    puts "----- Supply Action -----"
    puts "Loading #{quantity} units of #{type} in the supply hold."
    
    if @supplies[type]
      @supplies[type] += quantity
    else
      @supplies[type] = quantity
    end
  end
 
  def use_supplies(type, quantity)
    puts "----- Supply Action -----"
    if @supplies[type] != nil && @supplies[type] > quantity
      puts "Using #{quantity} of #{type} from the supply hold."
      @supplies[type] -= quantity
    else
      puts "Supply Error: Insufficient #{type} in the supply hold."
    end
  end
end
 
class FuelTank
  attr_accessor :fuel
  attr_reader :reporter
 
  def initialize
    @fuel = 0
  end
 
  def get_fuel_levels
    @fuel
  end
 
  def load_fuel(quantity)
    puts "----- Fuel Action -----"
    puts "Loading #{quantity} units of fuel in the tank."
    @fuel += quantity
  end
 
  def use_fuel(quantity)
    puts "----- Fuel Action -----"
    puts "Using #{quantity} units of fuel from the tank."
    @fuel -= quantity
  end
end
 
class Thrusters
  FUEL_PER_THRUST = 10
 
  def initialize(fuel_tank)
    @linked_fuel_tank = fuel_tank
  end
 
  def activate_thrusters
    puts "----- Thruster Action -----"
    
    if @linked_fuel_tank.get_fuel_levels >= FUEL_PER_THRUST
      puts "Thrusting action successful."
      @linked_fuel_tank.use_fuel(FUEL_PER_THRUST)
    else
      puts "Thruster Error: Insufficient fuel available."
    end
  end
end
 
class Reporter
  def initialize(item, type)
    @linked_item = item
    @type = type
  end
 
  def report
    puts "----- #{@type.capitalize} Report -----"
  end
end
 
class FuelReporter < Reporter
  def initialize(item)
    super(item, "fuel")
  end
 
  def report
    super
    puts "#{@linked_item.get_fuel_levels} units of fuel available."
  end
end
 
class SupplyReporter < Reporter
  def initialize(item)
    super(item, "supply")
  end
 
  def report
    super
    if @linked_item.get_supplies.keys.length > 0
      @linked_item.get_supplies.each do |type, quantity|
        puts "#{type} avalilable: #{quantity} units"
      end
    else
      puts "Supply hold is empty."
    end
  end
end
 
iss = SpaceStation.new
 
iss.sensors.run_sensors
  # ----- Sensor Action -----
  # Running sensors!
 
iss.supply_hold.use_supplies("parts", 2)
  # ----- Supply Action -----
  # Supply Error: Insufficient parts in the supply hold.
iss.supply_hold.load_supplies("parts", 10)
  # ----- Supply Action -----
  # Loading 10 units of parts in the supply hold.
iss.supply_hold.use_supplies("parts", 2)
  # ----- Supply Action -----
  # Using 2 of parts from the supply hold.
iss.supply_reporter.report
  # ----- Supply Report -----
  # parts avalilable: 8 units
 
iss.thrusters.activate_thrusters
  # ----- Thruster Action -----
  # Thruster Error: Insufficient fuel available.
iss.fuel_tank.load_fuel(100)
  # ----- Fuel Action -----
  # Loading 100 units of fuel in the tank.
iss.thrusters.activate_thrusters
  # ----- Thruster Action -----
  # Thrusting action successful.
  # ----- Fuel Action -----
  # Using 10 units of fuel from the tank.
iss.fuel_reporter.report
  # ----- Fuel Report -----
# 90 units of fuel available.

திட்டத்தின் இந்த சமீபத்திய பதிப்பில், பொறுப்புகள் இரண்டு புதிய வகுப்புகளாக பிரிக்கப்பட்டுள்ளன, FuelReporter மற்றும் SupplyReporter. அவர்கள் இருவரும் நிருபர் வகுப்பின் குழந்தைகள். கூடுதலாக, ஸ்பேஸ்ஸ்டேஷன் வகுப்பில் நிகழ்வு மாறிகளைச் சேர்த்துள்ளோம், இதனால் தேவையான துணைப்பிரிவை தேவைப்பட்டால் துவக்கலாம். இப்போது, ​​பூமி வேறு ஏதாவது மாற்ற முடிவு செய்தால், நாம் துணைப்பிரிவுகளில் மாற்றங்களைச் செய்வோம், முக்கிய வகுப்பில் அல்ல.

நிச்சயமாக, எங்கள் சில வகுப்புகள் இன்னும் ஒருவருக்கொருவர் சார்ந்துள்ளது. எனவே, சப்ளை ரிப்போர்ட்டர் பொருள் சப்ளைஹோல்டைச் சார்ந்தது, மேலும் ஃப்யூல் ரிப்போர்ட்டர் ஃப்யூல் டேங்கைப் பொறுத்தது. நிச்சயமாக, பூஸ்டர்கள் எரிபொருள் தொட்டியுடன் இணைக்கப்பட வேண்டும். ஆனால் இங்கே எல்லாம் ஏற்கனவே தர்க்கரீதியாகத் தெரிகிறது, மேலும் மாற்றங்களைச் செய்வது குறிப்பாக கடினமாக இருக்காது - ஒரு பொருளின் குறியீட்டைத் திருத்துவது மற்றொன்றை பெரிதும் பாதிக்காது.

இவ்வாறு, ஒவ்வொரு பொருள்கள்/வகுப்புகளின் பொறுப்புகள் துல்லியமாக வரையறுக்கப்பட்ட ஒரு மட்டு குறியீட்டை நாங்கள் உருவாக்கியுள்ளோம். அத்தகைய குறியீட்டுடன் பணிபுரிவது ஒரு பிரச்சனையல்ல, அதை பராமரிப்பது ஒரு எளிய பணியாக இருக்கும். முழு “தெய்வீகப் பொருளை” SRP ஆக மாற்றியுள்ளோம்.

Skillbox பரிந்துரைக்கிறது:

• இரண்டு வருட நடைமுறை படிப்பு "நான் ஒரு புரோ வெப் டெவலப்பர்".
• ஆன்லைன் படிப்பு "0 இலிருந்து C# டெவலப்பர்".
• நடைமுறை ஆண்டு படிப்பு "0 முதல் PRO வரையிலான PHP டெவலப்பர்".

ஆதாரம்: www.habr.com