Swift Language
उन्नत संचालक

कस्टम ऑपरेटर

स्विफ्ट कस्टम ऑपरेटरों के निर्माण का समर्थन करता है। नए ऑपरेटर को operator कीवर्ड का उपयोग करके वैश्विक स्तर पर घोषित किया जाता है।

ऑपरेटर की संरचना को तीन भागों द्वारा परिभाषित किया गया है: ऑपरेंड प्लेसमेंट, पूर्ववर्तीता, और संबद्धता।

1. कस्टम ऑपरेटर घोषणा को शुरू करने के लिए prefix , infix और postfix मॉडिफायर का उपयोग किया जाता है। prefix और postfix संशोधक घोषित करते हैं कि ऑपरेटर को पहले या बाद में होना चाहिए, जिस पर वह कार्य करता है। ऐसे ऑपरेटर urnary हैं, जैसे 8 और 3++ ** , क्योंकि वे केवल एक लक्ष्य पर कार्य कर सकते हैं। infix एक द्विआधारी ऑपरेटर की घोषणा करता है, जो दो मूल्यों के बीच कार्य करता है, जैसे कि 2+3 ।

2. उच्च वरीयता वाले ऑपरेटरों की गणना पहले की जाती है। डिफ़ॉल्ट ऑपरेटर पूर्ववर्तीता की तुलना में अधिक है ? ... : (स्विफ्ट 2.x में 100 का मान)। मानक स्विफ्ट ऑपरेटरों की पूर्वता यहां पाई जा सकती है ।

3. संबद्धता ही वरीयता का ऑपरेटरों के बीच आपरेशन के क्रम को परिभाषित करता है। बाएं सहयोगी संचालकों की गणना बाएं से दाएं (अधिकांश ऑपरेटरों की तरह पठन आदेश) से की जाती है, जबकि सही सहयोगी संचालक दाएं से बाएं की गणना करते हैं।

ऑपरेटर गणना कोड के आधार पर मान लौटाते हैं। यह कोड एक सामान्य फ़ंक्शन के रूप में कार्य करता है, जिसमें इनपुट के प्रकार को निर्दिष्ट करने वाले पैरामीटर और ऑपरेटर द्वारा लौटाए गए परिकलित मान को निर्दिष्ट करने वाला return कीवर्ड होता है।

यहाँ एक सरल घातांक ऑपरेटर की परिभाषा है, क्योंकि मानक स्विफ्ट में एक घातीय ऑपरेटर नहीं है।

import Foundation    

infix operator ** { associativity left precedence 170 }

func ** (num: Double, power: Double) -> Double{
    return pow(num, power)
}

infix कहना है कि ** ऑपरेटर दो मूल्यों के बीच काम करता है, जैसे कि 9**2 । क्योंकि फ़ंक्शन ने सहानुभूति छोड़ दी है, 3**3**2 की गणना (3**3)**2 । 170 की पूर्वता सभी मानक स्विफ्ट ऑपरेशनों की तुलना में अधिक है, जिसका अर्थ है कि 3+2**4 गणना 19 , ** की बाईं संगति के बावजूद।

import Foundation 

infix operator **: BitwiseShiftPrecedence

func ** (num: Double, power: Double) -> Double {
    return pow(num, power)
}

**: वेतन वृद्धि और वेतन वृद्धि को हटा दिया गया है और स्विफ्ट 3 में हटा दिया जाएगा।

शब्दकोश के लिए ओवरलोडिंग +

जैसा कि वर्तमान में स्विफ्ट में शब्दकोशों के संयोजन का कोई सरल तरीका नहीं है, जेनरिक का उपयोग करके इस कार्यक्षमता को जोड़ने के लिए + और += ऑपरेटरों को अधिभार देना उपयोगी हो सकता है।

// Combines two dictionaries together. If both dictionaries contain
// the same key, the value of the right hand side dictionary is used.
func +<K, V>(lhs: [K : V], rhs: [K : V]) -> [K : V] {
    var combined = lhs
    for (key, value) in rhs {
        combined[key] = value
    }
    return combined
}

// The mutable variant of the + overload, allowing a dictionary
// to be appended to 'in-place'.
func +=<K, V>(inout lhs: [K : V], rhs: [K : V]) {
    for (key, value) in rhs {
        lhs[key] = value
    }
}

func +=<K, V>(lhs: inout [K : V], rhs: [K : V]) { ... } 

उदाहरण उपयोग:

let firstDict = ["hello" : "world"]
let secondDict = ["world" : "hello"]
var thirdDict = firstDict + secondDict // ["hello": "world", "world": "hello"]

thirdDict += ["hello":"bar", "baz":"qux"] // ["hello": "bar", "baz": "qux", "world": "hello"]

कम्यूटेटिव ऑपरेटर्स

चलो एक CGSize गुणा करने के लिए एक कस्टम ऑपरेटर जोड़ते हैं

func *(lhs: CGFloat, rhs: CGSize) -> CGSize{
    let height = lhs*rhs.height
    let width = lhs*rhs.width
    return CGSize(width: width, height: height)
}

अब यह काम करता है

let sizeA = CGSize(height:100, width:200)    
let sizeB = 1.1 * sizeA         //=> (height: 110, width: 220)

लेकिन अगर हम रिवर्स में ऑपरेशन करने की कोशिश करते हैं, तो हमें एक त्रुटि मिलती है

