Depuración

Con todas las piezas en movimiento en Tauri, es posible que te encuentres con un problema que requiera depuración. Hay muchos lugares donde se imprimen detalles de error, y Tauri incluye algunas herramientas para hacer que el proceso de depuración sea más sencillo.

Código exclusivo de desarrollo

Una de las herramientas más útiles en tu caja de herramientas para la depuración es la capacidad de agregar declaraciones de depuración en tu código. Sin embargo, por lo general no quieres que estas terminen en producción, que es donde la capacidad de verificar si estás ejecutando en modo de desarrollo o no resulta muy útil.

En Rust

fn main() {
  // Whether the current instance was started with `tauri dev` or not.
  #[cfg(dev)]
  {
    // `tauri dev` only code
  }
  if cfg!(dev) {
    // `tauri dev` only code
  } else {
    // `tauri build` only code
  }
  let is_dev: bool = tauri::is_dev();

  // Whether debug assertions are enabled or not. This is true for `tauri dev` and `tauri build --debug`.
  #[cfg(debug_assertions)]
  {
    // Debug only code
  }
  if cfg!(debug_assertions) {
    // Debug only code
  } else {
    // Production only code
  }
}

Consola de Rust

El primer lugar para buscar errores es en la Consola de Rust. Se encuentra en la terminal donde ejecutaste, por ejemplo, tauri dev. Puedes usar el siguiente código para imprimir algo en esa consola desde un archivo de Rust:

println!("Message from Rust: {}", msg);

A veces puedes tener un error en tu código de Rust, y el compilador de Rust puede darte mucha información. Si, por ejemplo, tauri dev se bloquea, puedes volver a ejecutarlo así en Linux y macOS:

RUST_BACKTRACE=1 tauri dev

o así en Windows (PowerShell):

$env:RUST_BACKTRACE=1
tauri dev

Este comando te da un trazado de pila (stack trace) granular. En general, el compilador de Rust te ayuda dándote información detallada sobre el problema, como por ejemplo:

error[E0425]: cannot find value `sun` in this scope
  --> src/main.rs:11:5
   |
11 |     sun += i.to_string().parse::<u64>().unwrap();
   |     ^^^ help: a local variable with a similar name exists: `sum`

error: aborting due to previous error

For more information about this error, try `rustc --explain E0425`.

Consola de WebView

Haz clic derecho en el WebView y elige Inspeccionar elemento. Esto abre un inspector web similar a las herramientas de desarrollo de Chrome o Firefox a las que estás acostumbrado. También puedes usar el atajo Ctrl + Shift + i en Linux y Windows, y Command + Option + i en macOS para abrir el inspector.

El inspector es específico de la plataforma, renderizando el webkit2gtk WebInspector en Linux, el inspector de Safari en macOS y DevTools de Microsoft Edge en Windows.

Abrir Devtools mediante código

Puedes controlar la visibilidad de la ventana del inspector utilizando las funciones WebviewWindow::open_devtools y WebviewWindow::close_devtools:

tauri::Builder::default()
  .setup(|app| {
    #[cfg(debug_assertions)] // only include this code on debug builds
    {
      let window = app.get_webview_window("main").unwrap();
      window.open_devtools();
      window.close_devtools();
    }
    Ok(())
  });

Usar el inspector en producción

De forma predeterminada, el inspector solo está habilitado en las compilaciones de desarrollo y depuración a menos que lo habilites con una función de Cargo.

Crear una compilación de depuración

Para crear una compilación de depuración, ejecuta el comando tauri build --debug.

npm run tauri build -- --debug

yarn tauri build --debug

pnpm tauri build --debug

deno task tauri build --debug

bun tauri build --debug

cargo tauri build --debug

Al igual que los procesos de compilación y desarrollo normales, la compilación toma algo de tiempo la primera vez que ejecutas este comando, pero es significativamente más rápida en las ejecuciones posteriores. La aplicación empaquetada final tiene habilitada la consola de desarrollo y se coloca en src-tauri/target/debug/bundle.

También puedes ejecutar una aplicación compilada desde la terminal, lo que te brindará las notas del compilador de Rust (en caso de errores) o tus mensajes de println. Navega hasta el archivo src-tauri/target/(release|debug)/[nombre de la app] y ejecútalo directamente en tu consola o haz doble clic en el ejecutable en el sistema de archivos (nota: la consola se cierra ante errores con este método).

Habilitar la característica Devtools

Para habilitar devtools en compilaciones de producción, debes habilitar la característica de Cargo devtools en el archivo src-tauri/Cargo.toml:

[dependencies]
tauri = { version = "...", features = ["...", "devtools"] }

Depurar el proceso principal

El proceso principal (Core process) funciona con Rust, por lo que puedes usar GDB o LLDB para depurarlo. Puedes seguir la guía de Depuración en VS Code para aprender cómo usar la extensión LLDB de VS Code para depurar el proceso principal de las aplicaciones de Tauri.

Apoya en Open Collective Patrocina en GitHub