स्विफ्ट 4 ने बदल दिया कि तार कैसे काम करते हैं। हालांकि, ऐसा लगता है कि यह अधिक जटिल और कम पठनीय हो गया है। क्या कोई इस उदाहरण को सरल बना सकता है (स्ट्रिंग के रूप में स्ट्रिंग का तीसरा अक्षर प्राप्त करता है)? (लाइनों को विभाजित करने के अलावा।)

let myString="abc"
let thirdLetter = String(myString[myString.index(myString.startIndex, offsetBy: 2)])
3
Nick McConnell 16 सितंबर 2017, 00:27

2 जवाब

सबसे बढ़िया उत्तर

ऐसा प्रतीत होता है कि आप तीसरा वर्ण निकालने का प्रयास कर रहे हैं। मैं कहूँगा

let c = myString.prefix(3).last

दी, यह एक वैकल्पिक चरित्र है, लेकिन आप आराम से खोल सकते हैं और जरूरत पड़ने पर स्ट्रिंग के लिए मजबूर कर सकते हैं।

prefix विधि अत्यंत मूल्यवान है क्योंकि यह आपको String.Index की जंगली और निराला दुनिया में मजबूर करने के बजाय एक Int लेता है।

2
matt 16 सितंबर 2017, 17:35

स्विफ्ट 4 में आप String myString को [Character] में Array(myString) से बदल सकते हैं। फिर आप उस सरणी को Int के साथ अनुक्रमित कर सकते हैं और फिर उस [Character] को String में बदल सकते हैं।

let myString = "abc"
let thirdLetter = String(Array(myString)[2])    // "c"
let firstTwo = String(Array(myString)[0..<2])   // "ab"

अगर आप String पर बहुत सारे ऑपरेशन करने जा रहे हैं, तो अक्सर बेहतर होता है कि इसे केवल [Character] के रूप में परिवर्तित करें और रखें।


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

Array में कनवर्ट करना और Int के साथ अनुक्रमण करना लिखना और पढ़ना आसान है, लेकिन यह कैसा प्रदर्शन करता है? इसका उत्तर देने के लिए, मैंने रिलीज़ बिल्ड में निम्नलिखित का परीक्षण किया:

func time1(str: String, n: Int) -> (Double, String) {
    // Method 1: Index string with String.Index, convert to String

    let start = Date()
    let a = String(str[str.index(str.startIndex, offsetBy: n)])
    let interval = Date().timeIntervalSince(start)

    return (interval, a)
}

func time2(str: String, n: Int) -> (Double, String) {
    // Method 2: Convert string to array, index with Int, convert to String

    let start = Date()
    let a = String(Array(str)[n])
    let interval = Date().timeIntervalSince(start)

    return (interval, a)
}


func time3(str: String, n: Int) -> (Double, String) {
    // Method 3: Use prefix() and last(), convert to String

    let start = Date()
    let a = String(str.prefix(n + 1).last!)
    let interval = Date().timeIntervalSince(start)

    return (interval, a)
}

func time4(str: String, n: Int) -> (Double, String) {
    // Method 4: Use Leo Dabus' extensions
    // https://stackoverflow.com/q/24092884/1630618

    let start = Date()
    let a = str[n]
    let interval = Date().timeIntervalSince(start)

    return (interval, a)
}

func time5(str: String, n: Int) -> (Double, String) {
    // Method 5: Same as 2 but don't measure Array conversion time

    let arr = Array(str)

    let start = Date()
    let a = String(arr[n])
    let interval = Date().timeIntervalSince(start)

    return (interval, a)
}

func test() {
    for repetitions in [1, 10, 100, 1000] {
        var input = ""
        for _ in 0 ..< repetitions {
            input.append("abcdefghijklmnopqrstuvwxyz")
        }

        var t = [0.0, 0.0, 0.0, 0.0, 0.0]
        let funcs = [time1, time2, time3, time4, time5]

        for i in 0 ..< input.count {
            for f in funcs.indices {
                let (interval, _) = funcs[f](input, i)
                t[f] += interval
            }
        }

        print("For string length \(input.count):")
        for i in 0 ..< 5 {
            print(String(format: "Method %d time: %.8f", i + 1, t[i]))
        }
        print("")
    }
}

परिणाम:

For string length 26:
Method 1 time: 0.00108612
Method 2 time: 0.00085294
Method 3 time: 0.00005889
Method 4 time: 0.00002104
Method 5 time: 0.00000405

For string length 260:
Method 1 time: 0.00117570
Method 2 time: 0.00670648
Method 3 time: 0.00115579
Method 4 time: 0.00110406
Method 5 time: 0.00007111

For string length 2600:
Method 1 time: 0.09964919
Method 2 time: 0.57621503
Method 3 time: 0.09244329
Method 4 time: 0.09166771
Method 5 time: 0.00087011

For string length 26000:
Method 1 time: 9.78054154
Method 2 time: 56.92994779
Method 3 time: 9.02372885
Method 4 time: 9.01480001
Method 5 time: 0.03442019

विश्लेषण:

  1. सरणी में रूपांतरण महंगा है, खासकर जब सरणी का आकार बढ़ता है।
  2. यदि आप रूपांतरित [Character] को इधर-उधर रख सकते हैं, तो इस पर अनुक्रमण कार्य काफी तेज हैं। (विधि 5 देखें)
  3. तरीके 1, 3, और 4 सभी एक ही गति के बारे में हैं, इसलिए अपनी व्यक्तिगत पसंद के आधार पर चुनें।
6
vacawama 16 सितंबर 2017, 14:41