Os operadores “++” e “-” foram reprovados no Xcode 7.3

Estou olhando para as notas do Xcode 7.3 e noto esse problema.

Os operadores ++ e - foram descontinuados

Alguém poderia explicar por que está obsoleto? E estou certo de que, na nova versão do Xcode, agora você vai usar em vez ++disso x += 1;

Exemplo:

for var index = 0; index < 3; index += 1 {
    print("index is \(index)")
}

Uma explicação completa aqui de Chris Lattner, criador de Swift. Vou resumir os pontos:

1. É outra função que você precisa aprender enquanto aprende Swift
2. Não muito menor que x += 1
3. Swift não é C. Não deve carregá-los apenas para agradar aos programadores C
4. Seu principal uso é no estilo C para loop for i = 0; i < n; i++ { ... }:, que Swift tem melhores alternativas, como for i in 0..<n { ... }(o estilo C para loop também está saindo )
5. Pode ser difícil de ler e manter, por exemplo, qual é o valor de x - ++xou foo(++x, x++)?
6. Chris Lattner não gosta.

Para os interessados ​​(e para evitar o apodrecimento do link), as razões de Lattner em suas próprias palavras são:

1. Esses operadores aumentam o ônus de aprender o Swift como a primeira linguagem de programação - ou qualquer outro caso em que você ainda não os conheça de uma linguagem diferente.

2. Sua vantagem expressiva é mínima - x ++ não é muito menor que x + = 1.

3. O Swift já se desvia de C, pois as operações =, + = e outras operações semelhantes a atribuições retornam Void (por várias razões). Esses operadores são inconsistentes com esse modelo.

4. O Swift possui recursos poderosos que eliminam muitos dos motivos mais comuns pelos quais você usaria ++ i em um loop for no estilo C em outros idiomas; portanto, eles são usados ​​com pouca frequência em códigos Swift bem escritos. Esses recursos incluem o loop for-in, intervalos, enumerar, mapa, etc.

5. O código que realmente usa o valor resultante desses operadores geralmente é confuso e sutil para um leitor / mantenedor de código. Eles incentivam códigos "excessivamente complicados" que podem ser engraçados, mas difíceis de entender.

6. Embora o Swift tenha uma ordem de avaliação bem definida, qualquer código que dependesse dela (como foo (++ a, a ++)) seria indesejável, mesmo que estivesse bem definido.

7. Esses operadores são aplicáveis ​​a relativamente poucos tipos: escalares de números inteiros e de ponto flutuante e conceitos semelhantes ao iterador. Eles não se aplicam a números complexos, matrizes, etc.

Finalmente, eles falham na métrica de "se ainda não as tivéssemos, as adicionaríamos ao Swift 3?"

Sei que esse comentário não responde à pergunta, no entanto, pode haver pessoas procurando uma solução para manter esses operadores funcionando e essa solução pode ser encontrada na parte inferior. 😇

Eu pessoalmente prefiro ++e --operadores. Não posso concordar com a opinião de que eles são complicados ou difíceis de gerenciar. Depois que o desenvolvedor entender o que esses operadores fazem (e estamos falando de coisas bem simples), o código deve ficar bem claro.

Na explicação de por que os operadores foram descontinuados, é mencionado que seu principal uso era no estilo C para loops. Eu não sei sobre os outros, mas eu pessoalmente não usar loops de estilo C em tudo e ainda há muitos outros lugares ou situações quando ++ou --operador é útil.

Gostaria de mencionar também que varName++retorna um valor para que possa ser usado no returnwhile varName += 1não pode.

Para qualquer um de vocês que gostaria de manter esses operadores trabalhando aqui, é a solução:

prefix operator ++ {}
postfix operator ++ {}

prefix operator -- {}
postfix operator -- {}


// Increment
prefix func ++(inout x: Int) -> Int {
    x += 1
    return x
}

postfix func ++(inout x: Int) -> Int {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: UInt) -> UInt {
    x += 1
    return x
}

