flutter pub add weak_map根據套件公開資料產生的選型評估，僅供參考。
WeakMap 是一個 Dart 套件，實作了使用弱參考鍵的映射，當沒有其他參考存在時，允許對鍵物件進行垃圾回收。它透過防止記憶體洩漏來實現高效記憶體管理。WeakContainer 提供物件的身分檢查，確保它們與之前是同一個執行個體。該套件透過使用弱參考支援快取函數的備忘錄化，非常適合暫時性資料儲存。專為長時間執行的應用程式設計，兼具效能與安全性。
以下為關聯原始碼儲存庫的 README 原文快照，最新內容請造訪原始碼儲存庫。
This package contains the classes:
And also the functions:
Dart doesn't allow for real weak-references, but this package allows you to go as close as possible (internally it uses the Expando class). The Dart engine stores a value in memory while it is reachable (and can potentially be used). Usually, keys in a map are considered reachable and kept in memory while the map itself is in memory. This means if we put an object into a map or into a variable, then while the map is alive, the object will be alive as well, even if there are no other references to it. It occupies memory and may not be garbage collected. WeakMap and WeakContainer are fundamentally different in this aspect. They don't prevent garbage-collection of key objects.
Caches that keep the result of expensive processes calculated over immutable data can also benefit from weak-maps. I here provide functions similar to the ones of the reselect package, but better. This can be used with Redux or with any other calculations over immutable data.
A WeakMap lets you garbage-collect its keys. Please note the keys can be garbage-collected, not their corresponding values.
This means if you use some object as a key to a map-entry, this alone will not prevent Dart to garbage-collect this object.
In other words, after all other references to that object have been destroyed, its entry (key and value) may be removed automatically from the map at any moment. To create a map:
var map = WeakMap();
To add and retrieve a value:
map["John"] = 42;
var age = map["John"];
The following map methods work as expected:
map.remove("John")
map.clear()
map.contains("John"))
However, adding some null value to the map is the same as removing the key:
map["John"] = null; // Same as map.remove("John")
Notes:
The keys are compared using object identity, and not object equivalence (operator ==).
If you use null, a number, a boolean, a String, or a const type as the map key, it will act like a regular map, because these types are never garbage-collected. All other types of object may be garbage-collected.
To retrieve a value added to the map, you can use the equivalent syntaxes var y = map[x]
or var y = map.get(x).
Doing map[x] = y is equivalent to map.add(key: x, value: y), but the object is later
retrieved by identity.
As previously explained, Dart doesn't have real weak-references. But you can check that some object is the same you had before.
To create a weak-container:
var obj = Object();
var ref = WeakContainer(obj);
var someObj = Random().nextBool() ? obj : Object();
print(ref.contains(someObj)); // True or false.
This will print true if someObj is the same as the original obj, and will print false if
it's a different object, compared by identity. If all references to the original obj have been
destroyed, the weak-container will not prevent obj to be garbage-collected.
Because the creators of Dart don't want the GC (garbage-collector) to be "visible".
Expandos are not equivalent to weak-references (meaning the Java WeakReference behavior). A weak
reference is one that doesn't keep the referenced object alive, so the weak reference value may
change to null at any time in the program. This makes the GC visible in the program.
Expandos are maps (from key to value) which won't keep the key alive. There is no way to distinguish an Expando that garbage collects the entry when the key dies, and one that doesn't, because you don't have the key to do the lookup anymore.
Basically, it means that an expando keeps a value alive as long as you have a reference to both the expando and the key, and after that, you can't check if the entry is there or not. With expandos, the GC need not be part of the language specification. It's just an optimization that implementations (are expected to) do to release memory that isn't needed anymore. Disabling the GC will not change the behavior of programs unless they run out of memory.
Suppose you have some immutable information, which we call "state", and some parameters. We want to perform some expensive process (calculation, selection filtering etc) over the state, and we want to cache the result.
For example, suppose you want to filter an immutable list of millions of users, to create a new list with only the names that start with some text. You could filter the users list to remove all other names, like this:
List<User> filter(String text) => users.where((user)=>user.name.startsWith(text)).toList();
This is an expensive process, so you may want to cache the filtered list.
In this example, we have a single state and a single parameter, so we're going to use
the cache1state_1param method:
static List<User> filter(Users users, String text)
=> _filter(users)(text);
static final _filter = cache1state_1param(
(Users users)
=> (String text)
=> users.where((user)=>user.name.startsWith(text)).toList());
The above code will calculate the filtered list only once, and then return it when the filter
function is called again with the same users and text.
If the function is called with a different users and/or text, it will recalculate and cache
the new result.
However, it treats the state and the parameter differently. If you call the function while keeping the same state and changing only the parameter, it will cache all the results, one for each parameter.
However, as soon as you call the function with a changed state, it will delete all of its previous cached information, since it understands that they are no longer useful.
And even if you don't call that function ever again, it will delete the cached information if it detects that the state is no longer used in other parts of the program. In other words, it keeps the cached information in a weak-map, so that the cache will not hold to old information and have a negative impact in memory usage.
Some functions, marked with an "x", also let you pass some extra information which is not used in any way to decide whether the cache should be used/recalculated/evicted.
For the moment, the following 10 methods are provided, which combine 1, 2 or 3 states with 0, 1 or 2 parameters, and possibly some extra information:
cache1state((state) => () => ...);
cache1state_1param((state) => (parameter) => ...);
cache1state_2params((state) => (parameter1, parameter2) => ...);
cache2states((state1, state2) => () => ...);
cache2states_1param((state1, state2) => (parameter) => ...);
cache2states_2params((state1, state2) => (parameter1, parameter2) => ...);
cache3states((state1, state2, state3) => () => ...);
cache1state_0params_x((state1, extra) => () => ...);
cache2states_0params_x((state1, state2, extra) => () => ...);
cache3states_0params_x((state1, state2, state3, extra) => () => ...);
I have created only those above, because for my own usage I never required more than that. Please, open an issue to ask for more variations in case you feel the need.
Note: These cache functions are similar to the "createSelector" functions found in the reselect package. The differences are: First, here you can keep any number of cached results for each function, one for each time the function is called with the same state and different parameters. Meanwhile, the reselect package only keeps a single cached result per function. Second, here it discards the cached information when the state changes or is no longer used in other parts of the program. Meanwhile, the reselect package will always keep the states and cached results in memory.
glasberg.dev
github.com/marcglasberg
linkedin.com/in/marcglasberg/
twitter.com/glasbergmarcelo
stackoverflow.com/users/3411681/marcg
medium.com/@marcglasberg
My article in the official Flutter documentation:
The Flutter packages I've authored:
My Medium Articles: