सभी को नमस्कार! मेरा नाम साशा ज़िमिन है, मैं लन्दन के ऑफ़िस ऑफ़ द बुश में एक iOS डेवलपर के रूप में काम करती हूँ । उत्पाद प्रबंधकों के साथ बुश का बहुत करीबी रिश्ता है, और मैंने उन सभी परिकल्पनाओं को परखने की आदत डाल ली है जो उत्पाद के संबंध में हैं। इसलिए, मैंने अपनी परियोजनाओं के लिए विभाजन परीक्षण लिखना शुरू कर दिया।

इस लेख में जिस रूपरेखा पर चर्चा की जाएगी, वह दो उद्देश्यों के लिए लिखी गई थी। सबसे पहले, संभव त्रुटियों से बचने के लिए, एनालिटिक्स सिस्टम में गलत डेटा (या यहां तक कि डेटा जो गलत तरीके से व्याख्या और जलाऊ लकड़ी में तोड़ा जा सकता है) की तुलना में कोई डेटा नहीं होना बेहतर है। दूसरे, प्रत्येक बाद के परीक्षण के कार्यान्वयन को सरल बनाने के लिए। लेकिन आइए शुरुआत करें कि विभाजन परीक्षण क्या हैं।

आजकल, लाखों एप्लिकेशन हैं जो उपयोगकर्ताओं की अधिकांश आवश्यकताओं को हल करते हैं, इसलिए हर दिन नए प्रतिस्पर्धी उत्पादों को बनाना अधिक कठिन हो जाता है। इसने कई कंपनियों और स्टार्टअप्स को विभिन्न अनुसंधान और प्रयोगों का संचालन करने के लिए प्रेरित किया है ताकि यह पता लगाया जा सके कि कौन सी सुविधाएँ उनके उत्पाद को बेहतर बनाती हैं और किन लोगों के साथ विवाद किया जा सकता है।

ऐसे प्रयोगों के संचालन के लिए एक मुख्य उपकरण विभाजन परीक्षण (या ए / बी परीक्षण) है। इस लेख में मैं बताऊंगा कि स्विफ्ट पर इसे कैसे लागू किया जा सकता है।

सभी परियोजना डेमो यहां उपलब्ध हैं । यदि आपको पहले से ही ए / बी परीक्षण के बारे में पता है, तो आप सीधे कोड पर जा सकते हैं।

स्प्लिट परीक्षण के लिए एक संक्षिप्त परिचय

विभाजन परीक्षण, या ए / बी परीक्षण (यह शब्द हमेशा सही नहीं होता है, क्योंकि आपके पास प्रतिभागियों के दो से अधिक समूह हो सकते हैं), यह समझने के लिए कि कौन सा संस्करण बेहतर है, विभिन्न उपयोगकर्ता समूहों पर किसी उत्पाद के विभिन्न संस्करणों की जांच करने का एक तरीका है। आप इसके बारे में विकिपीडिया में या उदाहरण के लिए, वास्तविक उदाहरणों के साथ इस लेख में पढ़ सकते हैं।

बुश में, हम एक ही समय में बहुत सारे विभाजन परीक्षण चलाते हैं। उदाहरण के लिए, एक बार जब हमने तय किया कि हमारे आवेदन में उपयोगकर्ता प्रोफ़ाइल पृष्ठ पुराना लग रहा है, और कुछ बैनरों के साथ उपयोगकर्ता सहभागिता को भी सुधारना चाहता है। इसलिए, हमने तीन समूहों के साथ विभाजन परीक्षण शुरू किया:

पुरानी प्रोफ़ाइल
नया प्रोफाइल संस्करण 1
नया प्रोफ़ाइल संस्करण 2

जैसा कि आप देख सकते हैं, हमारे पास तीन विकल्प थे, जैसे कि ए / बी / सी परीक्षण (और यही कारण है कि हम "विभाजन परीक्षण" शब्द का उपयोग करना पसंद करते हैं)।

इसलिए विभिन्न उपयोगकर्ताओं ने अपने प्रोफाइल देखे:

उत्पाद प्रबंधक कंसोल में, हमारे पास चार उपयोगकर्ता समूह यादृच्छिक रूप से बने हैं और समान संख्या में हैं:

