blocks|key|2736343|text|你遇到了一个Swift泛型的问题，它现在不能以你喜欢的方式解决(也许在未来的Swift版本中)。另请参见Swift+Generics+issue。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2736344|目前，您需要定义一个函数(例如，在全局范围内)：|2736345|func+isSorted<T:+Comparable>(array:+Array<T>)+->+Bool+{
++++for+i+in+1..<array.count+{
++++++++if+array[i-1]+>+array[i]+{
++++++++++++return+false
++++++++}
++++}

++++return+true
}

let+i+=+[1,+2,+3]
let+j+=+[2,+1,+3]
let+k+=+[UIView(),+UIView()]
println(isSorted(i))+//+Prints+"true"
println(isSorted(j))+//+Prints+"false"
println(isSorted(k))+//+Error:+Missing+argument+for+parameter+#2+in+call|code-block|syntax|javascript|2736346|错误消息是误导性的，IMHO，因为实际错误类似于"UIView不满足类型约束可比较“。|2736347|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/24034119/swift-generics-issue^0|1G|K|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

You've hit a problem with Swift's generics that can't be solved the way you like it right now (maybe in a future Swift version). See also <a href="https://stackoverflow.com/questions/24034119/swift-generics-issue">Swift Generics issue</a>.

Currently, you'll need to define a function (for example at the global scope):

<pre><code>func isSorted&lt;T: Comparable&gt;(array: Array&lt;T&gt;) -&gt; Bool {
 for i in 1..&lt;array.count {
 if array[i-1] &gt; array[i] {
 return false
 }
 }

 return true
}

let i = [1, 2, 3]
let j = [2, 1, 3]
let k = [UIView(), UIView()]
println(isSorted(i)) // Prints "true"
println(isSorted(j)) // Prints "false"
println(isSorted(k)) // Error: Missing argument for parameter #2 in call
</code></pre>

The error message is misleading, IMHO, as the actual error is something like "UIView doesn't satisfy the type constraint Comparable".

blocks|key|2949127|text|自由函数的另一种解决方案是执行Swift内置的Array.sort和Array.sorted方法，并要求您将合适的比较器传递给该方法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2949128|extension+Array+{
++++func+isSorted(isOrderedBefore:+(T,+T)+->+Bool)+->+Bool+{
++++++++for+i+in+1..<self.count+{
++++++++++++if+!isOrderedBefore(self[i-1],+self[i])+{
++++++++++++++++return+false
++++++++++++}
++++++++}
++++++++return+true
++++}
}

[1,+5,+3].isSorted(<)+//+false
[1,+5,+10].isSorted(<)+//+true
[3.5,+2.1,+-5.4].isSorted(>)+//+true|code-block|syntax|javascript|2949129|entityMap^0|N|A|Y|C|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

The alternative solution to a free function is to do what Swift's built-in <code>Array.sort</code> and <code>Array.sorted</code> methods do, and require that you pass a suitable comparator to the method:

<pre><code>extension Array {
 func isSorted(isOrderedBefore: (T, T) -&gt; Bool) -&gt; Bool {
 for i in 1..&lt;self.count {
 if !isOrderedBefore(self[i-1], self[i]) {
 return false
 }
 }
 return true
 }
}

[1, 5, 3].isSorted(&lt;) // false
[1, 5, 10].isSorted(&lt;) // true
[3.5, 2.1, -5.4].isSorted(&gt;) // true
</code></pre>

blocks|key|2736374|text|在Swift+2.0中，您现在可以扩展协议！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2736375|extension+CollectionType+where+Generator.Element:+Comparable+{

++++public+var+isSorted:+Bool+{

++++++++var+previousIndex+=+startIndex
++++++++var+currentIndex+=+startIndex.successor()

++++++++while+currentIndex+!=+endIndex+{

++++++++++++if+self[previousIndex]+>+self[currentIndex]+{
++++++++++++++++return+false
++++++++++++}

++++++++++++previousIndex+=+currentIndex
++++++++++++currentIndex+=+currentIndex.successor()
++++++++}

++++++++return+true
++++}

}

[1,+2,+3,+4].isSorted+//+true
["a",+"b",+"c",+"e"].isSorted+//+true
["b",+"a",+"c",+"e"].isSorted+//+false
[/*+Anything+not+implementing+`Comparable`+*/].isSorted+//+<~~+Type-error|code-block|syntax|javascript|2736376|请注意，因为我们使用Indexable.Index而不是简单的Int作为索引，所以我们必须使用while循环，这看起来不太美观和清晰。|offset|length|style|CODE|2736377|entityMap^0|0|0|A|F|V|3|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

In Swift 2.0 you can now extend protocols!

<pre><code>extension CollectionType where Generator.Element: Comparable {

 public var isSorted: Bool {

 var previousIndex = startIndex
 var currentIndex = startIndex.successor()

 while currentIndex != endIndex {

 if self[previousIndex] &gt; self[currentIndex] {
 return false
 }

 previousIndex = currentIndex
 currentIndex = currentIndex.successor()
 }

 return true
 }

}

[1, 2, 3, 4].isSorted // true
["a", "b", "c", "e"].isSorted // true
["b", "a", "c", "e"].isSorted // false
[/* Anything not implementing `Comparable` */].isSorted // &lt;~~ Type-error
</code></pre>

Note that because we're using <code>Indexable.Index</code> instead of a simple <code>Int</code> as an index we have to use a while-loop instead, which looks a bit less pretty and clear.

blocks|key|2949152|text|对我来说，最灵活的解决方案是NSAddict和Wes+Campaigne的答案的组合。即结合了能够扩展协议和将比较器函数作为自变量传递的优点。这消除了仅将其与数组一起使用以及将其约束为符合Comparable协议的元素的限制。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2949153|extension+CollectionType
{
++++func+isSorted(isOrderedBefore:+(Generator.Element,+Generator.Element)+->+Bool)+->+Bool
++++{
++++++++var+previousIndex+=+startIndex
++++++++var+currentIndex+=+startIndex.successor()

++++++++while+currentIndex+!=+endIndex
++++++++{
++++++++++++if+isOrderedBefore(self[previousIndex],+self[currentIndex])+==+false
++++++++++++{
++++++++++++++++return+false
++++++++++++}

++++++++++++previousIndex+=+currentIndex
++++++++++++currentIndex+=+currentIndex.successor()
++++++++}

++++++++return+true
++++}
}|code-block|syntax|javascript|2949154|这可以在任何Collection类型上使用，并且可以根据需要定义排序标准。|2949155|entityMap^0|2M|A|0|0|6|A|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

The most flexible solution to me is a combination of NSAddict's and Wes Campaigne's answer. I.e. combine the advantage of being able to extend protocols and to pass comparator functions as arguments. This eliminates the restrictions both to use it only with arrays and to constrain it to elements conforming to <code>Comparable</code> protocol.

<pre><code>extension CollectionType
{
 func isSorted(isOrderedBefore: (Generator.Element, Generator.Element) -&gt; Bool) -&gt; Bool
 {
 var previousIndex = startIndex
 var currentIndex = startIndex.successor()

 while currentIndex != endIndex
 {
 if isOrderedBefore(self[previousIndex], self[currentIndex]) == false
 {
 return false
 }

 previousIndex = currentIndex
 currentIndex = currentIndex.successor()
 }

 return true
 }
}
</code></pre>

This can be used on any <code>Collection</code> type and sorting criteria can be defined according to your needs.

blocks|key|2736405|text|自适应，将在Swift+4中工作的solution|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2736406|extension+Array+where+Iterator.Element:+Comparable+{
++++func+isSorted(isOrderedBefore:+(Iterator.Element,+Iterator.Element)+->+Bool)+->+Bool++{
++++++++for+i+in+1+..<+self.count+{
++++++++++++if+isOrderedBefore(self[i],+self[i-1])+{
++++++++++++++++return+false
++++++++++++}
++++++++}
++++++++return+true
++++}
}|code-block|syntax|javascript|2736407|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/24768486/5316459^0|H|8|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Adaptation, a <a href="https://stackoverflow.com/a/24768486/5316459">solution</a> that will work in Swift 4


<pre><code>extension Array where Iterator.Element: Comparable {
 func isSorted(isOrderedBefore: (Iterator.Element, Iterator.Element) -&gt; Bool) -&gt; Bool {
 for i in 1 ..&lt; self.count {
 if isOrderedBefore(self[i], self[i-1]) {
 return false
 }
 }
 return true
 }
}
</code></pre>