postfix func ++(inout x: UInt) -> UInt {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: Int8) -> Int8 {
    x += 1
    return x
}

postfix func ++(inout x: Int8) -> Int8 {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: UInt8) -> UInt8 {
    x += 1
    return x
}

postfix func ++(inout x: UInt8) -> UInt8 {
    x += 1
    return (x - 1)
}
prefix func ++(inout x: Int16) -> Int16 {
    x += 1
    return x
}

postfix func ++(inout x: Int16) -> Int16 {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: UInt16) -> UInt16 {
    x += 1
    return x
}

postfix func ++(inout x: UInt16) -> UInt16 {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: Int32) -> Int32 {
    x += 1
    return x
}

postfix func ++(inout x: Int32) -> Int32 {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: UInt32) -> UInt32 {
    x += 1
    return x
}

postfix func ++(inout x: UInt32) -> UInt32 {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: Int64) -> Int64 {
    x += 1
    return x
}

postfix func ++(inout x: Int64) -> Int64 {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: UInt64) -> UInt64 {
    x += 1
    return x
}

postfix func ++(inout x: UInt64) -> UInt64 {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: Double) -> Double {
    x += 1
    return x
}

postfix func ++(inout x: Double) -> Double {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: Float) -> Float {
    x += 1
    return x
}

postfix func ++(inout x: Float) -> Float {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: Float80) -> Float80 {
    x += 1
    return x
}

postfix func ++(inout x: Float80) -> Float80 {
    x += 1
    return (x - 1)
}

prefix func ++<T : _Incrementable>(inout i: T) -> T {
    i = i.successor()
    return i
}

postfix func ++<T : _Incrementable>(inout i: T) -> T {
    let y = i
    i = i.successor()
    return y
}

// Decrement
prefix func --(inout x: Int) -> Int {
    x -= 1
    return x
}

postfix func --(inout x: Int) -> Int {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: UInt) -> UInt {
    x -= 1
    return x
}

postfix func --(inout x: UInt) -> UInt {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: Int8) -> Int8 {
    x -= 1
    return x
}

postfix func --(inout x: Int8) -> Int8 {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: UInt8) -> UInt8 {
    x -= 1
    return x
}

postfix func --(inout x: UInt8) -> UInt8 {
    x -= 1
    return (x + 1)
}
prefix func --(inout x: Int16) -> Int16 {
    x -= 1
    return x
}

postfix func --(inout x: Int16) -> Int16 {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: UInt16) -> UInt16 {
    x -= 1
    return x
}

postfix func --(inout x: UInt16) -> UInt16 {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: Int32) -> Int32 {
    x -= 1
    return x
}

postfix func --(inout x: Int32) -> Int32 {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: UInt32) -> UInt32 {
    x -= 1
    return x
}

postfix func --(inout x: UInt32) -> UInt32 {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: Int64) -> Int64 {
    x -= 1
    return x
}

postfix func --(inout x: Int64) -> Int64 {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: UInt64) -> UInt64 {
    x -= 1
    return x
}

postfix func --(inout x: UInt64) -> UInt64 {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: Double) -> Double {
    x -= 1
    return x
}

postfix func --(inout x: Double) -> Double {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: Float) -> Float {
    x -= 1
    return x
}

postfix func --(inout x: Float) -> Float {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: Float80) -> Float80 {
    x -= 1
    return x
}

postfix func --(inout x: Float80) -> Float80 {
    x -= 1
    return (x + 1)
}

prefix func --<T : BidirectionalIndexType>(inout i: T) -> T {
    i = i.predecessor()
    return i
}

postfix func --<T : BidirectionalIndexType>(inout i: T) -> T {
    let y = i
    i = i.predecessor()
    return y
}

A Apple removeu ++e tornou muito mais simples com a outra velha maneira tradicional.

Em vez de ++, você precisa escrever +=.

Exemplo:

var x = 1

//Increment
x += 1 //Means x = x + 1 

Da mesma forma para o operador de decremento --, você precisa escrever-=

Exemplo:

var x = 1

//Decrement
x -= 1 //Means x = x - 1