शायद आप पूछें कि हमारे पास नियंत्रण और control_check क्यों है (यदि control_check नियंत्रण समूह के तर्क की एक प्रति है)? इसका उत्तर बहुत सरल है: कोई भी परिवर्तन कई संकेतकों को प्रभावित करता है, इसलिए हम कभी भी पूरी तरह से निश्चित नहीं हो सकते हैं कि एक विशेष परिवर्तन विभाजन परीक्षण का परिणाम है, न कि अन्य कार्यों का।

यदि आपको लगता है कि विभाजन परीक्षण के कारण कुछ संकेतक बदल गए हैं, तो आपको यह जांचना चाहिए कि वे नियंत्रण और नियंत्रण_ समूह के अंदर समान हैं।

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

विभाजन परीक्षण और स्विफ्ट

उद्देश्य:

क्लाइंट साइड (सर्वर का उपयोग किए बिना) के लिए एक लाइब्रेरी बनाएं।
गलती से उत्पन्न होने के बाद स्थायी भंडारण में चयनित उपयोगकर्ता विकल्प को सहेजें।
विश्लेषण सेवा के लिए प्रत्येक विभाजन परीक्षण के लिए चयनित विकल्पों पर रिपोर्ट भेजें।
स्विफ्ट की क्षमताओं का अधिकतम लाभ उठाएं।

PS क्लाइंट भाग के विभाजन परीक्षण के लिए इस तरह के पुस्तकालय के उपयोग के अपने फायदे और नुकसान हैं। मुख्य लाभ यह है कि आपको सर्वर अवसंरचना या समर्पित सर्वर की आवश्यकता नहीं है। और नुकसान यह है कि यदि प्रयोग के दौरान कुछ गलत हो जाता है, तो आप ऐप स्टोर में नया संस्करण डाउनलोड किए बिना वापस नहीं लौट सकते।

कार्यान्वयन के बारे में कुछ शब्द:

प्रयोग के दौरान, उपयोगकर्ता के लिए विकल्प को समान रूप से संभावित सिद्धांत के अनुसार यादृच्छिक रूप से चुना जाता है।
विभाजन परीक्षण सेवा का उपयोग कर सकते हैं:

कोई भी डेटा स्टोर (उदाहरण के लिए, UserDefaults, Realm, SQLite या Core Data) एक निर्भरता के रूप में और उपयोगकर्ता को सौंपे गए मूल्य (इसके संस्करण का मूल्य) को इसमें सेव करें।
कोई भी एनालिटिक्स सेवा (उदाहरण के लिए, एम्प्लीट्यूड या फेसबुक एनालिटिक्स) एक निर्भरता के रूप में और उस समय वर्तमान संस्करण भेजती है जब उपयोगकर्ता एक विभाजित परीक्षण का सामना करता है।

यहाँ भविष्य की कक्षाओं का एक चित्र है:

स्प्लिटटेस्टप्रोटोकॉल का उपयोग करके सभी विभाजन परीक्षणों को प्रस्तुत किया जाएगा, और उनमें से प्रत्येक में कई विकल्प (समूह) होंगे जो स्प्लिटटेस्टग्रुपप्रोटोकॉल में प्रस्तुत किए जाएंगे ।

विभाजन परीक्षण वर्तमान संस्करण के बारे में विश्लेषक को सूचित करने में सक्षम होना चाहिए, इसलिए, यह एक निर्भरता के रूप में AnalyticsProtocol होगा।

सर्विस स्प्लिट्सटाइंग सर्विस सेव करेगी, ऑप्शंस जेनरेट करेगी और सभी स्प्लिट टेस्ट को मैनेज करेगी। यह वह है जो स्टोरेज से उपयोगकर्ता के वर्तमान संस्करण को डाउनलोड करता है, जो स्टोरेजप्रोटोकॉल द्वारा निर्धारित किया जाता है , और साथ ही एनालिटिक्सप्रोटोकॉल को स्प्लिटटेस्ट्रोकॉलोक तक पहुंचाता है ।

आइए AnalyticsProtocol और StorageProtocol निर्भरता के साथ कोड लिखना शुरू करें:

protocol AnalyticsServiceProtocol {    func setOnce(value: String, for key: String) } protocol StorageServiceProtocol {    func save(string: String?, for key: String)    func getString(for key: String) -> String? }

एक घटना को एक बार रिकॉर्ड करने के लिए एनालिटिक्स की भूमिका है। उदाहरण के लिए, बटन A_color विभाजन परीक्षण के दौरान उपयोगकर्ता A नीले समूह में है, जब वह इस बटन के साथ स्क्रीन देखता है।

