Struct JsFunction

pub struct JsFunction { /* private fields */ }

The type of JavaScript Function objects.

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 bind() method, which produces a BindOptions 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> = cx.global("parseInt")?;

// Call parseInt("42")
let x: Handle<JsNumber> = parse_int
    .bind(&mut cx)
    .arg("42")?
    .call()?;

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() method:

// Extract the URL constructor from the global object
let url: Handle<JsFunction> = cx.global("URL")?;

// Call new URL("https://neon-bindings.com")
let obj = url
    .bind(&mut cx)
    .arg("https://neon-bindings.com")?
    .construct()?;

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,

Returns a new JsFunction implemented by f.

pub fn with_name<'a, C, F, V>( cx: &mut C, name: &str, f: F, ) -> JsResult<'a, JsFunction>

where C: Context<'a>, F: Fn(FunctionContext<'_>) -> JsResult<'_, V> + 'static, V: Value,

Returns a new JsFunction implemented by f with specified name

impl JsFunction

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

Calls this function.

See also: JsFunction::bind.

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

Calls this function for side effect, discarding its result.

See also: JsFunction::bind.

pub fn construct<'a, 'b, C: Context<'a>, AS>( &self, cx: &mut C, args: AS, ) -> JsResult<'a, JsObject>

where AS: AsRef<[Handle<'b, JsValue>]>,

Calls this function as a constructor.

See also: JsFunction::bind.

impl JsFunction

pub fn bind<'a, 'cx: 'a>(&self, cx: &'a mut Cx<'cx>) -> BindOptions<'a, 'cx>

Create a BindOptions builder for calling this function.

The builder methods make it convenient to assemble the call from parts:

let x: f64 = parse_int
    .bind(&mut cx)
    .arg("42")?
    .call()?;

impl JsFunction

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

👎Deprecating in a future version: use JsFunction::bind instead

Create a CallOptions for calling this function.

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

👎Deprecating in a future version: use JsFunction::bind instead

Create a ConstructOptions for calling this function as a constructor.

Trait Implementations

impl Debug for JsFunction

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

Formats the value using the given formatter.

impl Object for JsFunction

fn prop<'a, 'cx: 'a, K: PropertyKey>( &self, cx: &'a mut Cx<'cx>, key: K, ) -> PropOptions<'a, 'cx, Self, K>

Create a PropOptions for accessing a property.

fn method<'a, 'cx: 'a, K: PropertyKey>( &self, cx: &'a mut Cx<'cx>, key: K, ) -> NeonResult<BindOptions<'a, 'cx>>

Gets a property from the object as a method and binds this to the object.

fn get_opt<'a, V: Value, C: Context<'a>, K: PropertyKey>( &self, cx: &mut C, key: K, ) -> NeonResult<Option<Handle<'a, V>>>

👎Deprecating in a future version: use Object::prop() instead

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

👎Deprecating in a future version: use Object::prop() instead

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

👎Deprecating in a future version: use Object::prop() instead

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>

👎Deprecating in a future version: use Object::prop() instead

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,

👎Deprecating in a future version: use Object::method() instead

impl Value for JsFunction

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

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

fn to_raw(&self) -> Value

Available on crate feature sys only.

Get a raw reference to the wrapped Node-API value.

unsafe fn from_raw<'cx, C: Context<'cx>>( cx: &C, value: Value, ) -> Handle<'cx, Self>

Available on crate feature sys only.

Creates a value from a raw Node-API value.