ฉันควรสร้างคลาสหรือไม่ถ้าฟังก์ชั่นของฉันซับซ้อนและมีตัวแปรมากมาย

คำถามนี้เป็นคำถามที่ค่อนข้างภาษาไม่เชื่อเรื่องพระเจ้า แต่ไม่สมบูรณ์ตั้งแต่โปรแกรมเชิงวัตถุ (OOP) อยู่ในที่แตกต่างกันเช่นJava , ซึ่งไม่ได้มีฟังก์ชั่นชั้นแรกมากกว่าที่เป็นอยู่ในหลาม

กล่าวอีกนัยหนึ่งฉันรู้สึกผิดน้อยลงสำหรับการสร้างคลาสที่ไม่จำเป็นในภาษาเช่น Java แต่ฉันรู้สึกว่าอาจมีวิธีที่ดีกว่าในภาษาที่มีจำนวนต้นแบบน้อยลงเช่น Python

โปรแกรมของฉันต้องทำการดำเนินการที่ค่อนข้างซับซ้อนหลายครั้ง การดำเนินการนั้นต้องใช้ "การบันทึกบัญชี" จำนวนมากต้องสร้างและลบไฟล์ชั่วคราวบางไฟล์ ฯลฯ

นั่นเป็นเหตุผลที่มันยังต้องการเรียก "suboperations" อื่น ๆ อีกมากมาย - การใส่ทุกอย่างลงในวิธีการอันใหญ่โตนั้นไม่ได้ดีมากโมดุลอ่านได้ ฯลฯ

ต่อไปนี้เป็นแนวทางที่อยู่ในใจของฉัน:

1. สร้างคลาสที่มีวิธีพับลิกเพียงวิธีเดียวเท่านั้นและรักษาสถานะภายในที่จำเป็นสำหรับการปฏิบัติการย่อยในตัวแปรอินสแตนซ์

มันจะมีลักษณะเช่นนี้:

class Thing:

    def __init__(self, var1, var2):
        self.var1 = var1
        self.var2 = var2
        self.var3 = []

    def the_public_method(self, param1, param2):
        self.var4 = param1
        self.var5 = param2
        self.var6 = param1 + param2 * self.var1
        self.__suboperation1()
        self.__suboperation2()
        self.__suboperation3()


    def __suboperation1(self):
        # Do something with self.var1, self.var2, self.var6
        # Do something with the result and self.var3
        # self.var7 = something
        # ...
        self.__suboperation4()
        self.__suboperation5()
        # ...

    def suboperation2(self):
        # Uses self.var1 and self.var3

#    ...
#    etc.

ปัญหาที่ฉันเห็นด้วยวิธีนี้คือสถานะของคลาสนี้เหมาะสมเฉพาะภายในและไม่สามารถทำอะไรกับอินสแตนซ์ของมันได้ยกเว้นเรียกวิธีการสาธารณะเท่านั้น

# Make a thing object
thing = Thing(1,2)

# Call the only method you can call
thing.the_public_method(3,4)

# You don't need thing anymore

2. สร้างกลุ่มของฟังก์ชันที่ไม่มีคลาสและส่งผ่านตัวแปรที่จำเป็นภายในต่างๆระหว่างพวกเขา (เป็นอาร์กิวเมนต์)

ปัญหาที่ฉันเห็นด้วยคือฉันต้องผ่านตัวแปรจำนวนมากระหว่างฟังก์ชั่น นอกจากนี้ฟังก์ชั่นจะเกี่ยวข้องกันอย่างใกล้ชิด แต่จะไม่ถูกจัดกลุ่มเข้าด้วยกัน

3. ชอบ 2. แต่ทำให้ตัวแปรสถานะเป็นโกลบอลแทนที่จะส่งต่อ

นี่คงไม่ดีเลยตั้งแต่ฉันต้องทำงานมากกว่าหนึ่งครั้งด้วยอินพุตที่แตกต่างกัน

มีวิธีที่สี่ดีกว่าหรือไม่? ถ้าไม่วิธีใดวิธีหนึ่งเหล่านี้จะดีกว่าและทำไม มีบางอย่างที่ฉันขาดหายไปหรือไม่?

1. สร้างคลาสที่มีวิธีพับลิกหนึ่งวิธีเท่านั้นและรักษาสถานะภายในที่จำเป็นสำหรับการปฏิบัติการย่อยในตัวแปรอินสแตนซ์

ปัญหาที่ฉันเห็นด้วยวิธีนี้คือสถานะของคลาสนี้เหมาะสมเฉพาะภายในและไม่สามารถทำอะไรกับอินสแตนซ์ของมันได้ยกเว้นเรียกวิธีสาธารณะเท่านั้น

ตัวเลือกที่ 1 เป็นตัวอย่างที่ดีของการห่อหุ้มที่ใช้อย่างถูกต้อง คุณต้องการซ่อนสถานะภายในจากรหัสภายนอก

