मैं अपने डिवाइस टोकन (NSData) को NSString में कैसे बदल सकता हूं?

Question

मैं पुश नोटिफिकेशन लागू कर रहा हूं। मैं अपने APNS टोकन को एक स्ट्रिंग के रूप में सहेजना चाहता हूं।

- (void)application:(UIApplication *)application
didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)newDeviceToken
{
    NSString *tokenString = [NSString stringWithUTF8String:[newDeviceToken bytes]]; //[[NSString alloc]initWithData:newDeviceToken encoding:NSUTF8StringEncoding];
    NSLog(@"%@", tokenString);
    NSLog(@"%@", newDeviceToken);
}

कोड की पहली पंक्ति शून्य को प्रिंट करती है। दूसरे टोकन को प्रिंट करता है। NSString के रूप में मैं अपना नया डेटा कैसे प्राप्त कर सकता हूं?

Comments

दूसरे का आउटपुट क्या है NSLog, जो प्रिंट करता है newDeviceToken?

— बजे लूट

डुप्लिकेट: stackoverflow.com/questions/1305225/...

— NiñoScript

वर्णन का उपयोग न करें

— फेटी

Answer 1

इसे इस्तेमाल करो :

NSString * deviceTokenString = [[[[deviceToken description]
                         stringByReplacingOccurrencesOfString: @"<" withString: @""] 
                        stringByReplacingOccurrencesOfString: @">" withString: @""] 
                       stringByReplacingOccurrencesOfString: @" " withString: @""];

NSLog(@"The generated device token string is : %@",deviceTokenString);

Comments

यह वर्णन का उपयोग करने के लिए एक बुरा विचार है: कुछ भी सुनिश्चित नहीं करता है कि बाद में आईओएस का संस्करण इस कॉल के कार्यान्वयन और परिणाम को नहीं बदलेगा।

— madewulf

वास्तव में, यह एक बहुत बुरा विचार है।

— डेविड स्नेबेल-कॉंट

@madewulf आपको यह बताने के लिए बहुत अच्छा है कि यह विवरण का उपयोग करने के लिए इतना भयानक विचार कैसे है .. यह भी अच्छा होता यदि आपने एक विकल्प सुझाया हो

— abbood

[डिवाइसटॉकेन बाइट्स] के तहत यहाँ समाधान बिल फिट बैठता है।

— मैडवुल्फ

स्विफ्ट 3 / iOS 10 के रूप में निकला, एक डिवाइस टोकन पर "32 बाइट्स" प्रतिलेखन। तो हाँ, यह प्रयोग न करें।

— विक्टर लुफ्ट

Answer 2

अगर कोई स्विफ्ट में ऐसा करने का तरीका ढूंढ रहा है:

func application(application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: NSData) {
    let tokenChars = UnsafePointer<CChar>(deviceToken.bytes)
    var tokenString = ""

    for i in 0..<deviceToken.length {
        tokenString += String(format: "%02.2hhx", arguments: [tokenChars[i]])
    }

    print("tokenString: \(tokenString)")
}

संपादित करें: स्विफ्ट 3 के लिए

स्विफ्ट 3 Dataवैल्यू शब्दार्थ के साथ टाइप का परिचय देता है । deviceTokenस्ट्रिंग में बदलने के लिए, आप निम्न कार्य कर सकते हैं:

func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
    let token = deviceToken.map { String(format: "%02.2hhx", $0) }.joined()
    print(token)
}

Comments

इसे इतना जटिल क्यों होना पड़ता है, ओएस के साथ क्या गलत है जो हमें एक स्ट्रिंग दे रहा है क्योंकि हर किसी को इसकी आवश्यकता है? इस समाधान के लिए धन्यवाद।

— पिवफ

@ साशा मुझे आशा है कि आप अपने बहुत उपयोगी उत्तर के लिए मेरे संपादन को मंजूरी देंगे :)

— जार्टर्टन

मैंने let token = deviceToken.map { String(format: "%02.2hhx", $0) }.joined() रिफैक्ट किया

— मोनो

मैं .description का उपयोग करने की अनुशंसा नहीं करता क्योंकि यह स्थिर होने की गारंटी नहीं है। मेरा जवाब यहां देखें: stackoverflow.com/questions/9372815/…

— स्विफ्ट टेलर

क्या आप बता सकते हैं कि क्या करता "%02.2hhxहै?

