Le mode Emacs pour éditer JSON

+1 pour Josh JSON-mode -- fonctionne bien pour moi. J'ai ajouté

(defun beautify-json ()
  (interactive)
  (let ((b (if mark-active (min (point) (mark)) (point-min)))
        (e (if mark-active (max (point) (mark)) (point-max))))
    (shell-command-on-region b e
     "python -mjson.tool" (current-buffer) t)))

et

(define-key json-mode-map (kbd "C-c C-f") 'beautify-json)

à JSON-mode.el pour faciliter l'invocation de la commande shell.

mise à JOUR: Pour ceux d'entre vous avec un besoin/envie de le faire avec unicode, voir ma question ici . Le résultat est, plutôt que d'utiliser:

python -mjson.tool

vous vous voulez utiliser

python -c 'import sys,json; data=json.loads(sys.stdin.read()); print json.dumps(data,sort_keys=True,indent=4).decode(\"unicode_escape\").encode(\"utf8\",\"replace\")'

cela embellit le JSON tout en préservant le contenu unicode original.

js-mode supporte la mise en évidence de la syntaxe et l'indentation pour les fichiers json.

c'est à partir D'Emacs 23.2 , quand espresso-mode a été incorporé dans Emacs et renommé js-mode.

Check it out: http://www.nongnu.org/espresso/

si vous voulez quelque chose de léger essayez ce mode majeur que j'ai piraté ensemble: https://github.com/joshwnj/json-mode

ce n'est en fait rien de plus qu'une mise en évidence de syntaxe supplémentaire en plus du mode javascript, mais pour mon usage, j'ai trouvé que ça marchait assez bien.

un autre cas d'usage courant est le formatage automatique d'un fichier JSON (p. ex. si c'est blanc, compressé et vous voulez plus de lisibilité). Pour ce faire, Je ne fais que Piper tampon par un script en ligne de commande: c-u M - |

j'ai préparé une solution de contournement pour JS2-mode donc il analyse les fichiers json sans erreurs. Vous pouvez le trouver dans mon commentaire: http://code.google.com/p/js2-mode/issues/detail?id=50#c7

(je voulais le poster comme un commentaire sur la solution de J. F. Sebastian, mais il semble que je ne suis pas autorisé à le faire (pas de lien "ajouter un commentaire"))

puisque JSON est un sous-ensemble de YAML, yaml-mode fonctionne aussi (je ne sais pas comment il se compare à js-mode et json-mode , cependant).

(Installer à partir d'emacs): M-x package-install yaml-mode .

Association de yaml-mode avec YAML et des fichiers JSON, dans ~/.emacs.d/init.el :

(add-to-list 'auto-mode-alist '("\.yaml$" . yaml-mode))
(add-to-list 'auto-mode-alist '("\.json$" . yaml-mode))

json.el de Edward O'Connor fait partie de GNU Emacs depuis le 23.1 (2008).

bien que ce ne soit pas un surligneur de syntaxe, il a une fonction utile pour formater JSON:

M-x json-pretty-print-buffer RET

donc, si vous avez une version récente D'Emacs, vous n'avez pas besoin de jq ou python -m json.tool .

JSON est supporté par espresso-mode

JS3-mode: https://github.com/thomblake/js3-mode

js3-mode est une amélioration de la js2 en mode

ce paquet peut être installé par la commande

je vais aussi seconder le mode JSON de Josh, mais je recommande aussi flymake-json comme ajout. Il aide à mettre en évidence les erreurs de syntaxe.

Je n'aime pas utiliser python -mjson.tool parce qu'il réordonne des articles dans des objets JSON. Je trouve que (prog-indent-sexp) fonctionne très bien à reindent, et en utilisant jsonlint au lieu de python -mjson.tool fonctionne pour la jolie impression / reformatage dans beautify-json

(eval-after-load "json-mode"
  '(progn
     (require 'flymake-json)
     ;; flymake-cursor displays error in minibuffer message area instead of requiring hover
     (require 'flymake-cursor)

     (add-hook 'json-mode-hook 'flymake-json-load)
     (define-key json-mode-map "\C-c\C-n" (function flymake-goto-next-error))
  )
)

j'ai développé sur le workaround de Mariusz Nowak , pour le rendre utilisable comme mode majeur à part entière. Peu de modifications étaient nécessaires au-delà de la simple dérivation du mode; le seul changement dont Nowak avait réellement besoin était la capacité de reconnaître les tampons non associés aux fichiers, ou associés aux fichiers dont les noms ne se terminent pas par .json , comme JSON, ce que nous accomplissons avec une variable buffer-local.

Voici la solution augmentée:

(make-variable-buffer-local 'js2-parse-as-json)

(defadvice js2-reparse (before json)
    (setq js2-buffer-file-name buffer-file-name))
(ad-activate 'js2-reparse)

(defadvice js2-parse-statement (around json)
    (if (and (= tt js2-LC)
           js2-buffer-file-name
           (or js2-parse-as-json
               (string-equal (substring js2-buffer-file-name -5) ".json"))
           (eq (+ (save-excursion
                    (goto-char (point-min))
                    (back-to-indentation)
                    (while (eolp)
                      (next-line)
                      (back-to-indentation))
                    (point)) 1) js2-ts-cursor))
      (setq ad-return-value (js2-parse-assign-expr))
        ad-do-it))
(ad-activate 'js2-parse-statement)

(define-derived-mode json-mode js2-mode "JSON"
  "Major mode for editing JSON data."
  :group 'json
  (setq js2-parse-as-json t)
  (js2-reparse t))

(add-to-list 'auto-mode-alist '("\.json$" . json-mode))

si vous utilisez déjà le mode js2, cela peut être une meilleure option que js-mode plus flymake-json parce que vous n'avez pas besoin d'installer quoi que ce soit de nouveau (le mode js2 vérifie déjà la syntaxe, pas besoin d'outil externe), et parce que ce mode héritera de votre configuration en mode js2, ce que le mode js ne fera pas.

je recommande aussi le mode js2.

JSON signifie JavaScript Object Notation. Ce n'est pas une autre langue, et c'est même pas un conteneur de données comme yaml ou xml. JSON pourrait être utilisé comme un conteneur de données s'il n'y a pas de fonction (ou dans ce cas nous devrions dire méthode) à l'intérieur d'un objet JSON, mais ce n'est pas le but principal de JSON: -)

var myJSObject = {
  attr: {foo: "bar", baz: ["quux", "truc", "pouet"]},
  fooAlert: function (num) {
    alert(this.attr.foo+' '+num);
  }
};
myJSObject.fooAlert(42);