还有一个选择：

sum(gsub(" ", "", vector, fixed = TRUE) == "")

以下是对前一个答案的简洁变体：

sum(trimws(vector) == "")

最后……因为我们对基准测试很感兴趣。与基本 R 相比，还有改进的空间，正如 SamR 使用 stringi 所显示的那样。这是另一个使用 Rcpp 的示例，我们避免修改向量并逐个检查字符，直到第一个非空格字符。

cppFunction("int count_empty_cpp(CharacterVector x) {
  int count = 0, j, n;
  std::string v;
  for (int i = 0; i < x.size(); i++) {
    v = Rcpp::as<std::string>(x[i]);
    n = v.length();
    if (n == 0) {
      count++;
    } else {
      j = 0;
      while (j < n && v[j] == ' ') j++;
      if (j == n) count++;
    }
  }
  return count;
}")

纯 R 方法

您有几个出色的 R 语言基础答案。我注意到您标记了stringr。我认为在这里使用 没有任何优势。但是，使用R 包在任何语言环境或字符编码中进行快速、可移植、正确、一致且方便的字符串/文本处理stringr可能会有优势。stringi

stringi往往非常快。stringr取决于stringi（实际上许多stringr函数都是stringi函数的薄包装器），因此如果您已经stringr安装了，那么您也有stringi。

与 不同stringr，stringi有一个检查空字符串的函数（相当于!base::nzchar()），它可能比字符串比较更快，并且几乎肯定比计算所有字符串（包括非空字符串）的字符更快。

library(stringi)
sum(stri_isempty(stri_trim_both(vector)))
# [1] 3

Rcpp 方法

正如 S. Baldur 的回答所表明的，您Rcpp也可以使用它。

这个速度太快了，我将把它包含在下面一个单独的基准测试部分中，以便更容易地看到纯 R 方法的差异。

纯 R 基准

只是为了好玩，我使用长度不超过 1m 的向量运行了一些基准测试。S . Baldur 的第二种方法对于长度为 10 和 100 的向量来说是最快的。对于长度为 1000 及以上的向量，该stringi方法是最快的。

如果 RAM 是一个因素，那么 Ben Bolker 的答案始终使用最少的内存。以下是表格形式的数据（请注意，时间是相对的，最快/最低内存方法始终是1）。

   expression vec_length   min median `itr/sec` mem_alloc `gc/sec` n_itr  n_gc total_time
   <bch:expr>      <dbl> <dbl>  <dbl>     <dbl>     <dbl>    <dbl> <int> <dbl>   <bch:tm>
 1 bolker             10  1.95   1.65      4.91    NaN         Inf  9999     1      161ms
 2 rudolph            10  5.64   7.11      1       NaN         Inf  6099     2      483ms
 3 baldur             10  1.09   1         7.13    NaN         Inf  9999     1      111ms
 4 baldur2            10  1.05   1         6.91    NaN         NaN 10000     0      115ms
 5 thomas             10  1.55   1.92      4.11    NaN         Inf  9999     1      193ms
 6 rui                10  5.82   7.38      1.18    NaN         Inf  7046     2      472ms
 7 rui2               10  5.55   6.95      1.23    NaN         Inf  7373     3      475ms
 8 samr               10  1      1.27      6.72    NaN         NaN 10000     0      118ms
 9 bolker            100  1.56   1.57      4.30      1         Inf  9999     1      320ms
