Los literales son los valores reales de enteros, números decimales, strings, etc. O podemos decir que los literales son los valores de una variable o constante. Podemos usar literales directamente en un programa sin ningún cálculo. De forma predeterminada en Swift, los literales no tienen ningún tipo propio. Las variables de tipo primitivo se pueden asignar con literales. Por ejemplo, 12 es un literal entero, 3.123 es un literal de punto flotante, «GeeksforGeeks» es un literal de string y true es un literal booleano. Cuando especificamos la anotación de tipo para un literal, se requiere que la notación de tipo sea un tipo que se pueda inferir del valor literal. El tipo de anotación debe seguir los protocolos de la biblioteca estándar de Swift:
- ExpressibleByIntegerLiteral: se utiliza para literales enteros.
- ExpressibleByFloatLiteral: se utiliza para literales de coma flotante.
- ExpressibleByStringLiteral: se utiliza para literales de string.
- ExpressibleByBooleanLiteral: se utiliza para literales booleanos.
Por ejemplo, Int32 sigue el «protocolo ExpressibleByIntegerLiteral», por lo tanto, lo usamos como una anotación de tipo para el valor literal 25 como,
let x: Int32 = 25.
Swift admite principalmente cuatro tipos de literales, como se explica a continuación.
literal entero
Los literales enteros se utilizan para la representación de valores enteros. Si no se especifica la base alternativa de un número entero, se asigna el tipo predeterminado, que es base 10, es decir, decimal. También podemos especificar un literal entero negativo usando un operador menos (-). Por ejemplo:
-25 // literal
Estos literales también pueden contener guiones bajos (_) entre sus dígitos para una mejor representación de los números, pero estos guiones bajos se ignoran y no tienen efecto en el valor general del literal.
Por ejemplo:
// Both integer literals are the same 025 // literal 1 25 // literal 2
Incluso, podemos usar ceros a la izquierda con un literal entero pero nuevamente no tienen efecto en el valor general del literal. Por ejemplo,
// Both integer literals are the same 025 // literal 1 25 // literal 2
Los literales enteros son los valores numéricos y pueden ser uno de estos
- Constante binaria: una constante binaria puede contener solo dos valores, 0 o 1.
- Constante decimal: una constante decimal puede contener valores en el rango de 0 a 9.
- Constante octal: una constante octal puede contener valores en el rango de 0 a 7.
- Constante hexadecimal: una constante hexadecimal puede contener valores en el rango de 0 a 9 o de A a F o de a a f.
De forma predeterminada, un literal entero no tiene ningún tipo por sí mismo. Por ejemplo,
let myVariable: Int32 = 10
Swift usa su notación de tipo explícito para inferir que el literal 20 es de tipo Int32. Cuando no se utiliza la notación de tipo explícito, el compilador de Swift infiere que el tipo del literal es uno de los tipos de literal predeterminados que están predefinidos en la biblioteca estándar de Swift. Entonces, el tipo predeterminado para los literales enteros es Int. Excepto el literal decimal, todas las constantes literales comienzan con un prefijo como se especifica a continuación,
- binario: 0b
- decimal: sin prefijo
- octales: 0o
- hexadecimal: 0x
Estos prefijos usados con literales son únicos para el compilador y tienen un significado especial. A continuación se muestra la implementación en Swift usando estos literales.
Ejemplo:
En el siguiente programa, hemos representado un número 10 como 10 en decimal, 0b1010 en binario, 0o12 en octal y 0xA en hexadecimal.
Swift
// Swift program to demonstrate the working of literals
// Initializing variables
// 10 in decimal notation
let decimalNumber = 10
// 10 in binary notation
let binaryNumber = 0b1010
// 10 in octal notation
let octalNumber = 0o12
// 10 in hexadecimal notation
let hexadecimalNumber = 0xA
// Print these numbers
print("Decimal Number:", decimalNumber)
print("Binary Number:", binaryNumber)
print("Octal Number:", octalNumber)
print("Hexadecimal Number:", hexadecimalNumber)
Producción:
Decimal Number: 10 Binary Number: 10 Octal Number: 10 Hexadecimal Number: 10
Literales de coma flotante
Los literales de punto flotante tienen un punto decimal en su representación. Aquí, los literales decimales de punto flotante representan una secuencia de dígitos decimales seguidos de una fracción decimal, un exponente decimal o ambos. Los literales de punto flotante no poseen ningún tipo propio. Si no se especifica la base alternativa de un literal de coma flotante, se asigna el tipo predeterminado, que es base 10, decimal. También podemos especificar literales de punto flotante negativos usando un operador menos (-). Por ejemplo,
-1.123 // literal
Al igual que un literal entero, podemos usar guiones bajos entre los dígitos de un literal de punto flotante. Estos guiones bajos se ignoran y no tienen efecto en el valor general del literal de coma flotante. Por ejemplo,
// Both floating-point literals are the same 0.2_5 // literal 1 0.25 // literal 2
Podemos proporcionar una notación de tipo explícita para inferir que un literal de punto flotante es de tipo Flotante. Por ejemplo,
let myVariable: Float = 10.123 // Explicitly specifying that myVariable is of type Float
Cuando no usamos una notación de tipo explícita, el compilador de Swift infiere que el tipo del literal es uno de los tipos de literales predeterminados que están predefinidos en la biblioteca estándar del lenguaje Swift. Por ejemplo,
let myVariable = 10.123 // Swift compiler internally infers that myVariable is of type Double
Entonces, el tipo predeterminado para los literales de punto flotante es Double. Hay dos formas en las que podemos clasificar los literales de coma flotante:
1. Literal decimal de punto flotante: representa una secuencia de dígitos decimales que sigue a una fracción decimal, un exponente decimal o ambos. Consta de un exponente opcional que se representa con mayúscula (E) o minúscula (e). Si un número decimal de coma flotante tiene x como exponente, entonces la base se multiplica por 10 x . Por ejemplo,
// Both are the same value 0.25e1 2.5
Ejemplo: En el siguiente programa, hemos representado que decimalFloatingNumber2 es igual a = 0.123e2 = 0.123 * 10 2 = 12.3.
Swift
// Swift program to demonstrate the working of
// decimal floating-point literal
// Initializing variables
let decimalFloatingNumber1 = 0.12
let decimalFloatingNumber2 = 0.123e2
// Display the result
print("decimalFloatingNumber1: \(decimalFloatingNumber1)")
print("decimalFloatingNumber2: \(decimalFloatingNumber2)")
Producción:
decimalFloatingNumber1: 0.12 decimalFloatingNumber2: 12.3
2. Literal de coma flotante hexadecimal: un literal de coma flotante hexadecimal consta de un exponente y se representa con una letra mayúscula (P) o una letra minúscula (p). Si en este literal x es exponente entonces la base se multiplica por 2 x . Por ejemplo,
// Both are the same value 0.25p1 0.5
Ejemplo: En el siguiente programa, hemos representado que hexadecimalFloatingNumber1 es igual a = 0xFp1 = 15 * 2 1 = 30 ya que F en hexadecimal es igual a 15 y hexadecimalFloatingNumber2 es igual a = 0xFp-1 = 15 * 2 -1 = 7.5 ya que F en hexadecimal es igual a 15.
Swift
// Swift program to demonstrate the working of
// Hexadecimal floating-point literal
// Initializing variables
let hexadecimalFloatingNumber1 = 0xFp1
let hexadecimalFloatingNumber2 = 0xFp-1
// Print variables
print("hexadecimalFloatingNumber1: \(hexadecimalFloatingNumber1)")
print("hexadecimalFloatingNumber2: \(hexadecimalFloatingNumber2)")
Producción:
hexadecimalFloatingNumber1: 30.0 hexadecimalFloatingNumber2: 7.5
Literales de string
Un literal de string de una sola línea es una colección de letras o caracteres entre dos comillas dobles. Por ejemplo,
"GeeksforGeeks" // A string literal
Ejemplo:
Swift
// Swift program to demonstrate the // working of string literals // Initializing strings let myString1 = "GeeksforGeeks" let myString2 = "Geeks" // Print strings print(myString1) print(myString2)
Producción:
GeeksforGeeks Geeks
Los literales de string no poseen ningún tipo propio, pero si no se especifica el tipo, el tipo predeterminado asignado internamente es String. Swift usa su notación de tipo explícito para inferir que el literal «GeeksforGeeks» es de tipo String. Cuando no se utiliza la notación de tipo explícito, el compilador de Swift infiere que el tipo del literal es uno de los tipos de literal predeterminados que están predefinidos en la biblioteca estándar de Swift. Por ejemplo,
let myVariable = "GeeksforGeeks" // Default type is String
let myVariable: String = "GeeksforGeeks" // Explicitly specifying that the
// "GeeksforGeeks" is of type String
Las secuencias de escape son la secuencia especial de caracteres. Cuando se utilizan dentro de una string, en lugar de representarse a sí mismos, se traducen a otro carácter o secuencia de caracteres que son difíciles de representar directamente. Los literales de string no pueden tener comillas dobles sin escape («), un retorno de carro, una barra invertida sin escape (\) o un salto de línea.
En Swift, también podemos usar literales de varias líneas. Un literal de string de varias líneas está rodeado por tres comillas dobles. O podemos decir que varias strings están presentes entre las tres comillas dobles de apertura y cierre. También puede usar una barra invertida (\) para dividir la línea dentro del literal de string multilínea. Por ejemplo,
let myVariable: String = """
GeeksforGeeks \
GFG
"""
Podemos incluir caracteres especiales en strings literales usando las siguientes secuencias de escape.
| Secuencias de escape | Significado |
|---|---|
| \b | Retroceso |
| \0 | Carácter nulo |
| \\ | barra invertida |
| \F | Avance de formulario |
| \norte | Nueva línea |
| \r | Retorno de carro |
| \t | Pestaña horizontal |
| \v | Pestaña vertical |
| \’ | Comillas simples |
| \” | Comillas dobles |
| Escalar Unicode (\u{n}) | Aquí, n es un número hexadecimal que contiene de uno a ocho dígitos |
Podemos usar el valor real de una expresión usando un carácter de barra invertida justo antes de la expresión. La expresión debe estar entre paréntesis. Tenga en cuenta que la expresión solo puede contener un literal de string. En otras palabras, no podemos usar una barra invertida sin escape, un retorno de carro o un salto de línea en una expresión.
Por ejemplo:
// All the following string literals are the same
"5 6 7"
"5 6 \("7")"
"5 6 \(7)"
"5 6 \(3 + 4)"
let x = 7;
"5 6 \(x)"
Una string que está entre comillas dobles y un conjunto equilibrado de signos numéricos (#) se conoce como «string delimitada por delimitadores extendidos». Estas strings tienen la siguiente forma,
// Delimited string 1 #"GeeksforGeeks"# // Delimited string 2 #""" GeeksforGeeks """#
Podemos hacer que los caracteres especiales aparezcan como caracteres normales en la salida final convirtiéndolos en una string delimitada.
Ejemplo:
Swift
// Swift program to illustrate the working of delimited strings
// Initializing a constant variable
let x = 10
// Initializing another variable using a delimited string
let delimitedString = #"\(x)"#
// Initializing another variable using a
// non-delimited string literal
let normalString = "\\(x)"
print("delimitedString:", delimitedString)
print("normalString:", normalString)
print("Are delimitedString and normalString equal?",
delimitedString == normalString)
// Prints "true"
Producción:
delimitedString: \(x) normalString: \(x) Are delimitedString and normalString equal? true
Cuando se utiliza un conjunto de más de un delimitador extendido, no se deben colocar espacios en blanco entre los delimitadores. Eso es,
let delimitedString = ##"\(x)"# # // Wrong let delimitedString = ##"\(x)"## // Right
En Swift, podemos concatenar dos strings literales y la concatenación ocurre durante el tiempo de compilación.
Sintaxis:
string1 = "Bhuwanesh" // String 1 string2 = "Nainwal" // String 2 string1 + string2 // "Bhuwanesh Nainwal"
Tenga en cuenta que el orden de las strings durante la concatenación es importante.
Ejemplo:
Swift
// Swift program to concatenate two strings
// Initializing a string
let string1 = "GeekforGeeks is one of the "
// Initializing another string
// by directly concatenating two strings
let string2 = "best learning " + "platforms."
// Concatenate strings
let result = string1 + string2
// Print the resulting string
// after concatenation
print("result:", result)
Producción:
result: GeekforGeeks is one of the best learning platforms.
Literales booleanos
Un literal booleano puede representar uno de los siguientes tipos de valores,
- verdadero
- falso
Un literal booleano no contiene ningún tipo propio. Por ejemplo,
let myVariable: Bool = true
Podemos usar la notación de tipo explícito para inferir que el literal verdadero tiene el tipo Bool. Cuando no se utiliza la notación de tipo explícito, el compilador de Swift infiere que el tipo del literal es uno de los tipos de literal predeterminados que están predefinidos en la biblioteca estándar de Swift. Entonces, el tipo predeterminado para los literales booleanos es booleano.
Ejemplo:
Swift
// Swift program to demonstrate the
// working of boolean literals
// Initializing strings
let booleanNumber1 = true
let booleanNumber2 = false
// Print the value represented by variables
print("booleanNumber1: \(booleanNumber1)")
print("booleanNumber2: \(booleanNumber2)")
Producción:
booleanNumber1: true booleanNumber2: false