ตัวดำเนินการ“ ++” และ“ -” เลิกใช้ Xcode 7.3 แล้ว

ฉันกำลังดูโน้ต Xcode 7.3 และฉันสังเกตเห็นปัญหานี้

ตัวดำเนินการ ++ และ - ถูกเลิกใช้แล้ว

บางคนอธิบายได้ไหมว่าทำไมมันถึงถูกเลิก? และฉันขวาว่าในรุ่นใหม่ของ Xcode ตอนนี้คุณจะใช้แทนการ++นี้x += 1;

ตัวอย่าง:

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

คำอธิบายเต็มได้ที่นี่จากคริสแลตต์เนอร์ผู้สร้างสวิฟท์ ฉันจะสรุปประเด็น:

1. เป็นอีกฟังก์ชั่นหนึ่งที่คุณต้องเรียนรู้ขณะเรียนรู้ Swift
2. ไม่สั้นกว่า x += 1
3. สวิฟต์ไม่ใช่ซีไม่ควรพกมันไว้เพื่อโปรแกรมเมอร์ซี
4. การใช้งานหลักคือ C-style สำหรับ loop: for i = 0; i < n; i++ { ... }ซึ่ง Swift มีทางเลือกที่ดีกว่าเช่นfor i in 0..<n { ... }(C-style สำหรับ loop ออกไปเช่นกัน) )
5. อาจเป็นเรื่องยุ่งยากในการอ่านและบำรุงรักษาเช่นค่าของอะไร x - ++xหรือfoo(++x, x++)?
6. Chris Lattner ไม่ชอบ

สำหรับผู้ที่สนใจ (และเพื่อหลีกเลี่ยงการเน่าลิงก์) เหตุผลของ Lattner ในคำพูดของเขาคือ:

1. ตัวดำเนินการเหล่านี้เพิ่มภาระในการเรียนรู้ Swift เป็นภาษาโปรแกรมแรก - หรือกรณีอื่น ๆ ที่คุณไม่รู้จักตัวดำเนินการเหล่านี้จากภาษาอื่น

2. ข้อได้เปรียบที่แสดงออกของพวกเขานั้นน้อยมาก - x ++ นั้นสั้นกว่า x + = 1 ไม่มาก

3. Swift เบี่ยงเบนจาก C ไปแล้วโดยที่การดำเนินการ =, + = และการมอบหมายลักษณะอื่น ๆ จะส่งกลับเป็นโมฆะ (ด้วยเหตุผลหลายประการ) ตัวดำเนินการเหล่านี้ไม่สอดคล้องกับรุ่นนั้น

4. Swift มีคุณสมบัติที่มีประสิทธิภาพซึ่งกำจัดสาเหตุทั่วไปหลายประการที่คุณต้องใช้ ++ i ในรูปแบบ C สำหรับการวนซ้ำในภาษาอื่น ๆ ดังนั้นสิ่งเหล่านี้จึงถูกใช้งานไม่บ่อยนักในรหัส Swift ที่เขียนขึ้นอย่างดี คุณสมบัติเหล่านี้รวมถึงการวนลูปใน, ช่วง, แจกแจง, แผนที่ ฯลฯ

5. รหัสที่ใช้ค่าผลลัพธ์ของตัวดำเนินการเหล่านี้มักทำให้เกิดความสับสนและบอบบางต่อผู้อ่าน / ผู้ดูแลรหัส พวกเขาสนับสนุนให้รหัส "ยุ่งยากมากเกินไป" ซึ่งอาจจะน่ารัก แต่ยากที่จะเข้าใจ

6. ในขณะที่ Swift มีลำดับการประเมินที่ดีรหัสใด ๆ ที่ขึ้นอยู่กับมัน (เช่น foo (++ a, a ++)) จะไม่เป็นที่พึงปรารถนาแม้ว่าจะถูกกำหนดไว้อย่างดีก็ตาม

7. ตัวดำเนินการเหล่านี้สามารถใช้ได้กับประเภทค่อนข้างน้อย: สเกลาร์จำนวนเต็มและทศนิยมและแนวคิดคล้ายตัววนซ้ำ ไม่สามารถใช้กับตัวเลขที่ซับซ้อนการฝึกอบรมและอื่น ๆ

ในที่สุดสิ่งเหล่านี้ทำให้เมตริกของ "ถ้าเราไม่มีสิ่งเหล่านี้เราจะเพิ่มใน Swift 3 หรือไม่"

ฉันรู้ว่าความคิดเห็นนี้ไม่ได้ตอบคำถาม แต่อาจมีคนที่กำลังมองหาวิธีแก้ปัญหาเพื่อให้ผู้ปฏิบัติงานเหล่านี้ทำงานได้และวิธีการแก้ปัญหาดังกล่าวสามารถพบได้ที่ด้านล่าง😇

โดยส่วนตัวแล้วฉันชอบ++และ--ผู้ประกอบการ ฉันไม่สามารถเห็นด้วยกับความเห็นที่ว่าพวกเขามีเล่ห์เหลี่ยมหรือยากที่จะจัดการ เมื่อนักพัฒนาเข้าใจสิ่งที่ผู้ประกอบการเหล่านี้ทำ (และเรากำลังพูดถึงเรื่องที่ค่อนข้างง่าย) โค้ดควรจะชัดเจนมาก

ในคำอธิบายว่าทำไมผู้ประกอบการถูกคัดค้านกล่าวถึงว่าการใช้งานหลักของพวกเขาในรูปแบบ C สำหรับลูป ฉันไม่รู้เกี่ยวกับคนอื่น แต่โดยส่วนตัวแล้วฉันไม่ได้ใช้ลูปแบบ C เลยและยังมีสถานที่หรือสถานการณ์อื่น ๆ อีกมากมายเมื่อ++หรือ--ผู้ปฏิบัติงานมีประโยชน์

ฉันต้องการพูดถึงว่าvarName++ส่งคืนค่าเพื่อให้สามารถใช้ในreturnขณะที่varName += 1ไม่สามารถ

สำหรับคุณที่ต้องการให้ผู้ให้บริการเหล่านี้ทำงานที่นี่เป็นวิธีแก้ปัญหา:

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 ได้ทำการลบ ++และทำให้มันง่ายขึ้นด้วยวิธีดั้งเดิมแบบเก่า

แทน +++=คุณจะต้องเขียน

ตัวอย่าง:

var x = 1

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

ในทำนองเดียวกันสำหรับผู้ประกอบการลดลง--คุณต้องเขียน-=

ตัวอย่าง:

var x = 1

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

สำหรับ forลูป:

ตัวอย่างที่เพิ่มขึ้น:

แทน

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

คุณสามารถเขียน:

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

ตัวอย่างการลดลง:

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

คุณสามารถเขียน:

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

หวังว่านี่จะช่วยได้!

Chris Lattner ทำสงครามกับ ++ และ - เขาเขียนว่า“ รหัสที่ใช้ค่าผลลัพธ์ของโอเปอเรเตอร์เหล่านี้มักสับสนและละเอียดอ่อนต่อผู้อ่าน / ผู้ดูแลรหัส พวกเขาสนับสนุนให้ใช้รหัส "ที่ยุ่งยากมากเกินไป" ซึ่งอาจจะน่ารัก แต่ยากที่จะเข้าใจ ... ในขณะที่ Swift ได้กำหนดลำดับการประเมินไว้อย่างดีรหัสใด ๆ ที่ขึ้นอยู่กับมัน (เช่น foo (++ a, a ++)) จะไม่เป็นที่พึงปรารถนา มีการกำหนดชัดเจน…สิ่งเหล่านี้ไม่สามารถวัด“ ถ้าเราไม่มีสิ่งเหล่านี้เราจะเพิ่มใน Swift 3 หรือไม่””

แอปเปิ้ลต้องการให้ภาษาสะอาด, ชัดเจน, ไม่สับสนและรวดเร็วตรงไปตรงมา ดังนั้นพวกเขาจึงเลิกใช้ ++ และ - คำหลัก

