Go'da neden listeler nadiren kullanılıyor?

Question 1

Go'da yeniyim ve bu konuda oldukça heyecanlıyım. Ancak, yoğun olarak çalıştığım tüm dillerde: Delphi, C #, C ++, Python - Listeler çok önemlidir çünkü dizilerin aksine dinamik olarak yeniden boyutlandırılabilirler.

Golang'da gerçekten bir list.Listyapı var, ancak bununla ilgili çok az belge görüyorum - Örneğe Göre Go'da ya da sahip olduğum üç Go kitabında - Summerfield, Chisnal ve Balbaert - hepsi diziler ve dilimler üzerinde çok zaman harcıyor ve ardından haritalara atlayın. Sos kodu örneklerinde de çok az veya hiç kullanmıyorum list.List.

Ayrıca Python'dan farklı Rangeolarak List için desteklenmediği anlaşılıyor - büyük dezavantaj IMO. Bir şey mi kaçırıyorum?

Dilimler kesinlikle iyidir, ancak yine de sabit kodlanmış boyuta sahip bir diziye dayanmaları gerekir. İşte List burada devreye giriyor. Go'da sabit kodlanmış dizi boyutu olmadan dizi / dilim oluşturmanın bir yolu var mı? Liste neden göz ardı ediliyor?

Question 2

Hemen hemen her zaman bir liste düşündüğünüzde - Go yerine bir dilim kullanın. Dilimler dinamik olarak yeniden boyutlandırılır. Bunların temelinde, boyutu değiştirebilen bitişik bir bellek dilimi vardır.

SliceTricks wiki sayfasını okursanız göreceğiniz için çok esnektirler .

İşte bir alıntı: -

Kopyala

b = make([]T, len(a))
copy(b, a) // or b = append([]T(nil), a...)

Kesmek

a = append(a[:i], a[j:]...)

Sil

a = append(a[:i], a[i+1:]...) // or a = a[:i+copy(a[i:], a[i+1:])]

Sırayı korumadan sil

a[i], a = a[len(a)-1], a[:len(a)-1]

Pop

x, a = a[len(a)-1], a[:len(a)-1]

it

a = append(a, x)

Güncelleme : Burada, tümüyle go ekibinin kendi dilimleriyle ilgili bir blog gönderisinin bağlantısı var ; bu, dilimler ve diziler ve dilim iç bileşenleri arasındaki ilişkiyi açıklamak için iyi bir iş çıkarıyor.

Question 3

Bu soruyu birkaç ay önce Go'yu araştırmaya başladığımda sordum. O zamandan beri her gün Go hakkında okuyorum ve Go'da kod yazıyorum.

Bu soruya net bir cevap alamadığım için (bir cevabı kabul etmiş olsam da), şimdi sorduğumdan beri öğrendiklerime dayanarak cevaplayacağım:

Go'da sabit kodlanmış dizi boyutu olmadan dizi / dilim oluşturmanın bir yolu var mı?

Evet. Dilimler, aşağıdakilerden sabit kodlanmış bir dizi gerektirmez slice:

var sl []int = make([]int,len,cap)

Bu kod ayırdığı dilim slboyutu, lenkapasiteli cap- lenve capzamanında atanabilir değişkenlerdir.

Neden list.Listgörmezden geliniyor?

Görünüşe göre list.ListGo'da çok az ilgi gören ana nedenler :

@Nick Craig-Wood'un cevabında açıklandığı gibi, dilimlerle, genellikle daha verimli ve daha temiz, daha zarif bir sözdizimi ile yapılamayan listelerle yapılabilecek neredeyse hiçbir şey yoktur. Örneğin, aralık yapısı:
```
for i:=range sl {
  sl[i]=i
}
```
listeyle kullanılamaz - döngü için C stili gereklidir. Ve çoğu durumda, C ++ koleksiyon stili sözdizimi listelerle birlikte kullanılmalıdır: push_backvb.
Belki daha da önemlisi, list.Listgüçlü bir şekilde yazılmamış - koleksiyonda çeşitli türleri karıştırmaya izin veren Python'un listeleri ve sözlüklerine çok benziyor. Bu, şeylere yönelik Go yaklaşımının tam tersi gibi görünüyor. Go, çok güçlü bir şekilde yazılmış bir dildir - örneğin, Go'da örtük tür dönüşümlerine hiçbir zaman izin verilmez, hatta bir upCast from intto int64açık olmalıdır. Ancak list.List için tüm yöntemler boş arayüzler alır - her şey gider.

