Início / coding / Perguntas / 79464245
Accepted
robertspierre
Asked: 2025-02-25 00:29:37 +0800 CST

Converter um tipo de aviso específico em um erro

  • 772

Considere o seguinte código:

> df <- tibble(gender=c(1,1,0))
> df$male
Warning: Unknown or uninitialised column: `male`.
NULL

Como posso converter esse tipo de aviso específico em um erro?

Gostaria de algo assim options(warn = 2), mas apenas para esse tipo específico de aviso (ou seja, referindo-se a uma coluna em um tibble que não existe)

5 respostas

  1. É um pouco hackeado, mas você pode corrigir a função $, ou seja, o getter. O aviso é lançado por rlang::warnquando o nome da coluna não é encontrado em df. Ao substituir esta chamada por uma para rlang::aborttransformamos este aviso em um erro.

    patch_tibble <- function() {
  if(is.null(attr(tibble:::`$.tbl_df`, "patched"))) {
    tt <- get("$.tbl_df", envir=asNamespace("tibble"), inherits=FALSE)
    
    body(tt) <- methods::substituteDirect(body(tt), list(warn=quote(abort)))
    attr(tt, "patched") <- TRUE
    
    unlockBinding("$.tbl_df", asNamespace("tibble"))
    assign("$.tbl_df", tt, envir=asNamespace("tibble"), inherits = FALSE)
    lockBinding("$.tbl_df", asNamespace("tibble"))
    packageStartupMessage("Patched tibble!")
  }
}

    library(tibble)
patch_tibble()

df <- tibble(gender=c(1,1,0))
df$male

Error in `df$male`:
! Unknown or uninitialised column: `male`.
Run `rlang::last_trace()` to see where the error occurred.
    • 4
  2. Best Answer

    A função original para o método S3 $.tbl_dfé definida como:

    function (x, name) 
{
    out <- .subset2(x, name)
    if (is.null(out)) {
        warn(paste0("Unknown or uninitialised column: ", tick(name), 
            "."))
    }
    out
}

    Você pode simplesmente substituir o aviso por um erro usando stopou rlang:abort():

    `$.tbl_df` <- function (x, name) {
  out <- .subset2(x, name)
  if (is.null(out)) {
    rlang::abort(paste0("Unknown or uninitialised column: ", name, "."))
  }
  out
}

    Então, como esperado:

    > df$male
Error in `$.tbl_df`(df, male) : Unknown or uninitialised column: male.

    Adenda

    Conforme apontado nos comentários, essa solução pode causar problemas se $.tbl_dfestiver sendo chamada internamente. Seguindo o exemplo de @Billy34, podemos substituir a $.tbl_dffunção interna pela nossa função modificada assim:

    patch_tibble <- function(){
  
  # The modified "$.tbl_df" function
  f <- function (x, name) {
    out <- .subset2(x, name)
    if (is.null(out)) {
      abort(paste0("Unknown or uninitialised column: ", tick(name), 
                   "."))
    }
    out
  }
  
  # Set the function's namespace to tibble
  environment(f) <- asNamespace("tibble")
  
  # Replace the original function with our modified version
  utils::assignInNamespace("$.tbl_df", f, "tibble")
  
  print("Patched tibble!")
}

    Isso produz a saída:

    > patch_tibble()
[1] "Patched tibble!"
> df$male
Error in `df$male`:
! Unknown or uninitialised column: `male`.
    • 3

  3. Com base na ideia da resposta de @BenBolker, você pode criar um manipulador global:

    globalCallingHandlers(warning = function(w) {
  if(grepl("Unknown or uninitialised column", w$message, fixed = TRUE)) 
    stop(errorCondition(w$message, class = "unknown_column_extract_error")) else w
  })


library(tibble)
df <- tibble(gender=c(1,1,0))
df$male
#Error: Unknown or uninitialised column: `male`.

#doesn't affect other warnings
as.numeric("a")
#[1] NA
#Warning message:
#  NAs introduced by coercion

    Claro que isso seria mais simples se o aviso fosse classificado.

    • 3

  4. Isso pode ser o mais próximo que você chegará (sem hackear como na resposta anterior): use um tryCatch()que verifique a mensagem de aviso (isso falhará se alguém usar configurações de idioma diferentes para onde o aviso foi traduzido).

    my_try <- function(expr, warnstr = "Unknown or uninitialised column") { 
   tryCatch(expr,
      warning = function(e) { 
         if(grepl(warnstr, e)) simpleError(e) })
}
my_try(df$male)
    • 2

  5. Outros lhe deram soluções alternativas para esse problema. Nesta resposta, explicarei o que os tibbleautores poderiam ter feito para facilitar o trabalho.

    R tem suporte para erros e avisos classificados, mas eles não são muito usados. O rlangpacote tem o classargumento para cada um de abort(), warn()e inform(). Você não precisa usar rlang, tudo pode ser feito com funções base, mas elas empacotam bem.

    Então o que tibblepoderia ter feito é definir uma classe separada em cada aviso que eles emitem. Então você poderia capturar a classe específica correspondente ao aviso que lhe interessa e convertê-la em um erro. Ou você poderia criar seu próprio $.tbl_dfmétodo que faz isso e então escolher se quer ou não a conversão.

    Por exemplo, em vez de

    warn(paste0("Unknown or uninitialised column: ", tick(name), 
        "."))

    eles poderiam ter escrito

    warn(paste0("Unknown or uninitialised column: ", tick(name), 
        "."), class = "warn.$.tbl_df")

    e então você poderia correr

    tryCatch(df$male, `warn.$.tbl_df` = function(w) abort(w$message, class = "error.$.tbl_df", call = NULL))

    para capturar esse aviso e convertê-lo em um erro. Eu converti para um erro de classe com class "error.$.tbl_df"apenas para que algum outro código pudesse capturar isso, mas não há necessidade disso. Eu também configurei call = NULLpara que você não seja informado sobre uma linha no código $.tbl_dfque não significaria nada para você. Você pode ser capaz de encontrar a df$maleexpressão se brincar com a configuração; não tenho certeza de quão longe ela estaria.

    • 2

relate perguntas