Junior — Middle

შეგიძლიათ ახსნათ SOLID-ის პრინციპები და როგორ გამოიყენოთ ისინი პროგრამული უზრუნველყოფის განვითარების დროს?

sobes.tech AI

პასუხი AI-სგან

SOLID პრინციპები ხუთი ძირითადი წესია ობიექტზე ორიენტირებული დიზაინის, რომლებიც ეხმარებიან მოქნილი, გაფართოებადი და შენარჩუნებადი კოდის შექმნას:

S — ერთგავარ პასუხისმგებლობის პრინციპი ყოველი კლასი უნდა ჰქონდეს მხოლოდ ერთი მიზეზი ცვლილებისთვის, ანუ პასუხისმგებელი იყოს ერთ ამოცანაზე.
O — გახსნილი/დახურული პრინციპი კლასები უნდა იყოს გახსნილი გაფართოებისთვის, მაგრამ დახურული ცვლილებისთვის.
L — ლისკოვის ჩანაცვლების პრინციპი დამკვიდრებული კლასების ობიექტები უნდა შეძლონ შეცვალონ ძირითადი კლასის ობიექტები, ისე რომ პროგრამის სისწორე არ დაირღვეს.
I — ინტერფეისების გამოყოფის პრინციპი მომხმარებლები არ უნდა იყვნენ დამოკიდებული იმ ინტერფეისებზე, რომლებიც არ გამოიყენება. უკეთესია რამდენიმე სპეციალიზებული ინტერფეისი, ვიდრე ერთიანი უნივერსალური.
D — დამოკიდებულებების უკუღმა გადატანა პრინციპი მაღალი დონის მოდულები არ უნდა იყოს დამოკიდებული დაბალი დონის მოდულებზე. ორივე უნდა იყოს დამოკიდებული აბსტრაქციებზე.

Go-ში გამოყენების მაგალითი:

// ერთგავარ პასუხისმგებლობის პრინციპი
// სტრუქტურა (კლასი) პასუხისმგებელია მხოლოდ მომხმარებლებთან მუშაობაზე

type UserRepository interface {
    GetUser(id int) (*User, error)
}

// დამოკიდებულებების უკუღმა გადატანა
// სერვისი დამოკიდებულია ინტერფეისზე, არა კონკრეტულ რეალიზაციაზე

type UserService struct {
    repo UserRepository
}

func (s *UserService) GetUserName(id int) (string, error) {
    user, err := s.repo.GetUser(id)
    if err != nil {
        return "", err
    }
    return user.Name, nil
}

SOLID პრინციპების გამოყენება ადვილია კოდის დაწერაში, რომელიც უფრო მარტივია ტესტირებისთვის, გაფართოებისთვის და შენარჩუნებისთვის.

წინა შემდეგი