Operadores básicos

Um operador é um símbolo ou frase especial que você usa para verificar, alterar ou combinar valores. Por exemplo, o operador de adição + adiciona dois números, como na expressão i = 1+2 e o operador lógico “E” && combina dois valores booleanos, como if maiorDeIdade&&temIngresso.

O Swift suporta a maioria dos operadores padrão da linguagem C e melhora vários recursos para eliminar erros comuns na hora de criar seu código. O operador de atribuição = não retorna um valor, para evitar que ele seja usado erroneamente quando o operador de igualdade ==. Operadores aritméticos (+, - , * , / , % e assim por diante) detectam e impedem o overflow (tentar armazenar um valor maior do que a variável ou constante suporta) para evitar resultados inesperados ao trabalhar com números que se tornam maiores ou menores do que o intervalo de valores permitidos do tipo que os armazena. Você pode optar por desabilitar esse comportamento de evitar o overflow usando os operadores de overflow do Swift, conforme descrito num final desse livro.

O Swift também fornece operadores de range (alcance de um valor até outro) que não são encontrados na linguagem C, como o ...<b e a...b, como um atalho para expressar uma range de valores.

Este capítulo descreve os operadores básicos do Swift. A seção de Operadores avançados mais a frente neste livro abrange os operadores avançados da Swift e descreve como definir seus próprios operadores personalizados e implementar os operadores padrão para seus próprios tipos personalizados.

Terminologia

Os operadores no Swift podem ser unários, binários ou ternários:

  • Operadores unários operam em um único valor (como -a). Os operadores unários de prefixo aparecem imediatamente antes do seu alvo (como !b) e os operadores unários de sufixo aparecem imediatamente após o destino (como c!).

  • Os operadores binários operam em dois alvos (como 2+3) e são infixos porque aparecem entre os dois alvos.

  • Os operadores ternários operam em três alvos. Como na linguagem C, o Swift tem apenas um operador ternário, o operador condicional ternário a ? b : c.

Os valores que os operadores afetam são chamados de operandos. Na expressão 1 + 2, o símbolo + é um operador binário e seus dois operandos são os valores 1 e 2.

Operador de atribuição

O operador de atribuição a = b inicializa ou atualiza o valor de a com o valor de b:

Se o lado direito do operador for uma tupla com múltiplos valores, seus elementos podem ser separados em várias constantes ou variáveis ​​em um único comando:

Ao contrário do operador de atribuição em C e Objective-C, o operador de atribuição no Swift não retorna um valor, portanto a seguinte declaração não é válida:

Esse comportamento impede que o operador de atribuição = seja usado por acidente quando o operador de igual == é realmente necessário. Fazendo com que a expressão x = y seja inválida como uma expressão booleana, o Swift ajuda você a evitar esses tipos de erros no seu código.

Operadores aritméticos

O Swift suporta os quatro operadores aritméticos padrão para todos os tipos de números:

  • Adição +

  • Subtracao -

  • Multiplicacao *

  • Divisão /

Ao contrário dos operadores aritméticos em C e Objective-C, os operadores aritméticos no Swift não permitem que os valores sofram overflow (tentar armazenar um valor maior do que a variável ou constante suporta) por padrão. Você pode optar por ignorar esse comportamento de overflow usando os operadores de overflow do Swift (como a &+ b). Veremos mais sobre esse assunto na seção de Operadores de overflow.

O operador de adição também suporta a concatenação String:

Operador de resto

O operador de resto a % b calcula quantos múltiplos debcabem dentro deae retornam o valor que sobra (conhecido como o restante).

Nota

O operador de resto % também é conhecido como operador de módulo em outras linguagens de programação. No entanto, seu comportamento no Swift para números negativos significa que, estritamente falando, é um resto em vez de um operador de módulo.

Aqui está como o operador de resto funciona. Para calcular 9 % 4, você primeiro calcula quantos 4 caberão dentro de 9:

Cabem dois 4 dentro do número 9 e o restante é 1 (mostrado em laranja). Em Swift, isso seria escrito como:

Para determinar o resultado da expressãoa%b, o operador%calcula a seguinte equação e retorna o resto como saída: a = (b * algum multiplicador) + resto Onde algum multiplicador é o maior número de múltiplos debque caberá dentro dea. Inserindo um 9 e um 4 nesta equação teremos o seguinte resultado:

9 = (4 * 2) + 1

O mesmo método é aplicado ao calcular o resto para um valor negativo de -a:

Inserindo -9 e 4 na equação teremos o seguinte resultado:**

-9 = (4 * -2) + -1

**Dando um valor restante de-1. O sinal debé ignorado por valores negativos deb. Isso significa que (a%b)e (a%-b)sempre dão a mesma resposta.

Operador unário menos

O sinal de um valor numérico pode ser alternado usando o prefixo - conhecido como o operador unário menos:

O operador unário menos - é adicionado diretamente antes do valor em que ele opera, sem espaços em branco.

Operador unário mais

O operador unário mais + simplesmente retorna o valor em que opera, sem qualquer alteração:

Embora o operador unário mais realmente não faça nada, você pode usá-lo para fornecer simetria em seu código para números positivos quando você também está usando o operador unário menos para números negativos.

Operadores de atribuição compostos

Como na linguagem C, o Swift fornece operadores de atribuição compostos que combinam a atribuição (=) com outra operação. Um exemplo é o operador de atribuição e adição +=:

A expressão a += 2 é uma abreviatura para a = a + 2. Efetivamente, a adição e a atribuição são combinadas em um operador que executa ambas as tarefas ao mesmo tempo.

Nota

Os operadores de atribuição compostos não retornam um valor. Por exemplo, você não pode escrever let b = a + = 2.

Para obter uma lista completa dos operadores de atribuição compostos fornecidos pela biblioteca padrão do Swift, consulte a seção de Referência dos Operadores de Biblioteca Padrão Swift neste livro.

Operadores de comparação

O Swift suporta todos os operadores de comparação da linguagem C.

  • Igual a a == b

  • Diferente de a != b

  • Maior que a > b

  • Menor que a < b

  • Maior que ou igual a a >= b

  • Menor que ou igual a a <= b

Nota

O Swift também fornece dois operadores de identidade === e !==, que você usa para testar se duas referências de um objeto se referem à mesma instância de um objeto. Para mais informações, veja a seção de Classes e Estruturas neste livro.

Cada um dos operadores de comparação retorna um valor booleano para indicar se a afirmação é verdadeira ou não.

Os operadores de comparação são freqüentemente usados ​​em declarações condicionais, como o comando if:

Falaremos mais a respeito do comando if na seção de Controle de fluxo neste livro.

Você também pode comparar as tuplas com o mesmo número de valores, desde que cada um dos valores da tupla possa ser comparado. Por exemplo, os tipos Int e String podem ser comparados, o que significa que as tuplas do tipo (Int, String) podem ser comparadas. Em contraste, o Bool não pode ser comparado, o que significa que as tuplas que contêm um valor booleano não podem ser comparadas.

As tuplas são comparados da esquerda para a direita, um valor de cada vez, até que a comparação encontre dois valores que não são iguais. Esses dois valores são comparados e o resultado dessa comparação determina o resultado geral da comparação de tupla. Se todos os elementos forem iguais, então as próprias tuplas são iguais, por exemplo:

No exemplo acima, você pode ver o comportamento da comparação da esquerda para a direita na primeira linha. Como 1 é inferior a 2, a tupla (1, "zebra") é considerado inferior a (2, "maçã"), independentemente de qualquer outro valor nas tuplas. Não importa que "zebra" não seja inferior a "maçã", porque a comparação já está determinada pelos primeiros elementos das tuplas. No entanto, quando os primeiros elementos das tuplas sao iguais, seus dois elementos são comparados: é o que acontece na segunda e terceira linha.

Nota

A biblioteca padrão Swift inclui operadores de comparação de tuplas para tuplas com menos de sete elementos. Para comparar tuplas com sete ou mais elementos, você deve implementar os operadores de comparação.

Operador condicional ternário

O operador condicional ternário é um operador especial com três partes, que deve ser escrito da seguinte forma: pergunta ?respostaTrue : respostaFalse. Ele é um atalho para executar uma das duas expressões com base na pergunta ser verdadeira ou falsa. Se a pergunta for verdadeira, ela executa a respostaTrue e retorna seu valor, caso contrário, ele executa a respostaFalse e retorna seu valor. O operador condicional ternário é um atalho para o código abaixo:

