En Clojure comment puis-je convertir une Chaîne en nombre?

J'ai des chaînes différentes, certains comme "45", certains, comme "45px". Comment je convertir à la fois de celles-ci au nombre de 45?

Je suis content que quelqu'un n'est pas peur de poser des questions de base.
+1 - une partie de la difficulté est que la Clojure docs parfois de ne pas répondre à ces "de base" des questions que nous tenons pour acquis dans d'autres langues. (J'ai eu la même question 3 ans plus tard et a trouvé ce).
Je serais intéressé de savoir "pourquoi" les gens ont peur de poser des questions de base?
il est censé choses de base sont déjà expliqué quelque part donc, vous avez probablement oublié quelque chose et votre question sera downvoted pour "aucun effort de recherche".
Oui, je pense que vous avez raison. J'ai fait des recherches et ce n'arrivais pas à trouver la réponse de n'importe où à l'époque. Si vous pouviez m'envoyer un lien où il a été expliqué puis que serait apprécié

InformationsquelleAutor Zubair | 2011-04-11

clojure

76

Cela fonctionnera sur 10px ou px10
```
(defn parse-int [s]
   (Integer. (re-find  #"\d+" s )))
```
il analyse la première continue des chiffres uniquement
```
user=> (parse-int "10not123")
10
user=> (parse-int "abc10def11")
10
```
- Belle réponse! C'est mieux que de lire à l'aide de cordes à mon avis. J'ai changé ma réponse pour l'utilisation de votre technique. J'ai fait quelques petites modifications.
InformationsquelleAutor jhnstn
79

Nouvelle réponse

J'aime snrobot la réponse de mieux. À l'aide de la méthode Java est plus simple et plus robuste que d'utiliser la lecture de la chaîne pour ce cas simple d'utilisation. J'ai fait quelques petites modifications. Étant donné que l'auteur n'exclut pas les nombres négatifs, j'ai ajusté pour permettre les nombres négatifs. J'ai aussi fait en sorte qu'elle exige le nombre de départ au début de la chaîne.
```
(defn parse-int [s]
  (Integer/parseInt (re-find #"\A-?\d+" s)))
```
En outre, j'ai trouvé que Entier/parseInt s'analyse comme décimal lorsque le pas de base est donnée, même si il y a des zéros à gauche.

Vieille réponse

Tout d'abord, analyser simplement un entier (puisque c'est un coup sur google et c'est bon arrière-plan de l'information):

Vous pouvez utiliser le lecteur:
```
(read-string "9") ; => 9
```
Vous pouvez vérifier que c'est un numéro après l'avoir lu:
```
(defn str->int [str] (if (number? (read-string str))))
```
Je ne suis pas sûr si la saisie de l'utilisateur peuvent être approuvées par le clojure lecteur ainsi, vous pouvez vérifier avant de la lire ainsi:
```
(defn str->int [str] (if (re-matches (re-pattern "\\d+") str) (read-string str)))
```
Je pense que je préfère la dernière solution.

Et maintenant, à votre question. Pour analyser quelque chose qui commence par un entier, comme 29px:
```
(read-string (second (re-matches (re-pattern "(\\d+).*") "29px"))) ; => 29
```
- J'aime votre réponse meilleures dommage que ce n'est pas fournie par la clojure bibliothèque de base. Une petite critique technique de votre if devrait être un when puisqu'il n'existe pas d'autre bloc dans votre programme pnr.
- (lire-chaîne "#=(println \"bon\")")
- Oui, s'il vous plaît ne pas arrêter de lire après la première ou la deuxième extrait de code!
- Un heads-up sur des chiffres avec des zéros. read-string interprète comme octal: (read-string "08") déclenche une exception. Integer/valueOf traite comme décimal: (Integer/valueOf "08") évalue à 8.
- Notez également que read-string lève une exception si vous lui donnez une chaîne vide ou quelque chose comme "29px"
- Comme il se doit. J'ai répondu à la question dans le titre, et ce que les gens attendent quand ils voient cette page, avant j'ai répondu à la question dans la question du corps. C'est le dernier extrait de code dans le corps de ma réponse.
- Vous pouvez utiliser ^ au lieu de votre de largeur nulle affirmation dans la regex.
InformationsquelleAutor Benjamin Atkin
28
```
(defn parse-int [s]
  (Integer. (re-find #"[0-9]*" s)))

user> (parse-int "10px")
10
user> (parse-int "10")
10
```
- +1 j'aime la façon dont vous analysée 10px
- Merci. Cela a été très utile dans mon fractionnement d'un produit dans une séquence de chiffres.
- Puisque nous sommes en Java terre pour répondre à cette question, il est généralement conseillé d'utiliser Integer/valueOf, plutôt que de l'Entier constructeur. La classe Integer caches des valeurs comprises entre -128 et 127 à minimiser la création de l'objet. L'Entier Javadoc décrit ce que fait ce post: stackoverflow.com/a/2974852/871012
InformationsquelleAutor MayDaniel
15

