39

我想将下面的字符串数组的元素转换为符号，并输出它们

strings = ["HTML", "CSS", "JavaScript", "Python", "Ruby"]

看看我在做什么：

strings.each { |x| puts x.to_sym }

没有成功。我究竟做错了什么？

4

9 回答 9

56

使用map而不是each：

>> strings.map { |x| x.to_sym }
=> [:HTML, :CSS, :JavaScript, :Python, :Ruby]

对于 Ruby 1.8.7 及更高版本或包含 ActiveSupport，您可以使用以下语法：

>> strings.map &:to_sym
=> [:HTML, :CSS, :JavaScript, :Python, :Ruby]

您的each方法似乎不起作用的原因是puts使用符号调用会输出符号的字符串表示形式（即，没有:）。此外，您只是循环并输出内容；你实际上并没有构建一个新数组。

于 2013-05-12T00:03:53.360 回答
30

清洁单线：

%w(HTML CSS JavaScript Python Ruby).map(&:to_sym)

&告诉参数应该被视为一个块，即建立数组并应用于to_sym每个元素。

于 2015-10-06T13:07:52.373 回答
10

我会做类似的事情

strings.map! &:to_sym
于 2015-02-17T19:37:07.073 回答
4

icktoofay 已经给出了正确答案。

附注：有

strings.map { |x| x.to_sym }

你得到一个新数组，原来的数组没有改变。

要使用它，您可以将其分配给另一个变量：

string2 = strings.map { |x| x.to_sym }

如果要修改字符串，可以使用map!：

strings.map! { |x| x.to_sym }
于 2013-05-12T18:08:46.327 回答
2

@icktoofay 有正确的答案，但只是为了帮助您更好地理解该each方法，以下是您可以使用以下方法执行相同操作的方法each：

strings = ["HTML", "CSS", "JavaScript", "Python", "Ruby"]
symbols = [] # an empty array to hold our symbols
strings.each { |s| symbols << s.to_sym }
于 2013-05-12T00:10:28.127 回答
1

如果您想走 gem 路线，finish_moves有一个Array#to_sym_strict方法可以完全满足您的需求：

strings = ["HTML", "CSS", "JavaScript", "Python", "Ruby"]
strings.to_sym_strict
# => [:HTML, :CSS, :JavaScript, :Python, :Ruby]

还有一个#to_sym_loose处理混合类型的数组：

strings = ["HTML", "CSS", "JavaScript", "Python", "Ruby", 1, /a regex/, {a: :hash}]
strings.to_sym_loose
# => [:HTML, :CSS, :JavaScript, :Python, :Ruby, 1, /a regex/, {a: :hash}]
# no exceptions thrown
于 2018-08-09T16:58:40.360 回答
1

@cb24 的回答通常是最合适的，我想将该解决方案与另一个解决方案进行比较

strings.collect {|x| x.to_sym }

我做了一些基准测试，@cb24 的答案在大多数情况下效果最好，当数组中有更多元素时，但如果它恰好是一个非常小的数组，那么 collect 方法的工作速度会更快一些。

我在这里发布代码和结果，这是我真正的第一个基准测试，所以如果我有什么错误，我们将不胜感激。我在 String -> Symbol 和 Symbol -> String 上都做了

n = 1000000 

a = [:a,:b,:c,:d,:e,:f,:g,:h,:i].freeze #A "long" array of symbols

Benchmark.bm do |x|
  x.report { n.times { a.map(&:to_s)} }
  x.report { n.times { a.collect{|x| x.to_s}} }
end  

       user     system      total        real
   2.040000   0.010000   2.050000 (  2.056784)
   2.100000   0.010000   2.110000 (  2.118546)


b = [:a, :b].freeze  #Small array

Benchmark.bm do |x|
  x.report { n.times { b.map(&:to_s)} }
  x.report { n.times { b.collect{|x| x.to_s}} }
end  


       user     system      total        real
   0.610000   0.000000   0.610000 (  0.622231)
   0.530000   0.010000   0.540000 (  0.536087)



w = %w(a b).freeze  #Again, a small array, now of Strings
Benchmark.bm do |x|
  x.report { n.times { w.map(&:to_sym)} }
  x.report { n.times { w.collect{|x| x.to_sym}} }
end 

       user     system      total        real
   0.510000   0.000000   0.510000 (  0.519337)
   0.440000   0.010000   0.450000 (  0.447990)



y = %w(a b c d e f g h i j k l m n o p q).freeze #And a pretty long one
Benchmark.bm do |x|
  x.report { n.times { y.map(&:to_sym)} }
  x.report { n.times { y.collect{|x| x.to_sym}} }
end 

       user     system      total        real
   2.870000   0.030000   2.900000 (  2.928830)
   3.240000   0.030000   3.270000 (  3.371295)

我没有计算出拐点，但这很有趣，我在某处读到了一些使用短数组进行的改进，因为它们中的大多数只是几个元素长。

于 2016-07-09T00:36:17.737 回答
0

或者可以这样做：

strings.each do |s|  
symbols.push(s.to_sym)
于 2015-04-11T02:05:21.877 回答
0

为了完整起见，您还可以使用%i至少从 Ruby 2.0.0 开始的字符串文字，从符号数组开始。

%i[HTML CSS JavaScript Python Ruby]
# => [:HTML, :CSS, :JavaScript, :Python, :Ruby]
于 2021-04-14T19:46:49.530 回答