Question

要在json中编码字符串，需要使用反斜杠转义几个保留字符，并且每个字符串都需要用双引号括起来。目前，jsonlite包使用基本R中的deparse函数实现此目的：

deparse_vector <- function(x) {
  stopifnot(is.character(x))
  vapply(x, deparse, character(1), USE.NAMES=FALSE)
}

这就是诀窍：

test <- c("line\nline", "foo\\bar", "I said: \"hi!\"")
cat(deparse_vector(test))

然而deparse对于大型载体来说效果很慢。另一种实现是单独gsub每个字符：

deparse_vector2 <- function(x) {
  stopifnot(is.character(x))
  if(!length(x)) return(x)
  x <- gsub("\\", "\\\\", x, fixed=TRUE)
  x <- gsub("\"", "\\\"", x, fixed=TRUE)
  x <- gsub("\n", "\\n", x, fixed=TRUE)
  x <- gsub("\r", "\\r", x, fixed=TRUE)
  x <- gsub("\t", "\\t", x, fixed=TRUE)
  x <- gsub("\b", "\\b", x, fixed=TRUE)
  x <- gsub("\f", "\\f", x, fixed=TRUE)
  paste0("\"", x, "\"")
}

这有点快，但也不多，也有点难看。什么是更好的方法来做到这一点？（最好没有额外的依赖）

此script可用于比较实现：

> system.time(out1 <- deparse_vector1(strings))
   user  system elapsed 
  6.517   0.000   6.523 
> system.time(out2 <- deparse_vector2(strings))
   user  system elapsed 
  1.194   0.000   1.194

Answer 1

这是Winston代码的C ++版本。它非常简单，因为你可以有效地增长std::string。它也不太可能崩溃，因为Rcpp会为你处理内存管理。

#include <Rcpp.h>
using namespace Rcpp;

// [[Rcpp::export]]
std::string escape_one(std::string x) {
  std::string out = "\"";

  int n = x.size();
  for (int i = 0; i < n; ++i) {
    char cur = x[i];

    switch(cur) {
      case '\\': out += "\\\\"; break;
      case '"':  out += "\\\""; break;
      case '\n': out += "\\n";  break;
      case '\r': out += "\\r";  break;
      case '\t': out += "\\t";  break;
      case '\b': out += "\\b";  break;
      case '\f': out += "\\f";  break;
      default:     out += cur;
    }
  }

  out += '"';

  return out;
}

// [[Rcpp::export]]
CharacterVector escape_chars(CharacterVector x) {
  int n = x.size();
  CharacterVector out(n);

  for (int i = 0; i < n; ++i) {
    String cur = x[i];
    out[i] = escape_one(cur);
  }

  return out;
}

在您的基准测试中，deparse_vector2(strings)需要0.8秒，escape_chars(strings)需要0.165秒。

Answer 2

我不知道使用R代码更快地完成此操作，但我确实尝试用C语言实现它，包含在一个名为deparse_vector3的R函数中。这很粗糙（而且我远离专家C程序员），但它似乎适用于您的示例：https://gist.github.com/wch/e3ec5b20eb712f1b22b2

在我的系统上（Mac，R 3.1.1），deparse_vector2比deparse_vector快20倍，这比你在测试中得到的5倍差。

我的deparse_vector3功能仅比deparse_vector2快3倍。可能还有改进的余地。

> system.time(out1 <- deparse_vector1(strings))
   user  system elapsed 
  8.459   0.009   8.470 
> system.time(out2 <- deparse_vector2(strings))
   user  system elapsed 
  0.368   0.007   0.374 
> system.time(out3 <- deparse_vector3(strings))
   user  system elapsed 
  0.120   0.001   0.120

但是，我认为这不会正确处理非ASCII字符编码。以下是R源代码处理方式的示例：https://github.com/wch/r-source/blob/trunk/src/main/grep.c#L704-L739

编辑：这似乎可以处理UTF-8，但我可能会在测试中遗漏一些东西。

Answer 3

您也可以尝试使用stri_escape_unicode包中的stringi（虽然您更喜欢没有其他依赖关系的解决方案，但我认为它对未来的读者也很有用），比{{1}快3倍比deparse_vector2

快约7倍

deparse_vector

定义功能

require(stringi)

检查所有功能是否给出了结果

deparse_vector3 <- function(x){
  paste0("\"",stri_escape_unicode(x), "\"")
}

一些基准

all.equal(deparse_vector2(test), deparse_vector3(test))
## [1] TRUE
all.equal(deparse_vector(test), deparse_vector3(test))
## [1] TRUE

Answer 4

再次利用一些事实来解决这个问题。

给定长度为x的字符串n，我们知道输出字符串的长度至少为x，最多为2 * x。我们可以利用这一点来确保我们只分配一次内存，而不是依赖于增长的容器（尽管有效）。

请注意，我在这里使用了C ++ 11的shared_ptr，因为我正在使用原始内存进行丑陋的操作（并希望确保自动清理它）。这也允许我避免初始传递，其中我试图计算匹配，但也迫使我过度分配（必须转义每个字符的情况很少）。

我认为将它改编为纯C解决方案会相对容易，但要确保内存得到适当清理会更加棘手。

#include <memory>
#include <Rcpp.h>
using namespace Rcpp;

// [[Rcpp::export]]
void escape_one_fill(CharacterVector const& x, int i, CharacterVector& output) {

  auto xi = CHAR(STRING_ELT(x, i));
  int n = strlen(xi);

  // Over-allocate memory -- we know that in the worst case the output
  // string is 2x the length of x (plus 1 for \0)
  auto out = std::make_shared<char*>(new char[n * 2 + 1]);

  int counter = 0;
  (*out)[counter++] = '"';

  #define HANDLE_CASE(X, Y) \
    case X: \
      (*out)[counter++] = '\\'; \
      (*out)[counter++] = Y; \
      break;

  for (int j = 0; j < n; ++j) {
    switch (xi[j]) {
      HANDLE_CASE('\\', '\\');
      HANDLE_CASE('"', '"');
      HANDLE_CASE('\n', 'n');
      HANDLE_CASE('\r', 'r');
      HANDLE_CASE('\t', 't');
      HANDLE_CASE('\b', 'b');
      HANDLE_CASE('\f', 'f');
      default: (*out)[counter++] = xi[j];
    }
  }

  (*out)[counter++] = '"';

  // Set a NUL so that Rf_mkChar does what it should
  (*out)[counter++] = '\0';
  SET_STRING_ELT(output, i, Rf_mkChar(*out));

}

// [[Rcpp::export]]
CharacterVector escape_chars_with_fill(CharacterVector x) {
  int n = x.size();
  CharacterVector out(n);

  for (int i = 0; i < n; ++i) {
    escape_one_fill(x, i, out);
  }

  return out;
}

对此进行基准测试，我得到（只是与Hadley的impl相比）：

> mychars <- c(letters, " ", '"', "\\", "\t", "\n", "\r", "'", "/", "#", "$");

> createstring <- function(length){
+   paste(mychars[ceiling(runif(length, 0, length(mychars)))], collapse="")
+ }

> strings <- vapply(rep(1000, 10000), createstring, character(1), USE.NAMES=FALSE)

> system.time(escape_chars(strings))
   user  system elapsed 
   0.14    0.00    0.14 

> system.time(escape_chars_with_fill(strings))
   user  system elapsed 
  0.080   0.001   0.081 

> identical(escape_chars(strings), escape_chars_with_fill(strings))
[1] TRUE

R中字符向量的快速转义/去除

4 个答案: