string - imprimir - leer cadena de caracteres en c
¿Cuál es la forma más curiosa de comparar caracteres y cuerdas?(cadena de caracteres individuales) (8)
Me preguntaba cuál es la mejor manera (clandestina) de comparar un personaje y una cuerda en Clojure. Obviamente algo como eso devuelve falso:
(= (first "clojure") "c")
porque primero devuelve un java.lang.Character y "c" es una cadena de un solo carácter. ¿Existe una construcción para comparar directamente char y string sin invocar un cast? No he encontrado una manera diferente de esto:
(= (str (first "clojure")) "c")
pero no estoy satisfecho ¿Algunas ideas? Adios Alfredo
¿Qué hay de la interoperabilidad String recta?
(= (.charAt "clojure" 0) /c)
o
(.startsWith "clojure" "c")
Debería ser lo más rápido posible y no asigna un objeto seq (y en su segundo ejemplo, una cadena adicional) que se tira de inmediato otra vez solo para hacer una comparación.
En estos días no necesariamente tienes que usar la interoperabilidad de Java:
(clojure.string/starts-with? "clojure" "c")
starts-with? es solo una envoltura delgada (alrededor de .startsWith ).
Así que ahora, si usa tanto Clojure como ClojureScript, no tendrá que recordar la interoperabilidad de Java y JavaScript.
Fundamentalmente (al menos en el nivel Clojure, aunque vea las respuestas de Kotarak y otras alternativas), está comparando dos secuencias: "clojure" y "c". La condición de igualdad es que el primer elemento de cada secuencia es igual. Así que si quieres expresar esto directamente puedes hacerlo.
(apply = (map first ["clojure" "c"]))
o al revés, donde creas una secuencia perezosa sobre la comparación de igualdad entre cada par de caracteres, y simplemente tomas el primer elemento:
(first (map = "clojure" "c"))
Los literales de caracteres están escritos /a /b /c ... en Clojure para que pueda simplemente escribir
(= (first "clojure") /c)
Podría usar la función de tomar de clojure.contrib.string . O escriba su propia función que devuelva el primer carácter si eso es algo que necesita con frecuencia.
Puedes usar str, como hiciste en tu segundo ejemplo. Realmente no hay nada malo con eso. Quiero decir, también podrías llamar primero a "c" para convertirlo en un personaje, pero realmente no hará una diferencia. ¿Hay alguna razón por la que no te gusta esto? Realmente no está agregando mucho a tu código llamando a str en el personaje.
las cadenas se pueden indexar directamente sin construir una secuencia a partir de entonces y tomar la primera de esa secuencia.
(= (nth "clojure" 0) /c)
=> true
nth llama a través de este código java:
static public Object nth(Object coll, int n){
if(coll instanceof Indexed)
return ((Indexed) coll).nth(n); <-------
return nthFrom(Util.ret1(coll, coll = null), n);
}
que lee con eficiencia el personaje directamente.
primera llamada a través de este código java:
static public Object first(Object x){
if(x instanceof ISeq)
return ((ISeq) x).first();
ISeq seq = seq(x); <----- (1)
if(seq == null)
return null;
return seq.first(); <------ (2)
}
que construye un seq para la cadena (1) (construir un seq es realmente rápido) y luego toma el primer elemento de ese seq (2). Después de la vuelta, el seq es basura.
Las secuencias son claramente la forma más idomática de acceder a cualquier secuencia en clojure y no las estoy eliminando en absoluto. Es interesante estar consciente de lo que estás creando cuando. cambiar todas sus llamadas a first con llamadas a nth es probable que sea un caso de optimización prematura. Si desea el número 100 de caracteres en la cadena, sugeriría usar una función de acceso indexado como nth
en resumen: no te preocupes por las cosas pequeñas :)
user=> (= (subs "clojure" 0 1) "c")
true
user=> (= (str (first "clojure") "c"))
true