Gibt es eine Methode wie Python popitem für assoziative Arrays in Dlang?

Question

Ich möchte jedes Schlüssel/Wert-Paar aus einem assoziativen Array erhalten und es entfernen. In Python ist es:

key, value = assoc.popitem() 

In D ich:

auto key = assoc.byKey.front; 
auto value = assoc[key]; 
assoc.remove(key); 

Gibt es eine bessere Art und Weise, dies zu tun? Ist es möglich, byKeyValue() außerhalb von foreach zu verwenden?

DMD 2.067.1

Answer 1

Ist es möglich, byKeyValue() außerhalb foreach zu benutzen?

Sure:

import std.stdio; 

void main() 
{ 
    int[string] assoc = ["apples" : 2, "bananas" : 4]; 

    while (!assoc.byKeyValue.empty) 
    { 
     auto pair = assoc.byKeyValue.front; 
     assoc.remove(pair.key); 
     writeln(pair.key, ": ", pair.value); 
    } 
} 

Gibt es eine bessere Art und Weise, dies zu tun?

Ich glaube nicht, D hat eine Bibliothek Funktion entspricht für popitem.

Answer 2

Bevor auch nur darüber nachzudenken, würde ich darauf hinweisen, dass Sie eine einfache Funktion schreiben konnte:

import std.typecons; 

Tuple!(K, V) popitem(K, V)(ref V[K] arr) { 
    foreach(k, v; arr) { 
     arr.remove(k); 
     return tuple(k, v); 
    } 
    throw new Exception("empty!"); 
} 
void main() { 
    int[string] cool; 
    cool["ten"] = 10; 
    cool["twenty"] = 20; 
    import std.stdio; 
    writeln(cool.popitem()); 
    writeln(cool.popitem()); 
} 

Oder mit byKeyValue:

auto popitem(K, V)(ref V[K] arr) { 
    foreach(item; arr.byKeyValue()) { 
     arr.remove(item.key); 
     return item; 
    } 
    throw new Exception("empty!"); 
} 
void main() { 
    int[string] cool; 
    cool["ten"] = 10; 
    cool["twenty"] = 20; 
    import std.stdio; 
    auto item = cool.popitem(); 
    writeln(item.key, item.value); 
    item = cool.popitem(); 
    writeln(item.key, item.value); 
} 

Im Allgemeinen Ich mag Menschen zu ermutigen, nicht zu Angst haben, ihre eigenen Funktionen zu schreiben. Wenn Sie etwas mit ein paar vorhandenen Dingen ausdrücken können, schreiben Sie einfach Ihre eigene Funktion, geben Sie ihr einen Namen, den Sie mögen, und benutzen Sie das! Mit der einheitlichen Funktionsaufrufsyntax können Sie problemlos Erweiterungsmethoden für eingebaute Typen schreiben, wie ich es hier getan habe, und sie verwenden, als ob sie schon immer da gewesen wären.