blocks|key|561717|text|Apply和reverse一样，适用于任何可排序的类型，而不仅仅是向量，因此|type|unstyled|depth|inlineStyleRanges|entityRanges|data|561718|(应用字符串(反转"Hello"))|561719|稍微短了一点。不过，clojure.string/reverse应该更有效。|561720|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Apply, like reverse, works on any seqable type, not just vectors, so

(apply str (reverse "Hello"))

is a little shorter. clojure.string/reverse should be more efficient, though.

blocks|key|561793|text|好的，所以使用apply+inside来滚动你自己的函数会很容易，或者使用专门的reverse版本，它在字符串上工作得更好(但只是这样)。不过，这里要考虑的主要问题是str函数的数量(参数的数量和类型)，以及反向在集合上工作的事实。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|561794|(doc+reverse)

clojure.core/reverse
([coll])
Returns+a+seq+of+the+items+in+coll+in+reverse+order.+Not+lazy.|code-block|syntax|javascript|561795|这意味着reverse不仅适用于字符串，也适用于所有其他集合。但是，因为reverse需要一个集合作为参数，所以它将字符串视为字符的集合|561796|(reverse+"Hello")|561797|，并同时返回一个|561798|(\o+\l+\l+\e+\H)|561799|现在，如果我们只用函数代替集合，您就可以发现不同之处：|561800|(str+'(\o+\l+\l+\e+\H)+)
"(\\o+\\l+\\l+\\e+\\H)"|561801|而|561802|(str+\o+\l+\l+\e+\H+)
"olleH"|561803|两者之间的最大区别在于参数的数量。在第一个示例中，str接受一个参数，即5个字符的集合。在第二个示例中，str接受5个参数:5个字符。|561804|str函数期望什么？|561805|(doc+str)
-------------------------
clojure.core/str
([]+[x]+[x+&+ys])
++With+no+args,+returns+the+empty+string.+With+one+arg+x,+returns
++x.toString().++(str+nil)+returns+the+empty+string.+With+more+than
++one+arg,+returns+the+concatenation+of+the+str+values+of+the+args.|561806|因此，当您提供一个参数(集合)时，所有字符串返回都是该集合的toString。但是为了得到您想要的结果，您需要将这5个字符作为单独的参数提供给str，而不是集合本身。Apply是用于“进入”集合并实现该操作的函数。|561807|(apply+str+'(\o+\l+\l+\e+\H)+)
"olleH"|561808|处理多个独立参数的函数经常出现在Clojure中，因此最好了解何时以及为什么需要使用apply。另一方面要认识到的是，为什么str函数的编写者让它接受多个参数而不是一个集合？通常，有一个很好的理由。str函数的流行用例是什么？当然不是连接独立字符的集合，而是连接值、字符串和函数结果。|561809|(let+[a+1+b+2]
++(str+a+"%2B"+b+"="+(%2B+a+b)))
"1%2B2=3"|561810|如果我们有一个接受单个集合作为参数字符串会怎样呢？|561811|(defn+str2
++[seq]
++(apply+str+seq)
++)

(str2+(reverse+"Hello"))
"olleH"|561812|酷，它起作用了！但现在：|561813|(let+[a+1+b+2]
++(str2+'(a+"%2B"+b+"="+(%2B+a+b)))
++)
"a%2Bb=(%2B+a+b)"|561814|嗯，现在该怎么解决呢？:)|561815|在这种情况下，让str接受在执行str函数之前计算的多个参数，这将为str提供最简单的语法。无论何时需要在集合上使用str，apply都是将集合转换为单独参数的一种简单方法。|561816|创建一个接受集合并计算其中每个部分字符串将花费更多的精力，只在不太常见的用例中有帮助，导致更复杂的代码或语法，或者限制它的适用性。因此可能有一种更好方法来反转字符串，但是reverse、apply和str在这方面做得最好。|561817|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|1V|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1W|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1X|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1Z|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|20|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|21|8|@]|9|@]|A|$]]|$1|10|3|11|5|D|7|22|8|@]|9|@]|A|$E|F]]|$1|12|3|13|5|6|7|23|8|@]|9|@]|A|$]]|$1|14|3|15|5|D|7|24|8|@]|9|@]|A|$E|F]]|$1|16|3|17|5|6|7|25|8|@]|9|@]|A|$]]|$1|18|3|19|5|D|7|26|8|@]|9|@]|A|$E|F]]|$1|1A|3|1B|5|6|7|27|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|D|7|28|8|@]|9|@]|A|$E|F]]|$1|1E|3|1F|5|6|7|29|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|D|7|2A|8|@]|9|@]|A|$E|F]]|$1|1I|3|1J|5|6|7|2B|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|6|7|2C|8|@]|9|@]|A|$]]|$1|1M|3|1N|5|6|7|2D|8|@]|9|@]|A|$]]|$1|1O|3|-4|5|6|7|2E|8|@]|9|@]|A|$]]]|1P|$]]

