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: