Swift Language
Números
Buscar..
Tipos de números y literales.
Los tipos numéricos incorporados de Swift son:
- Tamaño de palabra (dependiente de la arquitectura) firmado Int y sin firmar UInt .
- Enteros con signo de tamaño fijo Int8 , Int16 , Int32 , Int64 y enteros sin signo UInt8 , UInt16 , UInt32 , UInt64 .
- Tipos de punto flotante Float32 / Float , Float64 / Double y Float80 (solo x86).
Literales
El tipo de un literal numérico se deduce del contexto:
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
Los guiones bajos ( _ ) se pueden usar para separar dígitos en literales numéricos. Se ignoran los ceros iniciales.
Los literales de punto flotante pueden especificarse usando partes de significando y exponente ( «significand» e «exponent» para decimal; 0x «significand» p «exponent» para hexadecimal.
Sintaxis literal entera
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
Sintaxis literal de punto flotante
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
Convertir un tipo numérico a otro
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
Los inicializadores de enteros producen un error de tiempo de ejecución si el valor se desborda o se desborda:
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
La conversión de flotador a entero redondea los valores hacia cero :
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
La conversión de entero a flotador puede tener pérdidas :
Int(Float(1_000_000_000_000_000_000)) // 999999984306749440
Convertir números a / desde cadenas
Use inicializadores de cadena para convertir números en cadenas:
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"
O use la interpolación de cadenas para casos simples:
let x = 42, y = 9001
"Between \(x) and \(y)" // equivalent to "Between 42 and 9001"
Use inicializadores de tipos numéricos para convertir cadenas en números:
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)
Redondeo
redondo
Redondea el valor al número entero más cercano con x.5 redondeando hacia arriba (pero observa que -x.5 redondea hacia abajo).
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
hacer techo
Redondea cualquier número con un valor decimal hasta el siguiente número entero más grande.
ceil(3.000) // 3
ceil(3.001) // 4
ceil(3.999) // 4
ceil(-3.000) // -3
ceil(-3.001) // -3
ceil(-3.999) // -3
piso
Redondea cualquier número con un valor decimal al siguiente número entero más pequeño.
floor(3.000) // 3
floor(3.001) // 3
floor(3.999) // 3
floor(-3.000) // -3
floor(-3.001) // -4
floor(-3.999) // -4
En t
Convierte un Double en un Int , eliminando cualquier valor decimal.
Int(3.000) // 3
Int(3.001) // 3
Int(3.999) // 3
Int(-3.000) // -3
Int(-3.001) // -3
Int(-3.999) // -3
Notas
-
round,ceilyfloormanejan arquitectura tanto de 64 como de 32 bits.
Generación de números aleatorios
arc4random_uniform(someNumber: UInt32) -> UInt32
Esto le da enteros aleatorios en el rango de 0 a someNumber - 1 .
El valor máximo para UInt32 es 4,294,967,295 (es decir, 2^32 - 1 ).
Ejemplos:
Lanzamiento de moneda
let flip = arc4random_uniform(2) // 0 or 1Tirada de dados
let roll = arc4random_uniform(6) + 1 // 1...6Día aleatorio en octubre
let day = arc4random_uniform(31) + 1 // 1...31Año aleatorio en los años 90.
let year = 1990 + arc4random_uniform(10)
Forma general:
let number = min + arc4random_uniform(max - min + 1)
donde number , max y min son UInt32 .
Notas
- Hay un ligero sesgo de módulo con
arc4randomporarc4random_uniformse prefierearc4random_uniform. - Puede lanzar un valor
UInt32a unIntpero tenga cuidado de no estar fuera del rango.
Exposiciónción
En Swift, podemos exponen- ciar Double s con el método pow() incorporado:
pow(BASE, EXPONENT)
En el siguiente código, la base (5) se establece en la potencia del exponente (2):
let number = pow(5.0, 2.0) // Equals 25