Struct neon::types::JsFunction
source · [−]Expand description
A JavaScript function object.
A JsFunction
may come from an existing JavaScript function, for example
by extracting it from the property of another object such as the
global object, or it may be defined in Rust
with JsFunction::new()
.
Calling functions
Neon provides a convenient syntax for calling JavaScript functions with the
call_with()
method, which produces a CallOptions
struct that can be used to provide the function arguments (and optionally, the binding for
this
) before calling the function:
// Extract the parseInt function from the global object
let parse_int: Handle<JsFunction> = global.get(&mut cx, "parseInt")?;
// Call parseInt("42")
let x: Handle<JsNumber> = parse_int
.call_with(&mut cx)
.arg(cx.string("42"))
.apply(&mut cx)?;
Calling functions as constructors
A JsFunction
can be called as a constructor (like new Array(16)
or
new URL("https://neon-bindings.com")
) with the
construct_with()
method:
// Extract the URL constructor from the global object
let url: Handle<JsFunction> = global.get(&mut cx, "URL")?;
// Call new URL("https://neon-bindings.com")
let obj = url
.construct_with(&cx)
.arg(cx.string("https://neon-bindings.com"))
.apply(&mut cx)?;
Defining functions
JavaScript functions can be defined in Rust with the
JsFunction::new()
constructor, which takes
a Rust implementation function and produces a JavaScript function.
// A function implementation that adds 1 to its first argument
fn add1(mut cx: FunctionContext) -> JsResult<JsNumber> {
let x: Handle<JsNumber> = cx.argument(0)?;
let v = x.value(&mut cx);
Ok(cx.number(v + 1.0))
}
// Define a new JsFunction implemented with the add1 function
let f = JsFunction::new(&mut cx, add1)?;
Implementations
sourceimpl JsFunction
impl JsFunction
pub fn new<'a, C, F, V>(cx: &mut C, f: F) -> JsResult<'a, JsFunction> where
C: Context<'a>,
F: Fn(FunctionContext<'_>) -> JsResult<'_, V> + 'static,
V: Value,
sourceimpl<CL: Object> JsFunction<CL>
impl<CL: Object> JsFunction<CL>
pub fn call<'a, 'b, C: Context<'a>, T, AS>(
&self,
cx: &mut C,
this: Handle<'b, T>,
args: AS
) -> JsResult<'a, JsValue> where
T: Value,
AS: AsRef<[Handle<'b, JsValue>]>,
pub fn exec<'a, 'b, C: Context<'a>, T, AS>(
&self,
cx: &mut C,
this: Handle<'b, T>,
args: AS
) -> NeonResult<()> where
T: Value,
AS: AsRef<[Handle<'b, JsValue>]>,
pub fn construct<'a, 'b, C: Context<'a>, AS>(
&self,
cx: &mut C,
args: AS
) -> JsResult<'a, CL> where
AS: AsRef<[Handle<'b, JsValue>]>,
sourceimpl JsFunction
impl JsFunction
sourcepub fn call_with<'a, C: Context<'a>>(&self, _cx: &C) -> CallOptions<'a>
pub fn call_with<'a, C: Context<'a>>(&self, _cx: &C) -> CallOptions<'a>
Create a CallOptions
for calling this function.
sourcepub fn construct_with<'a, C: Context<'a>>(
&self,
_cx: &C
) -> ConstructOptions<'a>
pub fn construct_with<'a, C: Context<'a>>(
&self,
_cx: &C
) -> ConstructOptions<'a>
Create a ConstructOptions
for calling this function
as a constructor.
Trait Implementations
sourceimpl<T: Debug + Object> Debug for JsFunction<T>
impl<T: Debug + Object> Debug for JsFunction<T>
sourceimpl<T: Object> Managed for JsFunction<T>
impl<T: Object> Managed for JsFunction<T>
sourceimpl<T: Object> Object for JsFunction<T>
impl<T: Object> Object for JsFunction<T>
sourcefn get_opt<'a, V: Value, C: Context<'a>, K: PropertyKey>(
&self,
cx: &mut C,
key: K
) -> NeonResult<Option<Handle<'a, V>>>
fn get_opt<'a, V: Value, C: Context<'a>, K: PropertyKey>(
&self,
cx: &mut C,
key: K
) -> NeonResult<Option<Handle<'a, V>>>
Gets a property from a JavaScript object that may be undefined
and
attempts to downcast the value if it existed. Read more
sourcefn get_value<'a, C: Context<'a>, K: PropertyKey>(
&self,
cx: &mut C,
key: K
) -> NeonResult<Handle<'a, JsValue>>
fn get_value<'a, C: Context<'a>, K: PropertyKey>(
&self,
cx: &mut C,
key: K
) -> NeonResult<Handle<'a, JsValue>>
sourcefn get<'a, V: Value, C: Context<'a>, K: PropertyKey>(
&self,
cx: &mut C,
key: K
) -> NeonResult<Handle<'a, V>>
fn get<'a, V: Value, C: Context<'a>, K: PropertyKey>(
&self,
cx: &mut C,
key: K
) -> NeonResult<Handle<'a, V>>
Gets a property from a JavaScript object and attempts to downcast as a specific type.
Equivalent to calling obj.get(&mut cx)?.downcast_or_throw(&mut cx)
. Read more
sourcefn get_own_property_names<'a, C: Context<'a>>(
&self,
cx: &mut C
) -> JsResult<'a, JsArray>
fn get_own_property_names<'a, C: Context<'a>>(
&self,
cx: &mut C
) -> JsResult<'a, JsArray>
napi-6
only.fn set<'a, C: Context<'a>, K: PropertyKey, W: Value>(
&self,
cx: &mut C,
key: K,
val: Handle<'_, W>
) -> NeonResult<bool>
fn root<'a, C: Context<'a>>(&self, cx: &mut C) -> Root<Self>
Auto Trait Implementations
impl<T> RefUnwindSafe for JsFunction<T> where
T: RefUnwindSafe,
impl<T = JsObject> !Send for JsFunction<T>
impl<T = JsObject> !Sync for JsFunction<T>
impl<T> Unpin for JsFunction<T> where
T: Unpin,
impl<T> UnwindSafe for JsFunction<T> where
T: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more