Swift Language
नंबर

C Language firebase HTML iOS Java Language JavaScript Node.js Objective-C Language PHP Regular Expressions
खोज…


संख्या प्रकार और शाब्दिक

स्विफ्ट की अंतर्निहित संख्यात्मक प्रकार हैं:

शाब्दिक

एक संख्यात्मक शाब्दिक का प्रकार संदर्भ से अनुमानित है: 

let x = 42    // x is Int by default
let y = 42.0  // y is Double by default

let z: UInt = 42     // z is UInt
let w: Float = -1    // w is Float
let q = 100 as Int8  // q is Int8

संख्यात्मक अंको में अंको को अलग करने के लिए अंडरस्कोर ( _ ) का उपयोग किया जा सकता है। अग्रणी शून्य की अनदेखी की जाती है।

चल बिन्दु शाब्दिक का उपयोग कर निर्दिष्ट किया जा सकता significand (और प्रतिपादक भागों «significand» e «exponent» ; दशमलव के लिए 0x «significand» p «exponent» हेक्साडेसिमल के लिए)।

इंटेगर शाब्दिक वाक्य रचना 

let decimal = 10               // ten
let decimal = -1000            // negative one thousand
let decimal = -1_000           // equivalent to -1000
let decimal = 42_42_42         // equivalent to 424242
let decimal = 0755             // equivalent to 755, NOT 493 as in some other languages
let decimal = 0123456789

let hexadecimal = 0x10         // equivalent to 16
let hexadecimal = 0x7FFFFFFF
let hexadecimal = 0xBadFace
let hexadecimal = 0x0123_4567_89ab_cdef

let octal = 0o10               // equivalent to 8
let octal = 0o755              // equivalent to 493
let octal = -0o0123_4567             

let binary = -0b101010         // equivalent to -42
let binary = 0b111_101_101     // equivalent to 0o755
let binary = 0b1011_1010_1101  // equivalent to 0xB_A_D

फ्लोटिंग-पॉइंट शाब्दिक वाक्य-विन्यास 

let decimal = 0.0
let decimal = -42.0123456789
let decimal = 1_000.234_567_89

let decimal = 4.567e5               // equivalent to 4.567×10⁵, or 456_700.0
let decimal = -2E-4                 // equivalent to -2×10⁻⁴, or -0.0002
let decimal = 1e+0                  // equivalent to 1×10⁰, or 1.0

let hexadecimal = 0x1p0             // equivalent to 1×2⁰, or 1.0
let hexadecimal = 0x1p-2            // equivalent to 1×2⁻², or 0.25
let hexadecimal = 0xFEEDp+3         // equivalent to 65261×2³, or 522088.0
let hexadecimal = 0x1234.5P4        // equivalent to 0x12345, or 74565.0
let hexadecimal = 0x123.45P8        // equivalent to 0x12345, or 74565.0
let hexadecimal = 0x12.345P12       // equivalent to 0x12345, or 74565.0
let hexadecimal = 0x1.2345P16       // equivalent to 0x12345, or 74565.0
let hexadecimal = 0x0.12345P20      // equivalent to 0x12345, or 74565.0

एक संख्यात्मक प्रकार को दूसरे में बदलें

func doSomething1(value: Double) { /* ... */ }
func doSomething2(value: UInt) { /* ... */ }

let x = 42               // x is an Int
doSomething1(Double(x))  // convert x to a Double
doSomething2(UInt(x))    // convert x to a UInt

पूर्णांक या कम मूल्य पर पूर्णांक आरंभकर्ता एक रनटाइम त्रुटि उत्पन्न करते हैं: 

Int8(-129.0) // fatal error: floating point value cannot be converted to Int8 because it is less than Int8.min
Int8(-129)   // crash: EXC_BAD_INSTRUCTION / SIGILL
Int8(-128)   // ok
Int8(-2)     // ok
Int8(17)     // ok
Int8(127)    // ok
Int8(128)    // crash: EXC_BAD_INSTRUCTION / SIGILL
Int8(128.0)  // fatal error: floating point value cannot be converted to Int8 because it is greater than Int8.max

फ्लोट-टू-पूर्णांक रूपांतरण राउंड मान शून्य की ओर : 

Int(-2.2)  // -2
Int(-1.9)  // -1
Int(-0.1)  //  0
Int(1.0)   //  1
Int(1.2)   //  1
Int(1.9)   //  1
Int(2.0)   //  2

पूर्णांक-से-फ़्लोट रूपांतरण हानिपूर्ण हो सकता है: 

Int(Float(1_000_000_000_000_000_000))  // 999999984306749440

