Comment ajouter des objets JSON ensemble en Ruby

Je suis en train de créer un groupe de marqueurs de carte avec les résultats de to_gmaps4rails dans un each bloc. Sur un tableau en cours de validité avec geo coordonnées de la to_gmaps4rails méthode produit JSON valide.

Je suis l'aide de Mongoid et mon geo coordonnées sont dans une sous-collection de:

Account.locations.coordinates

Voici mon code du contrôleur. nearby_sales est une collection de Accounts:

@json = String.new
nearby_sales.each do |sale|
  @json << sale.locations.to_gmaps4rails
end

Le navigateur se plaint de mon @json de ne pas être bien formé.
Est-il un Rubis moyen d'ajouter JSON valide ensemble?

Ne voudriez-vous pas un tableau? Sinon, il venais d'objets json en ligne avec pas de virgules ou de la structure environnante.

OriginalL'auteur SteveO7 | 2012-12-21

18

Vous ne pouvez pas concaténer au format JSON chaînes retournées par to_gmaps4rails parce qu'ils ne se traduira pas par un objet valide une fois décodée.

Si j'ai quelques objets que je veux envoyer:
```
loc1 = {"longitude" => "2.13012", "latitude" => "48.8014"}
loc2 = {"longitude" => "-90.556", "latitude" => "41.0634"}
```
Et de les convertir en JSON comme to_gmaps4rails n':
```
loc1_json = loc1.to_json
=> "{\"longitude\":\"2.13012\",\"latitude\":\"48.8014\"}"
loc2_json = loc2.to_json
=> "{\"longitude\":\"-90.556\",\"latitude\":\"41.0634\"}"
```
Ils sont deux JSON-objets codés comme des chaînes de caractères.

Concaténer la résultante des chaînes:
```
loc1_json + loc2_json
=> "{\"longitude\":\"2.13012\",\"latitude\":\"48.8014\"}{\"longitude\":\"-90.556\",\"latitude\":\"41.0634\"}"
```
Et de les envoyer à une autre application avec un JSON décodeur, je vais obtenir:
```
JSON[loc1_json + loc2_json]
JSON::ParserError: 743: unexpected token at '{"longitude":"-90.556","latitude":"41.0634"}'
```
L'analyseur seulement fait par le biais de la chaîne en cours avant qu'elle trouve une fermeture délimiteur et sait qu'il y a une erreur.

Je peux enrouler dans un tableau ou une table de hachage, et puis l'encoder en JSON encore une fois, mais ça n'aide pas, parce que la personne chaînes JSON aura été encodée à deux reprises, et a besoin d'être décodé de nouveau deux fois pour récupérer les données d'origine:
```
JSON[([loc1_json, loc2_json]).to_json]
=> ["{\"longitude\":\"2.13012\",\"latitude\":\"48.8014\"}",
    "{\"longitude\":\"-90.556\",\"latitude\":\"41.0634\"}"]

JSON[([loc1_json, loc2_json]).to_json].map{ |s| JSON[s] }
=> [{"longitude"=>"2.13012", "latitude"=>"48.8014"},
    {"longitude"=>"-90.556", "latitude"=>"41.0634"}]
```
Ce n'est pas une situation un JSON décodeur attend, alors que j'avais besoin de quelques funky JavaScript côté client pour utiliser la magie JSON décodeur-bague deux fois.

La vraie solution est de les décoder retour à leurs foyers, des objets Ruby d'abord, puis de le ré-encoder dans le tableau ou de hachage, puis de les envoyer:
```
array_of_json = [loc1_json, loc2_json].map{ |s| JSON[s] }.to_json
=> "[{\"longitude\":\"2.13012\",\"latitude\":\"48.8014\"},{\"longitude\":\"-90.556\",\"latitude\":\"41.0634\"}]"
```
Les valeurs sont codés correctement maintenant et peut être envoyé à la destination du navigateur ou de l'application, ce qui peut alors donner un sens aux données qui en résultent, non pas comme un tableau de chaînes de caractères comme ci-dessus, mais comme un tableau de valeurs de hachage de données:
```
JSON[array_of_json]
=> [{"longitude"=>"2.13012", "latitude"=>"48.8014"},
    {"longitude"=>"-90.556", "latitude"=>"41.0634"}]

loc1 == JSON[array_of_json][0]
=> true
loc2 == JSON[array_of_json][1]
=> true
```
En l'appliquant à votre code, voici ce qui doit être fait:
```
@json = []
nearby_sales.each do |sale|
  @json << JSON[sale.locations.to_gmaps4rails]
end
@json.to_json
```
Ce décode les emplacements de retour à leur "pré-JSON" de l'état, les ajoute à la matrice, puis retourne un tableau au format JSON.

A parfaitement fonctionné! Je vous remercie pour le code de travail, mais surtout pour la grande explication!
Une question j'espère que vous pourrez m'aider. Bien que le json est maintenant bien formé, il contient des tableaux de tableaux de hachages. Comme [[{"lat":39,"lng":-104},{"lat":39,"lng":-105}],[{"lat":39,"lng":-104.5]] création d'un niveau trop profonde. Est-il possible d'ajouter des premières hachages pour @json à l'intérieur du bloc?
Attendez attendez... je crois que je l'ai eu. Ai-je ajouté .aplatir! pour la dernière ligne comme; @json.aplatir!.to_json et le json renvoyé au navigateur ressemble, j'attends qu'il. J'ai vu quelques mises en garde sur l'utilisation de l'aplatir peut provoquer des résultats inattendus, des conseils sur qui?
Vous êtes en train de faire quelque chose de différent de la solution si vous êtes d'avoir à faire une supplémentaire flatten, probablement à l'aide de l'opérateur incorrect. Je soupçonne que vous êtes en train de faire quelque chose comme foo = []; foo << ['bar'] au lieu de foo + ['bar']. Tableau de concaténation, fait de mal, va vous forcer à utiliser flatten comme un ouvrage autour de.
Aussi, @json.flatten!.to_json est la mutation de la forme de flatten et pas correct pour ce que vous faites. Utilisation @json.flatten.to_json si vous avez à flatten. Lire sur la différence entre les deux et de comprendre pourquoi vous devriez utiliser l'un sur l'autre.

OriginalL'auteur the Tin Man

require 'json'

@json = Array.new
nearby_sales.each do |sale|
  @json << sale.locations.to_gmaps4rails
end
@json.to_json

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.