Các nhà khai thác của C ++ ++ và các nhà mạng - đã bị từ chối Xcode 7.3

Tôi đang xem các ghi chú Xcode 7.3 và tôi nhận thấy vấn đề này.

Các toán tử ++ và - không được dùng nữa

Ai đó có thể giải thích tại sao nó bị phản đối? Và tôi có đúng rằng trong phiên bản Xcode mới bây giờ bạn sẽ sử dụng thay vì ++cái này x += 1;

Thí dụ:

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

Một lời giải thích đầy đủ ở đây từ Chris Lattner, người tạo ra Swift. Tôi sẽ tóm tắt các điểm:

1. Đó là một chức năng khác bạn phải học khi học Swift
2. Không ngắn hơn nhiều x += 1
3. Swift không phải C. Không nên mang chúng đi chỉ để làm hài lòng các lập trình viên C
4. Công dụng chính của nó là theo kiểu vòng lặp C for i = 0; i < n; i++ { ... }:, trong đó Swift có các lựa chọn thay thế tốt hơn, như for i in 0..<n { ... }(kiểu vòng lặp C cũng sẽ xuất hiện )
5. Có thể khó đọc và duy trì, ví dụ, giá trị của x - ++xhoặc là foo(++x, x++)gì?
6. Chris Lattner không thích nó.

Đối với những người quan tâm (và để tránh thối liên kết), lý do của Lattner theo cách riêng của anh ta là:

1. Các toán tử này tăng gánh nặng học Swift như một ngôn ngữ lập trình đầu tiên - hoặc bất kỳ trường hợp nào khác mà bạn chưa biết các toán tử này từ một ngôn ngữ khác.

2. Lợi thế biểu cảm của họ là tối thiểu - x ++ không ngắn hơn nhiều so với x + = 1.

3. Swift đã đi chệch khỏi C trong đó các hoạt động =, + = và các hoạt động giống như chuyển nhượng khác trả về Void (vì một số lý do). Các toán tử này không phù hợp với mô hình đó.

4. Swift có các tính năng mạnh mẽ loại bỏ nhiều lý do phổ biến mà bạn sử dụng ++ i theo kiểu C cho vòng lặp trong các ngôn ngữ khác, vì vậy những lý do này được sử dụng tương đối ít trong mã Swift được viết tốt. Các tính năng này bao gồm vòng lặp for-in, phạm vi, liệt kê, bản đồ, v.v.

5. Mã thực sự sử dụng giá trị kết quả của các toán tử này thường gây nhầm lẫn và tinh tế cho người đọc / người duy trì mã. Họ khuyến khích mã "quá khó" có thể dễ thương, nhưng khó hiểu.

6. Mặc dù Swift có thứ tự đánh giá được xác định rõ, bất kỳ mã nào phụ thuộc vào nó (như foo (++ a, a ++)) sẽ không mong muốn ngay cả khi nó được xác định rõ.

7. Các toán tử này có thể áp dụng cho tương đối ít loại: vô hướng số nguyên và dấu phẩy động và các khái niệm giống như trình lặp. Chúng không áp dụng cho số phức, ma trận, v.v.

Cuối cùng, những điều này thất bại trong số liệu "nếu chúng ta chưa có những thứ này, liệu chúng ta có thêm chúng vào Swift 3 không?"

Tôi nhận ra rằng nhận xét này không trả lời câu hỏi tuy nhiên có thể có người đang tìm giải pháp làm thế nào để giữ cho các nhà khai thác này hoạt động và một giải pháp như vậy có thể được tìm thấy ở phía dưới. 😇

Cá nhân tôi thích ++và --điều hành. Tôi không thể đồng ý với ý kiến ​​rằng chúng khó hoặc khó quản lý. Một khi nhà phát triển hiểu những gì các nhà khai thác này làm (và chúng ta đang nói về những thứ khá đơn giản), mã sẽ rất rõ ràng.