— हनी

Answer 3

किसी ने मेरी इसमें मदद की। मैं अभी गुजर रहा हूं

- (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)devToken {

    const unsigned *tokenBytes = [deviceToken bytes];
    NSString *hexToken = [NSString stringWithFormat:@"%08x%08x%08x%08x%08x%08x%08x%08x",
                         ntohl(tokenBytes[0]), ntohl(tokenBytes[1]), ntohl(tokenBytes[2]),
                         ntohl(tokenBytes[3]), ntohl(tokenBytes[4]), ntohl(tokenBytes[5]),
                         ntohl(tokenBytes[6]), ntohl(tokenBytes[7])];

    [[MyModel sharedModel] setApnsToken:hexToken];
}

Comments

यह सबसे अच्छा उपाय है, चूंकि हेक्स के रूप में एन्कॉन्डिग बाइट्स का तात्पर्य है कि आप इसे गिन सकते हैं;)

— लोरेटोपरिसी

XCode 5 पर मुझे इसे बनाने के लिए DeviceToken कास्ट करना पड़ा: const unsigned * tokenBytes = (const unsigned *) [deviceToken बाइट्स];

— पोनीटेक

टोकन जल्द ही 32 बाइट्स से बड़े होने वाले हैं, इसलिए इसे आठ हार्ड-कोडर पूर्णांकों के बजाय प्रत्येक बाइट पर लूप बनाने की आवश्यकता होगी।

— टॉम डेलिंग

क्या यह एक बेहतर समाधान होगा? const unsigned *tokenBytes = [deviceToken bytes]; NSMutableString *hexToken = [NSMutableString string]; for (NSUInteger byteCount = 0; byteCount * 4 < [deviceToken length]; byteCount++) { [hexToken appendFormat:@"%08x", ntohl(tokenBytes[byteCount])]; }

— हैरो

Important: APNs device tokens are of variable length. Do not hard-code their size.Apple कहता है।

— erkanyildiz

Answer 4

आप इसका उपयोग कर सकते हैं

- (NSString *)stringWithDeviceToken:(NSData *)deviceToken {
    const char *data = [deviceToken bytes];
    NSMutableString *token = [NSMutableString string];

    for (NSUInteger i = 0; i < [deviceToken length]; i++) {
        [token appendFormat:@"%02.2hhX", data[i]];
    }

    return [token copy];
}

Comments

यह स्वीकृत उत्तर होना चाहिए, क्योंकि यह उपयोग करने की तुलना में अधिक सुरक्षित है description।

— DrMickeyLauer

ऑब्जेक्टिव-सी में यह एकमात्र सही उत्तर है जो टोकन आकार में आगामी वृद्धि को संभाल लेगा।

— टॉम डेलिंग

सहमत है कि यह शायद सबसे सुरक्षित तरीका है क्योंकि यह किसी विशेष टोकन आकार / लंबाई को नहीं मानता है।

— रयान एच।

IOS 10 में काम करता है

— Tjalsma

मैंने प्रयोग किया है [token appendFormat:@"%02.2hhx", data[i]];क्योंकि अमेज़न एसएनएस को कम मामले की आवश्यकता होती है।

— मैनुअल शमित्ज़बर्गर

Answer 5

उन लोगों के लिए जो स्विफ्ट 3 और सबसे आसान तरीका चाहते हैं

func extractTokenFromData(deviceToken:Data) -> String {
    let token = deviceToken.reduce("", {$0 + String(format: "%02X", $1)})
    return token.uppercased();
}

Comments

मैंने एक ही कोड लिखा है :) यह सबसे स्विफ्टी संस्करण है, और केवल यही काम करता है

— Quver

@ आनंद यू को समझा सकते हैं कि इस कोड में क्या खुशी हैdeviceToken.reduce("", {$0 + String(format: "%02X", $1)})

— रामकृष्ण

यह स्विफ्ट के फंक्शन को कम करता है जो डेटा को हेक्साडेसिमल स्ट्रिंग और फिर स्ट्रिंग में क्रमबद्ध करता है। फंक्शन कम करने के बारे में अधिक जानने के लिए readyourloaf.com/blog/swift-guide-to-map-filter-reduce

— आनंद

Answer 6

%02.2hhxउच्च वोट उत्तर में स्पष्टीकरण :

