विरासत/quirks मोड कोड

Question

कुछ पुस्तकालय है कि कुछ बड़े पैमाने पर प्रोटोकॉल या (उदाहरण के एफ़टीपी के लिए) कुछ इसी तरह लागू करता है को देखते हुए से अच्छा कोड को अलग करने के लिए कैसे, कैसे मैं कोड है कि केवल सक्षम होने के लिए की जरूरत है से अपने मानक के अनुरूप कोड को अलग रखने होगा इतना मानक अनुपालन प्रणाली के साथ सहयोग करने के लिए?

एक अच्छा उदाहरण है, जहां इस अर्थ भी IMHO होगा jQuery की तरह पुस्तकालयों उन सभी ब्राउज़र विशेषताओं पर विचार करना पड़ता है। जिन परियोजनाओं को विरासत संगतता रखना है, वे शायद ऐसी तकनीकों के लिए एक अच्छा लक्षित दर्शक भी होंगे।

मुझे विशेष रूप से रूबी समाधानों में रुचि है लेकिन भाषा स्वतंत्र पैटर्न या अन्य भाषाओं के अच्छे उदाहरण भी स्वागत है।

मैं पहले से ही stackoverflow पर एक related question यहां पाया, लेकिन वहाँ किसी भी अन्य तरीके हैं?

Answer 1

1. अलग प्रकार के लिए अलग कार्यान्वयन को परिभाषित करें (यह आप कोड सिर्फ वहाँ पीछे संगतता रखने के लिए उस के साथ "अच्छा" कोड मिश्रण के लिए होने से रोकता है)। आदर्श रूप से, विरासत परत मानकों-अनुरूप कोड के आसपास केवल एक रैपर है।
2. पता लगाएं कि अंतर्निहित प्रणाली (ब्राउज़र, रिमोट सर्वर, ...) मानक डिग्री के अनुरूप है। यह विस्तार से कैसे किया जाता है स्पष्ट रूप से विशिष्ट मामले पर अत्यधिक निर्भर है।
3. विशिष्ट सिस्टम के लिए सही कार्यान्वयन चुनें और इसे पारदर्शी रूप से प्लग करें।
4. उपयोगकर्ता को यह जांचने का मौका दें कि हम कौन से मोड में हैं और एक विशिष्ट मोड को मजबूर करने के लिए।

छोटे रूबी उदाहरण:

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"