Como converter array de bytes para string em Common Lisp?

Question

Eu estou chamando uma API engraçado que retorna uma matriz de bytes, mas eu quero um fluxo de texto. Existe uma maneira fácil de obter um fluxo de texto a partir de uma matriz de bytes? Por agora eu só joguei junto:

(defun bytearray-to-string (bytes)
  (let ((str (make-string (length bytes))))
    (loop for byte across bytes
       for i from 0
       do (setf (aref str i) (code-char byte)))
    str))

e em seguida, enrole o resultado em com-input-de-corda, mas isso não pode ser o melhor caminho. (Além disso, é terrivelmente ineficiente.)

Neste caso, eu sei que é sempre ASCII, então interpretando-a como ASCII ou UTF-8 seria ótimo. Eu estou usando Unicode-aware SBCL, mas eu preferiria uma solução portátil (mesmo ASCII-only) para um específicos de SBCL-Unicode um.

Answer 1

Flexi-STREAMS ( http://weitz.de/flexi-streams/ ) tem portátil função de conversão

(flexi-streams:octets-to-string #(72 101 108 108 111) :external-format :utf-8)

=>

"Hello"

Ou, se você quiser um fluxo:

(flexi-streams:make-flexi-stream
   (flexi-streams:make-in-memory-input-stream
      #(72 101 108 108 111))
   :external-format :utf-8)

retornará um fluxo que lê o texto de byte-vector

Answer 2

Existem duas bibliotecas portáteis para esta conversão:

• flexi-correntes, já mencionado em outra resposta.

  Esta biblioteca é mais velho e tem mais recursos, em particular os fluxos extensíveis.

• Babel , uma biblioteca specificially para codificação de caracteres e decodificação

  A principal vantagem de Babel sobre flexi-córregos é a velocidade.

Para um melhor desempenho, utilize Babel se ele tem as características que você precisa, e cair de volta a flexi-córregos contrário. Abaixo um microbenchmark (slighly não científica) ilustrando a diferença de velocidade.

Para este caso de teste, Babel é 337 vezes mais rápido e precisa de 200 vezes menos memória.

(asdf:operate 'asdf:load-op :flexi-streams)
(asdf:operate 'asdf:load-op :babel)

(defun flexi-streams-test (bytes n)
  (loop
     repeat n
     collect (flexi-streams:octets-to-string bytes :external-format :utf-8)))

(defun babel-test (bytes n)
  (loop
     repeat n
     collect (babel:octets-to-string bytes :encoding :utf-8)))

(defun test (&optional (data #(72 101 108 108 111))
                       (n 10000))
  (let* ((ub8-vector (coerce data '(simple-array (unsigned-byte 8) (*))))
         (result1 (time (flexi-streams-test ub8-vector n)))
         (result2 (time (babel-test ub8-vector n))))
    (assert (equal result1 result2))))

#|
CL-USER> (test)
Evaluation took:
  1.348 seconds of real time
  1.328083 seconds of user run time
  0.020002 seconds of system run time
  [Run times include 0.12 seconds GC run time.]
  0 calls to %EVAL
  0 page faults and
  126,402,160 bytes consed.
Evaluation took:
  0.004 seconds of real time
  0.004 seconds of user run time
  0.0 seconds of system run time
  0 calls to %EVAL
  0 page faults and
  635,232 bytes consed.
|#

Answer 3

Se você não tem que se preocupar com a codificação UTF-8 (que, essencialmente, significa "apenas ASCII"), você pode ser capaz de utilizar MAP:

(Mapear 'cadeia #' código-char # (72 101 108 108 111))

Answer 4

Eu digo ir com as soluções flexistream ou babel propostas.

Mas só está completo e o benefício de futuros Googlers chegar a esta página Quero própria sb-ext menção de sbcl: octetos-a-string:

   SB-EXT:OCTETS-TO-STRING is an external symbol in #<PACKAGE "SB-EXT">.
   Function: #<FUNCTION SB-EXT:OCTETS-TO-STRING>
   Its associated name (as in FUNCTION-LAMBDA-EXPRESSION) is
     SB-EXT:OCTETS-TO-STRING.
   The function's arguments are:  (VECTOR &KEY (EXTERNAL-FORMAT DEFAULT) (START 0)
                                          END)
   Its defined argument types are:
     ((VECTOR (UNSIGNED-BYTE 8)) &KEY (:EXTERNAL-FORMAT T) (:START T) (:END T))
   Its result type is:
     *

Answer 5

SBCL suporta o chamado Grey Streams . Estes são fluxos extensíveis com base em classes CLOS e funções genéricas. Você pode criar uma subclasse fluxo de texto que recebe os caracteres a partir da matriz de bytes.

Answer 6

Tente a função FORMAT. (FORMAT NIL ...) retorna os resultados como uma string.