Python'u terk edip Go'ya geçmemin nedenlerinden biri, Python'un "güçlü yazılmış" olduğunu iddia etmesine rağmen (IMO değil) Python'un tür sistemindeki bu tür zayıflıktır. Go list.List, C ++ 'lar vector<T>ve Python'lardan doğan bir tür "melez" gibi görünüyor List()ve belki de Go'nun kendisinde biraz yerinde değil.

Çok uzak olmayan bir gelecekte bir noktada liste bulmamız beni şaşırtmaz. Liste, belki de kalmaya devam edecek olsa da, iyi tasarım uygulamaları kullanılsa bile bir sorunun en iyi şekilde çözülebileceği nadir durumlara uyum sağlamak için Go'da kullanımdan kaldırılmıştır. çeşitli türleri barındıran bir koleksiyonla. Ya da belki de C ailesi geliştiricilerinin, Go'ya özgü AFAIK'e özgü dilim nüanslarını öğrenmeden önce Go ile rahat olmaları için bir "köprü" sağlamak için oradadır. (Bazı açılardan dilimler C ++ veya Delphi'deki akış sınıflarına benziyor, ancak tamamen değil.)

Delphi / C ++ / Python arka planından gelmesine rağmen, Go ile ilk karşılaşmamda list.ListGo'nun dilimlerinden daha tanıdık buldum , Go ile daha rahat hale geldikçe, geri döndüm ve tüm listelerimi dilimlere dönüştürdüm. Henüz kullanmam gereken sliceve / veya mapyapmama izin vermeyen bir şey bulamadım list.List.

Question 4

Bunun nedeni , jenerik verilerle çalışmanın başlıca Go deyiminin ne olduğunu öğrendikten sonra , container/listpaket oldukça açıklayıcı olduğu için onlar hakkında söylenecek pek bir şey olmadığı için.

Delphi'de (jenerikler olmadan) veya C'de işaretçileri veya s'leri TObjectlistede saklayabilir ve ardından listeden alırken gerçek türlerine geri döndürebilirsiniz. C ++ 'da STL listeleri şablonlardır ve bu nedenle türe göre parametreleştirilmiştir ve C #' da (bu günlerde) listeler geneldir.

Go'da, herhangi bir başka (gerçek) türdeki değerleri temsil edebilen özel bir container/listtür interface{}olan türdeki değerleri bir çift işaretçi depolayarak depolar : biri içerilen değerin tür bilgisine ve değere (veya doğrudan, boyutu bir işaretçinin boyutundan büyük değilse). Bu nedenle, listeye bir eleman eklemek istediğinizde, bunu sadece türündeki fonksiyon parametreleri interface{}değerleri kabul ettikçe yaparsınız . Ancak listeden değerleri çıkardığınızda ve gerçek türleriyle ne çalışmanız gerektiğini ya yazmanız gerekir ya da üzerlerinde bir tür anahtarı yapmanız gerekir - her iki yaklaşım da aslında aynı şeyi yapmanın farklı yollarıdır.

İşte buradan alınan bir örnek :

package main

import ("fmt" ; "container/list")

func main() {
    var x list.List
    x.PushBack(1)
    x.PushBack(2)
    x.PushBack(3)

    for e := x.Front(); e != nil; e=e.Next() {
        fmt.Println(e.Value.(int))
    }
}

Burada kullanarak bir elemanın değerini elde ederiz e.Value()ve sonra onu intorijinal eklenen değerin bir türü olarak yazın-assert ederiz .

"Etkili Git" veya başka bir giriş kitabında tür iddialarını okuyabilir ve anahtarları yazabilirsiniz. container/listPaketin dokümantasyon özetleri tüm yöntemler listeleri desteği.

Question 5

