Packages can supply functions to be called when loaded, attached, detached or unloaded.
.onLoad(libname, pkgname) .onAttach(libname, pkgname) .onUnload(libpath) .onDetach(libpath) .Last.lib(libpath)
a character string giving the library directory where the package defining the namespace was found.
a character string giving the name of the package.
a character string giving the complete path to the package.
loadNamespace looks for a hook function
.onLoad and calls it (with two unnamed arguments) before
sealing the namespace and processing exports.
When the package is attached (via
attachNamespace), the hook function
looked for and if found is called (with two unnamed arguments) before
the package environment is sealed.
If a function
.onDetach is in the namespace or
is exported from the package, it will be called (with a single
argument) when the package is
detached. Beware that it
might be called if
.onAttach has failed, so it should be
written defensively. (It is called within
errors will not stop the package being detached.)
If a namespace is unloaded (via
unloadNamespace), a hook
.onUnload is run (with a single argument) before final
Note that the code in
.onUnload should not
assume any package except the base package is on the search path.
Objects in the current package will be visible (unless this is
circumvented), but objects from other packages should be imported or
the double colon operator should be used.
.onDetach are looked for as internal objects in the namespace
and should not be exported (whereas
.Last.lib should be).
Note that packages are not detached nor namespaces unloaded at the end
of an R session unless the user arranges to do so (e.g., via
Anything needed for the functioning of the namespace should be
handled at load/unload times by the
.onUnload hooks. For example, DLLs can be loaded (unless done
useDynLib directive in the ‘NAMESPACE’ file) and
.onLoad and unloaded in
.onAttach only for actions that are needed only when the
package becomes visible to the user (for example a start-up message)
or need to be run after the package environment has been created.
Loading a namespace should where possible be silent, with startup
messages given by
.onAttach. These messages (and any essential
.onLoad) should use
so they can be silenced where they would be a distraction.
There should be no calls to
require in these
hooks. The way for a package to load other packages is via the
Depends field in the ‘DESCRIPTION’ file: this ensures
that the dependence is documented and packages are loaded in the
correct order. Loading a namespace should not change the search path,
so rather than attach a package, dependence of a namespace on another
package should be achieved by (selectively) importing from the other
library with argument
help to display basic
information about the package should use
format on the
computed package information object and pass this to
There should be no calls to
installed.packages in startup
code: it is potentially very slow and may fail in versions of R
before 2.14.2 if package installation is going on in parallel. See
its help page for alternatives.
Compiled code should be loaded (e.g., via
.onLoad or a
directive in the ‘NAMESPACE’ file, and not in
Similarly, compiled code should not be unloaded (e.g., via
.onDetach, only in
setHook shows how users can set hooks on the same events, and
lists the sequence of events involving all of the hooks.
reg.finalizer for hooks to be run at the end of a session.
loadNamespace for more about namespaces.
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.