Comment analyser txt pour lister comme des symboles dans Clojure?

Question

Je suis encore nouveau à Clojure; J'essaie de diviser les valeurs analysées du fichier txt,

Je dois ajouter ces mots à la liste comme sembol. Par exemple

Exemple de fichier txt:

ceci est un test simple

et le résultat doit être le suivant:

'((t h i s) (i s) (a) (s i m p l e) (t e s t) 

s'il vous plaît un peu d'aide, merci à l'avance.

Answer 1

Tout d'abord, vous devez appeler split pour obtenir les mots d'une chaîne. Ensuite, pour chaque mot, vous devez itérer et convertir les caractères en symboles. Il est plus facile d'itérer en utilisant la macro for. Vous pouvez convertir un caractère en chaîne en utilisant str et convertir la chaîne en symbole en utilisant symbol.

(defn line-to-lists [line] 
    (for [word (clojure.string/split (clojure.string/trim line) #"\s+")] 
    (for [char word] (symbol (str char))))) 

(line-to-lists "this is a simple test") 

Vous pouvez obtenir le contenu d'un fichier en utilisant et appeler la fonction à ce sujet comme suit:

(line-to-lists (slurp "file.txt")) 

EDIT: fixe pour travailler avec de multiples espaces et/grands espaces alignées à. EDIT: ajout d'une chaîne ou d'un trim pour supprimer les pages blanches inutiles.

Answer 2

d'abord, vous devez diviser une ligne en mots, et chaque mot doit être mis en correspondance avec char->symbol fonction de conversion:

quelque chose comme ceci:

user> (require '[clojure.string :as cs]) 
nil 

user> (defn to-syms [s] 
     (let [words (cs/split (cs/trim s) #"\s+")] 
      (map #(map (comp symbol str) %) words))) 
#'user/to-syms 

user> (to-syms "this is a line") 
;;=> ((t h i s) (i s) (a) (l i n e)) 

MISE À JOUR

extension :

d'abord vous obtenez tous les mots de str tion, le fractionnement par des espaces:

(cs/split (cs/trim "aaa bbb ccc") #"\s+") 
;;=> ["aaa" "bbb" "ccc"] 

alors nous avons besoin de faire une fonction qui traite le mot conversion à une liste de symboles. Comme chaîne de Clojure est une séquence de caractères, vous pouvez map dessus, la production nouvelle collection:

(defn char->sym [c] 
    (symbol (string c)) 

user> (char->sym \a) 
;;=> a 

user> (map char->sym "asd") 
;;=> (a s d) 
;; in my example i use the functional composition: (comp symbol str) 
;; that creates the function that works exactly like char->sym 

;; let's wrap this mapping to a function: 
(defn word->syms [w] 
    (map char->sym w)) 

user> (word->syms "asd") 
;;=> (a s d) 

;; and now we just have to transform the whole list of words: 
user> (map word->syms ["asd" "fgh"]) 
;;=> ((a s d) (f g h)) 

en plus, pour convertir la liste des symboles pour sauvegarder chaîne que vous pouvez simplement appeler la fonction str avec les articles de la liste que arguments (apply str '(a s d)) => "asd" ou utiliser clojure.string/join pour que: (clojure.string/join '(a s d)) => "asd"