संख्याओं को / से स्ट्रिंग्स में बदलें

स्ट्रिंग में संख्याओं को परिवर्तित करने के लिए स्ट्रिंग इनिशियलाइज़र का उपयोग करें: 

String(1635999)                              // returns "1635999"
String(1635999, radix: 10)                   // returns "1635999"
String(1635999, radix: 2)                    // returns "110001111011010011111"
String(1635999, radix: 16)                   // returns "18f69f"
String(1635999, radix: 16, uppercase: true)  // returns "18F69F"
String(1635999, radix: 17)                   // returns "129gf4"
String(1635999, radix: 36)                   // returns "z2cf"

या सरल मामलों के लिए स्ट्रिंग प्रक्षेप का उपयोग करें: 

let x = 42, y = 9001
"Between \(x) and \(y)"  // equivalent to "Between 42 and 9001"

स्ट्रिंग्स को संख्याओं में बदलने के लिए संख्यात्मक प्रकारों के आरंभीकरण का उपयोग करें: 

if let num = Int("42") { /* ... */ }                // num is 42
if let num = Int("Z2cF") { /* ... */ }              // returns nil (not a number)
if let num = Int("z2cf", radix: 36) { /* ... */ }   // num is 1635999
if let num = Int("Z2cF", radix: 36) { /* ... */ }   // num is 1635999
if let num = Int8("Z2cF", radix: 36) { /* ... */ }  // returns nil (too large for Int8)

गोलाई

गोल

X.5 राउंड अप (लेकिन ध्यान दें कि -x.5 राउंड डाउन) के साथ वैल्यू को पूरे पूरे नंबर पर राउंड करता है। 

round(3.000) // 3
round(3.001) // 3
round(3.499) // 3
round(3.500) // 4
round(3.999) // 4

round(-3.000) // -3
round(-3.001) // -3
round(-3.499) // -3
round(-3.500) // -4  *** careful here ***
round(-3.999) // -4

प्लस्तर लगाना

दशमलव संख्या के साथ किसी भी संख्या को अगले बड़ी संख्या तक बढ़ाता है। 

ceil(3.000) // 3
ceil(3.001) // 4
ceil(3.999) // 4

ceil(-3.000) // -3
ceil(-3.001) // -3
ceil(-3.999) // -3

मंज़िल

दशमलव संख्या के साथ किसी भी संख्या को अगले छोटी पूरी संख्या में घटा देता है। 

floor(3.000) // 3
floor(3.001) // 3
floor(3.999) // 3

floor(-3.000) // -3
floor(-3.001) // -4
floor(-3.999) // -4

इंट

एक में कनवर्ट करता है Double एक को Int , किसी भी दशमलव मान छोड़ने। 

Int(3.000) // 3
Int(3.001) // 3
Int(3.999) // 3

Int(-3.000) // -3
Int(-3.001) // -3
Int(-3.999) // -3

टिप्पणियाँ

  • round , ceil और floor संभाल दोनों 64 और 32 बिट वास्तुकला।

यादृच्छिक संख्या पीढ़ी

arc4random_uniform(someNumber: UInt32) -> UInt32

यह आपको 0 से कुछ someNumber - 1 की सीमा में यादृच्छिक पूर्णांक देता है।

UInt32 का अधिकतम मूल्य 4,294,967,295 है (अर्थात, 2^32 - 1 )।

उदाहरण:

  • सिक्का उछालो 

      let flip = arc4random_uniform(2) // 0 or 1

  • पासा फेंकना 

      let roll = arc4random_uniform(6) + 1 // 1...6

  • अक्टूबर में रैंडम दिन 

      let day = arc4random_uniform(31) + 1 // 1...31

  • 1990 के दशक में यादृच्छिक वर्ष 

      let year = 1990 + arc4random_uniform(10)

सामान्य फ़ॉर्म: 

let number = min + arc4random_uniform(max - min + 1)

जहाँ number , max और min UInt32 ।

टिप्पणियाँ

  • वहाँ एक मामूली modulo पूर्वाग्रह है arc4random साथ इसलिए arc4random_uniform पसंद किया जाता है।
  • आप एक UInt32 मान को एक Int डाल सकते हैं लेकिन बस सीमा से बाहर जाने से सावधान रहें।

घातांक

स्विफ्ट में, हम निर्मित एस pow() विधि के साथ Double एस की व्याख्या कर सकते हैं: 

pow(BASE, EXPONENT)

नीचे दिए गए कोड में, बेस (5) घातांक की शक्ति पर सेट है (2): 

let number = pow(5.0, 2.0) // Equals 25


Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow