blocks|key|355157|text|问题的核心是您创建了一个JSON字符串数组，而不是一个数组，然后生成JSON。而不是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|355158|companies_json+=+[]

data_hash.each+do+%7Chash%7C
++companies_json+<<+hash.to_json
end|code-block|syntax|javascript|355159|执行以下操作：|355160|companies+=+[]

data_hash.each+do+%7Chash%7C
++companies+<<+hash
end

companies_json+=+companies.to_json|355161|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

The core of your problem is that you are creating an array of JSON strings, instead of an array and then making that JSON. Instead of:

<pre><code>companies_json = []

data_hash.each do |hash|
 companies_json &lt;&lt; hash.to_json
end
</code></pre>

do:

<pre><code>companies = []

data_hash.each do |hash|
 companies &lt;&lt; hash
end

companies_json = companies.to_json
</code></pre>

blocks|key|4931720|text|@Phrogz有正确的答案。这是为了对正在发生的事情提供更多的解释：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4931721|require+'json'

foo+=+{'a'+=>+1}
foo.to_json+#+=>+"{\"a\":1}"|code-block|syntax|javascript|4931722|这就是JSON序列化哈希的样子。它是一个包含转义引号的字符串，用:分隔键和值对。"{...}"始终是一个数组、"[...]"或散列JSON，无论哪种情况，它都是一个字符串。这就是序列化的作用和JSON的工作方式。|offset|length|style|CODE|4931723|[foo.to_json]+#+=>+["{\"a\":1}"]
[foo.to_json].class+#+=>+Array|4931724|这是一个包含JSON序列化散列的数组，这就是您要做的。可以看出它没有被正确序列化，因为它是一个数组，而不是一个字符串。周围的[...]在引号之外，而在JSON中，它们在引号内：|4931725|[].to_json+#+=>+"[]"
{}.to_json+#+=>+"{}"|4931726|继续..。|4931727|[foo].to_json+#+=>+"[{\"a\":1}]"
[foo].to_json.class+#+=>+String|4931728|这是一个序列化的哈希数组。在本例中，它是一个散列，但对于这个示例来说，它已经足够了。它是序列化后的字符串，您可以看出这一点，因为数组[...]位于引号内。|4931729|4931730|如果你真的想了解这些东西，我强烈建议你阅读JSON+home+page，以及Ruby的JSON，YAML和Psych文档。了解JSON+is+nearly+a+subset+of+YAML以及它是如何实现的，这对你开始使用JSON、YAML和互联网是非常有帮助的。|4931731|"Fer实例“：|4931732|json_hash+=+'{"a":1}'
yaml_hash+=+"---\na:+1"

require+'yaml'
YAML.load(json_hash)+#+=>+{"a"=>1}
YAML.load(yaml_hash)+#+=>+{"a"=>1}

Psych.load(json_hash)+#+=>+{"a"=>1}
Psych.load(yaml_hash)+#+=>+{"a"=>1}

require+'json'
JSON[json_hash]+#+=>+{"a"=>1}
JSON[yaml_hash]+#+=>+JSON::ParserError:+743:+unexpected+token+at+'---\na:+1'|4931733|有点让你大吃一惊，对吧？|4931734|entityMap|0|LINK|mutability|MUTABLE|url|http://www.json.org/|1|http://ruby-doc.org/stdlib-2.3.1/libdoc/json/rdoc/index.html|2|http://ruby-doc.org/stdlib-2.3.1/libdoc/yaml/rdoc/index.html|3|http://ruby-doc.org/stdlib-2.3.1/libdoc/psych/rdoc/index.html|4|https://stackoverflow.com/a/1729545/128421^0|0|0|W|1|14|7|1J|7|0|0|1Q|5|0|0|0|0|1U|5|0|0|L|E|0|17|4|1|1C|4|2|1H|5|3|1R|V|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1N|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1O|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1P|8|@$I|1Q|J|1R|K|L]|$I|1S|J|1T|K|L]|$I|1U|J|1V|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|1W|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1X|8|@$I|1Y|J|1Z|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|20|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|21|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|22|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|23|8|@$I|24|J|25|K|L]]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|26|8|@]|9|@]|A|$]]|$1|Z|3|10|5|6|7|27|8|@]|9|@$I|28|J|29|1|2A]|$I|2B|J|2C|1|2D]|$I|2E|J|2F|1|2G]|$I|2H|J|2I|1|2J]|$I|2K|J|2L|1|2M]]|A|$]]|$1|11|3|12|5|6|7|2N|8|@]|9|@]|A|$]]|$1|13|3|14|5|D|7|2O|8|@]|9|@]|A|$E|F]]|$1|15|3|16|5|6|7|2P|8|@]|9|@]|A|$]]|$1|17|3|-4|5|6|7|2Q|8|@]|9|@]|A|$]]]|18|$19|$5|1A|1B|1C|A|$1D|1E]]|1F|$5|1A|1B|1C|A|$1D|1G]]|1H|$5|1A|1B|1C|A|$1D|1I]]|1J|$5|1A|1B|1C|A|$1D|1K]]|1L|$5|1A|1B|1C|A|$1D|1M]]]]