blocks|key|2736414|text|实际上，您可以将Sequence协议扩展为更通用的解决方案：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2736415|extension+Sequence+{
++++func+isSorted(by+areInIncreasingOrder:+(Element,+Element)+throws+->+Bool)+rethrows+->+Bool+{
++++++++var+iterator+=+makeIterator()

++++++++guard+var+previous+=+iterator.next()+else+{
++++++++++++//+Sequence+is+empty
++++++++++++return+true
++++++++}

++++++++while+let+current+=+iterator.next()+{
++++++++++++guard+try+areInIncreasingOrder(previous,+current)+else+{
++++++++++++++++return+false
++++++++++++}

++++++++++++previous+=+current
++++++++}

++++++++return+true
++++}
}

extension+Sequence+where+Element+:+Comparable+{
++++func+isSorted()+->+Bool+{
++++++++return+isSorted(by:+<)
++++}
}|code-block|syntax|javascript|2736416|entityMap^0|8|8|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Actually, you can extend the <code>Sequence</code> protocol for a more generic solution:

<pre class="lang-swift prettyprint-override"><code>extension Sequence {
 func isSorted(by areInIncreasingOrder: (Element, Element) throws -&gt; Bool) rethrows -&gt; Bool {
 var iterator = makeIterator()

 guard var previous = iterator.next() else {
 // Sequence is empty
 return true
 }

 while let current = iterator.next() {
 guard try areInIncreasingOrder(previous, current) else {
 return false
 }

 previous = current
 }

 return true
 }
}

extension Sequence where Element : Comparable {
 func isSorted() -&gt; Bool {
 return isSorted(by: &lt;)
 }
}
</code></pre>

blocks|key|2949199|text|这是Swift+4中的一个解决方案，当self.count等于或小于1时不会崩溃：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2949200|extension+Array+where+Element:+Comparable+{
++++func+isSorted(by+isOrderedBefore:+(Element,+Element)+->+Bool)+->+Bool+{
++++++++for+i+in+stride(from:+1,+to:+self.count,+by:+1)+{
++++++++++++if+!isOrderedBefore(self[i-1],+self[i])+{
++++++++++++++++return+false
++++++++++++}
++++++++}
++++++++return+true
++++}
}|code-block|syntax|javascript|2949201|这段代码假设一个由1或0元素组成的数组已经排序。|2949202|在for循环范围内从1开始的原因是:在case+self.count+<=+1的情况下，循环将被跳过，性能略有提高。当上限小于范围的下限时，使用stride而不是..<可以避免崩溃。|2949203|下面是一些示例：|2949204|[1,+2,+3].isSorted(by:+>)+//+true
[3,+2,+2].isSorted(by:+>=)+//+true
[1,+4,+7].isSorted(by:+{x,+y+in
++++return+x+%2B+2+<+y+*+y
})+//+true

let+a:+[Int]+=+[1]
a.isSorted(by:+<)+//+true


let+b:+[Int]+=+[]
b.isSorted(by:+>)+//+true|2949205|entityMap^0|J|A|0|0|0|20|6|29|3|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|14|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|T|$]]

Here is a solution in Swift 4 that won't crash when <code>self.count</code> is equal or less than 1:

<pre><code>extension Array where Element: Comparable {
 func isSorted(by isOrderedBefore: (Element, Element) -&gt; Bool) -&gt; Bool {
 for i in stride(from: 1, to: self.count, by: 1) {
 if !isOrderedBefore(self[i-1], self[i]) {
 return false
 }
 }
 return true
 }
}
</code></pre>

This snippet supposes that an array of 1 or 0 elements is already sorted.

The reason to start with 1 in the for-loop range is: In case self.count &lt;= 1, the loop will be skipped, a small performance increase. Using <code>stride</code> instead of <code>..&lt;</code> avoids the crash when the upper bound is &lt; than the lower bound of a range.

Here are some examples:

<pre><code>[1, 2, 3].isSorted(by: &gt;) // true
[3, 2, 2].isSorted(by: &gt;=) // true
[1, 4, 7].isSorted(by: {x, y in
 return x + 2 &lt; y * y
}) // true

let a: [Int] = [1]
a.isSorted(by: &lt;) // true


let b: [Int] = []
b.isSorted(by: &gt;) // true
</code></pre>