• %: xरूपांतरण विनिर्देशक का परिचय देता है ।
• 02: परिवर्तित मूल्य की न्यूनतम चौड़ाई 2 है। यदि परिवर्तित मूल्य में फ़ील्ड की चौड़ाई की तुलना में कम बाइट्स हैं, तो इसे 0बाईं ओर गद्देदार किया जाएगा ।
• .2: xरूपांतरण विनिर्देशक के लिए प्रदर्शित होने के लिए न्यूनतम अंकों की संख्या देता है ।
• hh: निर्दिष्ट करता है कि xरूपांतरण विनिर्देशक हस्ताक्षर किए गए चार या अहस्ताक्षरित चार तर्क पर लागू होता है (पूर्णांक पदोन्नति के अनुसार तर्क को बढ़ावा दिया जाएगा, लेकिन इसका मूल्य मुद्रण से पहले हस्ताक्षरित चार्ट या अहस्ताक्षरित चार्ट में परिवर्तित किया जाएगा)।
• x: अहस्ताक्षरित तर्क को शैली "dddd" में अहस्ताक्षरित हेक्साडेसिमल प्रारूप में परिवर्तित किया जाएगा; "abcdef" अक्षरों का उपयोग किया जाता है। सटीक दिखने के लिए न्यूनतम अंकों की संख्या निर्दिष्ट करता है; यदि परिवर्तित किया जा रहा मान कम अंकों में दर्शाया जा सकता है, तो इसे अग्रणी शून्य के साथ विस्तारित किया जाएगा। डिफ़ॉल्ट परिशुद्धता 1. शून्य के स्पष्ट सटीकता के साथ शून्य को परिवर्तित करने का परिणाम कोई वर्ण नहीं होगा।

अधिक जानकारी के लिए, IEEE प्रिंटफ विनिर्देश देखें ।

---

उपरोक्त स्पष्टीकरण के आधार पर, मुझे लगता है कि इसे बदलना बेहतर %02.2hhxहै %02xया %.2x।

स्विफ्ट 5 के लिए, निम्नलिखित तरीके सभी संभव हैं:

deviceToken.map({String(format: "%02x", $0)}).joined()

deviceToken.map({String(format: "%.2x", $0)}).joined()

deviceToken.reduce("", {$0 + String(format: "%02x", $1)})

deviceToken.reduce("", {$0 + String(format: "%.2x", $1)})

परीक्षण इस प्रकार है:

let deviceToken = (0..<32).reduce(Data(), {$0 + [$1]})
print(deviceToken.reduce("", {$0 + String(format: "%.2x", $1)}))
// Print content:
// 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f

Comments

इस उत्तर के लिए धन्यवाद। क्या यह काम iOS 12 के साथ भी होता है? या यह केवल स्विफ्ट संस्करण पर निर्भर करता है?

— मार्कस

@ मर्कस यह iOS 12 में काम करता है, केवल स्विफ्ट संस्करण पर निर्भर करता है।

— jqgsninimo

Answer 7

यह मेरा समाधान है और यह मेरे ऐप में अच्छा काम करता है:

    NSString* newToken = [[[NSString stringWithFormat:@"%@",deviceToken] 
stringByTrimmingCharactersInSet:[NSCharacterSet characterSetWithCharactersInString:@"<>"]] stringByReplacingOccurrencesOfString:@" " withString:@""];

• के साथ परिवर्तित NSDataकरेंNSStringstringWithFormat
• ट्रिम "<>"
• रिक्त स्थान निकालें

Comments

यह केवल अंतर्निहित रूप से कॉल करता है -description, इसलिए यह स्वीकृत उत्तर की तुलना में कोई सुरक्षित नहीं है।

— jszumski 20

क्या आप कृपया अपने स्रोत को लिंक कर सकते हैं? मुझे इसके बारे में कहीं भी जानकारी नहीं मिल सकती है। धन्यवाद।

— ज़ेब

मिल गया! मुझे लगता है कि यह थोड़ा अलग है। वर्णन विशेषता का उपयोग करें सीधे सुरक्षित नहीं है क्योंकि यह भविष्य के संस्करणों में बदल सकता है, लेकिन यदि आप इसे एक NSString विधि का उपयोग करते हैं तो आपको शायद ही समस्या होगी।

— ज़ेब

यह वास्तव में descriptionडिवाइस पर कॉल नहीं करता है जैसे jszumski कहता है।

— जॉनी

@ ज़ेब यह भरोसा करने के लिए सुरक्षित नहीं है descriptionकि आप इसे सीधे कॉल करते हैं, या किसी अन्य विधि के माध्यम से इसका उपयोग करते हैं, क्योंकि किसी भी समय लौटे स्ट्रिंग के प्रारूप को बदला जा सकता है। सही समाधान यहाँ है: stackoverflow.com/a/16411517/108105

— टॉम डेलिंग

Answer 8

मुझे लगता है कि डिवाइस को परिवर्तित करके हेक्स बाइट स्ट्रिंग का कोई मतलब नहीं है। क्यों? आप इसे अपने बैकएंड पर भेजेंगे, जहां इसे APNS में धकेलने के लिए वापस बाइट्स में बदल दिया जाएगा। इसलिए, NSData की विधि का उपयोग करें base64EncodedStringWithOptions, इसे सर्वर पर धकेलें, और फिर रिवर्स बेस 64decoded डेटा का उपयोग करें :) यह बहुत अधिक है :)

NSString *tokenString = [tokenData base64EncodedStringWithOptions:NSDataBase64EncodingEndLineWithLineFeed];

Comments

@ jeet.chanchawat कृपया अन्य उपयोगकर्ताओं के उत्तरों में कोड न जोड़ें। हम उनके मुंह में शब्द नहीं डालना चाहते हैं, खासकर जब स्विफ्ट को एक उद्देश्य-सी उत्तर में जोड़ते हैं। इसके बजाय, अपना खुद का उत्तर जोड़ें।

— JAL

मैं अभी @Oleg शान्युक के उत्तर की प्रतिज्ञा नहीं करना चाहता था। जैसा कि उनके जवाब पर बनी एक अन्य भाषा में यह सिर्फ अनुवाद है, इसलिए वह भविष्य के वोटों के हकदार हैं। यदि मैं एक और उत्तर जोड़ता हूं तो यह मुझे उस उत्तर के लिए उत्थान देगा जो किसी और का शोध है। आशा है कि यह EDIT को सही ठहराएगा।

— jeet.chanchawat

Answer 9

आईओएस 13 descriptionमें टूट जाएगा तो इस का उपयोग करें

let deviceTokenString = deviceToken.map { String(format: "%02x", $0) }.joined()

स्पष्टता के लिए, आइए इसे तोड़ते हैं और प्रत्येक भाग की व्याख्या करते हैं:

मानचित्र विधि अनुक्रम के प्रत्येक तत्व पर कार्य करती है। क्योंकि डेटा स्विफ्ट में बाइट्स का एक क्रम है, डिवाइसटोकन में प्रत्येक बाइट के लिए पारित क्लोजर का मूल्यांकन किया जाता है। स्ट्रिंग (स्वरूप :) initializer डेटा में प्रत्येक बाइट का मूल्यांकन करता है (अनाम पैरामीटर $ 0 द्वारा प्रतिनिधित्व किया जाता है)% 02x प्रारूप विनिर्देशक का उपयोग करते हुए, बाइट के 8-बिट पूर्णांक के शून्य-गद्देदार, 2-अंकीय हेक्साडेसिमल प्रतिनिधित्व का उत्पादन करने के लिए। मानचित्र विधि द्वारा बनाए गए प्रत्येक बाइट प्रतिनिधित्व को इकट्ठा करने के बाद, प्रत्येक तत्व को एक स्ट्रिंग में सम्मिलित किया ()।

PS का उपयोग नहीं करते विवरण iOS 12 और iOS 13 में अलग-अलग स्ट्रिंग देता है और भविष्य के दायरे के अनुसार सुरक्षित नहीं है। डेवलपर्स को किसी वस्तु के विवरण के लिए एक विशिष्ट प्रारूप पर निर्भर नहीं होना चाहिए।

// iOS 12
(deviceToken as NSData).description // "<965b251c 6cb1926d e3cb366f dfb16ddd e6b9086a 8a3cac9e 5f857679 376eab7C>"

// iOS 13
(deviceToken as NSData).description // "{length = 32, bytes = 0x965b251c 6cb1926d e3cb366f dfb16ddd ... 5f857679 376eab7c }"

अधिक जानकारी के लिए पढ़ने के लिए यह ।

Answer 10

IOS 13 में विवरण अलग प्रारूप में होगा। डिवाइस टोकन लाने के लिए कृपया नीचे दिए गए कोड का उपयोग करें।

- (NSString *)fetchDeviceToken:(NSData *)deviceToken {
    NSUInteger len = deviceToken.length;
    if (len == 0) {
        return nil;
    }
    const unsigned char *buffer = deviceToken.bytes;
    NSMutableString *hexString  = [NSMutableString stringWithCapacity:(len * 2)];
    for (int i = 0; i < len; ++i) {
        [hexString appendFormat:@"%02x", buffer[i]];
    }
    return [hexString copy];
}

Comments

आईओएस के लिए सही समाधान 13. धन्यवाद विष्णु

— मनीष

यह वर्तमान lengthमें संकलित नहीं है - के लिए लूप में परिवर्तित किया जाना चाहिए len। जाहिरा तौर पर मेरे लिए एक संपादित करने के लिए बहुत छोटा परिवर्तन .. लेकिन बाकी पूरी तरह से काम करता है!

— एंडर्स फ्राइस

आप एक जीवन रक्षक हैं

— मोईज़ अकरम

Answer 11

यह एक छोटा सा समाधान है:

NSData *token = // ...
const uint64_t *tokenBytes = token.bytes;
NSString *hex = [NSString stringWithFormat:@"%016llx%016llx%016llx%016llx",
                 ntohll(tokenBytes[0]), ntohll(tokenBytes[1]),
                 ntohll(tokenBytes[2]), ntohll(tokenBytes[3])];

Answer 12

कार्यात्मक स्विफ्ट संस्करण

एक लाइन:

let hexString = UnsafeBufferPointer<UInt8>(start: UnsafePointer(data.bytes),
count: data.length).map { String(format: "%02x", $0) }.joinWithSeparator("")

---

यहां एक पुन: प्रयोज्य और स्व-दस्तावेजीकरण विस्तार फ़ॉर्म में है:

extension NSData {
    func base16EncodedString(uppercase uppercase: Bool = false) -> String {
        let buffer = UnsafeBufferPointer<UInt8>(start: UnsafePointer(self.bytes),
                                                count: self.length)
        let hexFormat = uppercase ? "X" : "x"
        let formatString = "%02\(hexFormat)"
        let bytesAsHexStrings = buffer.map {
            String(format: formatString, $0)
        }
        return bytesAsHexStrings.joinWithSeparator("")
    }
}

---

वैकल्पिक रूप से, अपने साथियों द्वारा कार्यात्मक मास्टर के रूप में देखे जाने के reduce("", combine: +)बजाय उपयोग joinWithSeparator("")करें।

---

संपादित करें: मैंने स्ट्रिंग ($ 0, मूलांक: 16) को स्ट्रिंग में बदल दिया (प्रारूप: "% 02x", $ 0), क्योंकि एक अंक संख्या में एक गद्दी शून्य होने की आवश्यकता होती है

(मुझे नहीं पता कि इस दूसरे के डुप्लिकेट के रूप में किसी प्रश्न को कैसे चिह्नित किया जाए, इसलिए मैंने अपना उत्तर फिर से पोस्ट किया)

Comments

मेरे लिए काम करता है, धन्यवाद।

— हसी

Answer 13

2020

पाठ के रूप में टोकन ...

let tat = deviceToken.map{ data in String(format: "%02.2hhx", data) }.joined()

या यदि आप पसंद करते हैं

let tat2 = deviceToken.map { String(format: "%02.2hhx", $0) }.joined()

(परिणाम वही है)

Answer 14

ढेर पर मेरा जवाब फेंक दिया। स्ट्रिंग पार्सिंग का उपयोग करने से बचें; यह डॉक्स द्वारा गारंटी नहीं है कि NSData.description हमेशा इस तरह से काम करेगा।

स्विफ्ट 3 कार्यान्वयन:

extension Data {
    func hexString() -> String {
        var bytesPointer: UnsafeBufferPointer<UInt8> = UnsafeBufferPointer(start: nil, count: 0)
        self.withUnsafeBytes { (bytes) in
            bytesPointer = UnsafeBufferPointer<UInt8>(start: UnsafePointer(bytes), count:self.count)
        }
        let hexBytes = bytesPointer.map { return String(format: "%02hhx", $0) }
        return hexBytes.joined()
    }
}

Answer 15

मैंने प्रारूप के साथ दो अलग-अलग तरीकों का परीक्षण करने की कोशिश की है "%02.2hhx"और"%02x"

    var i :Int = 0
    var j: Int = 0
    let e: Int = Int(1e4)
    let time = NSDate.timeIntervalSinceReferenceDate
    while i < e {
        _ =  deviceToken.map { String(format: "%02x", $0) }.joined()
        i += 1
    }
    let time2 = NSDate.timeIntervalSinceReferenceDate
    let delta = time2-time
    print(delta)

    let time3 = NSDate.timeIntervalSinceReferenceDate
    while j < e {
        _ =  deviceToken.reduce("", {$0 + String(format: "%02x", $1)})
        j += 1
    }
    let time4 = NSDate.timeIntervalSinceReferenceDate
    let delta2 = time4-time3
    print(delta2)

और परिणाम यह है कि सबसे "%02x"कम 2.0 संस्करण में 2.6 बनाम कम संस्करण के लिए है:

deviceToken.reduce("", {$0 + String(format: "%02x", $1)})

Answer 16

UpdateAccumulatingResult का उपयोग करना यहां पाए जाने वाले विभिन्न अन्य तरीकों की तुलना में अधिक कुशल है, इसलिए यहां अपने बाइट्स को सख्त करने का सबसे स्विफ्ट तरीका है Data:

func application(_ application: UIApplication,
                 didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
    let token = deviceToken.reduce(into: "") { $0 += String(format: "%.2x", $1) }
    print(token)
}

Comments

एलेक्स, यह नहीं होगा% 02.2hx

— फेटी

Answer 17

स्विफ्ट के लिए:

var characterSet: NSCharacterSet = NSCharacterSet( charactersInString: "<>" )
    var deviceTokenString: String = ( deviceToken.description as NSString )
    .stringByTrimmingCharactersInSet( characterSet )
    .stringByReplacingOccurrencesOfString( " ", withString: "" ) as String

println( deviceTokenString )

Answer 18

एक लाइन समाधान के बारे में क्या?

उद्देश्य सी

NSString *token = [[data.description componentsSeparatedByCharactersInSet:[[NSCharacterSet alphanumericCharacterSet]invertedSet]]componentsJoinedByString:@""];

तीव्र

let token = data.description.componentsSeparatedByCharactersInSet(NSCharacterSet.alphanumericCharacterSet().invertedSet).joinWithSeparator("")

Comments

यह सरल और सबसे अच्छा उपाय है। धन्यवाद

— एमी

Answer 19

यहाँ आप इसे Xamarin.iOS में कैसे करते हैं

public override void RegisteredForRemoteNotifications(UIApplication application, NSData deviceToken)
{
    var tokenStringBase64 = deviceToken.GetBase64EncodedString(NSDataBase64EncodingOptions.None);
    //now you can store it for later use in local storage
}

Answer 20

NSString *tokenString = [[newDeviceToken description] stringByReplacingOccurrencesOfString:@"[<> ]" withString:@"" options:NSRegularExpressionSearch range:NSMakeRange(0, [[newDeviceToken description] length])];

Comments

महान समाधान आज के रूप में, इसे क्रेडेंशियल्स.token.description.replacingOccurrences (of: "[<>]", के साथ: "", विकल्प: .ExExpression, रेंज: nil

— फ्रैंक

Answer 21

स्विफ्ट:

let tokenString = deviceToken.description.stringByReplacingOccurrencesOfString("[ <>]", withString: "", options: .RegularExpressionSearch, range: nil)

Answer 22

-(NSString *)deviceTokenWithData:(NSData *)data
{
    NSString *deviceToken = [[data description] stringByTrimmingCharactersInSet:[NSCharacterSet characterSetWithCharactersInString:@"<>"]];
    deviceToken = [deviceToken stringByReplacingOccurrencesOfString:@" " withString:@""];
    return deviceToken;
}

Answer 23

तीव्र

    // make sure that we have token for the devie on the App
    func application(application: UIApplication
        , didRegisterForRemoteNotificationsWithDeviceToken deviceToken: NSData) {

            var tokenStr = deviceToken.description
            tokenStr = tokenStr.stringByReplacingOccurrencesOfString("<", withString: "", options: [], range: nil)
            tokenStr = tokenStr.stringByReplacingOccurrencesOfString(">", withString: "", options: [], range: nil)
            tokenStr = tokenStr.stringByReplacingOccurrencesOfString(" ", withString: "", options: [], range: nil)



            print("my token is: \(tokenStr)")

    }

Answer 24

उत्कृष्ट श्रेणी का उपयोग करें!

// .h फ़ाइल

@interface NSData (DeviceToken)

- (NSString *)stringDeviceToken;

@end    

// .m फ़ाइल

#import "NSData+DeviceToken.h"

@implementation NSData (DeviceToken)

- (NSString *)stringDeviceToken {
    const unsigned *deviceTokenBytes = [deviceToken bytes];
    NSString *deviceToken = [NSString stringWithFormat:@"%08x%08x%08x%08x%08x%08x%08x%08x",
                     ntohl(deviceTokenBytes[0]), ntohl(deviceTokenBytes[1]), ntohl(deviceTokenBytes[2]),
                     ntohl(deviceTokenBytes[3]), ntohl(deviceTokenBytes[4]), ntohl(deviceTokenBytes[5]),
                     ntohl(deviceTokenBytes[6]), ntohl(deviceTokenBytes[7])];
    return deviceToken;
}

@समाप्त

// AppDelegate.m

#import "NSData+DeviceToken.h"

- (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken
{
    NSString *token = deviceToken.stringDeviceToken;
}

ठीक काम करता है!

Comments

"विवरण" का उपयोग करने पर भरोसा मत करो, यह भविष्य में प्रारूप बदल सकता है। यह केवल प्रदर्शन उद्देश्यों के लिए है।

— माइकल पीटरसन

Answer 25

स्विफ्ट 3:

यदि कोई भी स्विफ्ट 3 में डिवाइस टोकन प्राप्त करने का तरीका ढूंढ रहा है तो नीचे दिए गए संशोधित स्निपेट का उपयोग करें।

    let characterSet: CharacterSet = CharacterSet( charactersIn: "<>" )

    let deviceTokenString: String = (deviceToken.description as NSString)
        .trimmingCharacters(in: characterSet as CharacterSet)
        .replacingOccurrences(of: " ", with: "")
        .uppercased()

    print(deviceTokenString)

Comments

मैं .description का उपयोग करने की अनुशंसा नहीं करता क्योंकि वह समान बने रहने की गारंटी नहीं है। मेरा जवाब यहाँ देखें: stackoverflow.com/questions/9372815/…

— स्विफ्ट टेलर

Answer 26

var token: String = ""
for i in 0..<deviceToken.count {
    token += String(format: "%02.2hhx", deviceToken[i] as CVarArg)
}

print(token)

Comments

विवरण का उपयोग करना सुरक्षित नहीं है क्योंकि यह भविष्य में समान परिणाम देने की गारंटी नहीं है।

— साहिल कपूर

Answer 27

समाधान @kulss यहाँ पोस्ट किया गया है, जबकि लालित्य में कमी है लेकिन सादगी का गुण अब iOS 13 में काम नहीं करता है, क्योंकि descriptionNSData के लिए अलग तरह से काम करेगा। आप अभी भी उपयोग कर सकते हैं debugDescription।

NSString * deviceTokenString = [[[[deviceToken debugDescription]
                     stringByReplacingOccurrencesOfString: @"<" withString: @""] 
                    stringByReplacingOccurrencesOfString: @">" withString: @""] 
                   stringByReplacingOccurrencesOfString: @" " withString: @""];

Answer 28

जब तक डेटा शून्य-समाप्त नहीं हो जाता है, तब तक यह प्रयास करें।

NSString* newStr = [[NSString alloc] initWithData:newDeviceToken encoding:NSUTF8StringEncoding];

Comments

मैंने कोशिश की कि एक, यह काम नहीं करता है। मैंने इसे अपने कोड स्निपेट में टिप्पणी की है।

— शीहान आलम

@ शेहेअल्लम इस आदमी ने इसे बनाया। एक नज़र डालें कि यह कैसे स्ट्रिंग में परिवर्तित हो रहा है। stackoverflow.com/questions/4994302/…

— नवेद अहमद

Answer 29

NSString *tokenstring = [[NSString alloc] initWithData:token encoding:NSUTF8StringEncoding];

Comments

यह तब काम करता है जब डेटा एक स्ट्रिंग है, हालांकि, डिवाइसटोकन एक स्ट्रिंग नहीं है।

— बजे साइमन एप्सकैंप