Cela fonctionne dans repl pour moi, beaucoup plus simple.

(lire-chaîne "123")

=> 123
- Soyez prudent en utilisant ce avec la saisie de l'utilisateur. read-string peut exécuter du code par la documentation: clojuredocs.org/clojure.core/read-string
- ce qui est excellent pour la confiance d'entrée, comme par exemple, un puzzle de programmation. @jerney est juste: attention à ne pas l'utiliser dans le code.
InformationsquelleAutor f3rz_net
9

Autant que je sache, il n'y a pas de solution standard pour votre problème. Je pense que quelque chose comme le suivant, qui utilise clojure.contrib.str-utils2/remplacez, devrait aider:
```
(defn str2int [txt]
  (Integer/parseInt (replace txt #"[a-zA-Z]" "")))
```
- Pas recommandé. Il fonctionnera jusqu'à ce que quelqu'un se lance 1.5 à elle...et il ne fait pas de l'utilisation de l'intégré dans clojure.string/replace fonction.
InformationsquelleAutor skuro
7

Ce n'est pas parfait, mais voici quelque chose avec filter, Character/isDigit et Integer/parseInt. Il ne fonctionnera pas pour les nombres à virgule flottante et il échoue, si il n'y a pas de chiffres dans l'entrée, de sorte que vous devriez nettoyer. J'espère qu'il y a une jolie manière de faire qui n'implique pas autant de Java.
```
user=> (defn strToInt [x] (Integer/parseInt (apply str (filter #(Character/isDigit %) x))))
#'user/strToInt
user=> (strToInt "45px")
45
user=> (strToInt "45")
45
user=> (strToInt "a")
java.lang.NumberFormatException: For input string: "" (NO_SOURCE_FILE:0)
```
InformationsquelleAutor michiakig
3

La question porte sur l'analyse d'une chaîne de caractères en un nombre.
```
(number? 0.5)
;;=> true
```
Donc à partir du dessus de décimales doit être analysée en tant que bien.

Peut-être pas exactement la réponse à la question maintenant, mais pour un usage général, je pense que vous voulez être rigoureux quant à savoir si c'est un nombre ou non (donc "px" ne sont pas permis) et de laisser l'appelant omet de numéros en retournant néant:
```
(defn str->number [x]
  (when-let [num (re-matches #"-?\d+\.?\d*" x)]
    (try
      (Float/parseFloat num)
      (catch Exception _
        nil))))
```
Et si les Flotteurs sont problématiques pour votre nom de domaine au lieu de Float/parseFloat mettre bigdec ou quelque chose d'autre.

InformationsquelleAutor Chris Murphy
2

Je serais probablement ajouter quelques choses aux exigences:
- A commencer par un chiffre
- A à tolérer vide entrées
- Tolère d'être passé à un objet (toString est standard)
Peut-être quelque chose comme:
```
(defn parse-int [v] 
   (try 
     (Integer/parseInt (re-find #"^\d+" (.toString v))) 
     (catch NumberFormatException e 0)))

(parse-int "lkjhasd")
; => 0
(parse-int (java.awt.Color. 4 5 6))
; => 0
(parse-int "a5v")
; => 0
(parse-int "50px")
; => 50
```
et puis peut-être des points de bonus pour en faire une multi-méthode qui permet à un utilisateur fourni par défaut autre que 0.

InformationsquelleAutor Tony K.
2

Expansion sur snrobot réponse:
```
(defn string->integer [s] 
  (when-let [d (re-find #"-?\d+" s)] (Integer. d)))
```
Cette versions retourne nil si il n'existe pas de chiffres dans l'entrée, plutôt que de lever une exception.

