Operator "++" dan "-" telah usang Xcode 7.3

Saya melihat catatan Xcode 7.3 dan saya perhatikan masalah ini.

Operator ++ dan - telah ditinggalkan

Bisakah seseorang menjelaskan mengapa itu usang? Dan apakah saya benar bahwa dalam versi Xcode baru sekarang Anda akan menggunakan bukan ++ini x += 1;

Contoh:

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

Sebuah penjelasan lengkap di sini dari Chris Lattner, pencipta Swift. Saya akan merangkum poin-poinnya:

1. Ini fungsi lain yang harus Anda pelajari saat belajar Swift
2. Tidak jauh lebih pendek dari x += 1
3. Swift bukan C. Seharusnya tidak membawanya hanya untuk menyenangkan programmer C.
4. Penggunaan utamanya adalah dalam C-style untuk loop for i = 0; i < n; i++ { ... }:, yang Swift memiliki alternatif yang lebih baik, seperti for i in 0..<n { ... }(C-style untuk loop juga akan keluar )
5. Dapat sulit untuk dibaca dan dikelola, misalnya, apa nilai x - ++xatau foo(++x, x++)?
6. Chris Lattner tidak menyukainya.

Bagi mereka yang tertarik (dan untuk menghindari pembusukan tautan), alasan Lattner dalam kata-katanya sendiri adalah:

1. Operator-operator ini menambah beban untuk mempelajari Swift sebagai bahasa pemrograman pertama - atau kasus lain di mana Anda belum mengetahui operator-operator ini dari bahasa yang berbeda.

2. Keuntungan ekspresif mereka minimal - x ++ tidak jauh lebih pendek dari x + = 1.

3. Swift sudah menyimpang dari C di mana operasi =, + = dan penugasan lainnya mengembalikan Void (karena sejumlah alasan). Operator-operator ini tidak konsisten dengan model itu.

4. Swift memiliki fitur-fitur canggih yang menghilangkan banyak alasan umum Anda menggunakan ++ i dalam gaya C untuk loop dalam bahasa lain, jadi ini relatif jarang digunakan dalam kode Swift yang ditulis dengan baik. Fitur-fitur ini termasuk for-in loop, range, enumerate, map, dll.

5. Kode yang benar-benar menggunakan nilai hasil dari operator ini seringkali membingungkan dan halus bagi pembaca / pemelihara kode. Mereka mendorong kode "terlalu rumit" yang mungkin lucu, tetapi sulit dimengerti.

6. Sementara Swift memiliki urutan evaluasi yang jelas, kode apa pun yang bergantung padanya (seperti foo (++ a, a ++)) akan tidak diinginkan bahkan jika itu didefinisikan dengan baik.

7. Operator ini berlaku untuk jenis yang relatif sedikit: bilangan bulat bilangan bulat dan bilangan bulat, dan konsep mirip iterator. Mereka tidak berlaku untuk bilangan kompleks, matriks, dll.

Akhirnya, ini gagal metrik "jika kita belum memiliki ini, apakah kita akan menambahkannya ke Swift 3?"

Saya menyadari bahwa komentar ini tidak menjawab pertanyaan, namun mungkin ada orang yang mencari solusi bagaimana menjaga operator ini bekerja dan solusi seperti itu dapat ditemukan di bagian bawah. 😇

Saya pribadi lebih suka ++dan --operator. Saya tidak setuju dengan pendapat bahwa mereka rumit atau sulit dikelola. Setelah pengembang memahami apa yang dilakukan operator ini (dan kami berbicara tentang hal-hal yang cukup sederhana) kode tersebut harus sangat jelas.

Dalam penjelasan mengapa operator tidak digunakan disebutkan bahwa penggunaan utama mereka adalah dalam gaya C untuk loop. Saya tidak tahu tentang orang lain tetapi saya pribadi tidak menggunakan loop gaya C sama sekali dan masih ada banyak tempat atau situasi lain ketika ++atau --operator berguna.

Saya juga ingin menyebutkan bahwa varName++mengembalikan nilai sehingga dapat digunakan returnsementara varName += 1tidak bisa.

Bagi Anda yang ingin menjaga agar operator ini tetap bekerja di sini adalah solusinya:

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
}

Apple telah menghapus ++dan membuatnya lebih sederhana dengan cara tradisional lama lainnya.

Alih-alih ++, Anda perlu menulis +=.

Contoh:

var x = 1

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

Demikian pula untuk operator pengurangan --, Anda perlu menulis-=

Contoh:

var x = 1

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

Untuk forloop:

Contoh Penambahan:

Dari pada

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

Kamu bisa menulis:

//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)")
}

Contoh Pengurangan:

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

Kamu bisa menulis:

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)
}

Semoga ini membantu!

Chris Lattner telah berperang melawan ++ dan -. Dia menulis, “Kode yang benar-benar menggunakan nilai hasil dari operator ini seringkali membingungkan dan halus bagi pembaca / pemelihara kode. Mereka mendorong kode "terlalu rumit" yang mungkin lucu, tetapi sulit dimengerti .... Sementara Swift memiliki urutan evaluasi yang jelas, kode apa pun yang bergantung padanya (seperti foo (++ a, a ++)) tidak akan diinginkan walaupun didefinisikan dengan baik ... ini gagal metrik "jika kita belum memiliki ini, apakah kita akan menambahkannya ke Swift 3?"

Apple ingin tetap menggunakan bahasa yang bersih, jelas, tidak membingungkan, dan langsung ke sasaran. Jadi mereka tidak lagi menggunakan ++ dan - kata kunci.

The Fix-it featureXcode memberikan jawaban yang jelas untuk ini.

Ganti ++ increment operatordengan yang lama value += 1(operator tangan pendek) dan -- decrement operatordenganvalue -= 1