Go dilimlerinin append()yerleşik işlevi ile genişletilebileceğini unutmayın . Bu bazen arka dizinin bir kopyasını almayı gerektirse de, Go yeni diziyi fazla boyutlandıracağından bu diziye bildirilen uzunluktan daha büyük bir kapasite vereceği için bu her seferinde gerçekleşmez. Bu, sonraki bir ekleme işleminin başka bir veri kopyası olmadan tamamlanabileceği anlamına gelir.

Bağlantılı listelerle uygulanan eşdeğer koda göre daha fazla veri kopyası elde ederken, listedeki öğeleri ayrı ayrı tahsis etme ihtiyacını ve Nextişaretçileri güncelleme ihtiyacını ortadan kaldırırsınız . Birçok kullanım için dizi tabanlı uygulama daha iyi veya yeterince iyi performans sağlar, bu nedenle dilde vurgulanan şey budur. İlginç bir şekilde, Python'un standart listtürü de dizi desteklidir ve değerleri eklerken benzer performans özelliklerine sahiptir.

Bununla birlikte, bağlantılı listelerin daha iyi bir seçim olduğu durumlar vardır (örneğin, uzun bir listenin başlangıcından / ortasından öğeler eklemeniz veya çıkarmanız gerektiğinde) ve bu nedenle standart bir kitaplık uygulaması sağlanır. Sanırım onlarla çalışmak için herhangi bir özel dil özelliği eklemediler çünkü bu durumlar dilimlerin kullanıldığı durumlardan daha az yaygındır.

Question 6

Dilim çok sık güncellenmedikçe (silin, rastgele konumlarda öğeler ekleyin), dilimlerin bellek bitişikliği, bağlantılı listelere kıyasla mükemmel önbellek isabet oranı sunacaktır.

Scott Meyer'in önbelleğin önemi hakkındaki konuşması .. https://www.youtube.com/watch?v=WDIkqP4JbkE

Question 7

list.Listçift bağlantılı bir liste olarak uygulanmaktadır. Dizi tabanlı listeler (C ++ 'daki vektörler veya golang'daki dilimler), listenin ortasına sık sık eklemezseniz, çoğu durumda bağlantılı listelerden daha iyi bir seçimdir. Ekleme için amortize edilmiş zaman karmaşıklığı, dizi listesinin kapasiteyi genişletmesi ve mevcut değerleri kopyalaması gerekmesine rağmen, hem dizi listesi hem de bağlantılı liste için O (1) 'dir. Dizi listeleri daha hızlı rasgele erişime, daha küçük bellek ayak izine ve daha da önemlisi veri yapısında işaretçiler bulunmadığından çöp toplayıcıya daha kolay sahiptir.

Question 8

Gönderen: https://groups.google.com/forum/#!msg/golang-nuts/mPKCoYNwsoU/tLefhE7tQjMJ

Listelerinizdeki öğelerin sayısına çok bağlıdır,
 gerçek bir liste mi yoksa bir dilim mi daha verimli olacak
 Listenin 'ortasında' birçok silme işlemi yapmanız gerektiğinde.

# 1
Ne kadar çok eleman, bir dilim o kadar az çekici hale gelir. 

# 2
Öğelerin sıralaması önemli olmadığında,
 bir dilim kullanmak en verimlidir ve
 bir öğeyi dilimdeki son öğe ile değiştirerek silmek ve
 dilimi, len'i 1 küçültmek için yeniden biçimlendirme
 (SliceTricks wiki'sinde açıklandığı gibi)

Öyleyse
dilim
1'i kullanın . Listedeki öğelerin sırası önemli değilse ve silmeniz gerekiyorsa,
List'i kullanarak silmek için öğeyi son öğeyle takas edin ve
öğeler daha fazla olduğunda (uzunluk-1) 2'ye yeniden dilimleyin ( daha fazla anlamı ne olursa olsun)

There are ways to mitigate the deletion problem --
e.g. the swap trick you mentioned or
just marking the elements as logically deleted.
But it's impossible to mitigate the problem of slowness of walking linked lists.

Öyleyse
dilim
1'i kullanın . Çaprazlamada hıza ihtiyacınız varsa