Làm cách nào để tách mã tốt khỏi mã chế độ cũ/quirks

Question

Cho một số thư viện triển khai một số giao thức phổ biến hoặc một cái gì đó tương tự (ví dụ FTP), làm cách nào để giữ mã tuân thủ chuẩn của tôi tách biệt với mã chỉ cần thiết để có thể hợp tác với hệ thống không tuân thủ tiêu chuẩn như vậy?

Một ví dụ điển hình về điều này có nghĩa là quá IMHO là các thư viện như jQuery phải xem xét tất cả những đặc điểm của trình duyệt đó. Các dự án phải giữ khả năng tương thích cũ cũng có thể là đối tượng mục tiêu tốt cho các kỹ thuật như vậy.

Tôi đặc biệt quan tâm đến các giải pháp ruby ​​nhưng các mẫu ngôn ngữ độc lập hoặc các ví dụ hay từ các ngôn ngữ khác cũng được chào đón.

Tôi đã tìm thấy một số related question ở đây trên stackoverflow, nhưng có cách tiếp cận nào khác không?

Answer 1

1. Xác định các cách triển khai khác nhau cho các chế độ khác nhau (điều này ngăn bạn không phải trộn mã "tốt" với mã chỉ để duy trì tính tương thích ngược). Lý tưởng nhất, lớp kế thừa chỉ là một trình bao bọc xung quanh mã tuân thủ tiêu chuẩn.
2. Phát hiện đến mức độ nào hệ thống cơ bản (trình duyệt, máy chủ từ xa, ...) tuân thủ các tiêu chuẩn. Làm thế nào điều này được thực hiện chi tiết rõ ràng là rất phụ thuộc vào trường hợp cụ thể.
3. Chọn triển khai đúng cho hệ thống cụ thể và cắm vào một cách rõ ràng.
4. Cho người dùng cơ hội kiểm tra chế độ nào chúng tôi đang có và bắt buộc một chế độ cụ thể.

của Ruby nhỏ ví dụ:

class GoodServer 
    def calculate(expr) 
    return eval(expr).to_s 
    end 
end 

class QuirkyServer 
    def calculate(expr) 
    # quirky server prefixes the result with "result: " 
    return "result: %s" % eval(expr) 
    end 
end 

module GoodClient 
    def calculate(expr) 
    @server.calculate(expr) 
    end 
end 

# compatibility layer 
module QuirkyClient 
    include GoodClient 
    def calculate(expr) 
    super(expr).gsub(/^result: /, '') 
    end 
end 

class Client 
    def initialize(server) 
    @server = server 
    # figure out if the server is quirky and mix in the matching module 
    if @server.calculate("1").include?("result") 
     extend QuirkyClient 
    else 
     extend GoodClient 
    end 
    end 
end 

good_server = GoodServer.new 
bad_server = QuirkyServer.new 

# we can access both servers using the same interface 
client1 = Client.new(good_server) 
client2 = Client.new(bad_server) 

p client1.is_a? QuirkyClient # => false 
p client1.calculate("1 + 2") # => "3" 

p client2.is_a? QuirkyClient # => true 
p client2.calculate("1 + 2") # => "3"