The Fix-it featureof Xcode ให้คำตอบที่ชัดเจนสำหรับเรื่องนี้

แทนที่++ increment operatorด้วยแบบเก่าvalue += 1(ตัวดำเนินการมือสั้น) และ-- decrement operatorด้วยvalue -= 1

สำหรับ Swift 4 คุณสามารถกู้คืน++และ--ตัวดำเนินการเป็นส่วนขยายIntและประเภทอื่น ๆ นี่คือตัวอย่าง:

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

มันทำงานในลักษณะเดียวกันประเภทอื่น ๆ เช่นUIInt, Int8, Float, Doubleฯลฯ

คุณสามารถวางส่วนขยายเหล่านี้ในไฟล์เดียวในไดเรกทอรีรากของคุณและจะสามารถใช้งานได้ภายในไฟล์อื่น ๆ ของคุณที่นั่น

ฉันสังเกตเห็นการลงคะแนนสองสามครั้งสำหรับคำตอบที่นี่เกือบจะทันทีที่ฉันโพสต์ไว้ ซึ่งฉันใช้เป็นข้อขัดแย้งทางปรัชญามากกว่าการวิจารณ์ว่ารหัสของฉันทำงานอย่างไร มันทำงานได้อย่างสมบูรณ์แบบถ้าคุณตรวจสอบในสนามเด็กเล่น

เหตุผลที่ฉันโพสต์คำตอบนี้เป็นเพราะฉันไม่เห็นด้วยกับการทำให้ภาษาการเขียนโปรแกรมคอมพิวเตอร์แตกต่างกันโดยไม่จำเป็น

การมีความคล้ายคลึงกันมากระหว่างภาษาทำให้พวกเขาเรียนรู้และสลับจากภาษาหนึ่งไปอีกภาษาหนึ่งได้ง่ายขึ้น

นักพัฒนามักใช้ภาษาการเขียนโปรแกรมหลายภาษามากกว่าหนึ่งภาษา และเป็นเรื่องยุ่งยากที่จะเปลี่ยนจากภาษาหนึ่งเป็นอีกภาษาหนึ่งเมื่อไม่มีการประชุมและไม่มีมาตรฐานทั่วไปในทุกภาษา

ฉันเชื่อว่าควรมีความแตกต่างทางไวยากรณ์ระหว่างภาษาเท่าที่จำเป็นเท่านั้นและไม่มากไปกว่านี้

นี่คือรหัสทั่วไปบางเวอร์ชันที่โพสต์แล้ว ฉันต้องการแสดงความกังวลเช่นเดียวกับคนอื่น ๆ : มันเป็นแนวปฏิบัติที่ดีที่สุดที่จะไม่ใช้สิ่งเหล่านี้ใน Swift ฉันยอมรับว่าอาจทำให้ผู้ที่อ่านรหัสของคุณสับสนในอนาคต

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
}

ซึ่งสามารถเขียนเป็นส่วนขยายบนชนิดตัวเลขได้

จากเอกสาร :

ตัวดำเนินการเพิ่ม / ลดลงใน Swift ถูกเพิ่มเข้ามาเร็วมากในการพัฒนาของ Swift ในฐานะที่เป็นการส่งมอบจาก C สิ่งเหล่านี้ถูกเพิ่มเข้ามาโดยไม่คำนึงถึงมากนักและยังไม่ได้คิดมากนับตั้งแต่นั้นมา เอกสารนี้ให้ภาพลักษณ์ใหม่แก่พวกเขาและในที่สุดเราก็แนะนำให้เราลบมันอย่างสิ้นเชิงเนื่องจากสับสนและไม่ถือน้ำหนัก

var value : Int = 1

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

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

นี่เป็นข้อเสียแน่นอน

เนื่องจากคุณไม่เคยทำงานจริงๆกับคำแนะนำในสวิฟท์ก็เลยทำให้รู้สึกที่จะลบ++และ--ผู้ประกอบการในความคิดของฉัน อย่างไรก็ตามหากคุณขาดไม่ได้คุณสามารถเพิ่มประกาศSwift 5+เหล่านี้ในโครงการของคุณ:

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