रिपॉजिटरी की भूमिका वर्तमान उपयोगकर्ता के लिए एक विशिष्ट विकल्प को बचाने के लिए है ( स्प्लिटिंगस्ट्रीम सेवा के बाद यह विकल्प उत्पन्न होता है) और फिर इसे हर बार पढ़ने के बाद कार्यक्रम इस विभाजन परीक्षण तक पहुंचता है।

तो, आइए स्प्लिटटेस्टग्रुपप्रोटोकॉल पर एक नज़र डालें , जो एक विशिष्ट विभाजन परीक्षण के लिए विकल्पों के एक सेट की विशेषता है:

 protocol SplitTestGroupProtocol: RawRepresentable where RawValue == String {   static var testGroups: [Self] { get } }

चूंकि RawRepresentable जहां RawValue एक स्ट्रिंग है, आप आसानी से स्ट्रिंग से एक वेरिएंट बना सकते हैं या इसे वापस स्ट्रिंग में परिवर्तित कर सकते हैं, जो एनालिटिक्स और स्टोरेज के साथ काम करने के लिए बहुत सुविधाजनक है। स्प्लिटटेस्टग्रुपप्रोटोकॉल में टेस्टग्रुप की एक सरणी भी होती है, जो वर्तमान विकल्पों की संरचना का संकेत दे सकती है (यह सरणी उपलब्ध विकल्पों में से यादृच्छिक पीढ़ी के लिए भी उपयोग की जाएगी)।

यह स्प्लिटटेस्टप्रोटोकोल स्प्लिट टेस्ट के लिए बेस प्रोटोटाइप है :

 protocol SplitTestProtocol {   associatedtype GroupType: SplitTestGroupProtocol   static var identifier: String { get }   var currentGroup: GroupType { get }   var analytics: AnalyticsServiceProtocol { get }   init(currentGroup: GroupType, analytics: AnalyticsServiceProtocol) } extension SplitTestProtocol {   func hitSplitTest() {       self.analytics.setOnce(value: self.currentGroup.rawValue, for: Self.analyticsKey)   }   static var analyticsKey: String {       return "split_test-\(self.identifier)"   }   static var dataBaseKey: String {       return "split_test_database-\(self.identifier)"   } }

स्प्लिटस्टप्रोटोकॉल में शामिल हैं:

एक GroupType प्रकार जो विकल्पों के एक सेट को परिभाषित करने वाले प्रकार का प्रतिनिधित्व करने के लिए SplitTestGroupProtocol प्रोटोकॉल को लागू करता है।
विश्लेषिकी और भंडारण कुंजी के लिए स्ट्रिंग मान पहचानकर्ता ।
स्प्लिटटेस्टप्रोटोकॉल का एक विशिष्ट उदाहरण रिकॉर्ड करने के लिए वर्तमान समूह चर।
HitSplitTest विधि के लिए विश्लेषिकी निर्भरता।
और हिटस्प्लिटटेस्ट विधि, जो विश्लेषक को सूचित करती है कि उपयोगकर्ता ने विभाजन परीक्षण का परिणाम देखा था।

HitSplitTest विधि आपको यह सुनिश्चित करने की अनुमति देती है कि उपयोगकर्ता न केवल किसी विशेष संस्करण में हैं, बल्कि परीक्षा परिणाम भी देखा है। यदि आप ऐसे उपयोगकर्ता को चिह्नित करते हैं, जिन्होंने खरीदारी अनुभाग "saw_red_button_on_purcahse_screen" के रूप में नहीं देखा है, तो यह परिणामों को विकृत करेगा।

अब हम SplitTestingService के लिए तैयार हैं:

 protocol SplitTestingServiceProtocol {   func fetchSplitTest<Value: SplitTestProtocol>(_ splitTestType: Value.Type) -> Value } class SplitTestingService: SplitTestingServiceProtocol {   private let analyticsService: AnalyticsServiceProtocol   private let storage: StorageServiceProtocol   init(analyticsService: AnalyticsServiceProtocol, storage: StorageServiceProtocol) {       self.analyticsService = analyticsService       self.storage = storage   }   func fetchSplitTest<Value: SplitTestProtocol>(_ splitTestType: Value.Type) -> Value {       if let value = self.getGroup(splitTestType) {           return Value(currentGroup: value, analytics: self.analyticsService)       }       let randomGroup = self.randomGroup(Value.self)       self.saveGroup(splitTestType, group: randomGroup)       return Value(currentGroup: randomGroup, analytics: self.analyticsService)   }   private func saveGroup<Value: SplitTestProtocol>(_ splitTestType: Value.Type, group: Value.GroupType) {       self.storage.save(string: group.rawValue, for: Value.dataBaseKey)   }   private func getGroup<Value: SplitTestProtocol>(_ splitTestType: Value.Type) -> Value.GroupType? {       guard let stringValue = self.storage.getString(for: Value.dataBaseKey) else {           return nil       }       return Value.GroupType(rawValue: stringValue)   }   private func randomGroup<Value: SplitTestProtocol>(_ splitTestType: Value.Type) -> Value.GroupType {       let count = Value.GroupType.testGroups.count       let random = Int.random(lower: 0, count - 1)       return Value.GroupType.testGroups[random]   } }