@Phrogz has the correct answer. This is to provide a bit more explanation of what's happening:

<pre><code>require 'json'

foo = {'a' =&gt; 1}
foo.to_json # =&gt; "{\"a\":1}"
</code></pre>

That's what a JSON serialized hash looks like. It's a string containing escaped quotes wrapping the key, with <code>:</code> delimiting the key and value pair. JSON is always an array, <code>"[...]"</code>, or a hash, <code>"{...}"</code>, and in either case it's a String. That's just what serializing does and how JSON works.

<pre><code>[foo.to_json] # =&gt; ["{\"a\":1}"]
[foo.to_json].class # =&gt; Array
</code></pre>

That's an array containing a JSON serialized hash, which is what you're doing. You can tell it's not serialized correctly because it's an Array, not a String. The surrounding <code>[...]</code> are outside the quotes whereas in JSON they're inside the quotes:

<pre><code>[].to_json # =&gt; "[]"
{}.to_json # =&gt; "{}"
</code></pre>

Moving on...

<pre><code>[foo].to_json # =&gt; "[{\"a\":1}]"
[foo].to_json.class # =&gt; String
</code></pre>

That's a serialized array of hashes. In this case it's a single hash, but it's sufficient for this example. It's a String after serializing, which you can tell because the array <code>[...]</code> is inside the surrounding quotes.

<hr>

If you really want to understand this stuff I highly recommend reading both the <a href="http://www.json.org" rel="noreferrer">JSON home page</a>, along with Ruby's <a href="http://ruby-doc.org/stdlib-2.3.1/libdoc/json/rdoc/index.html" rel="noreferrer">JSON</a>, <a href="http://ruby-doc.org/stdlib-2.3.1/libdoc/yaml/rdoc/index.html" rel="noreferrer">YAML</a> and <a href="http://ruby-doc.org/stdlib-2.3.1/libdoc/psych/rdoc/index.html" rel="noreferrer">Psych</a> documentation. <a href="https://stackoverflow.com/a/1729545/128421">JSON is nearly a subset of YAML</a>, so knowing YAML and how Psych implements it is really helpful as you move into working with JSON, YAML and the internet.

"Fer instance":

<pre><code>json_hash = '{"a":1}'
yaml_hash = "---\na: 1"

require 'yaml'
YAML.load(json_hash) # =&gt; {"a"=&gt;1}
YAML.load(yaml_hash) # =&gt; {"a"=&gt;1}

Psych.load(json_hash) # =&gt; {"a"=&gt;1}
Psych.load(yaml_hash) # =&gt; {"a"=&gt;1}

require 'json'
JSON[json_hash] # =&gt; {"a"=&gt;1}
JSON[yaml_hash] # =&gt; JSON::ParserError: 743: unexpected token at '---\na: 1'
</code></pre>

Kinda blows your mind doesn't it?

I am creating a JSON file with Ruby.
I need to create the object "companies" within the JSON file.

Expected result: 

<pre><code>{"companies":[
 {\"label\":\"Wayfair \",\"values\":[54]},
 {\"label\":\"Move24 \",\"values\":[29]},
 {\"label\":\"Auto1 \",\"values\":[23]},
...
]}
</code></pre>

What I am getting:

<pre><code>[ 
 "{\"label\":\"Wayfair \",\"values\":[54,54]}",
 "{\"label\":\"Move24 \",\"values\":[29,29]}",
 "{\"label\":\"GetYourGuide \",\"values\":[28,28]}",
 "{\"label\":\"Auto1.com \",\"values\":[20,20]}", ...
]
</code></pre>

My code:

<pre><code>data_hash = data_hash.map {|k,v| {label: k, values: v}}

companies_json = []

data_hash.each do |hash|
 companies_json &lt;&lt; hash.to_json
end

File.open('companies.json', 'w') do |f|
 f &lt;&lt; companies_json
end
</code></pre>

How to create a JSON object in Ruby

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我正在用Ruby创建一个JSON文件。我需要在JSON文件中创建对象"companies“。预期结果：{"companies":[    {\"label\":\"Wayfair \",\"values\":[54]},    {\"label\":\"Move24 \",\"values\":[29]},    {\...

问如何在Ruby中创建JSON对象
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Ruby中创建JSON对象EN