Para forloops:

Exemplo de incremento:

Ao invés de

for var index = 0; index < 3; index ++ {
    print("index is \(index)")
}

Você pode escrever:

//Example 1
for index in 0..<3 {
    print("index is \(index)")
}

//Example 2
for index in 0..<someArray.count {
    print("index is \(index)")
}

//Example 3
for index in 0...(someArray.count - 1) {
    print("index is \(index)")
}

Exemplo de Decremento:

for var index = 3; index >= 0; --index {
   print(index)
}

Você pode escrever:

for index in 3.stride(to: 1, by: -1) {
   print(index)
}
//prints 3, 2

for index in 3.stride(through: 1, by: -1) {
   print(index)
}
//prints 3, 2, 1

for index in (0 ..< 3).reverse() {
   print(index)
}

for index in (0 ... 3).reverse() {
   print(index)
}

Espero que isto ajude!

Chris Lattner entrou em guerra contra ++ e -. Ele escreve: “O código que realmente usa o valor resultante desses operadores geralmente é confuso e sutil para um leitor / mantenedor de código. Eles incentivam códigos "excessivamente complicados", que podem ser engraçados, mas difíceis de entender ... Embora o Swift tenha uma ordem de avaliação bem definida, qualquer código que dependesse dele (como foo (++ a, a ++)) seria indesejável, mesmo que foi bem definido ... eles falham na métrica de "se ainda não os tivéssemos, os adicionaríamos ao Swift 3?"

A Apple queria manter rápida uma linguagem limpa, clara, não confusa e direta ao ponto. E então eles preteriram ++ e - palavra-chave.

O Fix-it featuredo Xcode dá uma resposta clara para isso.

Substitua ++ increment operatorpor antiquado value += 1(operador de mão curta) e -- decrement operatorporvalue -= 1

Para o Swift 4, você pode restaurar os operadores ++e --como extensões para Inte outros tipos. Aqui está um exemplo:

extension Int{
   static prefix func ++(x: inout Int) -> Int {
        x += 1
        return x
    }

    static postfix func ++(x: inout  Int) -> Int {
        defer {x += 1}
        return x
    }

    static prefix func --(x: inout Int) -> Int {
        x -= 1
        return x
    }

    static postfix func --(x: inout Int) -> Int {
        defer {x -= 1}
        return x
    }
}

Ele funciona da mesma maneira para outros tipos, tais como UIInt, Int8, Float, Double, etc.

Você pode colar essas extensões em um único arquivo no diretório raiz e elas estarão disponíveis para uso em todos os seus outros arquivos lá.

Percebi alguns votos negativos para a minha resposta aqui, quase assim que a publiquei. O que considero um desacordo filosófico, em vez de uma crítica de como meu código funciona. Funciona perfeitamente, se você der uma olhada em um playground.

A razão pela qual publiquei esta resposta é porque discordo de tornar as linguagens de programação de computador desnecessariamente diferentes uma da outra.

Ter muitas semelhanças entre idiomas facilita a aprendizagem e a troca de um idioma para outro.

Os desenvolvedores normalmente usam várias linguagens de programação, em vez de apenas uma. E é um verdadeiro aborrecimento mudar de um idioma para outro, quando não há convenções nem padronização comum entre os idiomas.

Acredito que deve haver diferenças de sintaxe entre os idiomas apenas o necessário e não mais do que isso.

Aqui está uma versão genérica de alguns dos códigos publicados até o momento. Eu expressaria as mesmas preocupações que os outros: é uma prática recomendada não usá-las no Swift. Concordo que isso pode ser confuso para quem ler seu código no futuro.

prefix operator ++
prefix operator --
prefix func ++<T: Numeric> (_ val: inout T) -> T {
    val += 1
    return val
}

prefix func --<T: Numeric> (_ val: inout T) -> T {
    val -= 1
    return val
}

postfix operator ++
postfix operator --
postfix func ++<T: Numeric> (_ val: inout T) -> T {
    defer { val += 1 }
    return val
}

