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

139

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

Tangkapan layar untuk peringatan

Oleg Gordiichuk
sumber
6
Saya pikir pertanyaan ini jika di luar cakupan stackoverflow terutama karena semua proposal yang diterima untuk evolusi cepat dapat ditemukan di Github, Anda dapat membaca lebih lanjut tentang mengapa proposal ini github.com/apple/swift-evolution/blob/master / proposal / ...
Victor Sigler
7
Saya serius mempertimbangkan untuk kembali ke Objective-C. Tidak layak mencoba mengikuti semua perubahan pada Swift.
Greg Brown
3
@OlegGordiichuk Ini hal untuk-loop karena gaya-C akan dihapus juga, lihat ini github.com/Vkt0r/swift-evolution/blob/master/proposals/... sehingga Anda tidak perlu menggunakan lebih banyak ++dan --operator
Victor Sigler
10
Ada terlalu banyak perubahan yang merusak seleraku. Saya semua untuk perbaikan, tetapi saya tidak benar-benar ingin menghabiskan waktu saya menulis ulang sebagian besar basis kode saya setiap kali rilis titik Xcode keluar.
Greg Brown
4
@ Fogmeister Saya tidak yakin bagaimana saya bisa lebih jelas. Saya lebih suka menggunakan Swift, tetapi saya tidak merasa cukup stabil. Saya telah bekerja secara luas dengan bahasa lain di masa lalu dan tidak pernah mengalami begitu banyak perubahan dalam waktu singkat. Saya merasa Apple ingin kita semua mengadopsi Swift, tetapi mereka membuatnya lebih sulit dari yang seharusnya.
Greg Brown

Jawaban:

210

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

Kode Berbeda
sumber
54
I thing, jawaban sebenarnya adalah nomor 6. Itu OK, kita (mantan C, Java, ... programmer) cukup fleksibel :-). Secara umum, untuk dunia nyata, mutasi, crossover dan seleksi sudah cukup. Saya, Anda dan Cris juga, kita semua adalah hasil dari ketiga operator ...
user3441734
5
Butir 5: Itu selalu tergantung pada implementasi dalam C, dan tidak ada seorang pun yang pernah melakukannya. Cukup tentukan perilaku dan kita akan terbiasa. Lebih baik daripada harus kembali dan mengubah kode lama yang sangat baik tanpa alasan yang jelas.
Echelon
3
Saya suka poin 3. Anda tidak dapat dibelenggu untuk kontrak warisan selamanya. Saya suka C tetapi Anda sedang menciptakan bahasa pemrograman baru; masuk akal untuk memulai dengan batu tulis sebersih yang Anda inginkan.
Nicolas Miari
8
Karena apel suka memaksa Anda berpikir seperti itu. Saya pikir itu baik-baik saja dan digunakan di mana saja Anda perlu untuk menambah atau mengurangi variabel. Ini bukan sesuatu yang Anda "harus pelajari" Anda akan baik-baik saja tanpanya. Dan # 5 adalah kode yang ditulis dengan buruk, yang belum pernah saya lihat. Jadi nomor 6. Mengurangkannya sudah cukup untuk membuatku menggaruk kepalaku dan melakukan pencarian google, jadi terima kasih sudah membuang waktuku Chris.
csga5000
4
@ csga5000 Itu argumen yang cukup lemah mengingat Anda bisa mendefinisikan operator sendiri jika Anda benar-benar mau. Ini tidak ada hubungannya dengan apel yang ingin orang berpikir seperti mereka. Itu tidak sesuai dengan bahasa. Jika ++tidak ada dalam bahasa C-style, tidak ada yang waras akan melihat desain Swift 3.0 dan berpikir bahwa ++operator akan menjadi tambahan yang bagus untuk itu.
overactor
37

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
}
0101
sumber
Saya tidak suka Anda return (x - 1)untuk operator postfix - IMHO lebih bersih untuk menjaga semantik bahwa mereka mengembalikan (salinan) nilai asli daripada apa yang Anda dapatkan jika Anda melakukannyax + 1 - 1
Alnitak
Saya juga tidak suka tapi saya tidak tahu tentang cara lain (lebih baik, lebih bersih) dalam melakukan ini. Saya tidak sepenuhnya mengerti poin kedua Anda.
0101
1
Saya mengerti, saya tidak ingin melakukan itu hanya untuk menciptakan variabel lain (atau lebih tepatnya konstan dalam kasus ini). Jika kita berbicara tentang Inthanya maka hasil (x + 1)akan meluap yang akan mengganggu eksekusi dan karenanya result - 1tidak akan dijalankan. Tipe data lain seperti Doublemisalnya, berperilaku namun berbeda sehingga saya perlu menyelidiki itu.
0101
3
Anda dapat menggunakan deferini juga. defer { x += 1 }; return x
Tim Vermeulen
4
mengapa tidak menggunakan obat generik dan menulis ini dalam beberapa baris?
μολὼν.λαβέ
22

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!