ใน Swift 4.1 สามารถทำได้ด้วยวิธีนี้:

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

โปรดสังเกตว่าแม้จะมีความจริงที่ว่าโซลูชันนี้คล้ายกับโซลูชันก่อนหน้าในโพสต์นี้พวกเขาไม่ทำงานอีกต่อไปใน Swift 4.1 และตัวอย่างนี้ทำ นอกจากนี้โปรดสังเกตว่าใครก็ตามที่กล่าวถึงข้างต้นว่า + = เป็นการแทนที่สำหรับ ++ เพียงแค่ไม่เข้าใจตัวดำเนินการเช่น ++ ที่รวมกับการกำหนดเป็นสองการดำเนินการจริง ๆ ดังนั้นทางลัด ในตัวอย่างของฉัน:var s = t++ทำสองสิ่ง: กำหนดค่าของ t ให้ s แล้วเพิ่มที ถ้า ++ มาก่อนมันเป็นการดำเนินการสองรายการเดียวกันในลำดับที่กลับรายการ ตามความเห็นของฉันเหตุผลของ Apple เกี่ยวกับสาเหตุที่ต้องลบโอเปอเรเตอร์นี้ (กล่าวถึงในคำตอบก่อนหน้า) ไม่เพียง แต่มีเหตุผลที่ผิดพลาดเท่านั้น แต่ฉันเชื่อว่ามันเป็นเรื่องโกหกและเหตุผลที่แท้จริงคือ มันทำให้พวกเขามีปัญหาในรุ่นก่อนหน้าดังนั้นพวกเขาจึงยอมแพ้ ตรรกะของ "ซับซ้อนเกินกว่าที่จะเข้าใจตัวดำเนินการดังนั้นการลบ" จึงเป็นเรื่องโกหกเพราะ Swift มีตัวดำเนินการที่ซับซ้อนและมีประโยชน์น้อยกว่าซึ่งไม่ได้ลบออก นอกจากนี้ภาษาโปรแกรมส่วนใหญ่ก็มีเช่นกัน JavaScript, C, C #, Java, C ++ และอีกมากมาย โปรแกรมเมอร์ใช้อย่างมีความสุข ใครก็ตามที่ยากเกินไปที่จะเข้าใจตัวดำเนินการนี้

กลยุทธ์ที่อยู่เบื้องหลัง Swift นั้นง่าย: Apple เชื่อว่าโปรแกรมเมอร์นั้นเป็นคนโง่ดังนั้นจึงควรได้รับการปฏิบัติตาม

ความจริงก็คือ Swift ที่เปิดตัวเมื่อเดือนกันยายน 2014 น่าจะเป็นที่อื่นในตอนนี้ ภาษาอื่น ๆ โตเร็วกว่ามาก

ฉันสามารถแสดงรายการข้อผิดพลาดที่สำคัญมากมายในภาษาจากสิ่งที่ร้ายแรง: เช่นอาร์เรย์ที่วางโดยค่าและไม่ใช่โดยการอ้างอิงถึงสิ่งที่น่ารำคาญ: ฟังก์ชั่นพารามิเตอร์ผันแปรไม่สามารถยอมรับอาร์เรย์ที่เป็นแนวคิดทั้งหมดที่อยู่เบื้องหลัง ฉันไม่คิดว่าพนักงานของ Apple จะได้รับอนุญาตให้ดูภาษาอื่นเช่น Java ดังนั้นพวกเขาจึงไม่รู้ด้วยซ้ำว่า Apple นั้นล้าหลังหลายปี Apple อาจใช้ภาษาจาวาเป็นภาษา แต่ทุกวันนี้ความท้าทายไม่ใช่เทคโนโลยี แต่เป็นอัตตา หากพวกเขาจะเปิด IntelliJ เพื่อเขียน Java พวกเขาจะต้องปิดความเข้าใจในธุรกิจของพวกเขาอย่างแน่นอนว่า ณ จุดนี้พวกเขาไม่สามารถและจะไม่ทัน