10 rudolph           100  6.83   6.53      1.10      5.79      Inf  3892     1      487ms
11 baldur            100  1.03   1.04      6.64      2.89      Inf  9999     1      207ms
12 baldur2           100  1      1         6.87      3.89      Inf  9999     1      200ms
13 thomas            100  1.64   1.58      4.19      2         NaN 10000     0      328ms
14 rui               100  7      7.07      1         5.79      Inf  3546     1      488ms
15 rui2              100  6.69   6.5       1.12      5.79      Inf  3904     2      482ms
16 samr              100  1.19   1.05      6.38      2.89      NaN 10000     0      216ms
17 bolker           1000  1.31   1.64      4.09      1         Inf  3025     1      487ms
18 rudolph          1000  5.43   5.97      1.10      5.98      NaN   830     0      499ms
19 baldur           1000  1.06   1.23      5.13      2.99      Inf  3109     1      399ms
20 baldur2          1000  1      1.18      5.57      3.99      NaN  4186     0      495ms
21 thomas           1000  1.17   1.41      4.89      2         NaN  3685     0      496ms
22 rui              1000  7.32   6.58      1         5.98      NaN   758     0      499ms
23 rui2             1000  7.17   5.85      1.12      5.98      NaN   853     0      500ms
24 samr             1000  1.05   1         6.01      2.99      Inf  4439     1      486ms
25 bolker          10000  1.77   1.61      4.39      1         NaN   355     0      501ms
26 rudolph         10000  8.56   6.18      1.13      6.00      NaN    92     0      502ms
27 baldur          10000  1.06   1.26      5.56      3.00      Inf   443     1      492ms
28 baldur2         10000  1      1.21      5.69      4.00      NaN   460     0      500ms
29 thomas          10000  1.57   1.44      4.81      2         Inf   388     1      499ms
30 rui             10000  8.28   6.89      1         6.00      NaN    81     0      501ms
31 rui2            10000  8.69   6.19      1.13      6.00      NaN    92     0      505ms
32 samr            10000  1.23   1         6.69      3.00      Inf   533     1      493ms
33 bolker         100000  1.92   1.58      4.21      1         NaN    36     0      510ms
34 rudolph        100000  7.83   6.31      1.07      6.00      NaN     9     0      504ms
35 baldur         100000  1.37   1.31      5.08      3.00      Inf    42     1      493ms
36 baldur2        100000  1.45   1.37      4.96      4.00      Inf    41     1      493ms
37 thomas         100000  1.52   1.37      4.89      2         NaN    41     0      500ms
38 rui            100000  7.46   6.60      1         6.00      NaN     9     0      537ms
39 rui2           100000  6.93   6.05      1.11      6.00      Inf     9     1      483ms
40 samr           100000  1      1         6.56      3.00      NaN    55     0      500ms
41 bolker        1000000  1.81   1.79      4.39      1         NaN     4     0      551ms
42 rudolph       1000000  7.76   7.13      1.09      6.00      NaN     1     0      553ms
43 baldur        1000000  1.48   1.44      5.42      3.00      Inf     4     1      447ms
44 baldur2       1000000  1.52   1.44      5.44      4.00      Inf     4     1      445ms
45 thomas        1000000  1.64   1.53      5.04      2         Inf     4     1      480ms
46 rui           1000000  8.50   7.80      1         6.00      NaN     1     0      605ms
47 rui2          1000000  7.59   6.97      1.12      6.00      NaN     1     0      541ms
48 samr          1000000  1      1         7.88      3.00      Inf     6     1      460ms

基准代码：

results <- bench::press(
    vec_length = 10^(1:6),
    {
        vals <- c("Red", "", " ", " ", "   ", "   ", "5", letters[1:3])
        v <- sample(vals, vec_length, replace = TRUE)
        bench::mark(
            relative = TRUE,
            bolker = sum(grepl("^ *$", v)),
            rudolph = sum(!nzchar(trimws(v))),
            baldur = sum(gsub(" ", "", v, fixed = TRUE) == ""),
            baldur2 = sum(!nzchar(gsub(" ", "", v, fixed = TRUE))),
            thomas = sum(!grepl("\\S", v)),
            rui = sum(nchar(trimws(v)) == 0),
            rui2 = sum(!nzchar(trimws(v))),
            samr = sum(stri_isempty(stri_trim_both(v)))
        )
    }
)

Rcpp基准

