Ruby 转换某些输入或拆分某些输入？

我正在写一个程序来计算输入短语的数字根。我使用了整个数字根算法，但某些输入短语似乎与

split

方法不匹配。我想将输入短语分成一个“字符”数组或单个字符串

puts "Please enter a phrase to be converted"
phrase = gets.chomp.downcase!
phrase = phrase.split("")

---

每当输入字符串没有任何大写字母时，我就会得到nil:NilClass（NoMethodError）的错误

未定义的方法“split”

。有什么想法吗？谢谢。

删除

puts "Please enter a phrase to be converted"
phrase = gets.chomp.downcase
phrase = phrase.split("")

按照惯例，使用拖尾
的方法表示更改接收器而不是创建新副本。如果字符串中没有小写字符，则返回
nil
。
删除

puts "Please enter a phrase to be converted"
phrase = gets.chomp.downcase
phrase = phrase.split("")

按照惯例，使用拖尾
的方法表示更改接收器而不是创建新副本。如果字符串中没有大小写字符，则返回
nil
。
您也可以通过其他几种方法执行此操作

puts "Please enter a phrase to be converted"
phrase = gets.chomp.downcase.chars.to_a

或（虽然由于在阵列上进行迭代，速度会较慢，但仍比
#split
快）

你也可以用其他一些方法来做

puts "Please enter a phrase to be converted"
phrase = gets.chomp.downcase.chars.to_a

或（虽然由于在阵列上进行迭代，速度会较慢，但仍比
#split
快）

@engineersmnky展示了两种方法来完成相同的任务，但两者的速度有很大差异：

require 'fruity'

phrase = "Please enter a phrase to be converted"

puts "Running chars.to_a vs. split"
compare {
  chars_to_a1 { phrase.chars.to_a }
  split1 { phrase.split("") }
}

puts '-' * 20

puts "Running downcase.chars.to_a vs. chars.to_a.map(&:downcase)"
compare {
  chars_to_a2 { phrase.chomp.downcase.chars.to_a }
  map_downcase { phrase.chomp.chars.to_a.map(&:downcase) }
}

在我的笔记本电脑上运行会产生以下输出：

# >> Running chars.to_a vs. split
# >> Running each test 1024 times. Test will take about 1 second.
# >> chars_to_a1 is faster than split1 by 5x ± 0.1

在第一次测试中，
split
的速度要慢得多，这让我感到惊讶，但很难反驳这些数字

借助这些知识，我使用更快的结果来测试字符串上的
downcase
结果，而不是单个字母

# >> --------------------
# >> Running downcase.chars.to_a vs. chars.to_a.map(&:downcase)
# >> Running each test 1024 times. Test will take about 1 second.
# >> chars_to_a2 is faster than map_downcase by 2.4x ± 0.1

因此，为了获得最快的结果，请使用
downcase.chars.to_a


还想指出chars.map（&:downcase）仍然比downcase.split（“”）更快

以下是额外的基准：

compare {
  chars_to_a2 { phrase.chomp.downcase.chars.to_a }
  map_downcase { phrase.chomp.chars.to_a.map(&:downcase) }
  chars_map { phrase.chomp.chars.map(&:downcase) }
}
# >> Running each test 1024 times. Test will take about 1 second.
# >> chars_to_a2 is faster than chars_map by 2.4x ± 0.1
# >> chars_map is similar to map_downcase

phrase.chomp.downcase.chars.to_a
的运行速度仍然是其他的2倍

重要的是要注意，使用
map
到
downcase
拆分字符串的成本很高，并且源字符串越长，拆分字符串的成本就越高。将初始字符串延长10倍可以使
phrase.chomp.downcase.chars.to_a
的运行速度比其他两个字符串快3倍

phrase = "Please enter a phrase to be converted" * 10

compare {
  chars_to_a2 { phrase.chomp.downcase.chars.to_a }
  map_downcase { phrase.chomp.chars.to_a.map(&:downcase) }
  chars_map { phrase.chomp.chars.map(&:downcase) }
}
# >> Running each test 128 times. Test will take about 1 second.
# >> chars_to_a2 is faster than map_downcase by 3.0x ± 0.1
# >> map_downcase is similar to chars_map

@engineersmnky展示了两种方法来完成相同的任务，但两者的速度有很大差异：

require 'fruity'

phrase = "Please enter a phrase to be converted"

puts "Running chars.to_a vs. split"
compare {
  chars_to_a1 { phrase.chars.to_a }
  split1 { phrase.split("") }
}

puts '-' * 20

puts "Running downcase.chars.to_a vs. chars.to_a.map(&:downcase)"
compare {
  chars_to_a2 { phrase.chomp.downcase.chars.to_a }
  map_downcase { phrase.chomp.chars.to_a.map(&:downcase) }
}

在我的笔记本电脑上运行会产生以下输出：

# >> Running chars.to_a vs. split
# >> Running each test 1024 times. Test will take about 1 second.
# >> chars_to_a1 is faster than split1 by 5x ± 0.1

在第一次测试中，
split
的速度要慢得多，这让我感到惊讶，但很难反驳这些数字

借助这些知识，我使用更快的结果来测试字符串上的
downcase
结果，而不是单个字母

# >> --------------------
# >> Running downcase.chars.to_a vs. chars.to_a.map(&:downcase)
# >> Running each test 1024 times. Test will take about 1 second.
# >> chars_to_a2 is faster than map_downcase by 2.4x ± 0.1

因此，为了获得最快的结果，请使用
downcase.chars.to_a


还想指出chars.map（&:downcase）仍然比downcase.split（“”）更快

以下是额外的基准：

compare {
  chars_to_a2 { phrase.chomp.downcase.chars.to_a }
  map_downcase { phrase.chomp.chars.to_a.map(&:downcase) }
  chars_map { phrase.chomp.chars.map(&:downcase) }
}
# >> Running each test 1024 times. Test will take about 1 second.
# >> chars_to_a2 is faster than chars_map by 2.4x ± 0.1
# >> chars_map is similar to map_downcase

phrase.chomp.downcase.chars.to_a
的运行速度仍然是其他的2倍

重要的是要注意，使用
map
到
downcase
拆分字符串的成本很高，并且源字符串越长，拆分字符串的成本就越高。将初始字符串延长10倍可以使
phrase.chomp.downcase.chars.to_a
的运行速度比其他两个字符串快3倍

phrase = "Please enter a phrase to be converted" * 10

compare {
  chars_to_a2 { phrase.chomp.downcase.chars.to_a }
  map_downcase { phrase.chomp.chars.to_a.map(&:downcase) }
  chars_map { phrase.chomp.chars.map(&:downcase) }
}
# >> Running each test 128 times. Test will take about 1 second.
# >> chars_to_a2 is faster than map_downcase by 3.0x ± 0.1
# >> map_downcase is similar to chars_map

太好了，谢谢！我现在知道哪里出了问题，哎呀@如果答案解决了你的问题，请接受。是的，我只是在等待时间的流逝。谢谢太好了，谢谢！我现在知道哪里出了问题，哎呀@如果答案解决了你的问题，请接受。是的，我只是在等待时间的流逝。谢谢最好是
downcase
一次，而不是遍历数组和
downcase
每个元素。我将添加一个基准。@theTinMan我知道我只是想指出，在ruby中执行相同任务有很多方法，除非字符串非常长，否则性能影响似乎可以忽略不计。但是感谢您提供的基准测试，很高兴看到我的方法中有一个是最快的。多个示例很好，但是在有一些折衷的情况下添加警告也是很好的；新手不会理解这个问题，可能会因为“原因”而做错事，比如选择的答案，虽然从技术上讲是正确的，但并没有更好的方法。；-）最好是
downcase
一次，而不是遍历数组和
downcase
每个元素。我将添加一个基准。@theTinMan我知道我只是想指出，在ruby中执行相同任务有很多方法，除非字符串非常长，否则性能影响似乎可以忽略不计。但是感谢您提供的基准测试，很高兴看到我的方法中有一个是最快的。多个示例很好，但是在有一些折衷的情况下添加警告也是很好的；新手不会理解这个问题，可能会因为“原因”而做错事，比如选择的答案，虽然从技术上讲是正确的，但并没有更好的方法。；-）我还想指出，
chars.map（&:downcase）
仍然比
downcase.split（“”）
快，并且在map之前将
Enumerable#chars
转换为
数组
是不必要的，因为
Enumerable#map
在给定
块时返回数组，但是将添加它作为第三个测试来显示结果。还想指出
chars.map（&:downcase）
仍然比
downcase.split（“”）更快
并且在映射之前将
可枚举字符
转换为
数组
是不必要的，因为
可枚举#映射
在给定一个
块时返回一个数组
我正在对您的代码进行RIFF，但将添加该数组作为第三个测试，以显示