Ma question est de savoir si c'est acceptable pour abréger le nom de "str->int", ou si des choses comme cela devrait toujours être entièrement spécifié.

InformationsquelleAutor Nick Vargish
2

Également à l'aide de (re-seq) fonction peut étendre la valeur de retour d'une chaîne de caractères contenant tous les nombres existants dans la chaîne d'entrée dans l'ordre:

(defn convert-to-int [s] (->> (re-seq #"\d" s) (apply str) (Integer.)))

(convert-to-int "10not123") => 10123

(type *1) => java.lang.Integer

InformationsquelleAutor amirt

Pour les cas simples, vous pouvez utiliser une expression régulière pour sortir la première chaîne de chiffres mentionnés ci-dessus.

Si vous avez une situation plus compliquée, vous pouvez utiliser le InstaParse bibliothèque:

(ns tst.parse.demo
  (:use tupelo.test)
  (:require
    [clojure.string :as str]
    [instaparse.core :as insta]
    [tupelo.core :as t] ))
(t/refer-tupelo)

(dotest
  (let [abnf-src            "
size-val      = int /int-px
int           = digits          ; ex '123'
int-px        = digits <'px'>   ; ex '123px'
<digits>      = 1*digit         ; 1 or more digits
<digit>       = %x30-39         ; 0-9
"
    tx-map        {:int      (fn fn-int [& args]
                               [:int (Integer/parseInt (str/join args))])
                   :int-px   (fn fn-int-px [& args]
                               [:int-px (Integer/parseInt (str/join args))])
                   :size-val identity
                  }

    parser              (insta/parser abnf-src :input-format :abnf)
    instaparse-failure? (fn [arg] (= (class arg) instaparse.gll.Failure))
    parse-and-transform (fn [text]
                          (let [result (insta/transform tx-map
                                         (parser text))]
                            (if (instaparse-failure? result)
                              (throw (IllegalArgumentException. (str result)))
                              result)))  ]
  (is= [:int 123]     (parse-and-transform "123"))
  (is= [:int-px 123]  (parse-and-transform "123px"))
  (throws?            (parse-and-transform "123xyz"))))

Aussi, juste une curieuse question: pourquoi utilisez-vous (t/refer-tupelo) au lieu de se faire à l'utilisateur de faire (:require [tupelo.core :refer :all])?
refer-tupelo est modélisé d'après refer-clojure, en ce qu'elle ne comprend pas tout le chemin (:require [tupelo.core :refer :all]) n'.

InformationsquelleAutor Alan Thompson

0

Pour quiconque cherche à analyser un plus normal littéral de Chaîne en un nombre, c'est une chaîne qui n'a pas d'autres non caractères numériques. Ce sont les deux meilleures approches:

À l'aide de Java interop:
```
(Long/parseLong "333")
(Float/parseFloat "333.33")
(Double/parseDouble "333.3333333333332")
(Integer/parseInt "-333")
(Integer/parseUnsignedInt "333")
(BigInteger. "3333333333333333333333333332")
(BigDecimal. "3.3333333333333333333333333332")
(Short/parseShort "400")
(Byte/parseByte "120")
```
Cela vous permet de contrôler avec précision le type que vous souhaitez analyser le nombre de, lors de votre cas d'utilisation.

À l'aide de la Clojure EDN lecteur:
```
(require '[clojure.edn :as edn])
(edn/read-string "333")
```
Contrairement à l'utilisation de read-string de clojure.core ce qui n'est pas sûr à utiliser sur les autres entrées, edn/read-string est sûr de courir sur les autres intrants tels que la saisie de l'utilisateur.

C'est souvent plus pratique que le Java interop si vous n'avez pas besoin d'avoir de contrôle spécifiques à des types. Il peut analyser n'importe quel nombre littéral de Clojure peut analyser comme:
```
;; Ratios
(edn/read-string "22/7")
;; Hexadecimal
(edn/read-string "0xff")
```
Liste complète ici: https://www.rubberducking.com/2019/05/clojure-for-non-clojure-programmers.html#numbers

InformationsquelleAutor Didier A.

Vous devez vous connecter pour publier un commentaire.

Nouvelle réponse

Vieille réponse