我单独提供了 S. Baldur 函数的基准测试count_empty_cpp()。这比我的方法快得多stringi，所以我添加了另一个Rcpp使用 C++ 标准库的函数，该函数主要基于对 C++ 问题的回答，即检查 std::string 是否仅包含空格的有效方法。

Rcpp::cppFunction("int count_empty_cpp2(CharacterVector x) {
  int count = 0, j, n;
  std::string str;
  for (int i = 0; i < x.size(); i++) {
    str = Rcpp::as<std::string>(x[i]);
    if(str.find_first_not_of(' ') == std::string::npos)
    {
        count++;
    }
  }
  return count;
}")

我还添加了第三个Rcpp函数，它查看字符向量每个元素的底层S 表达式CHAR()。这意味着我们可以在字符串为空的情况下避免类型转换。此外，当我们需要查看字符串的内容时，我使用将转换SEXP为 C 样式指针，指向以空字符结尾的字符串（const char*），而不是 C++ std::string。这意味着我们复制引用（每个字符串可能 8 个字节），而不是数据。

Rcpp::cppFunction("int count_empty_cpp3(CharacterVector x) {
  int count = 0;
  for (int i = 0; i < x.size(); i++) {
    SEXP elem = x[i];
    R_xlen_t len = Rf_length(elem);
    if (len == 0) {
      count++;
    } else {
      const char* str = CHAR(elem);
      bool is_empty = true;
      for (R_xlen_t j = 0; j < len; j++) {
        if (str[j] != ' ') {
          is_empty = false;
          break;
        }
      }
      if (is_empty) count++;
    }
  }
  return count;
}")

我将这些方法与两个最快的 R 答案进行了比较。Rcpp一旦向量长度为​​，所有方法都比最快的 R 方法快得多>1e4。

以下是结果表。前两种方法之间差别很小Rcpp。避免的方法std::string比其他两种方法稍快一些：

   expression    vec_length   min median `itr/sec` mem_alloc `gc/sec` n_itr  n_gc total_time
   <bch:expr>         <dbl> <dbl>  <dbl>     <dbl>     <dbl>    <dbl> <int> <dbl>   <bch:tm>
 1 baldur2_baser         10  1.56   1.55      1.61    NaN         Inf  9999     1    84.46ms
 2 samr_stringi          10  2.44   2.18      1       NaN         NaN 10000     0   135.71ms
 3 baldercpp             10  1.11   1.05      2.22    Inf         NaN 10000     0    61.11ms
 4 samrcpp               10  1.11   1.09      1.95    Inf         Inf  9999     1    69.62ms
 5 samrcpp2              10  1      1         2.10    Inf         Inf  9999     1    64.57ms
 6 baldur2_baser        100  2.64   2.57      1         1.35      NaN 10000     0   200.12ms
 7 samr_stringi         100  3      2.57      1.01      1         Inf  9999     1   198.57ms
 8 baldercpp            100  1.14   1.03      2.33      1.97      NaN 10000     0    85.74ms
 9 samrcpp              100  1.14   1.1       1.90      1.97      Inf  9999     1   105.58ms