Aqui está um exemplo que calcula a altura para uma linha de uma tabela. A altura da linha deve ser 50 pontos mais alta do que a altura do conteúdo se a linha tiver um cabeçalho e 20 pontos mais alto se a linha não tiver um cabeçalho:

O exemplo acima e um atalho o seguinte código:

O uso do primeiro exemplo do operador condicional ternário significa que rowHeight pode ser setado para o valor correto em uma única linha de código, que é mais conciso e fácil de ler do que o código usado no segundo exemplo.

O operador condicional ternário fornece uma atalho eficiente para decidir qual das duas expressões usar. Use o operador condicional ternário com cuidado, pois sua concisão pode deixar seu código difícil de ler, se este recurso for usado em excesso. Evite combinar várias instâncias do operador condicional ternário em uma declaração composta.

Operador Nil-Coalescing

O operador nil-coalescing a ?? b desembrulha um valor opcional a somente se ele contém um valor ou retorna um valor padrão b se a for nulo. A valor de a precisa ser sempre um opcional, e o valor de b deve corresponder ao tipo que está armazenado dentro de a. O operador nil-coalescing é um atalho para o código abaixo:

O código acima usa o operador condicional ternário e o forced unwrap a! para acessar o valor embrulhado dentro do opcional a quando a não é nulo ou retorna o valor de b caso contrário. O operador nil-coalescing fornece uma maneira mais elegante de encapsular esta verificação condicional e desembrulhar o opcional de forma mais concisa e legível.

Nota

Se o valor de a nao for nulo, o valor de b não é processado. Isso é conhecido comoshort-circuit evaluation (avaliação de curto-circuito).

O exemplo abaixo usa o operador nil-coalescing para escolher entre um nome de cor padrão e um nome de uma cor opcional definida (ou não) pelo usuário:

A variável userDefinedColorName é definida como uma String opcional, com um valor padrão nil. Como userDefinedColorName é um opcional, você pode usar o operador nil-coalescing para usar seu valor. No exemplo acima, o operador é usado para determinar um valor inicial para uma variável String chamada colorNameToUse. Como a variável userDefinedColorName é nula, a expressão userDefinedColorName ?? defaultColorName retorna o valor de defaultColorName, ou "red".

Se você atribuir um valor que não seja nulo para a variável userDefinedColorName e executar a verificação do operador nil-coalescing novamente, o valor dentro de userDefinedColorName é desembrulhado usado em vez do padrão:

Operadores de range

O Swift inclui vários operadores de range, que são atalhos para expressar uma range de valores (valores que começam de determinado valor e acabam em outro). O primeiro que veremos é o operador de range fechado a...b que define um range que percorre de a até b sendo que o valor de a deve ser menor do que o valor de b.

O operador de range fechado é útil ao iterar em um intervalo no qual você deseja que todos os valores sejam usados, como, por exemplo, com um loop for-in:

Falaremos mais a respeito do comando for-in e sobre loops como eles funcionam na seção de controle de fluxo nesse mesmo livro.

O próximo é o operador de range meio-aberto a..<b que define um range de a até b mas não inclui o valor de b. Ele é chamado de meio aberto porque contém o primeiro valor, mas não contém o valor final.Tal como acontece com o operador de range fechado, o valor de a não deve ser maior do que b. Se o valor de a for igual ao de b, o range será vazio e não será executado.

Os range meio-abertos são particularmente úteis quando você trabalha com listas baseadas no índice zero, como arrays, onde é útil contar até (mas não incluir) o comprimento da lista:

Observe que o array contém quatro itens, mas 0 ..< count so conta até 3 (o índice do último item no array), porque é um operador de range meio aberto. Veremos mais a respeito de arrays neste livro.
Voltando ao operador de rage fechado, ele possui uma forma alternativa para ranges que continuam o mais longe possível em uma direção - por exemplo, um range que inclui todos os elementos de um array começando do índice 2 até o final do array. Nesses casos, você pode omitir o valor de um lado do operador de range. Esse tipo de range é chamado de range de lado único, porque o operador possui um valor em apenas um lado. Por exemplo:

O operador de intervalo semi-aberto também possui uma forma de lado único escrita com apenas seu valor final. Assim como quando você inclui um valor em ambos os lados, o valor final não faz parte do intervalo. Por exemplo:

