Variables, constantes y literals en Swift

En este artículo, conocerá las variables, constantes, literals y ejemplos en la programación Swift.

¿Qué es una variable?

En la programación, las variables se utilizan para almacenar datos en la memoria, y pueden ser utilizadas en todo el programa. Pero debe dársele a cada variable un nombre único, denominadoidentifier（标识符）。可以将变量看作保存信息的容器，并且以后可以更改这些信息。

从技术上讲，您可以将变量视为用于在其中存储书包的一些书，以后也可以将这些书替换为其他书籍。

如何在Swift中声明变量？

在Swift中，我们使用var关键字声明变量。

var siteName: String
print(siteName)

我们已经声明了一个名为 siteName 的String变量，这意味着它只能保存字符串值。访问Swift字符串可以了解有关字符串的更多信息。

如果您尝试在Playground中运行以上代码，则会给我们带来编译时错误（在初始化之前使用变量），因为它没有存储/包含任何值。

如何在Swift中为变量赋值？

您可以使用赋值运算符（=）在变量中赋值。

Ejemplo1：声明并将值分配给变量

var siteName: String
siteName = "Apple.com"
print(siteName)

o}}

您还可以将该值内联赋值为：

var siteName: String = "Apple.com"
print(siteName)

Al ejecutar el programa, la salida es:

Apple.com

变量 siteName，现在包含值“ Apple.com”。

由于Swift是一种类型推断语言，因此它可以自动推断（知道）“ Apple.com”是一个字符串，并声明siteName为String类型。因此，您甚至可以将(:String)声明中的类型删除为：

Ejemplo2：在Swift中类型推断的变量

var siteName = "Apple.com"
print(siteName)

Al ejecutar el programa, la salida es:

Apple.com

由于siteName是一个变量，因此您还可以通过简单地使用赋值运算符来更改其值，而无需使用var关键字，例如：

Ejemplo3：更改变量的值

var siteName = "Apple.com"　
//　为siteName分配一个新值
siteName = "w"3codebox.com"
print(siteName)

Al ejecutar el programa, la salida es:

oldtoolbag.com

什么是常量？

常量是变量的一种特殊类型，其值不能更改。将常量视为保存以后无法更改的信息的容器。

从技术上讲，您可以将常量视为用于存储某些书籍的书包，而将这些书放入书包后就无法替换。

如何在Swift中声明常量？

在Swift中，我们使用 let 关键字来声明变量。

let siteName: String
print(siteName)

我们已经声明了一个名为 siteName 的常量字符串。

如果您尝试运行以上代码，则会给我们带来编译时错误（初始化之前使用常量），因为它不包含/保留任何值。

如何在Swift中为常量分配值？

您可以使用赋值运算符（=）在与变量相同的常量中赋值。

Ejemplo4：声明一个值并将其分配给一个常量

let siteName: String
siteName = "Apple.com"
print(siteName)

o}}

también se puede especificar el valor en línea como

let siteName:String = "Apple.com"

Al ejecutar el programa, la salida es:

Apple.com

Ahora, la constante siteName contiene/que contiene el valor "Apple.com".

Al igual que con las variables, puede eliminar el tipo (:String) de la declaración, como se muestra a continuación:

Ejemplo5: Constantes con inferencia de tipo en Swift

let siteName = "Apple.com"
print(siteName)

Al ejecutar el programa, la salida es:

Apple.com

Pero a diferencia de las variables, no se puede cambiar el valor de la constante. Por lo tanto, no se puede hacer así:

Ejemplo6: Cambiar el valor de la constante (no permitido)

let siteName = "Apple.com"
siteName = "w"3codebox.com"　//error de tiempo de compilación
print(siteName)

La declaración anterior nos da un error porque, como dijimos, una vez que se almacena los datos, el valor de la constante no puede cambiarse. Esta es la diferencia clave entre variables y constantes.

¿Qué son los literals?

Los literals son valores que aparecen directamente en el código fuente. Pueden ser números, caracteres o cadenas, por ejemplo: "Hello, World",12,23.0, "C" es un ejemplo simple de literal. Los literals se utilizan comúnmente para inicializar variables o constantes (asignarles valores).

Por ejemplo:

let siteName = "Apple.com"

En la expresión anterior, siteName es una variable y "Apple.com" es un literal.

Tipos de literals en Swift

Literals de número entero

Representa valores decimales, binarios, octales o hexadecimales. Tiene cuatro tipos.

• Literals de número binario

• Representa un valor binario.

