Swift Academy · Pelajaran

Mutasi dan Penetapan Semula self

Gantikan keseluruhan self daripada kaedah mutating.

Pelajaran 3 daripada 413 langkah

Mutasi dan Penetapan Semula self ialah pelajaran Swift Academy percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Swift Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Swift Academy merangkumi sejumlah 4 pelajaran.

Menetapkan Semula Diri

Dalam kaedah mutating, Anda boleh menetapkan nilai baharu sepenuhnya kepada self, lalu menggantikan keseluruhan instans.

struct Point {
    var x = 0
    var y = 0
    mutating func reset() {
        self = Point(x: 0, y: 0)
    }
}
var p = Point(x: 3, y: 4)
p.reset()
print(p.x, p.y)

Mengapa Diri Ditetapkan Semula

Menetapkan semula self berguna apabila keadaan baharu lebih mudah dinyatakan sebagai instans baharu berbanding menyunting medan satu demi satu.

struct Vector {
    var dx: Int
    var dy: Int
    mutating func negate() {
        self = Vector(dx: -dx, dy: -dy)
    }
}
var v = Vector(dx: 2, dy: -3)
v.negate()
print(v.dx, v.dy)

Enumerasi Menetapkan Semula Diri

Bagi enumerasi, penukaran kes dilakukan dengan menetapkan kes baharu kepada self.

enum State {
    case idle, running, done
    mutating func advance() {
        switch self {
        case .idle: self = .running
        case .running: self = .done
        case .done: self = .done
        }
    }
}
var s = State.idle
s.advance()
s.advance()
print(s)

Setara dengan Menyunting Medan

Menetapkan self = Point(x: 1, y: 1) setara dengan menetapkan x dan y secara berasingan, cuma lebih ringkas.

struct Point {
    var x = 0
    var y = 0
    mutating func setBoth(_ n: Int) {
        self = Point(x: n, y: n)
    }
}
var p = Point()
p.setBoth(7)
print(p.x, p.y)

Membaca Diri Lama Dahulu

Anda boleh mengira instans baharu daripada instans semasa sebelum menetapkannya semula.

struct Counter {
    var value: Int
    mutating func doubled() {
        self = Counter(value: value * 2)
    }
}
var c = Counter(value: 5)
c.doubled()
print(c.value)

Transformasi Gaya Pembina

Penetapan semula diri membolehkan kaedah menyatakan transformasi lengkap dalam satu langkah.

struct Temperature {
    var celsius: Double
    mutating func toRounded() {
        self = Temperature(celsius: celsius.rounded())
    }
}
var t = Temperature(celsius: 21.7)
t.toRounded()
print(t.celsius)

Hanya dalam Kaedah mutating

Anda hanya boleh menetapkan self dalam kaedah yang ditandai sebagai mutating. Kaedah biasa tidak boleh berbuat demikian.

struct Flag {
    var on = false
    mutating func turnOn() {
        self = Flag(on: true)
    }
}
var f = Flag()
f.turnOn()
print(f.on)

Menggabungkan dengan Logik

Anda boleh membuat cabang dan menetapkan semula self hanya dalam keadaan tertentu.

struct Score {
    var points: Int
    mutating func clamp() {
        if points > 100 {
            self = Score(points: 100)
        }
    }
}
var s = Score(points: 150)
s.clamp()
print(s.points)

Corak Togol Enumerasi

Togol enumerasi dengan dua kes ialah contoh klasik penetapan semula diri.

enum Switch {
    case off, on
    mutating func flip() {
        self = (self == .off) ? .on : .off
    }
}
var sw = Switch.off
sw.flip()
print(sw)

Tiada Kesan pada Salinan Lain

Menetapkan semula self hanya mengubah instans ini. Salinan nilai yang lain kekal tidak berubah.

struct Box { var n: Int; mutating func zero() { self = Box(n: 0) } }
var a = Box(n: 5)
var b = a
a.zero()
print(a.n, b.n)

Niat yang Jelas

Gunakan penetapan semula diri apabila transformasi itu menjadi jelas; gunakan suntingan medan apabila hanya satu sifat berubah.

struct Pair {
    var a: Int
    var b: Int
    mutating func swapValues() {
        self = Pair(a: b, b: a)
    }
}
var p = Pair(a: 1, b: 2)
p.swapValues()
print(p.a, p.b)

Semakan Pantas

Uji penetapan semula diri.

Imbas Kembali

Dalam kaedah mutating, Anda boleh menetapkan nilai baharu sepenuhnya kepada self, lalu menggantikan instans tersebut. Cara ini ringkas untuk transformasi lengkap dan merupakan cara enumerasi menukar kes. Kesan perubahan hanya pada instans ini, bukan pada salinan lain.

enum T { case a, b; mutating func go() { self = .b } }
var t = T.a
t.go()
print(t)
Percuma untuk bermula

Pelajari Swift dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus
122
Pelajaran
409

Soalan Lazim

Adakah pelajaran “Mutasi dan Penetapan Semula self” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Swift Academy, termasuk “Mutasi dan Penetapan Semula self”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Swift Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Mutasi dan Penetapan Semula self”?

Gantikan keseluruhan self daripada kaedah mutating. Anda berlatih Swift Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Swift Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Swift Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “Mutasi dan Penetapan Semula self” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Swift Academy ini?

Ya. Setiap pelajaran Swift Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

  1. Jenis Nilai dan Ketidakbolehubahan
  2. Kata Kunci mutating
  3. Mutasi dan Penetapan Semula self
  4. Alternatif Tanpa Mutasi
← Kembali ke Swift Academy