Diff ऑप्टिमाइज़ेशन

डिफ़ ऑप्टिमाइज़ेशन

यह गाइड दिखाता है कि कैसे एक कच्चा डिफ़ — एक सूची को साफ़ किया जाए DiffOperation मान (देखें Diff कि कैसे उन्हें बनाया गया है) — पोस्ट-प्रोसेसिंग पासों का उपयोग करके मानक, न्यूनतम रूप में बदलने के लिए DiffOptimization सब-नेमस्पेस। प्रत्येक पास लागू करता है IDiffOptimizationOperation और डिफ़ सूची को स्थान पर बदलता है, इसलिए पासों को क्रम में जोड़कर परिणाम को क्रमशः सरल बनाया जा सकता है।

ऑप्टिमाइज़ेशन अनुबंध

IDiffOptimizationOperation एक एकल मेथड, Execute(diffs), को परिभाषित करता है, जो डिफ़ द्वारा प्रतिनिधित्व किए गए स्रोत और गन्तव्य पाठों को संरक्षित रखते हुए DiffOperation मानों की एक परिवर्तनशील सूची को स्थान पर सामान्यीकृत करता है। इस सब-नेमस्पेस के प्रत्येक ऑप्टिमाइज़र इस इंटरफ़ेस को लागू करता है, इसलिए उन्हें परस्पर बदलकर बुलाया जा सकता है या पाइपलाइन में संयोजित किया जा सकता है।

List<DiffOperation> diffs = new List<DiffOperation>
{
    new DiffOperation(Operation.Equal, "The quick "),
    new DiffOperation(Operation.Delete, "brown "),
    new DiffOperation(Operation.Insert, "red "),
    new DiffOperation(Operation.Equal, "fox")
};

IDiffOptimizationOperation optimizer = new OperationsMerger(EditOperationsOrder.DeleteFirst);
optimizer.Execute(diffs);

सन्निकट ऑपरेशनों को मिलाना

OperationsMerger एक डिफ़ को उसके मानक न्यूनतम रूप में मर्ज करता है: यह समान ऑपरेशन प्रकार के सन्निकट रन को एक साथ जोड़ता है, और मिश्रित delete/insert रन के लिए यह किसी भी सामान्य प्रीफ़िक्स को पूर्ववर्ती समानता में और किसी भी सामान्य सफ़िक्स को अगले समानता में सम्मिलित करता है।

var merger = new OperationsMerger(EditOperationsOrder.DeleteFirst);
merger.Execute(diffs);

छोटी समानताओं को समाप्त करना

MergingOptimizer एक सेमान्टिक क्लीन-अप पास करता है: यह उन समानताओं को हटा देता है जो उनके आसपास की संपादनों से बड़ी नहीं होतीं, उन छोटे सामान्य क्रमों को पास के बगल वाले delete/insert में वापस फोल्ड करता है, और फिर परिणाम को कैनोनिकल रूप में पुनः मिलाता है।

var semanticOptimizer = new MergingOptimizer(EditOperationsOrder.InsertFirst);
semanticOptimizer.Execute(diffs);

समानताओं के ऊपर संपादनों को स्लाइड करना

OperationsSlideMerger एक एकल संपादन को जो दोनों ओर समानताओं से घिरा है, पार्श्व रूप से शिफ्ट करता है, उन समानताओं में से एक को हटाता है और डिफ़ को आगे कैनोनिकल बनाता है।

IDiffOptimizationOperation slideMerger = new OperationsSlideMerger();
slideMerger.Execute(diffs);

delete/insert क्रम को नियंत्रित करना

जब एक ही स्थिति के लिए delete और insert दोनों निकाले जाते हैं, तो EditOperationsOrder enum यह नियंत्रित करता है कि ऑप्टिमाइज़र परिणामस्वरूप ऑपरेशन क्रम में कौन सा पहले रखता है: DeleteFirst या InsertFirst।

var order = EditOperationsOrder.DeleteFirst;
var optimizer = new MergingOptimizer(order);
optimizer.Execute(diffs);

टिप्स और सर्वोत्तम प्रथाएँ

