Struct neon::types::JsFunction

#[repr(transparent)]
pub struct JsFunction<T: Object = JsObject> { /* private fields */ }

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

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, 

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>]>, 

impl JsFunction

pub fn call_with<'a, C: Context<'a>>(&self, _cx: &C) -> CallOptions<'a>

Create a CallOptions for calling this function.

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

impl<T: Debug + Object> Debug for JsFunction<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Object> Managed for JsFunction<T>

fn to_raw(&self) -> *mut Value__

fn from_raw(_: Env, h: *mut Value__) -> Self

impl<T: Object> Object for JsFunction<T>

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.

fn get_value<'a, C: Context<'a>, K: PropertyKey>(
    &self,
    cx: &mut C,
    key: K
) -> NeonResult<Handle<'a, JsValue>>

Gets a property from a JavaScript object as a JsValue.

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_value(&mut cx)?.downcast_or_throw(&mut cx).

fn get_own_property_names<'a, C: Context<'a>>(
    &self,
    cx: &mut C
) -> JsResult<'a, JsArray>

Available on crate feature napi-6 only.

fn freeze<'a, C: Context<'a>>(&self, cx: &mut C) -> NeonResult<&Self>

fn seal<'a, C: Context<'a>>(&self, cx: &mut C) -> NeonResult<&Self>

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>

fn call_method_with<'a, C, K>(
    &self,
    cx: &mut C,
    method: K
) -> NeonResult<CallOptions<'a>> where
    C: Context<'a>,
    K: PropertyKey, 

impl<T: Object> Value for JsFunction<T>

fn to_string<'a, C: Context<'a>>(&self, cx: &mut C) -> JsResult<'a, JsString>

fn as_value<'a, C: Context<'a>>(&self, _: &mut C) -> Handle<'a, JsValue>