Properti NSString: salin atau simpan?

Katakanlah saya memiliki kelas yang dipanggil SomeClassdengan stringnama properti:

@interface SomeClass : NSObject
{
    NSString* name;
}

@property (nonatomic, retain) NSString* name;

@end

Saya mengerti bahwa nama dapat diberikan NSMutableStringdalam hal ini dapat menyebabkan perilaku yang salah.

• Untuk string secara umum, apakah selalu lebih baik menggunakan copyatribut bukan retain?
• Apakah properti "yang disalin" dengan cara apa pun kurang efisien daripada properti "yang dipertahankan-ed" seperti itu?

Untuk atribut yang tipenya adalah kelas nilai tidak berubah yang sesuai dengan NSCopyingprotokol, Anda hampir selalu harus menentukan copydalam @propertydeklarasi Anda . Menentukan retainadalah sesuatu yang hampir tidak pernah Anda inginkan dalam situasi seperti itu.

Inilah mengapa Anda ingin melakukan itu:

NSMutableString *someName = [NSMutableString stringWithString:@"Chris"];

Person *p = [[[Person alloc] init] autorelease];
p.name = someName;

[someName setString:@"Debajit"];

Nilai Person.nameproperti saat ini akan berbeda tergantung pada apakah properti itu dinyatakan retainatau copy- itu akan menjadi @"Debajit"jika properti ditandai retain, tetapi @"Chris"jika properti ditandai copy.

Karena di hampir semua kasus Anda ingin mencegah mutasi atribut objek di belakangnya, Anda harus menandai properti yang mewakili mereka copy. (Dan jika Anda menulis sendiri penyetel alih-alih menggunakan, @synthesizeAnda harus ingat untuk benar-benar menggunakannya copydaripada retaindi dalamnya.)

Salinan harus digunakan untuk NSString. Jika itu Mutable, maka itu akan disalin. Jika tidak, maka hanya akan dipertahankan. Tepatnya semantik yang Anda inginkan dalam suatu aplikasi (biarkan tipe melakukan yang terbaik).

Untuk string secara umum, apakah selalu lebih baik menggunakan atribut copy daripada mempertahankan?

Ya - secara umum selalu menggunakan atribut salin.

Ini karena properti NSString Anda dapat melewati instance NSString atau instance NSMutableString , dan oleh karena itu kami tidak dapat benar-benar menentukan apakah nilai yang diteruskan adalah objek yang tidak dapat diubah atau dapat diubah.

Apakah properti "yang disalin" dengan cara apa pun kurang efisien daripada properti "yang dipertahankan-ed" seperti itu?

• Jika properti Anda diberikan instance NSString , jawabannya adalah " Tidak " - penyalinan tidak kurang efisien daripada mempertahankan.
  (Ini tidak kalah efisien karena NSString cukup pintar untuk tidak benar-benar melakukan salinan.)

• Jika properti Anda lulus instance NSMutableString maka jawabannya adalah " Ya " - menyalin kurang efisien daripada mempertahankan.
  (Ini kurang efisien karena alokasi memori dan penyalinan yang sebenarnya harus terjadi, tetapi ini mungkin hal yang diinginkan.)

• Secara umum, properti "yang disalin" memiliki potensi untuk menjadi kurang efisien - namun melalui penggunaan NSCopyingprotokol, dimungkinkan untuk mengimplementasikan kelas yang "sama efisien" untuk disalin dan dipertahankan. Contoh NSString adalah contoh dari ini.

Secara umum (bukan hanya untuk NSString), kapan saya harus menggunakan "copy" daripada "retain"?

Anda harus selalu menggunakan copyketika Anda tidak ingin keadaan internal properti berubah tanpa peringatan. Bahkan untuk objek yang tidak dapat diubah - objek yang tidak dapat diubah yang ditulis dengan benar akan menangani penyalinan secara efisien (lihat bagian selanjutnya tentang kekekalan dan NSCopying).

Mungkin ada alasan kinerja untuk retainobjek, tetapi itu datang dengan overhead pemeliharaan - Anda harus mengelola kemungkinan keadaan internal berubah di luar kode Anda. Seperti yang mereka katakan - optimalkan yang terakhir.

Tapi, saya menulis kelas saya menjadi tidak berubah - tidak bisakah saya "mempertahankan" saja?

Tidak digunakan copy. Jika kelas Anda benar-benar tidak dapat diubah maka praktik terbaik untuk menerapkan NSCopyingprotokol untuk membuat kelas Anda kembali sendiri ketika copydigunakan. Jika kamu melakukan ini:

• Pengguna kelas Anda yang lain akan mendapatkan manfaat kinerja saat mereka menggunakannya copy.
• The copypenjelasan membuat kode Anda sendiri lebih dipertahankan - yang copypenjelasan menunjukkan bahwa Anda benar-benar tidak perlu khawatir tentang objek ini mengubah negara tempat lain.

Saya mencoba mengikuti aturan sederhana ini:

• Apakah saya ingin mempertahankan nilai objek pada titik waktu ketika saya menugaskannya ke properti saya? Gunakan salinan .

• Apakah saya ingin berpegang pada objek dan saya tidak peduli apa nilai internal saat ini atau di masa depan? Gunakan yang kuat (pertahankan).