Trong phần giải thích lý do tại sao các toán tử bị phản đối được đề cập rằng việc sử dụng chính của chúng là theo kiểu C cho các vòng lặp. Tôi không biết về người khác nhưng cá nhân tôi hoàn toàn không sử dụng các vòng kiểu C và vẫn còn nhiều địa điểm hoặc tình huống khác khi ++hoặc --nhà điều hành hữu ích.

Tôi cũng muốn đề cập rằng varName++trả về một giá trị để nó có thể được sử dụng trong returnkhi varName += 1không thể.

Đối với bất kỳ ai trong số các bạn muốn giữ các nhà khai thác này làm việc ở đây là giải pháp:

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 đã loại bỏ ++và làm cho nó đơn giản hơn nhiều với một cách truyền thống cũ khác.

Thay vì ++, bạn cần phải viết +=.

Thí dụ:

var x = 1

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

Tương tự cho toán tử giảm dần --, bạn cần viết-=

Thí dụ:

var x = 1

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

Đối với forcác vòng lặp:

Ví dụ tăng:

Thay vì

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

Bạn có thể viết:

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

Ví dụ giảm:

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

Bạn có thể viết:

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

Hi vọng điêu nay co ich!

Chris Lattner đã chiến đấu chống lại ++ và -. Ông viết, Mã Code thực sự sử dụng giá trị kết quả của các toán tử này thường gây nhầm lẫn và tinh tế cho người đọc / người duy trì mã. Họ khuyến khích mã quá phức tạp, mã này có thể dễ thương, nhưng khó hiểu, đó là. đã được xác định rõ ràng những điều này làm thất bại số liệu của nếu chúng ta chưa có những thứ này, liệu chúng ta có thêm chúng vào Swift 3 không?

Apple muốn giữ cho ngôn ngữ sạch sẽ, rõ ràng, không khó hiểu và thẳng thắn. Và vì vậy họ không tán thành ++ và - từ khóa.

Các Fix-it featurecủa Xcode cho câu trả lời rõ ràng cho điều này.

Thay thế ++ increment operatorbằng kiểu cũ value += 1(toán tử tay ngắn) và -- decrement operatorbằngvalue -= 1

Đối với Swift 4, bạn có thể khôi phục ++và các --toán tử dưới dạng tiện ích mở rộng cho Intvà các loại khác. Đây là một ví dụ:

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

Nó hoạt động theo cùng một cách với nhiều loại khác, chẳng hạn như UIInt, Int8, Float, Doublevv

Bạn có thể dán các phần mở rộng này vào một tệp trong thư mục gốc của mình và chúng sẽ có sẵn để sử dụng bên trong tất cả các tệp khác của bạn ở đó.

Tôi đã nhận thấy một vài phiếu bầu cho câu trả lời của tôi ở đây, gần như ngay sau khi tôi đăng nó. Mà tôi coi là một sự bất đồng về triết học, hơn là chỉ trích về cách thức hoạt động của bộ quy tắc của tôi. Nó hoạt động hoàn hảo, nếu bạn kiểm tra nó trong một sân chơi.

Lý do tại sao tôi đăng câu trả lời này là vì tôi không đồng ý với việc làm cho các ngôn ngữ lập trình máy tính khác biệt một cách không cần thiết với nhau.

Có nhiều điểm tương đồng giữa các ngôn ngữ giúp mọi người dễ học hơn và chuyển từ ngôn ngữ này sang ngôn ngữ khác.

Các nhà phát triển thường sử dụng một số ngôn ngữ lập trình, thay vì chỉ một ngôn ngữ. Và thật rắc rối khi chuyển từ ngôn ngữ này sang ngôn ngữ khác, khi không có quy ước và không có tiêu chuẩn hóa chung giữa các ngôn ngữ.

Tôi tin rằng nên có sự khác biệt về cú pháp giữa các ngôn ngữ chỉ khi cần thiết, và không nhiều hơn thế.

Đây là một phiên bản chung của một số mã được đăng cho đến nay. Tôi sẽ nói lên những mối quan tâm giống như những người khác: đó là cách tốt nhất để không sử dụng những thứ này trong Swift. Tôi đồng ý rằng điều này có thể gây nhầm lẫn cho những người đọc mã của bạn trong tương lai.

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
}