OK, so it would be easy to roll your own function with apply inside, or use a dedicated version of reverse that works better (but only) at strings. The main things to think about here though, is the arity (amount and type of parameters) of the str function, and the fact that reverse works on a collection.

<pre><code>(doc reverse)

clojure.core/reverse
([coll])
Returns a seq of the items in coll in reverse order. Not lazy.
</code></pre>

This means that reverse not only works on strings, but also on all other collections. However, because reverse expects a collection as parameter, it treats a string as a collection of characters

<pre><code>(reverse "Hello")
</code></pre>

and returns one as well

<pre><code>(\o \l \l \e \H)
</code></pre>

Now if we just substitute the functions for the collection, you can spot the difference:

<pre><code>(str '(\o \l \l \e \H) )
"(\\o \\l \\l \\e \\H)"
</code></pre>

while

<pre><code>(str \o \l \l \e \H )
"olleH"
</code></pre>

The big difference between the two is the amount of parameters. In the first example, str takes one parameter, a collection of 5 characters. In the second, str takes 5 parameters: 5 characters.

What does the str function expect ?

<pre><code>(doc str)
-------------------------
clojure.core/str
([] [x] [x &amp; ys])
 With no args, returns the empty string. With one arg x, returns
 x.toString(). (str nil) returns the empty string. With more than
 one arg, returns the concatenation of the str values of the args.
</code></pre>

So when you give in one parameter (a collection), all str returns is a toString of the collection.
But to get the result you want, you need to feed the 5 characters as separate parameters to str, instead of the collection itself. Apply is the function that is used to 'get inside' the collection and make that happen.

<pre><code>(apply str '(\o \l \l \e \H) )
"olleH"
</code></pre>

Functions that handle multiple separate parameters are often seen in Clojure, so it's good to realise when and why you need to use apply. The other side to realize is, why did the writer of the str function made it accept multiple parameters instead of a collection ? Usually, there's a pretty good reason. What's the prevalent use case for the str function ? Not concatenating a collection of separate characters surely, but concatenating values, strings and function results.

<pre><code>(let [a 1 b 2]
 (str a "+" b "=" (+ a b)))
"1+2=3"
</code></pre>

What if we had a str that accepted a single collection as parameter ?

<pre><code>(defn str2
 [seq]
 (apply str seq)
 )

(str2 (reverse "Hello"))
"olleH"
</code></pre>

Cool, it works ! But now:

<pre><code>(let [a 1 b 2]
 (str2 '(a "+" b "=" (+ a b)))
 )
"a+b=(+ a b)"
</code></pre>

Hmmm, now how to solve that ? :)

In this case, making str accept multiple parameters that are evaluated before the str function is executed gives str the easiest syntax. Whenever you need to use str on a collection, apply is a simple way to convert a collection to separate parameters.

Making a str that accepts a collection and have it evaluate each part inside would take more effort, help out only in less common use cases, result in more complicated code or syntax, or limit it's applicability. So there might be a better way to reverse strings, but reverse, apply and str are best at what they do.

Is there a better way to do this in Clojure?

<pre><code>daniel=&gt; (reverse "Hello")
(\o \l \l \e \H)

daniel=&gt; (apply str (vec (reverse "Hello")))
"olleH"
</code></pre>

Do you have to do the <code>apply $ str $ vec</code> bit every time you want to reverse a string back to its original form?

Reverse a string (simple question)

在Clojure中有没有更好的方法来做到这一点？daniel=> (reverse "Hello")(\o \l \l \e \H)daniel=> (apply str (vec (reverse "Hello")))"olleH"每次要将字符串还原为其原始形式时，是否都需要执行apply $ str $ vec？

问颠倒字符串(简单问题)
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问颠倒字符串(简单问题)EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问颠倒字符串(简单问题)
EN