PS इस श्रेणी में हम Int.random फ़ंक्शन का उपयोग करते हैं, जिससे लिया गया है
यहां , लेकिन स्विफ्ट 4.2 में यह पहले से ही डिफ़ॉल्ट रूप से बनाया गया है।

इस वर्ग में एक सार्वजनिक fetSplitTest विधि और तीन निजी विधियाँ हैं: saveGroup , getGroup , randomGroup ।

रैंडमग्रुप विधि चयनित स्प्लिट टेस्ट के लिए एक रैंडम वेरिएंट तैयार करती है, जबकि गेटग्रुप और सेवग्रुप आपको वर्तमान उपयोगकर्ता के लिए विशिष्ट स्प्लिट टेस्ट के लिए वेरिएंट को बचाने या लोड करने की अनुमति देते हैं।

इस वर्ग का मुख्य और सार्वजनिक कार्य है fetchSplitTest: यह निरंतर भंडारण से वर्तमान संस्करण को वापस करने की कोशिश करता है और, अगर यह सफल नहीं होता है, तो इसे वापस करने से पहले एक यादृच्छिक संस्करण उत्पन्न करता है और बचाता है।

अब हम अपना पहला विभाजन परीक्षण बनाने के लिए तैयार हैं:

 final class ButtonColorSplitTest: SplitTestProtocol {   static var identifier: String = "button_color"   var currentGroup: ButtonColorSplitTest.Group   var analytics: AnalyticsServiceProtocol   init(currentGroup: ButtonColorSplitTest.Group, analytics: AnalyticsServiceProtocol) {       self.currentGroup = currentGroup       self.analytics = analytics   }   typealias GroupType = Group   enum Group: String, SplitTestGroupProtocol {       case red = "red"       case blue = "blue"       case darkGray = "dark_gray"       static var testGroups: [ButtonColorSplitTest.Group] = [.red, .blue, .darkGray]   } } extension ButtonColorSplitTest.Group {   var color: UIColor {       switch self {       case .blue:           return .blue       case .red:           return .red       case .darkGray:           return .darkGray       }   } }

यह प्रभावशाली दिखता है, लेकिन यह चिंता की बात नहीं है: जैसे ही आप स्प्लिटटेस्टप्रोटोकॉल को एक अलग वर्ग के रूप में लागू करते हैं, कंपाइलर आपको सभी आवश्यक गुणों को लागू करने के लिए कहेगा।

यहाँ महत्वपूर्ण हिस्सा एनम समूह प्रकार है। आपको अपने सभी समूहों को इसमें (हमारे उदाहरण में, लाल, नीला और डार्कग्रे में) रखना चाहिए, और एनालिटिक्स में सही स्थानांतरण सुनिश्चित करने के लिए यहां स्ट्रिंग मान को परिभाषित करना चाहिए।

हमारे पास एक एक्सटेंशन ButtonColorSplitTest.Group है , जिससे आप स्विफ्ट की पूरी क्षमता का उपयोग कर सकते हैं। अब AnalyticsProtocol और StorageProtocol के लिए ऑब्जेक्ट बनाते हैं :

 extension UserDefaults: StorageServiceProtocol {   func save(string: String?, for key: String) {       self.set(string, forKey: key)   }   func getString(for key: String) -> String? {       return self.object(forKey: key) as? String   } }

StorageProtocol के लिए हम UserDefaults क्लास का उपयोग करेंगे क्योंकि इसे लागू करना आसान है, लेकिन आपकी परियोजनाओं में आप किसी भी अन्य स्थिर भंडारण के साथ काम कर सकते हैं (उदाहरण के लिए, मैंने खुद के लिए किचेन को चुना, क्योंकि यह उपयोगकर्ता को हटाने के बाद भी समूह को बचाता है)।