blocks|key|2949217|text|如果您想要不带参数的简单函数，如Swift中的sort()或sorted()：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2949218|extension+Array+where+Element+:+Comparable+{
++++func+isSorted()+->+Bool+{
++++++++guard+self.count+>+1+else+{
++++++++++++return+true
++++++++}

++++++++for+i+in+1..<self.count+{
++++++++++++if+self[i-1]+>+self[i]+{
++++++++++++++++return+false
++++++++++++}
++++++++}
++++++++return+true
++++}
}|code-block|syntax|javascript|2949219|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you want simple function without arguments, like sort() or sorted() in Swift:

<pre><code>extension Array where Element : Comparable {
 func isSorted() -&gt; Bool {
 guard self.count &gt; 1 else {
 return true
 }

 for i in 1..&lt;self.count {
 if self[i-1] &gt; self[i] {
 return false
 }
 }
 return true
 }
}
</code></pre>

blocks|key|2949226|text|泛型函数zip()可以提供实现的快捷方式。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2949227|extension+Collection+where+Element:+Comparable+{
++++var+isSorted:+Bool+{
++++++++guard+count+>+1+else+{
++++++++++++return+true+
++++++++}

++++++++let+pairs+=+zip(prefix(count+-+1),+suffix(count+-+1))

++++++++return+!pairs.contains+{+previous,+next+in
++++++++++++previous+>+next
++++++++}
++++}
}

[0,+1,+1,+2].isSorted++//+true
[0,+2,+2,+1].isSorted++//+false|code-block|syntax|javascript|2949228|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.apple.com/documentation/swift/1541125-zip^0|4|5|4|5|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

The generic function, <a href="https://developer.apple.com/documentation/swift/1541125-zip" rel="nofollow noreferrer"><code>zip()</code></a>, can provide a shortcut for implementation.

<pre><code>extension Collection where Element: Comparable {
 var isSorted: Bool {
 guard count &gt; 1 else {
 return true 
 }

 let pairs = zip(prefix(count - 1), suffix(count - 1))

 return !pairs.contains { previous, next in
 previous &gt; next
 }
 }
}

[0, 1, 1, 2].isSorted // true
[0, 2, 2, 1].isSorted // false
</code></pre>

blocks|key|153521|text|在Swift+4.2和更高版本中，您可以通过一些序列切片将allSatisfy和zip拼凑在一起：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|153522|extension+Array+where+Element:+Comparable+{
++++func+isAscending()+->+Bool+{
++++++++return+zip(self,+self.dropFirst()).allSatisfy(<=)
++++}

++++func+isDescending()+->+Bool+{
++++++++return+zip(self,+self.dropFirst()).allSatisfy(>=)
++++}
}|code-block|syntax|javascript|153523|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.apple.com/documentation/swift/sequence/2996794-allsatisfy|1|https://developer.apple.com/documentation/swift/1541125-zip^0|T|A|14|3|T|A|0|14|3|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]|$9|12|A|13|1|14]]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]|S|$5|N|O|P|E|$Q|T]]]]

In Swift 4.2 and later you can cobble together <a href="https://developer.apple.com/documentation/swift/sequence/2996794-allsatisfy" rel="noreferrer"><code>allSatisfy</code></a> and <a href="https://developer.apple.com/documentation/swift/1541125-zip" rel="noreferrer"><code>zip</code></a> with some sequence slicing:

<pre class="lang-swift prettyprint-override"><code>extension Array where Element: Comparable {
 func isAscending() -&gt; Bool {
 return zip(self, self.dropFirst()).allSatisfy(&lt;=)
 }

 func isDescending() -&gt; Bool {
 return zip(self, self.dropFirst()).allSatisfy(&gt;=)
 }
}
</code></pre>

blocks|key|154928|text|当元素相等时，@kAzec的答案似乎不起作用。这是因为根据the+documentation，areInIncreasingOrder(a，a)必须为假。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|154929|以下代码应该可以很好地工作。|154930|extension+Sequence+{
++++func+isSorted(by+areInIncreasingOrder:+(Element,+Element)+throws+->+Bool)
++++++++rethrows+->+Bool+{
++++++++var+it+=+makeIterator()
++++++++guard+var+previous+=+it.next()+else+{+return+true+}
++++++++
++++++++while+let+current+=+it.next()+{
++++++++++++if+try+!areInIncreasingOrder(previous,+current)+&&
++++++++++++++++areInIncreasingOrder(current,+previous)+{
++++++++++++++++return+false
++++++++++++}
++++++++++++previous+=+current
++++++++}
++++++++return+true
++++}
}

extension+Sequence+where+Element:+Comparable+{
++++func+isSorted()+->+Bool+{
++++++++return+isSorted(by:+<)
++++}
}|code-block|syntax|javascript|154931|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.apple.com/documentation/swift/arrayslice/2298431-sort#discussion^0|T|H|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

@kAzec's answer seems to not working when elements are equal. This is because areInIncreasingOrder(a, a) must be false according to <a href="https://developer.apple.com/documentation/swift/arrayslice/2298431-sort#discussion" rel="nofollow noreferrer">the documentation</a>.
The following should work fine.
<pre class="lang-swift prettyprint-override"><code>extension Sequence {
 func isSorted(by areInIncreasingOrder: (Element, Element) throws -&gt; Bool)
 rethrows -&gt; Bool {
 var it = makeIterator()
 guard var previous = it.next() else { return true }
 
 while let current = it.next() {
 if try !areInIncreasingOrder(previous, current) &amp;&amp;
 areInIncreasingOrder(current, previous) {
 return false
 }
 previous = current
 }
 return true
 }
}

extension Sequence where Element: Comparable {
 func isSorted() -&gt; Bool {
 return isSorted(by: &lt;)
 }
}
</code></pre>

blocks|key|2949300|text|总结之前的答案，有一个最小的通用数组扩展需要检查：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2949301|extension+Array+{
++++func+isSorted(_+predicate:+(Element,+Element)+throws+->+Bool)+->+Bool+{
++++++++guard+count+>+1+else+{+return+true+}
++++++++return+(try?+zip(self,+self.dropFirst()).allSatisfy(predicate))+==+true
++++}
}

//+Standard+types

[1,+2,+3,+4,+5].isSorted(<)+//+true
[1,+2,+10,+4,+5].isSorted(<)+//+false

[10,+5,+4,+3,+1].isSorted(>)+//+true
[10,+20,+4,+3,+1].isSorted(>)+//+false


//+Custom+types

struct+MyStruct+{
++++let+i:+Int
}

let+items+=+[MyStruct(i:+1),+MyStruct(i:+2),+MyStruct(i:+3),+MyStruct(i:+10)]
let+sorted+=+items.isSorted+{+$0.i+<+$1.i+}+//+true|code-block|syntax|javascript|2949302|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Summarising previous answers there is a smallest universal Array extension to check:
<pre class="lang-swift prettyprint-override"><code>extension Array {
 func isSorted(_ predicate: (Element, Element) throws -&gt; Bool) -&gt; Bool {
 guard count &gt; 1 else { return true }
 return (try? zip(self, self.dropFirst()).allSatisfy(predicate)) == true
 }
}

// Standard types

[1, 2, 3, 4, 5].isSorted(&lt;) // true
[1, 2, 10, 4, 5].isSorted(&lt;) // false

[10, 5, 4, 3, 1].isSorted(&gt;) // true
[10, 20, 4, 3, 1].isSorted(&gt;) // false


// Custom types

struct MyStruct {
 let i: Int
}

let items = [MyStruct(i: 1), MyStruct(i: 2), MyStruct(i: 3), MyStruct(i: 10)]
let sorted = items.isSorted { $0.i &lt; $1.i } // true
</code></pre>

I want to extend Array class so that it can know whether it is sorted (ascending) or not. I want to add a computed property called <code>isSorted</code>. How can I state the elements of the Array to be comparable?

My current implementation in Playground

<pre><code>extension Array {
 var isSorted: Bool {
 for i in 1..self.count {
 if self[i-1] &gt; self[i] { return false }
 }
 return true
 }
}

// The way I want to get the computed property
[1, 1, 2, 3, 4, 5, 6, 7, 8].isSorted //= true
[2, 1, 3, 8, 5, 6, 7, 4, 8].isSorted //= false
</code></pre>

The error <code>Could not find an overload for '&gt;' that accepts the supplied arguments</code>

Of course, I still got an error because Swift doesn't know how to compare the elements. How can I implement this extension in Swift? Or am I doing something wrong here?

Extending Array to check if it is sorted in Swift?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想扩展Array类，这样它就可以知道它是否排序(升序)。我想添加一个名为isSorted的计算属性。我如何声明数组的元素是可比较的？我目前在Playground中的实现extension Array {  var isSorted: Bool {    for i in 1..self.count {      if...

问扩展Array以检查它是否在Swift中排序？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问扩展Array以检查它是否在Swift中排序？EN