10 samrcpp2             100  1      1         2.23      1.97      Inf  9999     1    89.85ms
11 baldur2_baser       1000  3.67   4.51      1         6.33      Inf  4408     2   481.84ms
12 samr_stringi        1000  3.64   3.93      1.03      4.74      Inf  4591     1   488.59ms
13 baldercpp           1000  1.45   1.41      2.77      1         Inf  9999     1   395.14ms
14 samrcpp             1000  1.55   1.49      2.58      1         Inf  9999     1   423.62ms
15 samrcpp2            1000  1      1         3.92      1         NaN 10000     0   278.97ms
16 baldur2_baser      10000  4.06   5.29      1        62.8       Inf   465     3   480.15ms
17 samr_stringi       10000  3.73   4.26      1.16     47.1       Inf   555     1   494.04ms
18 baldercpp          10000  1.52   1.56      2.99      1         NaN  1444     0   498.64ms
19 samrcpp            10000  1.58   1.64      3.05      1         Inf  1457     1    492.9ms
20 samrcpp2           10000  1      1         4.79      1         NaN  2305     0   496.85ms
21 baldur2_baser     100000  5.35   5.16      1       627.        Inf    48     2   529.89ms
22 samr_stringi      100000  4.61   4.08      1.23    470.        Inf    54     2    484.1ms
23 baldercpp         100000  1.51   1.53      3.34      1         NaN   152     0    501.8ms
24 samrcpp           100000  1.57   1.57      3.31      1         NaN   150     0   500.94ms
25 samrcpp2          100000  1      1         4.89      1         NaN   222     0    501.5ms
26 baldur2_baser    1000000  4.46   5.04      1      6270.        Inf    27    23      2.89s
27 samr_stringi     1000000  3.94   3.89      1.27   4702.        Inf    37    13      3.11s
28 baldercpp        1000000  1.30   1.41      3.50      1         NaN    50     0      1.53s
29 samrcpp          1000000  1.45   1.53      3.15      1         NaN    50     0      1.69s
30 samrcpp2         1000000  1      1         4.65      1         NaN    50     0      1.15s

这些是相对较短的字符串。我不会运行更多基准测试，但我怀疑如果字符串更长，我们会看到复制指针而不是数据的相对优势。

关于基准的说明

这些基准测试主要是为了好玩。所有答案之间的差异相对较小，因此除非您使用巨大的向量重复多次，字符串非常长或内存资源非常有限，否则我会优化可读代码，而不是推出我自己的 Rcpp 解决方案，该解决方案的速度快几纳秒。

对于代码高尔夫，你可能感兴趣

> sum(!grepl("\\S", vector))
[1] 3

使用sum(grepl())加上适当的正则表达式：

vector<-c("Red", "   ", "", "5", "")
sum(grepl("^ *$", vector))

• ^：字符串的开头
• *：零个或多个空格
• $：字符串结尾

如果您想更普遍地寻找“空白”（例如允许制表符），请使用"^[[:space:]]*$"，尽管正如所指出的那样?grep，空白的定义取决于语言环境......

length(grep(...))也可以，或者stringr::str_count(vector, "^ *$")。

物有所值：

 microbenchmark::microbenchmark(
     bolker =  sum(grepl("^ *$", vector)),
     rudolph = sum(! nzchar(trimws(vector))),
     baldur = sum(gsub(" ", "", vector, fixed = TRUE) == ""),
    baldur2 = sum(! nzchar(gsub(" ", "", vector, fixed = TRUE))))

Unit: microseconds
    expr    min      lq     mean  median      uq    max neval cld
  bolker 10.499 10.8900 12.31869 11.8020 12.7990 40.976   100 a  
 rudolph 19.306 20.0125 22.01722 20.7990 22.9480 66.815   100  b 
  baldur  2.294  2.5700  2.76420  2.7455  2.8950  3.567   100   c
 baldur2  2.294  2.4740  2.66267  2.6450  2.7755  5.130   100   c

（@RuiBarradas 未包括在内，因为 vs 与 @KonradRudolph 类似）。我很惊讶 @s_baldur 的回答如此之快……但可能还值得记住的是，除非这个操作占了你整个工作流程的很大一部分，否则它的速度足够快，不用担心效率……

我会nzchar()与...结合使用trimws()（尽管...的双重否定!nzchar()使得阅读起来有点尴尬）：

sum(! nzchar(trimws(vector)))
# [1] 3

trimws删除所有空格。然后nchar会得到字符数。与零进行比较并仅计算那些。但这比Ben Bolker 的答案慢大约 3 倍。

v <- c("Red", "   ", "", "5", "")
sum(nchar(trimws(v)) == 0)
#> [1] 3

^{创建于 2024-06-30，使用reprex v2.1.0}

编辑

根据现已删除的评论，

sum(!nzchar(trimws(v)))
#> [1] 3

^{创建于 2024-06-30，使用reprex v2.1.0}