ถ้านั่นหมายความว่าชั้นเรียนของคุณมีวิธีสาธารณะเพียงวิธีเดียว มันจะง่ายกว่านั้นในการดูแลรักษา

ใน OOP ถ้าคุณมีชั้นเรียนที่ทำสิ่งหนึ่งอย่างแน่นอนมีพื้นผิวสาธารณะเล็ก ๆ และซ่อนสถานะภายในทั้งหมดไว้แล้วคุณก็จะชนะอย่างที่ชาร์ลีชีนพูด

2. ทำฟังก์ชั่นมากมายโดยไม่มีคลาสและส่งผ่านตัวแปรที่ต้องการภายในต่างๆระหว่างกัน (เป็นอาร์กิวเมนต์)

ปัญหาที่ฉันเห็นด้วยคือฉันต้องผ่านตัวแปรจำนวนมากระหว่างฟังก์ชั่น นอกจากนี้ฟังก์ชั่นจะเกี่ยวข้องกันอย่างใกล้ชิด แต่จะไม่ถูกจัดกลุ่มเข้าด้วยกัน

ตัวเลือกที่ 2 ทนทุกข์ทรมานจากการทำงานร่วมกันในระดับต่ำ สิ่งนี้จะทำให้การบำรุงรักษายากขึ้น

3. กดไลค์ 2 แต่ทำให้ตัวแปรสถานะเป็นโกลบอลแทนที่จะส่งต่อ

ตัวเลือกที่ 3 เช่นตัวเลือกที่ 2 ทนทุกข์ทรมานจากการทำงานร่วมกันต่ำ แต่รุนแรงมากขึ้น!

ประวัติศาสตร์แสดงให้เห็นว่าความสะดวกสบายของตัวแปรทั่วโลกนั้นมีมากกว่าเมื่อเทียบกับค่าใช้จ่ายในการบำรุงรักษาที่โหดร้ายที่เกิดขึ้น นั่นเป็นเหตุผลที่คุณได้ยินเสียงผายลมเก่าอย่างฉันคุยโวเกี่ยวกับการห่อหุ้มตลอดเวลา

ตัวเลือกที่ชนะเลิศคือ# 1

ฉันคิดว่า # 1 เป็นตัวเลือกที่แย่จริงๆ

ลองพิจารณาฟังก์ชั่นของคุณ:

def the_public_method(self, param1, param2):
    self.var4 = param1
    self.var5 = param2 
    self.var6 = param1 + param2 * self.var1
    self.__suboperation1()
    self.__suboperation2()
    self.__suboperation3()

ข้อมูลย่อยใดที่ suboperation1 ใช้ มันรวบรวมข้อมูลที่ใช้โดย suboperation2 หรือไม่ เมื่อคุณส่งข้อมูลไปรอบ ๆ ด้วยการจัดเก็บด้วยตนเองฉันไม่สามารถบอกได้ว่าชิ้นส่วนของการทำงานเกี่ยวข้องกันอย่างไร เมื่อฉันดูตัวเองคุณลักษณะบางอย่างมาจากตัวสร้างบางตัวจากการเรียกไปยัง _public_method และมีการเพิ่มแบบสุ่มในที่อื่น ๆ ในความคิดของฉันมันเป็นระเบียบ

แล้วหมายเลข # 2 ล่ะ ก่อนอื่นมาดูปัญหาที่สองด้วย:

นอกจากนี้ฟังก์ชั่นจะเกี่ยวข้องกันอย่างใกล้ชิด แต่จะไม่ถูกจัดกลุ่มเข้าด้วยกัน

พวกเขาจะอยู่ในโมดูลด้วยกันดังนั้นพวกเขาทั้งหมดจึงถูกจัดกลุ่มเข้าด้วยกัน

ปัญหาที่ฉันเห็นด้วยคือฉันต้องผ่านตัวแปรจำนวนมากระหว่างฟังก์ชั่น

ในความคิดของฉันนี้เป็นสิ่งที่ดี สิ่งนี้ทำให้การอ้างอิงข้อมูลในอัลกอริทึมของคุณชัดเจน โดยการจัดเก็บไว้ไม่ว่าจะเป็นในตัวแปรระดับโลกหรือในตัวคุณเองคุณซ่อนการพึ่งพาและทำให้พวกเขาดูแย่น้อยลง แต่พวกเขายังคงอยู่ที่นั่น

โดยปกติเมื่อสถานการณ์นี้เกิดขึ้นหมายความว่าคุณไม่พบวิธีที่เหมาะสมในการย่อยสลายปัญหาของคุณ คุณพบว่ามันน่าอึดอัดใจที่จะแบ่งออกเป็นหลายฟังก์ชั่นเพราะคุณกำลังพยายามแยกมันผิดวิธี