Sohil R. Memon
sumber
Mereka belum mengganti apa pun; +=ada di sana selama ini.
Nicolas Miari
@NicolasMiari Ya hanya mengedit dengan format yang jauh lebih baik
Sohil R. Memon
@NicolasMiari Bisakah Anda periksa sekarang?
Sohil R. Memon
3
Bagaimana dengan ++idan --i?
Zigii Wong
7

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.

Jay Mehta
sumber
9
Bersih? Lihatlah neraka panggilan balik ini dan menyebutnya bersih? Saya tidak setuju ... Dan saya akan menambahkan: tinggalkan ++ & - alone
mcatach
22
sesuatu seperti ...for i in 0.stride(to: 10, by: 2)...atau ...for i in (1...10).reverse()...bersih ?!
mad_manny
6
Saya setuju. Argumen 'bersih' pada dasarnya bertentangan dengan Swift. Berasal dari Objective-C, yang secara objektif tidak bersih, cukup sulit untuk menerima 'bersih' sebagai tujuan bahasa Apple.
Adrian Bartholomew
2
Coba parsing json dan cepat dan katakan padaku betapa bersihnya itu.
nickthedude
6

Tangkapan layar untuk peringatan

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

Solusi untuk peringatan

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

Jayprakash Dubey
sumber
6

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.


sumber
Saya suka ketika bahasa “berani” berbeda. Sejujurnya ada terlalu banyak bahasa 'C-syntax', dan C dirancang LAMA beberapa waktu yang lalu .. sudah ada lebih dari 50 tahun pengalaman bahasa .. terlepas dari itu, karena jawaban ini tidak membuat omelan operator, masih sebuah upvote.
user2864740
5

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.

Doghound
sumber
Saya menambahkan @discardableResultke masing-masing fungsi ini untuk membungkam peringatan tentang nilai kembali yang tidak digunakan; jika tidak tepat apa yang saya cari.
Devin Lane
4

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.

Dániel Nagy
sumber
Dengan kata lain operasi ini terlalu mahal untuk digunakan?
Oleg Gordiichuk
2
github.com/apple/swift-evolution/blob/master/proposals/... di sini Anda dapat membacanya, tetapi ini bukan karena mahal, melainkan desain bahasa.
Dániel Nagy
Jadi saat saya andersen Swift akan menurunkan dukungan fitur C-style
Oleg Gordiichuk
2
@OlegGordiichuk saya akan mengatakan mereka ingin menekankan bahwa Swift bukan superset dari C tidak seperti Objective-C.
Dániel Nagy
1
@ Ya, banyak dari apa yang Anda katakan tidak masuk akal sama sekali. "Tidak berorientasi pada pengembang yang ada" dengan cara apa? Dengan cara yang sama bahwa Java tidak berorientasi pada pengembang PHP? "berorientasi pada mereka yang mungkin tidak memiliki kecenderungan untuk menjadi pengembang"? Ya, karena semua non-pengembang di luar sana menggigit tangan dengan pemrograman berorientasi protokol dan generik. "Cara mengaktifkan desain yang bagus" lihat saja SO, Anda akan melihat bahwa tidak ada bahasa pemrograman yang dapat "mengaktifkan desain yang baik".
Fogmeister
0
var value : Int = 1

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

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

Ini jelas merupakan kerugian, bukan?

orang buangan
sumber
5
Maksud Anda anggun seperti pada "Anda harus mengingat semua seluk-beluk bahasa pemrograman C, kalau tidak, tidak segera jelas apakah panggilan pertama mengembalikan 1 atau 2"? Saya pikir kita semua dapat meluangkan beberapa baris kode tambahan sebagai imbalan karena tidak menghabiskan beberapa menit menggaruk-garuk kepala kita mencoba menemukan penyebab bug oleh kesalahan konyol ...
Nicolas Miari
0

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
}
LimeRed
sumber
-3

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.

Elad Lavi
sumber