Điều này cũng có thể được viết dưới dạng một phần mở rộng trên loại Số.

Từ các tài liệu :

Các toán tử tăng / giảm trong Swift đã được thêm vào từ rất sớm trong quá trình phát triển Swift, vì một sự chuyển đổi từ C. Chúng được thêm vào mà không cần quan tâm nhiều, và từ đó đã không được nghĩ đến nhiều. Tài liệu này cung cấp một cái nhìn mới về chúng, và cuối cùng khuyên chúng ta chỉ nên loại bỏ chúng hoàn toàn, vì chúng gây nhầm lẫn và không mang trọng lượng của chúng.

var value : Int = 1

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

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

Đây chắc chắn là một nhược điểm, phải không?

Vì bạn không bao giờ thực sự làm việc với các con trỏ trong Swift, nên theo ý kiến ​​của tôi là loại bỏ các toán tử ++và --toán tử. Tuy nhiên, nếu bạn không thể sống thiếu, bạn có thể thêm các khai báo toán tử Swift 5+ này vào dự án của mình:

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

Trong Swift 4.1, nó có thể đạt được theo cách này:

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

Lưu ý rằng mặc dù thực tế là giải pháp này tương tự như các giải pháp trước đây trong bài đăng này, chúng không hoạt động nữa trong Swift 4.1 và ví dụ này có. Cũng lưu ý rằng bất kỳ ai ở trên đều đề cập rằng + = là sự thay thế cho ++, chỉ không hiểu đầy đủ về toán tử vì ++ kết hợp với gán thực sự là hai thao tác, do đó là một phím tắt. Trong ví dụ của tôi:var s = t++thực hiện hai điều: gán giá trị của t cho s và sau đó tăng t. Nếu ++ xuất hiện trước, thì đó là hai thao tác được thực hiện theo thứ tự đảo ngược. Theo ý kiến ​​của tôi, lý do của Apple về lý do loại bỏ toán tử này (đã được đề cập trong các câu trả lời trước), không chỉ là lý do sai mà hơn nữa tôi tin rằng đó là một lời nói dối và lý do thực sự là họ không thể khiến trình biên dịch của họ xử lý nó. Nó đã cho họ những rắc rối trong các phiên bản trước để họ từ bỏ. Logic của "quá phức tạp để hiểu toán tử, do đó bị loại bỏ" rõ ràng là một lời nói dối bởi vì Swift chứa các toán tử phức tạp hơn nhiều và ít hữu ích hơn mà không bị loại bỏ. Ngoài ra, phần lớn các ngôn ngữ lập trình có nó. JavaScript, C, C #, Java, C ++ và nhiều hơn nữa. Các lập trình viên vui vẻ sử dụng nó. Bất cứ ai cũng quá khó để hiểu toán tử này,

Chiến lược đằng sau Swift rất đơn giản: Apple tin rằng lập trình viên bị câm và do đó nên được đối xử phù hợp.

Sự thật là Swift, được ra mắt vào tháng 9 năm 2014 được cho là ở một nơi khác vào lúc này. Các ngôn ngữ khác lớn lên nhanh hơn nhiều.

Tôi có thể liệt kê nhiều lỗi chính trong ngôn ngữ, từ những lỗi nghiêm trọng: chẳng hạn như mảng được dán theo giá trị và không tham chiếu, đến lỗi khó chịu: các hàm tham số matrixdic không thể chấp nhận một mảng là toàn bộ ý tưởng đằng sau nó. Tôi không nghĩ rằng các nhân viên của Apple thậm chí còn được phép xem xét các ngôn ngữ khác như Java để họ thậm chí không biết rằng Apple chậm hơn nhiều năm. Apple có thể đã chấp nhận Java như một ngôn ngữ nhưng ngày nay, thách thức không phải là công nghệ, mà là bản ngã. Nếu họ đã mở IntelliJ để viết một số Java, họ chắc chắn sẽ đóng cửa sự hiểu biết kinh doanh của họ rằng tại thời điểm này, họ không thể và sẽ không bắt kịp bao giờ.