इस उदाहरण में, मैं एक काल्पनिक एनालिटिक्स क्लास बनाऊंगा, लेकिन आप अपने प्रोजेक्ट में वास्तविक एनालिटिक्स का उपयोग कर सकते हैं। उदाहरण के लिए, आप एम्प्लिट्यूड सेवा का उपयोग कर सकते हैं।

 // Dummy class for example, use something real, like Amplitude class Analytics {   func logOnce(property: NSObject, for key: String) {       let storageKey = "example.\(key)"       if UserDefaults.standard.object(forKey: storageKey) == nil {           print("Log once value: \(property) for key: \(key)")           UserDefaults.standard.set("", forKey: storageKey) // String because of simulator bug       }   } } extension Analytics: AnalyticsServiceProtocol {   func setOnce(value: String, for key: String) {       self.logOnce(property: value as NSObject, for: key)   } }

अब हम अपने विभाजन परीक्षण का उपयोग करने के लिए तैयार हैं:

 let splitTestingService = SplitTestingService(analyticsService: Analytics(),                                                      storage: UserDefaults.standard) let buttonSplitTest = splitTestingService.fetchSplitTest(ButtonColorSplitTest.self) self.button.backgroundColor = buttonSplitTest.currentGroup.color buttonSplitTest.hitSplitTest()

बस अपना स्वयं का उदाहरण बनाएं, विभाजन परीक्षण निकालें और इसका उपयोग करें। सामान्यीकरण आपको buttonSplitTest.currentGroup.color. कॉल करते हैं buttonSplitTest.currentGroup.color.

पहले उपयोग के दौरान, आप कुछ ऐसा देख सकते हैं ( लॉग एक बार मान लें ) : कुंजी के लिए विभाजित_ बटन-बटन_रंग: dark_gray , और यदि आप डिवाइस से एप्लिकेशन को नहीं निकालते हैं, तो बटन हर बार आपके द्वारा शुरू होने पर समान होगा।

इस तरह की लाइब्रेरी को लागू करने की प्रक्रिया में कुछ समय लगता है, लेकिन इसके बाद, आपकी परियोजना के अंदर प्रत्येक नया विभाजन परीक्षण कुछ मिनटों में बन जाएगा।

यहां एक वास्तविक एप्लिकेशन में इंजन का उपयोग करने का एक उदाहरण है: एनालिटिक्स में, हमने उपयोगकर्ताओं को खेल मुद्रा खरीदने की जटिलता और संभावना के गुणांक से खंडित किया।

जिन लोगों ने कभी इस कठिनाई कारक का सामना नहीं किया है (कोई नहीं) शायद सभी में नहीं खेलते हैं और खेल में कुछ भी नहीं खरीदते हैं (जो तार्किक है), यही कारण है कि विभाजन परीक्षण के परिणाम (उत्पन्न संस्करण) को एक समय में सर्वर पर भेजना महत्वपूर्ण है उपयोगकर्ता वास्तव में आपके परीक्षण का सामना करते हैं।

एक कठिनाई कारक के बिना, केवल 2% उपयोगकर्ताओं ने खेल मुद्रा खरीदी। एक छोटे अनुपात के साथ, खरीद पहले से ही 3% थी। और एक उच्च कठिनाई कारक के साथ, 4% खिलाड़ियों ने मुद्रा खरीदी। इसका मतलब है कि आप गुणांक को बढ़ाना जारी रख सकते हैं और संख्याओं का निरीक्षण कर सकते हैं। :)

यदि आप अधिकतम विश्वसनीयता के साथ परिणामों का विश्लेषण करने में रुचि रखते हैं, तो मैं आपको इस उपकरण का उपयोग करने की सलाह देता हूं।

उस अद्भुत टीम का धन्यवाद जिसने मुझे इस लेख (विशेषकर इगोर , केली और हिरो ) पर काम करने में मदद की।

संपूर्ण डेमो प्रोजेक्ट इस लिंक पर उपलब्ध है।

विभाजन परीक्षणों का उपयोग करके स्विफ्ट पर कैसे परिकल्पना करें और पैसे कमाएं

स्प्लिट परीक्षण के लिए एक संक्षिप्त परिचय

विभाजन परीक्षण और स्विफ्ट

More articles: