Swift Language
लूप्स

वाक्य - विन्यास

• क्रम में निरंतर रहने के लिए {कथन}
• अनुक्रम में निरंतर रहने के लिए जहां स्थिति {कथन}
• क्रम में वेरिएबल के लिए {स्टेटमेंट}
• क्रम में _ के लिए {कथन}
• मामले को क्रम में स्थिर रहने दें {कथनों}
• मामले में क्रम को स्थिर रहने दें जहाँ स्थिति {कथन}
• अनुक्रम में केस वेरिएबल के लिए {स्टेटमेंट}
• जबकि हालत {कथन}
• शर्त करते हुए {कथन} दोहराएं
• अनुक्रम। प्रत्येक (शरीर: (तत्व) फेंकता -> शून्य)

लूप के लिए

फ़ॉर -इन लूप आपको किसी भी अनुक्रम पर पुनरावृति करने की अनुमति देता है।

एक सीमा से अधिक का परिवर्तन

आप अर्ध-खुली और बंद दोनों श्रेणियों में पुनरावृति कर सकते हैं:

for i in 0..<3 {
    print(i)
}

for i in 0...2 {
    print(i)
}

// Both print:
// 0
// 1
// 2

किसी सरणी या सेट पर Iterating

let names = ["James", "Emily", "Miles"]

for name in names {
   print(name)
}

// James
// Emily
// Miles

for (index, name) in names.enumerate() {
   print("The index of \(name) is \(index).")
}

// The index of James is 0.
// The index of Emily is 1.
// The index of Miles is 2.

for (index, name) in names.enumerated() {
   print("The index of \(name) is \(index).")
}

एक शब्दकोश से अधिक

let ages = ["James": 29, "Emily": 24]

for (name, age) in ages {
    print(name, "is", age, "years old.")
}

// Emily is 24 years old.
// James is 29 years old.

उल्टे में छेड़छाड़ करना

for i in (0..<3).reverse() {
    print(i)
}

for i in (0...2).reverse() {
    print(i)
}

// Both print:
// 2
// 1
// 0

let names = ["James", "Emily", "Miles"]

for name in names.reverse() {
    print(name)
}

// Miles
// Emily
// James

for i in (0..<3).reversed() {
    print(i)
}

कस्टम स्ट्राइड के साथ श्रेणियों पर फेरबदल

for i in 4.stride(to: 0, by: -2) {
    print(i)
}

// 4
// 2

for i in 4.stride(through: 0, by: -2) {
    print(i)
}

// 4
// 2
// 0

for i in stride(from: 4, to: 0, by: -2) {
    print(i)
}

for i in stride(from: 4, through: 0, by: -2) {
    print(i)
}

बार-बार लूप

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

var i: Int = 0

repeat {
   print(i)
   i += 1
} while i < 3

// 0
// 1
// 2

घुमाव के दौरान

while तक हालत सही है तब तक एक लूप निष्पादित करेगा।

var count = 1

while count < 10 {
    print("This is the \(count) run of the loop")
    count += 1
}

अनुक्रम प्रकार फॉर ब्लॉक

एक प्रकार जो SequenceType प्रोटोकॉल के अनुरूप होता है वह एक बंद के भीतर तत्वों के माध्यम से पुनरावृति कर सकता है:

collection.forEach { print($0) }

नामांकित पैरामीटर के साथ भी ऐसा किया जा सकता है:

collection.forEach { item in
    print(item)
}

* नोट: नियंत्रण प्रवाह विवरण (जैसे विराम या जारी) का उपयोग इन ब्लॉकों में नहीं किया जा सकता है। एक वापसी कहा जा सकता है, और अगर कहा जाता है, तो तुरंत वर्तमान पुनरावृत्ति के लिए ब्लॉक लौटाएगा (बहुत कुछ जारी रहेगा)। इसके बाद अगली पुनरावृत्ति निष्पादित होगी।

let arr = [1,2,3,4]

arr.forEach {
    
    // blocks for 3 and 4 will still be called
    if $0 == 2 {
        return
    }
}

छानने के साथ लूप के लिए

1. where खंड

एक जोड़ कर where खंड आप जो कि किसी स्थिति को पूरा करने के पुनरावृत्तियों सीमित कर सकते हैं।

for i in 0..<5 where i % 2 == 0 {
    print(i)
}

// 0
// 2
// 4


let names = ["James", "Emily", "Miles"]

for name in names where name.characters.contains("s") {
    print(name)
}

// James
// Miles

2. case खंड

यह उपयोगी है जब आपको केवल कुछ पैटर्न से मेल खाने वाले मूल्यों के माध्यम से पुनरावृति करने की आवश्यकता होती है:

let points = [(5, 0), (31, 0), (5, 31)]
for case (_, 0) in points {
    print("point on x-axis")
}

//point on x-axis
//point on x-axis

इसके अलावा, आप वैकल्पिक मानों को फ़िल्टर कर सकते हैं और उन्हें जोड़ सकते हैं यदि जोड़कर उचित है ? निरंतर बांधने के बाद निशान:

let optionalNumbers = [31, 5, nil]
for case let number? in optionalNumbers {
    print(number)
}

//31    
//5

एक पाश को तोड़ना

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

var peopleArray = ["John", "Nicole", "Thomas", "Richard", "Brian", "Novak", "Vick", "Amanda", "Sonya"]
var positionOfNovak = 0

for person in peopleArray {
    if person == "Novak" { break }
    positionOfNovak += 1
}

print("Novak is the element located on position [\(positionOfNovak)] in peopleArray.")
//prints out: Novak is the element located on position 5 in peopleArray. (which is true)