postfix func --<T: Numeric> (_ val: inout T) -> T {
    defer { val -= 1 }
    return val
}

Isso também pode ser escrito como uma extensão no tipo numérico.

Dos documentos :

Os operadores de incremento / decréscimo no Swift foram adicionados muito cedo no desenvolvimento do Swift, como uma transferência de C. Estes foram adicionados sem muita consideração e não se pensou muito desde então. Este documento fornece uma nova visão para eles e, em última análise, recomenda que os removamos completamente, pois são confusos e não carregam seu peso.

var value : Int = 1

func theOldElegantWay() -> Int{
return value++
}

func theNewFashionWay() -> Int{
let temp = value
value += 1
return temp
}

Esta é definitivamente uma desvantagem, certo?

Como você nunca trabalha com ponteiros no Swift, faz sentido remover os operadores ++e --na minha opinião. No entanto, se você não pode viver sem, você pode adicionar estas declarações do operador Swift 5+ ao seu projeto:

@discardableResult
public prefix func ++<T: Numeric>(i: inout T) -> T {
    i += 1
    return i
}

@discardableResult
public postfix func ++<T: Numeric>(i: inout T) -> T {
    defer { i += 1 }
    return i
}

@discardableResult
public prefix func --<T: Numeric>(i: inout T) -> T {
    i -= 1
    return i
}

@discardableResult
public postfix func --<T: Numeric>(i: inout T) -> T {
    defer { i -= 1 }
    return i
}

No Swift 4.1, isso pode ser alcançado da seguinte maneira:

    prefix operator ++
    postfix operator ++
    extension Int{
        static prefix func ++(x: inout Int)->Int{
            x += 1
            return x
        }
        static postfix func ++(x: inout Int)->Int{
            x += 1
            return x-1
        }
    }
    //example:
    var t = 5
    var s = t++
    print("\(t) \(s)")

Observe que, apesar do fato de que esta solução é semelhante às soluções anteriores deste post, elas não funcionam mais no Swift 4.1 e este exemplo funciona. Observe também que quem menciona acima que + = é um substituto para ++ simplesmente não entende completamente o operador, pois ++ combinado com a atribuição é na verdade duas operações, portanto, um atalho. No meu exemplo:var s = t++faz duas coisas: atribua o valor de t a se incremente t. Se o ++ vier antes, são as mesmas duas operações feitas em ordem inversa. Na minha opinião, o raciocínio da Apple sobre o motivo de remover esse operador (mencionado nas respostas anteriores) não é apenas um raciocínio falso, mas além disso acredito que é uma mentira e o verdadeiro motivo é que eles não conseguiram fazer com que o compilador lidasse com isso. Isso deu a eles problemas nas versões anteriores, então eles desistiram. A lógica do "operador muito complicado de entender, portanto removido" é obviamente uma mentira porque o Swift contém operadores muito mais complicados e muito menos úteis que não foram removidos. Além disso, a grande maioria das linguagens de programação possui. JavaScript, C, C #, Java, C ++ e muito mais. Os programadores o usam alegremente. Para quem é muito difícil entender esse operador,

A estratégia por trás do Swift é simples: a Apple acredita que o programador é burro e, portanto, deve ser tratado de acordo.

A verdade é que o Swift, lançado em setembro de 2014, deveria estar em outro lugar até agora. Outras línguas cresceram muito mais rapidamente.

Posso listar muitos erros importantes na linguagem, desde os graves: como arrays colados por valor e não por referência, até os irritantes: funções de parâmetros variados não podem aceitar um array, que é a idéia por trás dele. Não acho que os funcionários da Apple tenham permissão para procurar outras linguagens como Java, para que nem saibam que a Apple está anos-luz atrás. A Apple poderia ter adotado o Java como uma linguagem, mas atualmente, o desafio não é a tecnologia, mas o ego. Se eles tivessem aberto o IntelliJ para escrever um pouco de Java, certamente fechariam seus negócios, entendendo que, neste momento, eles não podem e nunca vão se atualizar.