let sizeC = sizeB * 20          // ERROR

लेकिन यह जोड़ना आसान है:

func *(lhs: CGSize, rhs: CGFloat) -> CGSize{
    return rhs*lhs
}

अब संचालक सराहनीय है।

let sizeA = CGSize(height:100, width:200)    
let sizeB = sizeA * 1.1              //=> (height: 110, width: 220)

बिटवाइज ऑपरेटर्स

स्विफ्ट बिटवाइज ऑपरेटर आपको संख्याओं के द्विआधारी रूप पर संचालन करने की अनुमति देते हैं। आप संख्या को 0b साथ प्रीफ़िक्स करके एक बाइनरी शाब्दिक निर्दिष्ट कर सकते हैं, इसलिए उदाहरण के लिए 0b110 बाइनरी नंबर 110 (दशमलव संख्या 6) के बराबर है। प्रत्येक 1 या 0 संख्या में एक सा है।

बिटवाइज नहीं ~ :

var number: UInt8 = 0b01101100
let newNumber = ~number
// newNumber is equal to 0b01101100

यहां, प्रत्येक बिट इसके विपरीत में बदल जाता है। संख्या को स्पष्ट रूप से घोषित करते हुए UInt8 यह सुनिश्चित करता है कि संख्या सकारात्मक है (ताकि हमें उदाहरण में नकारात्मक से निपटना न पड़े) और यह केवल 8 बिट्स है। यदि 0b01101100 एक बड़ा UInt था, तो 0s अग्रणी होगा जो 1s में परिवर्तित हो जाएगा और व्युत्क्रम में महत्वपूर्ण हो जाएगा:

var number: UInt16 = 0b01101100
// number equals 0b0000000001101100
// the 0s are not significant
let newNumber = ~number
// newNumber equals 0b1111111110010011
// the 1s are now significant

• ० -> १
• १ -> ०

बिटवाइज़ और & :

var number = 0b0110
let newNumber = number & 0b1010
// newNumber is equal to 0b0010

यहां, एक दिया गया बिट 1 होगा यदि और केवल तभी बाइनरी नंबर & ऑपरेटर के दोनों तरफ उस बिट स्थान पर 1 निहित होता है।

• 0 & 0 -> 0
• 0 & 1 -> 0
• 1 & 1 -> 1

बिटवाइज OR | :

var number = 0b0110
let newNumber = number | 0b1000
// newNumber is equal to 0b1110

यहाँ, एक दिया गया बिट 1 होगा यदि और केवल यदि बाइनरी संख्या कम से कम एक तरफ | ऑपरेटर उस बिट स्थान पर 1 सम्‍मिलित करता है।

• 0 | ० -> ०
• 0 | 1 -> 1
• 1 | 1 -> 1

बिटवाइज़ XOR (एक्सक्लूसिव OR) ^ :

var number = 0b0110
let newNumber = number ^ 0b1010
// newNumber is equal to 0b1100

यहां, एक दिया गया बिट 1 होगा यदि और केवल तभी जब दोनों ऑपरेंड की स्थिति में बिट्स अलग-अलग हों।

• 0 ^ 0 -> 0
• 0 ^ 1 -> 1
• 1 ^ 1 -> 0

सभी बाइनरी ऑपरेशंस के लिए, ऑपरेंड्स का क्रम परिणाम पर कोई अंतर नहीं डालता है।

ओवरफ्लो ऑपरेटर्स

ओवरफ्लो से तात्पर्य उस समय होता है जब किसी ऑपरेशन के परिणामस्वरूप ऐसी संख्या उत्पन्न होती है जो उस संख्या के लिए बिट्स की निर्धारित मात्रा से बड़ी या छोटी होती है।

जिस तरह से द्विआधारी अंकगणित काम करता है, उसके बिट्स के लिए एक संख्या बहुत बड़ी हो जाने के बाद, यह संख्या सबसे छोटी संभव संख्या (बिट आकार के लिए) से अधिक हो जाती है और फिर वहाँ से गिनती जारी रखती है। इसी तरह, जब कोई संख्या बहुत छोटी हो जाती है, तो यह सबसे बड़ी संभावित संख्या (इसके आकार के लिए) तक कम हो जाती है और वहां से नीचे गिनती जारी रखती है।

क्योंकि यह व्यवहार अक्सर वांछित नहीं होता है और गंभीर सुरक्षा समस्याओं को जन्म दे सकता है, स्विफ्ट अंकगणितीय ऑपरेटर + , - और, * त्रुटियों को फेंक देगा जब एक ऑपरेशन अतिप्रवाह या अंडरफ्लो का कारण होगा। ओवरफ़्लो और अंडरफ़्लो की स्पष्ट रूप से अनुमति देने के लिए, &+ &- , और &* बजाय का उपयोग करें।

var almostTooLarge = Int.max
almostTooLarge + 1 // not allowed
almostTooLarge &+ 1 // allowed, but result will be the value of Int.min

मानक स्विफ्ट ऑपरेटरों की प्राथमिकता

टीयर (उच्च पूर्वता) को बाध्य करने वाले ऑपरेटरों को पहले सूचीबद्ध किया जाता है।

• यह तालिका Apple के API संदर्भ पर भी पाई जा सकती है
• GitHub पर स्रोत कोड में पूर्ववर्ती समूहों की वास्तविक परिभाषा पाई जा सकती है