SOLID નો ઉપયોગ કરીને લવચીક કોડ લખો

અનુવાદક તરફથી: તમારા માટે પ્રકાશિત સેવેરીન પેરેઝ દ્વારા લેખ પ્રોગ્રામિંગમાં સોલિડ સિદ્ધાંતોનો ઉપયોગ કરવા વિશે. લેખમાંથી માહિતી નવા નિશાળીયા અને અનુભવી પ્રોગ્રામરો બંને માટે ઉપયોગી થશે.

જો તમે વિકાસમાં છો, તો તમે મોટા ભાગે SOLID સિદ્ધાંતો વિશે સાંભળ્યું હશે. તેઓ પ્રોગ્રામરને સ્વચ્છ, સારી રીતે સંરચિત અને સરળતાથી જાળવી શકાય તેવા કોડ લખવામાં સક્ષમ કરે છે. તે નોંધવું યોગ્ય છે કે પ્રોગ્રામિંગમાં કોઈ ચોક્કસ કાર્યને યોગ્ય રીતે કેવી રીતે કરવું તે માટે ઘણા અભિગમો છે. જુદા જુદા નિષ્ણાતોના "સાચા માર્ગ" વિશેના જુદા જુદા વિચારો અને સમજ હોય ​​છે; તે બધું દરેક વ્યક્તિના અનુભવ પર આધારિત છે. જો કે, SOLID માં જાહેર કરાયેલા વિચારો IT સમુદાયના લગભગ તમામ પ્રતિનિધિઓ દ્વારા સ્વીકારવામાં આવે છે. તેઓ ઘણી સારી વિકાસ વ્યવસ્થાપન પદ્ધતિઓના ઉદભવ અને વિકાસ માટે પ્રારંભિક બિંદુ બન્યા.

ચાલો સમજીએ કે સોલિડ સિદ્ધાંતો શું છે અને તે આપણને કેવી રીતે મદદ કરે છે.

સ્કિલબોક્સ ભલામણ કરે છે: પ્રેક્ટિકલ કોર્સ "મોબાઇલ ડેવલપર પ્રો".

અમે યાદ કરાવીએ છીએ: Habrના તમામ વાચકો માટે - Habr પ્રોમો કોડનો ઉપયોગ કરીને કોઈપણ સ્કિલબોક્સ કોર્સમાં નોંધણી કરતી વખતે 10 રૂબલ ડિસ્કાઉન્ટ.

સોલિડ શું છે?

આ શબ્દ સંક્ષેપ છે, શબ્દનો દરેક અક્ષર ચોક્કસ સિદ્ધાંતના નામની શરૂઆત છે:

• Sએકલ જવાબદારી સિદ્ધાંત. મોડ્યુલમાં ફેરફારનું એક અને માત્ર એક જ કારણ હોઈ શકે છે.
• આ Oપેન/બંધ સિદ્ધાંત (ખુલ્લો/બંધ સિદ્ધાંત). વર્ગો અને અન્ય ઘટકો એક્સ્ટેંશન માટે ખુલ્લા હોવા જોઈએ, પરંતુ ફેરફાર માટે બંધ હોવા જોઈએ.
•  આ Lઇસ્કોવ અવેજી સિદ્ધાંત (લિસ્કોવ અવેજી સિદ્ધાંત). ફંક્શન કે જે બેઝ ટાઈપનો ઉપયોગ કરે છે તે જાણ્યા વગર બેઝ ટાઈપના પેટાપ્રકારનો ઉપયોગ કરવા સક્ષમ હોવા જોઈએ.
• આ Iઇન્ટરફેસ સેગ્રિગેશન સિદ્ધાંત  (ઇન્ટરફેસ વિભાજન સિદ્ધાંત). સૉફ્ટવેર સંસ્થાઓએ તે પદ્ધતિઓ પર આધાર રાખવો જોઈએ નહીં જેનો તેઓ ઉપયોગ કરતા નથી.
• આ Dઅવલંબન વ્યુત્ક્રમ સિદ્ધાંત (નિર્ભરતા વ્યુત્ક્રમનો સિદ્ધાંત). ઉચ્ચ સ્તર પરના મોડ્યુલો નીચલા સ્તરના મોડ્યુલો પર આધારિત ન હોવા જોઈએ.

એક જવાબદારી સિદ્ધાંત

 
સિંગલ રિસ્પોન્સિબિલિટી પ્રિન્સિપલ (SRP) જણાવે છે કે પ્રોગ્રામમાં દરેક વર્ગ અથવા મોડ્યુલ તે પ્રોગ્રામની કાર્યક્ષમતાના માત્ર એક ભાગ માટે જવાબદાર હોવા જોઈએ. વધુમાં, આ જવાબદારીના ઘટકો અસંબંધિત વર્ગોમાં વિખેરાઈ જવાને બદલે તેમના પોતાના વર્ગને સોંપવા જોઈએ. SRP ના ડેવલપર અને મુખ્ય પ્રચારક, રોબર્ટ એસ. માર્ટિન, બદલાવના કારણ તરીકે જવાબદારીનું વર્ણન કરે છે. તેમણે મૂળરૂપે આ શબ્દને તેમના કાર્ય "ઑબ્જેક્ટ-ઓરિએન્ટેડ ડિઝાઇનના સિદ્ધાંતો" ના ઘટકોમાંના એક તરીકે પ્રસ્તાવિત કર્યો હતો. કોન્સેપ્ટમાં કનેક્ટિવિટી પેટર્નનો મોટાભાગનો સમાવેશ થાય છે જે અગાઉ ટોમ ડીમાર્કો દ્વારા વ્યાખ્યાયિત કરવામાં આવી હતી.