सेमान्टिक पास लागू करने से पहले कच्चे संपादनों को एकत्रित करने के लिए पहले OperationsMerger चलाएँ — MergingOptimizer और OperationsSlideMerger दोनों मानते हैं कि समान प्रकार की क्रमबद्ध ऑपरेशन्स पहले ही मिलाए जा चुके हैं।
एक EditOperationsOrder मान चुनें और पाइपलाइन के प्रत्येक ऑप्टिमाइज़र में इसे लगातार उपयोग करें; पासों के बीच DeleteFirst और InsertFirst को मिलाने से पिछले पास द्वारा स्थापित क्रम उलट सकता है।
तीनों ऑप्टिमाइज़र List<DiffOperation> को उसी स्थान पर बदलते हैं — यदि आपको तुलना के लिए अनऑप्टिमाइज़्ड डिफ़ को बरकरार रखना है तो पहले सूची की क्लोन बनाएं।
क्योंकि प्रत्येक ऑप्टिमाइज़र IDiffOptimizationOperation को लागू करता है, आप एक पाइपलाइन को IDiffOptimizationOperation[] के रूप में रख सकते हैं और प्रत्येक पर लूप में Execute को कॉल कर सकते हैं, बजाय प्रत्येक पास को नाम से हार्डकोड करने के।
मर्ज पासों के बाद OperationsSlideMerger लागू करें — एक संपादन को स्लाइड करना केवल तब उपयोगी होता है जब समान प्रकार के सन्निकट रन पहले ही मिलाए जा चुके हों।

सामान्य समस्याएँ

समस्या	कारण	समाधान
Diff अभी भी छोटे टुकड़े-टुकड़े समानताएँ रखता है	केवल `OperationsMerger` चलाया गया; संपादन के बीच छोटी समानताएँ कभी फोल्ड नहीं हुईं	`OperationsMerger` के बाद `MergingOptimizer` भी चलाएँ
Delete/insert क्रम पासों के बीच अप्रत्याशित रूप से उलट जाता है	विभिन्न `EditOperationsOrder` मान अलग-अलग ऑप्टिमाइज़र को पास किए गए	पाइपलाइन में प्रत्येक ऑप्टिमाइज़र के लिए समान `EditOperationsOrder` मान उपयोग करें
ऑप्टिमाइज़र का कोई प्रभाव नहीं दिख रहा है	Diff सूची पहले से ही मानक रूप में थी, या सूची की एक प्रति मूल संदर्भ के बजाय ऑप्टिमाइज़ की गई थी	पुष्टि करें कि आप वही `List<DiffOperation>` संदर्भ पास कर रहे हैं जो डाउनस्ट्रीम कोड पढ़ता है

FAQ

डिफ़ के लिए “canonical form” क्या मतलब है?

इसका अर्थ है कि समान प्रकार की सन्निकट ऑपरेशनों को मिलाया गया है और मिश्रित delete/insert क्रमों में कोई भी सामान्य उपसर्ग/प्रत्यय निकटवर्ती समानता में मिलाकर रखा गया है, जिससे क्रम में कोई अनावश्यक टुकड़े-टुकड़े नहीं रहता।

क्या मुझे सभी तीन ऑप्टिमाइज़र का उपयोग करना आवश्यक है?

No. IDiffOptimizationOperation आपको केवल आवश्यक पास लागू करने देता है, लेकिन OperationsMerger को सिमैंटिक पास (MergingOptimizer, OperationsSlideMerger) से पहले चलाने से सबसे सुसंगत परिणाम मिलते हैं।

`OperationsMerger` और `MergingOptimizer` के बीच अंतर क्या है?

OperationsMerger संरचनात्मक समेकन करता है (समान-प्रकार की रन, सामान्य प्रीफ़िक्स/सफ़िक्स)। MergingOptimizer और आगे जाता है और संपादनों से घिरे छोटे समानताओं को निकटवर्ती डिलीट/इन्सर्ट में वापस सम्मिलित करता है पुनः मिलाने से पहले।

क्या `EditOperationsOrder` diff के प्रतिनिधित्व को बदलता है?

नहीं। यह केवल उसी स्थिति पर लागू होने वाले डिलीट और इन्सर्ट के उत्सर्जन क्रम को नियंत्रित करता है — परिणामस्वरूप टेक्स्ट पुनर्निर्माण अप्रभावित रहता है।

API Reference सारांश

क्लास / मेथड	विवरण
`IDiffOptimizationOperation`	एक पोस्ट-प्रोसेसिंग पास के लिए इंटरफ़ेस जो जगह पर एक diff को सामान्यीकृत करता है
`IDiffOptimizationOperation.Execute(diffs)`	परिवर्तनीय `DiffOperation` मानों की सूची पर अनुकूलन पास चलाता है
`OperationsMerger`	सन्निकट समान-प्रकार के संचालन को मिलाता है और सामान्य उपसर्ग/उपसर्ग को बराबरियों में परिवर्तित करता है
`MergingOptimizer`	संपादनों द्वारा घिरे छोटे समानताओं को समाप्त करता है, फिर उन्हें मानक रूप में पुनः मिलाता है
`OperationsSlideMerger`	समानताओं से घिरे एक संपादन को स्थानांतरित करके उनमें से एक को समाप्त करता है
`EditOperationsOrder`	एक Enum जो नियंत्रित करता है कि साझा स्थिति पर `DeleteFirst` या `InsertFirst` में से कौन सा उत्पन्न किया जाए