Untuk Swift 4, Anda dapat memulihkan ++dan --operator sebagai ekstensi untuk Intdan jenis lainnya. Berikut ini sebuah contoh:

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
    }
}

Ia bekerja dengan cara yang sama untuk jenis lain, seperti UIInt, Int8, Float, Double, dll

Anda dapat menempelkan ekstensi ini dalam satu file di direktori root Anda, dan ekstensi itu akan tersedia untuk digunakan di dalam semua file Anda yang lain di sana.

Saya telah memperhatikan beberapa suara untuk jawaban saya di sini, segera setelah saya mempostingnya. Yang saya anggap sebagai perselisihan filosofis, bukan kritik tentang cara kerja kode saya. Ini berfungsi dengan baik, jika Anda memeriksanya di taman bermain.

Alasan mengapa saya memposting jawaban ini adalah karena saya tidak setuju dengan membuat bahasa pemrograman komputer yang tidak perlu berbeda satu sama lain.

Memiliki banyak kesamaan antar bahasa membuatnya lebih mudah bagi orang untuk belajar dan beralih dari satu bahasa ke bahasa lain.

Pengembang biasanya menggunakan beberapa bahasa pemrograman, bukan hanya satu. Dan sungguh merepotkan untuk beralih dari satu bahasa ke bahasa lain, ketika tidak ada konvensi dan tidak ada standardisasi umum lintas bahasa.

Saya percaya bahwa harus ada perbedaan sintaks antara bahasa hanya sebanyak yang diperlukan, dan tidak lebih dari ini.

Ini adalah versi umum dari beberapa kode yang diposting sejauh ini. Saya akan menyuarakan keprihatinan yang sama dengan yang lain: ini adalah praktik terbaik untuk tidak menggunakannya di Swift. Saya setuju bahwa ini dapat membingungkan bagi mereka yang membaca kode Anda di masa depan.

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
}

Ini juga dapat ditulis sebagai ekstensi pada tipe Numerik.

Dari dokumen :

Operator kenaikan / penurunan di Swift ditambahkan sangat awal dalam pengembangan Swift, sebagai carry-over dari C. Ini ditambahkan tanpa banyak pertimbangan, dan tidak banyak dipikirkan sejak itu. Dokumen ini memberikan pandangan baru pada mereka, dan pada akhirnya menyarankan agar kita menghapusnya seluruhnya, karena mereka membingungkan dan tidak membawa beban mereka.

var value : Int = 1

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

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

Ini jelas merupakan kerugian, bukan?

Karena Anda tidak pernah benar-benar bekerja dengan pointer di Swift, masuk akal untuk menghapus ++dan --operator menurut saya. Namun jika Anda tidak dapat hidup tanpanya, Anda dapat menambahkan deklarasi operator Swift 5+ ini ke proyek Anda:

@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
}

Dalam Swift 4.1 itu bisa dicapai dengan cara ini:

    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)")

Perhatikan bahwa terlepas dari kenyataan bahwa solusi ini mirip dengan solusi sebelumnya dalam posting ini, mereka tidak berfungsi lagi di Swift 4.1 dan contoh ini tidak. Juga perhatikan bahwa siapa pun di atas yang menyebutkan bahwa + = adalah pengganti ++ hanya tidak sepenuhnya memahami operator karena ++ digabungkan dengan penugasan sebenarnya adalah dua operasi, karenanya jalan pintas. Dalam contoh saya:var s = t++melakukan dua hal: tetapkan nilai t ke s dan kemudian kenaikan t. Jika ++ datang sebelumnya, ini adalah dua operasi yang sama dilakukan dalam urutan terbalik. Menurut pendapat saya, alasan Apple tentang mengapa harus menghapus operator ini (disebutkan dalam jawaban sebelumnya), bukan hanya alasan palsu tetapi lebih lanjut saya percaya itu bohong dan alasan sebenarnya adalah bahwa mereka tidak dapat membuat kompiler mereka menanganinya. Itu memberi mereka masalah di versi sebelumnya sehingga mereka menyerah. Logika "operator yang terlalu rumit untuk dipahami, maka dihilangkan" jelas merupakan kebohongan karena Swift mengandung operator yang jauh lebih rumit dan jauh lebih tidak berguna yang tidak dihapus. Juga, sebagian besar bahasa pemrograman memilikinya. JavaScript, C, C #, Java, C ++ dan banyak lagi. Pemrogram dengan senang hati menggunakannya. Siapa pun yang terlalu sulit untuk memahami operator ini untuk,

Strategi di belakang Swift sederhana: Apple percaya programmer itu bodoh dan karenanya harus diperlakukan sesuai.

Yang benar adalah bahwa Swift, yang diluncurkan pada September 2014 seharusnya sudah berada di tempat lain sekarang. Bahasa lain tumbuh lebih cepat.

Saya dapat membuat daftar banyak kesalahan besar dalam bahasa, dari yang serius: seperti array yang disisipkan oleh nilai dan bukan dengan referensi, ke yang menjengkelkan: fungsi parameter variadic tidak dapat menerima array yang merupakan keseluruhan ide di baliknya. Saya tidak berpikir bahwa karyawan Apple bahkan diizinkan untuk melihat bahasa lain seperti Java sehingga mereka bahkan tidak tahu bahwa Apple berada di belakang. Apple bisa saja mengadopsi Jawa sebagai bahasa tetapi belakangan ini, tantangan bukanlah teknologi, tetapi ego. Jika mereka akan membuka IntelliJ untuk menulis beberapa Java, mereka pasti akan menutup pemahaman bisnis mereka bahwa pada titik ini, mereka tidak bisa dan tidak akan pernah bisa mengejar ketinggalan.