Os operadores de range de lado único podem ser usados ​​em outros contextos, não apenas com índices de arrays. Você não pode iterar em um range que omite o primeiro valor, porque não está claro onde a iteração deve começar, porém ele pode ser criado. Você pode iterar em um range de lado único que omite seu valor final, no entanto, porque o intervalo continua indefinidamente, certifique-se de adicionar uma condição final explícita para o loop para não ficar travado eternamente. Você também pode verificar se um range de lado único contém um valor específico, conforme mostrado no código abaixo.

Operadores lógicos

Os operadores lógicos modificam ou combinam os valores lógicos booleanos true e false. O Swift suporta os três operadores lógicos padrão encontrados em linguagens baseadas em C:

  • NOT !a

  • AND a && b

  • OR a || b

Operador lógico NOT

O operador lógico NOT !a inverte um valor booleano para que true se torne false e false se torne true.

O operador lógico NOT é um operador de prefixo e aparece imediatamente antes do valor em que ele opera, sem espaços em branco. Pode ser lido como "não (a)", como visto no exemplo a seguir:

    • A variável com o nome allowedEntry significa permitida a entrada se traduzido para português, portanto a sentença if !allowedEntry pode ser lida como "se não for permitida a entrada". O comando dentro do bloco if só é executado se a "entrada não permitida" for true, isto é, se allowedEntry tiver o valor false.

Como neste exemplo, a escolha cuidadosa dos nomes das constantes e variáveis Booleanas pode ajudar a manter o código legível e conciso, evitando simultaneamente valores booleanos sendo negativados sem necessidade ou declarações de lógica confusas.

Operador lógico AND

O operador lógico AND a && b cria expressões lógicas em que ambos os valores devem ser true para que a expressão toda seja avaliada como verdadeira.

Se qualquer valor da expressão for false, a expressão toda também será false. Na verdade, se o primeiro valor for false, o segundo valor nem será avaliado, porque não pode tornar toda a expressão equivalente atrue. Isso é conhecido como short-circuit evaluation (avaliação de curto-circuito).

Este exemplo considera dois valores do tipo Bool e só permite o acesso se ambos os valores forem verdadeiros:

Operador lógico OR

O operador lógico OR a || b é um operador infixo feito a partir de dois caracteres de pipe adjacentes. Você pode usá-lo para criar expressões lógicas em que apenas um dos dois valores deve ser true para a expressão inteira ser verdadeira.

Como o operador lógico AND acima, o operador OR usa o short-circuit evaluation para considerar suas expressões. Se o lado esquerdo de uma expressão lógica OR for true, o lado direito não é avaliado, porque não pode alterar o resultado da expressão em geral.

No exemplo abaixo, o primeiro valor booleano hasDoorKey é false, mas o segundo valor knowOverridePassword é true. Como um valor é verdadeiro, a expressão em geral também é avaliada como verdadeira e o acesso é permitido:

Combinando operadores lógicos

Você pode combinar vários operadores lógicos para criar expressões compostas mais longas:

Este exemplo usa vários operadores && e || para criar uma expressão composta mais longa. No entanto, os operadores && e || ainda operam em apenas dois valores, então estas são, na verdade, três expressões menores juntas que podem ser lidas como:

Se inserimos o código da porta correto e passamos pela varredura de retina, ou se nós possuímos uma chave de porta válida, ou se conhecemos a senha de emergência, então permita o acesso.

Com base nos valores das constantes inputDoorCode , pasedRetinaScan e hasDoorKey, as duas primeiras subexpressões são falsas. No entanto, a constante knowsOverridePassword tem o valor true, então a expressão em geral ainda é avaliada como verdadeira.

Nota

Os operadores lógicos do Swift && e || são associativos à esquerda, o que significa que as expressões compostas com vários operadores lógicos avaliam primeiro a expressão mais à esquerda.

Parênteses explícitos

Às vezes é útil incluir parênteses quando não são estritamente necessários, para facilitar a leitura da intenção de uma expressão complexa. No exemplo acima, é útil adicionar parênteses em torno da primeira parte da expressão composta para tornar explícita sua intenção:

Os parênteses deixam claro que os dois primeiros valores são considerados como parte de um expressão separada na lógica geral. O resultado da expressão composta não muda, mas a intenção geral é mais clara para o leitor. A legibilidade é sempre preferida em relação à brevidade, portanto use parênteses onde eles ajudem a tornar suas intenções claras.

results matching ""

    No results matching ""