આ વિભાવનામાં ડેવિડ પર્નાસ દ્વારા ઘડવામાં આવેલા ઘણા ખ્યાલોનો પણ સમાવેશ થાય છે. બે મુખ્ય છે એન્કેપ્સ્યુલેશન અને માહિતી છુપાવવી. પરનાસે દલીલ કરી હતી કે સિસ્ટમને અલગ મોડ્યુલમાં વિભાજીત કરવી એ બ્લોક ડાયાગ્રામ અથવા એક્ઝેક્યુશન ફ્લોના વિશ્લેષણ પર આધારિત હોવું જોઈએ નહીં. કોઈપણ મોડ્યુલમાં ચોક્કસ સોલ્યુશન હોવું આવશ્યક છે જે ગ્રાહકોને ન્યૂનતમ માહિતી પ્રદાન કરે છે.

માર્ગ દ્વારા, માર્ટિને કંપનીના વરિષ્ઠ સંચાલકો (COO, CTO, CFO) સાથે એક રસપ્રદ ઉદાહરણ આપ્યું, જેમાંથી દરેક અલગ-અલગ હેતુઓ માટે ચોક્કસ બિઝનેસ સોફ્ટવેરનો ઉપયોગ કરે છે. પરિણામે, તેમાંથી કોઈપણ અન્ય મેનેજરોના હિતોને અસર કર્યા વિના સૉફ્ટવેરમાં ફેરફારોનો અમલ કરી શકે છે.

દૈવી પદાર્થ

હંમેશની જેમ, SRP શીખવાની શ્રેષ્ઠ રીત તેને ક્રિયામાં જોવાનું છે. ચાલો પ્રોગ્રામના એક વિભાગને જોઈએ જે સિંગલ રિસ્પોન્સિબિલિટી સિદ્ધાંતનું પાલન કરતું નથી. આ રૂબી કોડ છે જે સ્પેસ સ્ટેશનના વર્તન અને લક્ષણોનું વર્ણન કરે છે.

ઉદાહરણની સમીક્ષા કરો અને નીચેનાને નિર્ધારિત કરવાનો પ્રયાસ કરો:
તે ઑબ્જેક્ટ્સની જવાબદારીઓ જે સ્પેસસ્ટેશન વર્ગમાં જાહેર કરવામાં આવી છે.
જેઓ સ્પેસ સ્ટેશનના સંચાલનમાં રસ ધરાવી શકે છે.

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 અનુરૂપ નથી? હા પાક્કુ. પરંતુ સ્પેસસ્ટેશન વર્ગ એ એક લાક્ષણિક "ઈશ્વર પદાર્થ" છે જે બધું જાણે છે અને બધું કરે છે. ઑબ્જેક્ટ-ઓરિએન્ટેડ પ્રોગ્રામિંગમાં આ એક મુખ્ય વિરોધી પેટર્ન છે. શિખાઉ માણસ માટે, આવી વસ્તુઓ જાળવવી અત્યંત મુશ્કેલ છે. અત્યાર સુધીનો પ્રોગ્રામ ખૂબ જ સરળ છે, હા, પરંતુ કલ્પના કરો કે જો આપણે નવી સુવિધાઓ ઉમેરીશું તો શું થશે. કદાચ આપણા સ્પેસ સ્ટેશનને મેડિકલ સ્ટેશન અથવા મીટિંગ રૂમની જરૂર પડશે. અને જેટલા વધુ કાર્યો હશે, તેટલું વધુ સ્પેસસ્ટેશન વધશે. ઠીક છે, કારણ કે આ સુવિધા અન્ય લોકો સાથે જોડાયેલ હશે, સમગ્ર સંકુલની સેવા કરવી વધુ જટિલ બનશે. પરિણામે, અમે ઑપરેશનમાં વિક્ષેપ પાડી શકીએ છીએ, ઉદાહરણ તરીકે, એક્સિલરેટર્સ. જો કોઈ સંશોધક સેન્સરમાં ફેરફારની વિનંતી કરે છે, તો આ સ્ટેશનની સંચાર પ્રણાલીને ખૂબ સારી રીતે અસર કરી શકે છે.

એસઆરપી સિદ્ધાંતનું ઉલ્લંઘન કરવાથી ટૂંકા ગાળાની વ્યૂહાત્મક જીત મળી શકે છે, પરંતુ અંતે આપણે "યુદ્ધ હારી જઈશું", અને ભવિષ્યમાં આવા રાક્ષસને જાળવી રાખવું ખૂબ મુશ્કેલ બનશે. પ્રોગ્રામને કોડના અલગ વિભાગોમાં વિભાજીત કરવાનું શ્રેષ્ઠ છે, જેમાંથી દરેક ચોક્કસ કામગીરી કરવા માટે જવાબદાર છે. આને સમજીને, ચાલો SpaceStation ક્લાસ બદલીએ.

ચાલો જવાબદારી વહેંચીએ

ઉપર અમે ચાર પ્રકારની કામગીરીઓ વ્યાખ્યાયિત કરી છે જે સ્પેસસ્ટેશન વર્ગ દ્વારા નિયંત્રિત છે. રિફેક્ટર કરતી વખતે અમે તેમને ધ્યાનમાં રાખીશું. અપડેટ કરેલ કોડ 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 માં રૂપાંતરિત કર્યું છે.

સ્કિલબોક્સ ભલામણ કરે છે:

• બે વર્ષનો પ્રેક્ટિકલ કોર્સ "હું પ્રો વેબ ડેવલપર છું".
• ઓનલાઇન કોર્સ "0 થી C# વિકાસકર્તા".
• એક વર્ષનો પ્રેક્ટિકલ કોર્સ "0 થી PRO સુધી PHP વિકાસકર્તા".

સોર્સ: www.habr.com