JsValue

JsValue representa o valor do JavaScript em Rust.

JsUndefined

undefined em JavaScript representa a ausência de um valor definido. Não pode ser convertido em um valor Rust Rust, e nenhum valor Rust pode ser convertido em JsUndefined.

A única maneira de criar um JsUndefined em Rust é chamando Env::get_undefined().

JsNull

Representa null em JavaScript. Assim como JsUndefined, não pode ser convertido para um valor Rust, e nenhum valor Rust pode ser convertido para ele.

A única maneira de criar JsNull em Rust é chamando Env::get_null().

JsNumber

use std::convert::TryInto;
 
use napi::*;
 
#[js_function(1)]
fn fib(ctx: CallContext) -> Result<JsNumber> {
  let input_number: i64 = ctx.get::<JsNumber>(0)?.try_into()?;
  ctx.env.create_int64(fibonacci_native(input_number))
}
 
#[inline(always)]
fn fibonacci_native(n: i64) -> i64 {
  match n {
    1 | 2 => 1,
    _ => fibonacci_native(n - 1) + fibonacci_native(n - 2),
  }
}

JsBoolean

JsBoolean representa um valor booleano em JavaScript.

Use JsBoolean::get_value() para converter JsBoolean em bool do Rust. E Env::get_boolean() para converter bool do Rust em JsBoolean.

#[js_function(1)]
fn not(ctx: CallContext) -> Result<JsBoolean> {
  let condition: JsBoolean = ctx.get(0)?;
  ctx.env.get_boolean(!condition.get_value()?)
}

not(true) // false
not(false) // true

JsString

Representa valores de string em JavaScript. Existem três tipos de encoding de string com os quais você pode interagir usando N-API: utf8, utf16 e latin1.

Há um artigo que pode ajudá-lo a entender a história do encoding no Node.js: https://kevin.burke.dev/kevin/node-js-string-encoding/ (opens in a new tab)

Você pode criar um JsString a partir de um &str em Rust usando Env::create_string(). Se você deseja obter o valor utf8 de um JsString, você deve usar JsString::into_utf8() para obter o valor utf8 explicitamente.

#[js_function(1)]
fn world(ctx: CallContext) -> Result<JsString> {
  // ou into_utf16/into_latin1 aqui
  // Se você deseja usar into_latin1, deve habilitar o recurso `latin1` para `napi-rs`.
  let input_string = ctx.get::<JsString>(0)?.into_utf8()?;
  let output = format!("{} world!", input_string.as_str()?);
  ctx.env.create_string(output.as_str())
}

world('hello') // hello world!

JsBuffer

JsBuffer é usado para representar um valor Buffer no Node.js. Passar dados entre JavaScript e Rust usando JsBuffer tem uma pequena sobrecarga, então você pode preferi-lo em relação a outros tipos.

Por exemplo, em alguns casos, converter uma string JavaScript em um Buffer, passá-lo para Rust como um JsBuffer e convertê-lo como um &[u8] é mais rápido do que passar a string diretamente para Rust. A implementação de string no V8 é muito mais complicada do que a de ArrayBuffer, que é como o Buffer é implementado.

#[js_function(1)]
fn set_buffer(ctx: CallContext) -> Result<JsUndefined> {
  let buf = &mut ctx.get::<JsBuffer>(0)?.into_value()?; // &mut [u8]
  buf[0] = 1;
  buf[1] = 2;
  ctx.env.get_undefined()
}

setBuffer(Buffer.from([0, 1])) // <Buffer 01 02>

JsSymbol

Representa um valor Symbol em JavaScript. Você pode criar um JsSymbol a partir de &str ou JsString.

// Criar a partir de &str
#[js_function(1)]
fn create_symbol(ctx: CallContext) -> Result<JsSymbol> {
  let desc = ctx.get::<JsString>(0)?.into_utf8()?;
  ctx.env.create_symbol(Some(desc.as_str()?))
}

// Criar a partir de JsString
#[js_function(1)]
fn create_symbol(ctx: CallContext) -> Result<JsSymbol> {
  let desc = ctx.get::<JsString>(0)?;
  ctx.env.create_symbol_from_js_string(desc)
}

JsObject

Representa um valor Object em JavaScript. Existem muitas API's relacionadas a objetos em JsObject. Veja a documentação (opens in a new tab).

#[js_function(1)]
fn set_bar(ctx: CallContext) -> Result<JsUndefined> {
  let mut obj = ctx.get::<JsObject>(0)?;
  let bar: JsString = obj.get_named_property("bar")?;
  let bar_str = bar.into_utf8()?;
  obj.set_named_property("bar", ctx.env.create_string_from_std(format!("{} bar", bar_str.as_str()?)))?;
  ctx.env.get_undefined()
}

setBar({ bar: 'bar' }) // { bar: "bar bar" }

JsDate

Representa um objeto Date em JavaScript. Os objetos Date JavaScript são descritos na Seção 20.3 (opens in a new tab) da Especificação da Linguagem ECMAScript.

JsBigint

Representa um valor Bigint em JavaScript.

JsExternal

Esta API aloca um valor JavaScript com dados externos anexados a ele. Isso é usado para passar dados externos através do código JavaScript, para que possam ser recuperados posteriormente pelo código nativo usando Env::get_value_external (opens in a new tab).