Variáveis, Constantes e Literais no Swift

Neste artigo, você aprenderá sobre variáveis, constantes, literais e exemplos no Swift programação.

O que é uma variável?

No programação, as variáveis são usadas para armazenar dados na memória, podendo ser usadas em todo o programa. Mas é necessário dar um nome único a cada variável, chamado deidentifier（标识符）。可以将变量看作保存信息的容器，并且以后可以更改这些信息。

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

如何在Swift中声明变量？

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

var siteName: String
print(siteName)

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

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

如何在Swift中为变量赋值？

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

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

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

ou}}

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

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

Quando você executar o programa, a saída será:

Apple.com

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

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

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

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

Quando você executar o programa, a saída será:

Apple.com

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

Exemplo3：更改变量的值

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

Quando você executar o programa, a saída será:

oldtoolbag.com

什么是常量？

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

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

如何在Swift中声明常量？

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

let siteName: String
print(siteName)

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

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

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

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

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

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

ou}}

também pode especificar o valor inline como

let siteName:String = "Apple.com"

Quando você executar o programa, a saída será:

Apple.com

Agora, a constante siteName contém/que contém o valor "Apple.com".

Da mesma forma que as variáveis, você pode remover o tipo (:String) da declaração, conforme mostrado a seguir:

Exemplo5: Constantes com inferência de tipo no Swift

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

Quando você executar o programa, a saída será:

Apple.com

Mas ao contrário das variáveis, você não pode alterar o valor da constante. Portanto, você não pode fazer isso:

Exemplo6: Alterar o valor da constante (não permitido)

let siteName = "Apple.com"
siteName = "w"3codebox.com"　//erro de tempo de compilação
print(siteName)

A instrução acima nos dá um erro, porque, como dissemos, uma vez que os dados são armazenados, o valor da constante não pode ser alterado. Esta é a diferença crucial entre variáveis e constantes.

O que é um litteral?

Os litterais são valores que aparecem diretamente no código-fonte. Eles podem ser números, caracteres ou strings, por exemplo: "Hello, World",12,23.0, "C" é um exemplo simples de litteral. Os litterais são frequentemente usados para inicializar variáveis ou constantes (atribuir valores a elas).

Por exemplo:

let siteName = "Apple.com"

Na expressão acima, siteName é uma variável e "Apple.com" é um litteral.

Tipos de litterais no Swift

Litterais inteiros

Ele representa valores decimais, binários, octais ou hexadecimais. Ele tem quatro tipos.

• Litteral binário

• Representa o valor binário.

• Começa com 0b.

• Litteral octal

• Representa o valor octal.

• Começa com 0o.

• Litteral hexadecimal

• Representa o valor hexadecimal.

• Começa com 0x.

• Litteral de número decimal

• Representa o valor decimal.

• Começa do zero. Tudo o que você declarar como litteral inteiro é do tipo decimal.

Exemplo7Como usar litterais inteiros no Swift?

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

Quando você executar o programa, a saída será:

255
1231

No programa acima, há dois litterais inteiros 0b11111111（literral binário）e1231（literral decimal）。11111111 O valor decimal é 255Portanto, a declaração print(binaryNumber) imprime na tela 255.

Da mesma forma, print(1231) Imprima o valor decimal no console 255.

Strings e literais de caracteres

Os literais de string são sequências de caracteres entre aspas duplas, enquanto os literais de caractere são caracteres únicos entre aspas duplas.

Exemplo8Como usar strings e literais de caracteres no Swift?

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

No programa acima "C" é um literal de caractere, "Swift is awesome" é um literal de string.

Literals de ponto flutuante

Usado para inicializar variáveis de tipos de dados float e double. Ele pode ter dois tipos:

Decimal:

Ele pode ter um expoente opcional, representado por e, em maiúscula ou minúscula. Para números decimais com expoente exp, o基数 é multiplicado por 10 ^exp:

Exemplo9Como usar literals decimais em Swift?

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

Quando você executar o programa, a saída será:

12.23
314.0

No programa acima12.23,3.14e2É um literal de ponto flutuante.3.14e2 Representado em expoente, é equivalente a3.14 * 10 ².

Hexadecimal:

Os números hexadecimais de ponto flutuante devem ter um expoente representado por p, em maiúscula ou minúscula. Para números hexadecimais com expoente exp, o基数 é multiplicado por2 ^exp:

Exemplo10Como usar literals hexadecimais em Swift?

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

Quando você executar o programa, a saída será:

15360.0
0.003662109375

No programa acima 0xFp10，0xFp-12 É um literal de ponto flutuante. 0xFp10Representado em expoente, é equivalente a15 * 210Onde F é representado como decimal15Portanto, print(someFloat) imprime na tela15360.0。

Da mesma forma, 0xFp-12 É equivalente a 15 * 2-12Portanto, print(someAnotherFloat) imprime 0.00 na tela3662109375.

Literals booleanos

No Swift, há dois literals booleanos. Eles são true e false.。

Exemplo11Como usar literals booleanos em Swift?

let result:Bool = false

No programa acima, false é uma constante booleana, atribuída à constante result.

Regras e boas práticas de variáveis e constantes

1. Escolha um nome significativo. Por exemplo:var name Mais var n Mais significativo.

2. Use a notação camelCase para declarar variáveis ou constantes. A notação camelCase começa com letra minúscula. Por exemplo:

   var studentName
   let studentAge
   let address

3. Você também pode definir variáveis e constantes sem precisar marcá-las. Não usar nome como marca significa que você não usará isso no programa. Em muitos casos, você deseja criar uma variável não usada. Neste caso, você pode usar o marcador de posição _.

   var _ = "Apple.com"　//A string foi inicializada, mas não armazenada em uma variável
   let _ = "Apple.com"

   　 　 　 　 　 　 Até isso também é válido

   _ = "Apple.com"

4. Se precisar definir um valor apenas uma vez e não precisar alterá-lo novamente no programa, use uma constante. No entanto, se precisar alterá-lo posteriormente, use uma variável.

5. Os nomes de constantes e variáveis não podem conter caracteres de espaço, símbolos matemáticos, setas, pontos Unicode inválidos (ou privados) ou caracteres de linha e caixa. Eles também não podem começar com números, embora os números possam estar em outros lugares do nome.

   var　12　= "Apple.com"　//dá um erro de compilação: esperado padrão
   var @hello = “Hello”　//dá um erro de compilação: esperado padrão