แน่นอนว่าถ้าไม่เห็นการทำงานจริงของคุณมันยากที่จะเดาว่าอะไรจะเป็นคำแนะนำที่ดี แต่คุณได้ให้คำแนะนำเล็กน้อยเกี่ยวกับสิ่งที่คุณกำลังทำอยู่ที่นี่:

โปรแกรมของฉันต้องทำการดำเนินการที่ค่อนข้างซับซ้อนหลายครั้ง การดำเนินการนั้นต้องใช้ "การบันทึกบัญชี" จำนวนมากต้องสร้างและลบไฟล์ชั่วคราวบางรายการเป็นต้น

ให้ฉันเลือกตัวอย่างของสิ่งที่ sorta ตรงกับคำอธิบายของคุณตัวติดตั้ง โปรแกรมติดตั้งจะต้องคัดลอกไฟล์หลายไฟล์ แต่ถ้าคุณยกเลิกไปทางส่วนหนึ่งคุณจะต้องย้อนกระบวนการทั้งหมดรวมถึงการนำไฟล์ที่คุณแทนที่กลับมา อัลกอริทึมสำหรับสิ่งนี้ดูเหมือนว่า:

def install_program():
    copied_files = []
    try:
        for filename in FILES_TO_COPY:
           temporary_file = create_temporary_file()
           copy(target_filename(filename), temporary_file)
           copied_files = [target_filename(filename), temporary_file)
           copy(source_filename(filename), target_filename(filename))
     except CancelledException:
        for source_file, temp_file in copied_files:
            copy(temp_file, source_file)
     else:
        for source_file, temp_file in copied_files:
            delete(temp_file)

ทีนี้ทวีคูณตรรกะนั้นออกไปเพราะต้องทำการตั้งค่ารีจิสตรี, ไอคอนโปรแกรม, และอื่น ๆ

ฉันคิดว่าโซลูชันอันดับ 1 ของคุณดูเหมือน:

class Installer:
    def install(self):
        try:
            self.copy_new_files()
        except CancellationError:
            self.restore_original_files()
        else:
            self.remove_temp_files()

สิ่งนี้ทำให้อัลกอริทึมโดยรวมชัดเจนขึ้น แต่ซ่อนวิธีการสื่อสารที่แตกต่างกัน

วิธีที่ # 2 ดูเหมือนว่า:

def install_program():
    try:
       temp_files = copy_new_files()
    except CancellationError as error:
       restore_old_files(error.files_that_were_copied)
    else:
       remove_temp_files(temp_files)

ตอนนี้มันชัดเจนว่าชิ้นส่วนของข้อมูลเคลื่อนย้ายระหว่างฟังก์ชั่นได้อย่างไร แต่มันก็น่าอึดอัดใจมาก

ดังนั้นฟังก์ชั่นนี้ควรถูกเขียนอย่างไร?

def install_program():
    with FileTransactionLog() as file_transaction_log:
         copy_new_files(file_transaction_log)

วัตถุ FileTransactionLog เป็นตัวจัดการบริบท เมื่อ copy_new_files ทำการคัดลอกไฟล์มันจะทำผ่าน FileTransactionLog ซึ่งจัดการการทำสำเนาชั่วคราวและติดตามว่าไฟล์ใดถูกคัดลอก ในกรณีที่มีข้อยกเว้นมันจะคัดลอกไฟล์ต้นฉบับกลับมาและในกรณีที่ประสบความสำเร็จก็จะลบสำเนาชั่วคราว

ใช้งานได้เพราะเราพบการย่อยสลายที่เป็นธรรมชาติมากขึ้นของงาน ก่อนหน้านี้เราได้ intermixing ตรรกะเกี่ยวกับวิธีการติดตั้งแอปพลิเคชันด้วยตรรกะเกี่ยวกับวิธีการกู้คืนการติดตั้งที่ถูกยกเลิก ตอนนี้บันทึกธุรกรรมจะจัดการรายละเอียดทั้งหมดเกี่ยวกับไฟล์ชั่วคราวและการบันทึกบัญชีและฟังก์ชั่นสามารถมุ่งเน้นไปที่อัลกอริทึมพื้นฐาน

ฉันสงสัยว่ากรณีของคุณอยู่ในเรือลำเดียวกัน คุณต้องแยกองค์ประกอบการทำบัญชีออกเป็นวัตถุบางประเภทเพื่อให้งานที่ซับซ้อนของคุณสามารถแสดงออกได้ง่ายขึ้นและสวยงามมากขึ้น

เนื่องจากข้อเสียเปรียบที่ชัดเจนเพียงอย่างเดียวของวิธีที่ 1 คือรูปแบบการใช้งานที่ไม่ดีนักฉันคิดว่าทางออกที่ดีที่สุดคือการห่อหุ้มไดรฟ์หนึ่งขั้นต่อไป: ใช้คลาส แต่ยังมีฟังก์ชั่นอิสระยืนที่สร้างวัตถุเท่านั้น :

def publicFunction(var1, var2, param1, param2)
    thing = Thing(var1, var2)
    thing.theMethod(param1, param2)

ด้วยสิ่งนี้คุณจะมีอินเทอร์เฟซที่เล็กที่สุดเท่าที่จะเป็นไปได้สำหรับโค้ดของคุณและคลาสที่คุณใช้ภายในจะกลายเป็นเพียงรายละเอียดการใช้งานของฟังก์ชั่นสาธารณะของคุณ รหัสการโทรไม่จำเป็นต้องรู้เกี่ยวกับคลาสภายในของคุณ

ในอีกด้านหนึ่งคำถามก็คือภาษาที่ไม่เชื่อเรื่องพระเจ้า แต่ในทางกลับกันการดำเนินการขึ้นอยู่กับภาษาและกระบวนทัศน์ของมัน ในกรณีนี้คือ Python ซึ่งรองรับกระบวนทัศน์หลายอัน

นอกจากวิธีแก้ปัญหาของคุณแล้วยังมีความเป็นไปได้ที่จะดำเนินการไร้สัญชาติอย่างสมบูรณ์แบบในลักษณะที่ใช้งานได้มากกว่าเช่น

def outer(param1, param2):
    def inner1(param1, param2, param3):
        pass
    def inner2(param1, param2):
        pass
    return inner2(inner1(param1),param2,param3)

ทุกอย่างลงมา

• การอ่าน
• ความมั่นคง
• การบำรุงรักษา

แต่ถ้า codebase ของคุณเป็น OOP จะเป็นการฝ่าฝืนความสอดคล้องหากจู่ๆบางส่วนก็ถูกเขียนในรูปแบบการใช้งาน (มากกว่า)

ทำไมต้องออกแบบเมื่อฉันสามารถเข้ารหัสได้?

ฉันเสนอมุมมองที่แตกสำหรับคำตอบที่ฉันอ่าน จากมุมมองนั้นคำตอบทั้งหมดและตรงไปตรงมาแม้แต่คำถามเองก็มุ่งเน้นไปที่กลไกการเข้ารหัส แต่นี่เป็นปัญหาการออกแบบ

ฉันควรสร้างคลาสหรือไม่ถ้าฟังก์ชั่นของฉันซับซ้อนและมีตัวแปรมากมาย

ใช่มันเหมาะสมสำหรับการออกแบบของคุณ มันอาจจะเป็นชั้นเรียนกับตัวเองหรือเป็นส่วนหนึ่งของชั้นเรียนอื่น ๆ หรือพฤติกรรมของมันอาจมีการกระจายระหว่างชั้นเรียน

การออกแบบเชิงวัตถุนั้นเกี่ยวกับความซับซ้อน

จุดประสงค์ของ OO คือการสร้างและบำรุงรักษาระบบที่ซับซ้อนและมีขนาดใหญ่โดยการห่อหุ้มโค้ดในแง่ของระบบเอง การออกแบบ "เหมาะสม" กล่าวว่าทุกอย่างอยู่ในระดับเดียวกัน

การออกแบบ OO จะจัดการความซับซ้อนตามหลักผ่านชั้นเรียนที่มุ่งเน้นซึ่งเป็นไปตามหลักการความรับผิดชอบเดียว คลาสเหล่านี้ให้โครงสร้างและการทำงานตลอดทั้งลมหายใจและความลึกของระบบโต้ตอบและรวมมิติเหล่านี้

ระบุว่ามันมักจะกล่าวว่าฟังก์ชั่นห้อยเกี่ยวกับระบบ - ทุกระดับยูทิลิตี้ทั่วไปที่แพร่หลายมากเกินไป - เป็นกลิ่นรหัสแนะนำการออกแบบที่ไม่เพียงพอ ฉันมักจะเห็นด้วย

ทำไมไม่เปรียบเทียบความต้องการของคุณกับสิ่งที่มีอยู่ในไลบรารี Python มาตรฐานแล้วดูว่ามีการนำไปใช้อย่างไร

หมายเหตุหากคุณไม่ต้องการวัตถุคุณยังสามารถกำหนดฟังก์ชั่นภายในฟังก์ชั่น ด้วยPython 3มีการnonlocalประกาศใหม่เพื่อให้คุณสามารถเปลี่ยนตัวแปรในฟังก์ชั่นหลักของคุณ

คุณยังอาจพบว่ามีประโยชน์ที่จะมีคลาสส่วนตัวที่เรียบง่ายภายในฟังก์ชันของคุณเพื่อนำไปใช้กับ abstractions และจัดระเบียบการดำเนินการ