Sebagai ilustrasi: Apakah saya ingin berpegang pada nama "Lisa Miller" ( copy ) atau saya ingin berpegang pada orang yang bernama Lisa Miller ( kuat )? Namanya mungkin kemudian berubah menjadi "Lisa Smith", tetapi dia akan tetap menjadi orang yang sama.

Melalui contoh ini salin dan simpan dapat dijelaskan seperti:

NSMutableString *someName = [NSMutableString stringWithString:@"Chris"];

Person *p = [[[Person alloc] init] autorelease];
p.name = someName;

[someName setString:@"Debajit"];

jika properti itu tipe copy maka,

salinan baru akan dibuat untuk [Person name]string yang akan menampung konten someNamestring. Sekarang setiap operasi pada someNamestring tidak akan berpengaruh [Person name].

[Person name]dan someNamestring akan memiliki alamat memori yang berbeda.

Tetapi dalam hal mempertahankan,

keduanya [Person name]akan memiliki alamat memori yang sama dengan string somename, hanya jumlah penahan string somename yang akan bertambah 1.

Jadi setiap perubahan dalam string nama wanita akan tercermin dalam [Person name]string.

Tentunya menempatkan 'copy' pada deklarasi properti terbang di muka menggunakan lingkungan berorientasi objek di mana objek pada heap dilewatkan dengan referensi - salah satu manfaat yang Anda dapatkan di sini adalah bahwa, ketika mengubah suatu objek, semua referensi ke objek itu lihat perubahan terbaru. Banyak bahasa yang menyediakan kata kunci 'ref' atau sejenis untuk memungkinkan tipe nilai (yaitu struktur di stack) mendapat manfaat dari perilaku yang sama. Secara pribadi, saya akan menggunakan salinan hemat, dan jika saya merasa bahwa nilai properti harus dilindungi dari perubahan yang dilakukan pada objek tempat ia ditugaskan, saya bisa memanggil metode salin objek itu selama penugasan, misalnya:

p.name = [someName copy];

Tentu saja, ketika mendesain objek yang berisi properti itu, hanya Anda yang akan tahu apakah desain mendapat manfaat dari pola tempat penugasan mengambil salinan - Cocoawithlove.com memiliki yang berikut ini untuk mengatakan:

"Anda harus menggunakan copy accessor ketika parameter setter mungkin bisa berubah tetapi Anda tidak bisa mengubah status internal suatu properti tanpa peringatan " - jadi penilaian apakah Anda dapat mempertahankan nilai untuk berubah secara tak terduga adalah milik Anda sendiri. Bayangkan skenario ini:

//person object has details of an individual you're assigning to a contact list.

Contact *contact = [[[Contact alloc] init] autorelease];
contact.name = person.name;

//person changes name
[[person name] setString:@"new name"];
//now both person.name and contact.name are in sync.

Dalam hal ini, tanpa menggunakan salinan, objek kontak kami mengambil nilai baru secara otomatis; jika kami menggunakannya, kami harus memastikan secara manual bahwa perubahan terdeteksi dan disinkronkan. Dalam hal ini, mempertahankan semantik mungkin diinginkan; di tempat lain, salinan mungkin lebih sesuai.

@interface TTItem : NSObject    
@property (nonatomic, copy) NSString *name;
@end

{
    TTItem *item = [[TTItem alloc] init];    
    NSString *test1 = [NSString stringWithFormat:@"%d / %@", 1, @"Go go go"];  
    item.name = test1;  
    NSLog(@"-item.name: point = %p, content = %@; test1 = %p", item.name, item.name, test1);  
    test1 = [NSString stringWithFormat:@"%d / %@", 2, @"Back back back"];  
    NSLog(@"+item.name: point = %p, content = %@, test1 = %p", item.name, item.name, test1);
}

Log:  
    -item.name: point = 0x9a805a0, content = 1 / Go go go; test1 = 0x9a805a0  
    +item.name: point = 0x9a805a0, content = 1 / Go go go, test1 = 0x9a84660

Anda harus menggunakan copy setiap saat untuk mendeklarasikan properti NSString

@property (nonatomic, copy) NSString* name;

Anda harus membaca ini untuk informasi lebih lanjut tentang apakah ia mengembalikan string yang tidak dapat diubah (jika string yang dapat diubah dilewati) atau mengembalikan string yang dipertahankan (jika string yang tidak dapat diubah telah dilewatkan)

Referensi Protokol NSCopying

Terapkan NSCopying dengan mempertahankan yang asli alih-alih membuat salinan baru ketika kelas dan isinya tidak berubah

Nilai Objek

Jadi, untuk versi abadi kita, kita bisa melakukan ini:

- (id)copyWithZone:(NSZone *)zone
{
    return self;
}

Karena nama adalah (tidak dapat diubah) NSString, salin atau simpan tidak ada bedanya jika Anda menetapkan NSStringnama yang lain. Dengan kata lain, salin berperilaku seperti mempertahankan, meningkatkan jumlah referensi satu. Saya pikir itu adalah optimasi otomatis untuk kelas yang tidak dapat diubah, karena mereka tidak dapat diubah dan tidak perlu dikloning. Tetapi ketika a NSMutalbeString mstrdiatur ke nama, konten mstrakan disalin demi kebenaran.

Jika string sangat besar maka salinan akan mempengaruhi kinerja dan dua salinan string besar akan menggunakan lebih banyak memori.