Подтвердить что ты не робот

В Clojure как преобразовать строку в число?

У меня разные строки, некоторые вроде "45", некоторые вроде "45px". Как я конвертирую их оба в число 45?

4b9b3361

ОТВЕТЫ

Ответ 1

Это будет работать на 10px или px10

(defn parse-int [s]
   (Integer. (re-find  #"\d+" s )))

он будет анализировать первую непрерывную цифру только так

user=> (parse-int "10not123")
10
user=> (parse-int "abc10def11")
10

Ответ 2

Новый ответ

Мне нравится snrobot лучше. Использование метода Java проще и надежнее, чем использование строки чтения для этого простого варианта использования. Я сделал пару небольших изменений. Поскольку автор не исключал отрицательных чисел, я скорректировал его, чтобы разрешить отрицательные числа. Я также сделал так, чтобы оно начиналось в начале строки.

(defn parse-int [s]
  (Integer/parseInt (re-find #"\A-?\d+" s)))

Кроме того, я обнаружил, что Integer/parseInt анализируется как десятичный, если не задано значение radix, даже если есть ведущие нули.

Старый ответ

Во-первых, для синтаксического анализа просто целого числа (так как это удар по google и хорошая справочная информация):

Вы можете использовать reader:

(read-string "9") ; => 9

Вы можете проверить, что это число после чтения:

(defn str->int [str] (if (number? (read-string str))))

Я не уверен, что читателю clojure можно доверять пользовательский ввод, чтобы вы могли проверить его перед тем, как его прочитать:

(defn str->int [str] (if (re-matches (re-pattern "\\d+") str) (read-string str)))

Я думаю, что предпочитаю последнее решение.

И теперь, к вашему конкретному вопросу. Чтобы разобрать что-то, начинающееся с целого числа, например 29px:

(read-string (second (re-matches (re-pattern "(\\d+).*") "29px"))) ; => 29

Ответ 3

(defn parse-int [s]
  (Integer. (re-find #"[0-9]*" s)))

user> (parse-int "10px")
10
user> (parse-int "10")
10

Ответ 4

Это работает для меня, гораздо более прямолинейно.

(read-string "123" )

= > 123

Ответ 5

AFAIK нет стандартного решения вашей проблемы. Я думаю, что что-то вроде следующего, которое использует clojure.contrib.str-utils2/replace, должно помочь:

(defn str2int [txt]
  (Integer/parseInt (replace txt #"[a-zA-Z]" "")))

Ответ 6

Это не идеально, но здесь что-то с filter, Character/isDigit и Integer/parseInt. Он не будет работать для чисел с плавающей запятой, и он не сработает, если на входе нет цифры, поэтому вы, вероятно, должны его очистить. Надеюсь, там будет более приятный способ сделать это, что не предполагает столько 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)

Ответ 7

Вопрос задает вопрос о разборе строки в число.

(number? 0.5)
;;=> true

Таким образом, из вышеуказанных десятичных знаков следует также проанализировать.

Возможно, не совсем ответив на вопрос сейчас, но для общего использования я думаю, что вы бы хотели быть строгим относительно того, является ли это числом или нет (так что "px" не разрешено), и пусть вызывающий обрабатывает не номера, возвращая nil

(defn str->number [x]
  (when-let [num (re-matches #"-?\d+\.?\d*" x)]
    (try
      (Float/parseFloat num)
      (catch Exception _
        nil))))

И если Floats являются проблемными для вашего домена вместо Float/parseFloat поместите bigdec или что-то еще.

Ответ 8

Я бы добавил несколько вещей к требованиям:

  • Нужно начинать с цифры
  • Должен переносить пустые входы
  • Толеранты передаются любому объекту (стандартная строка toString)

Может быть что-то вроде:

(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

а затем, возможно, бонусные баллы для создания этого мульти-метода, который позволяет использовать по умолчанию, отличное от 0.

Ответ 9

Расширение ответа snrobot:

(defn string->integer [s] 
  (when-let [d (re-find #"-?\d+" s)] (Integer. d)))

Эти версии возвращают значение nil, если на входе нет цифр, вместо того, чтобы создавать исключение.

Мой вопрос заключается в том, допустимо ли сокращать имя до "str- > int", или если такие вещи всегда должны быть полностью указаны.

Ответ 10

Также использование функции (re-seq) может расширить возвращаемое значение до строки, содержащей все числа, существующие во входной строке, в порядке:

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

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

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

Ответ 11

Для простых случаев вы можете просто использовать регулярное выражение, чтобы вытащить первую строку цифр, как указано выше.

Если у вас более сложная ситуация, вы можете использовать библиотеку InstaParse:

(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"))))

Ответ 12

Для тех, кто хочет разобрать более обычный строковый литерал в число, то есть строку, в которой нет других нечисловых символов. Это два лучших подхода:

Использование взаимодействия Java:

(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")

Это позволяет точно контролировать тип, в котором вы хотите проанализировать число, когда это имеет значение для вашего варианта использования.

Использование считывателя Clojure EDN:

(require '[clojure.edn :as edn])
(edn/read-string "333")

В отличие от использования read-string из clojure.core который небезопасно использовать на ненадежном вводе, edn/read-string безопасно запускать на ненадежном вводе, таком как ввод пользователя.

Это часто более удобно, чем взаимодействие с Java, если вам не требуется особый контроль над типами. Он может анализировать любой числовой литерал, который может анализировать Clojure, например:

;; Ratios
(edn/read-string "22/7")
;; Hexadecimal
(edn/read-string "0xff")

Полный список здесь: https://www.rubberducking.com/2019/05/clojure-for-non-clojure-programmers.html#numbers