• Comienza con 0b.

• Literals de número octal

• Representa un valor octal.

• Comienza con 0o.

• Literals de texto hexadecimal

• Representa un valor hexadecimal.

• Comienza con 0x.

• Literals de número decimal

• Representa un valor decimal.

• Comienza en cero. Todo lo que declare en un literal de número entero es de tipo decimal.

Ejemplo7¿Cómo usar literals de números enteros en Swift?

let binaryNumber = 0b11111111
print(binaryNumber)
print(1231)

Al ejecutar el programa, la salida es:

255
1231

En el programa anterior, hay dos literals de número entero 0b11111111（literal binario）y1231（literal decimal）。11111111 el valor decimal es 255por lo tanto, la declaración print(binaryNumber) se imprime en la pantalla 255

Del mismo modo, print(1231) Imprimir en la consola el valor decimal 255

Cadenas de caracteres y literals de caracteres

Los literals de cadena son secuencias de caracteres entre comillas dobles, y los literals de caracteres son un solo carácter entre comillas dobles.

Ejemplo8¿Cómo usar cadenas de caracteres y literals de caracteres en Swift?

let someCharacter:Character = "C"
let someString:String = "Swift is awesome"

En el programa anterior "C" es un literal de carácter, "Swift is awesome" es un literal de cadena.

Literales de punto flotante

Usado para inicializar variables de tipo float y double. Puede tener dos tipos:

Decimal:

Puede tener un exponente opcional representado por una e mayúscula o minúscula. Para los números decimales con el exponente exp, el base se multiplica por 10 ^exp

Ejemplo9¿Cómo se utilizan los literales decimales en Swift?

let someFloat =　12.23
let someAnotherFloat =　3.14e2　
print(someFloat)
print(someAnotherFloat)

Al ejecutar el programa, la salida es:

12.23
314.0

En el programa anterior12.23,3.14e2Es un literal de punto flotante.3.14e2 Expresado en exponente, es equivalente a3.14 * 10 ²

Hexadecimal:

Los números de coma flotante hexadecimales deben tener un exponente representado por una p mayúscula o minúscula. Para los números hexadecimales con el exponente exp, el base se multiplica por2 ^exp

Ejemplo10¿Cómo se utilizan los literales hexadecimales en Swift?

let someFloat = 0xFp10　
let someAnotherFloat = 0xFp-12
print(someFloat)
print(someAnotherFloat)

Al ejecutar el programa, la salida es:

15360.0
0.003662109375

En el programa anterior 0xFp10，0xFp-12 Es un literal de punto flotante. 0xFp10Expresado en exponente, equivalente a15 * 210(F se representa como decimal15Por lo tanto, print(someFloat) muestra15360.0.

Del mismo modo, 0xFp-12 Equivalente a 15 * 2-12Por lo tanto, print(someAnotherFloat) muestra 0.00 en la pantalla3662109375

Literales booleanos

Swift tiene dos valores literales booleanos. Son true y false.

Ejemplo11¿Cómo se utilizan los literales booleanos en Swift?

let result:Bool = false

En el programa anterior, false es una constante booleana que se asigna a la constante result.

Reglas y mejores prácticas de variables y constantes

1. Elija un nombre significativo. Por ejemplo:var name En comparación con var n Más significativo

2. Declare variables o constantes utilizando la notación camelCase. La notación de camelCase comienza con una letra minúscula. Por ejemplo:

   var studentName
   let studentAge
   let address

3. También puede definir variables y constantes sin necesidad de marcarlas. No usar etiquetas de nombre significa que no las utilizará en el programa. En muchos casos, desea crear una variable no utilizada. En este caso, puede usar el marcador de posición _.

   var _ = "Apple.com"　//La cadena se ha inicializado, pero no se ha almacenado en una variable
   let _ = "Apple.com"

   　 　 　 　 　 　 Incluso esto es válido

   _ = "Apple.com"

4. Si solo necesita establecer un valor una vez y no necesita cambiarlo en el programa, utilice una constante. Pero si necesita cambiarla más tarde, utilice una variable.

5. Los nombres de constantes y variables no pueden contener caracteres de espacio, símbolos matemáticos, flechas, puntos de código Unicode privados (o inválidos) o caracteres de línea y cuadrícula. tampoco pueden comenzar con un número, aunque los números pueden estar en otros lugares del nombre.

   var　12　= "Apple.com"　//da un error de compilación: se esperaba un patrón
   var @hello = “Hello”　//da un error de compilación: se esperaba un patrón