blocks|key|4422639|text|Swift+3.0%2B：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4422640|let+element+=+arr.remove(at:+3)
arr.insert(element,+at:+2)|code-block|syntax|javascript|4422641|并且在函数形式中：|4422642|func+rearrange<T>(array:+Array<T>,+fromIndex:+Int,+toIndex:+Int)+->+Array<T>{
++++var+arr+=+array
++++let+element+=+arr.remove(at:+fromIndex)
++++arr.insert(element,+at:+toIndex)

++++return+arr
}|4422643|Swift+2.0：|4422644|这会将3置于位置4。|4422645|let+element+=+arr.removeAtIndex(3)
arr.insert(element,+atIndex:+2)|4422646|您甚至可以创建一个通用函数：|4422647|func+rearrange<T>(array:+Array<T>,+fromIndex:+Int,+toIndex:+Int)+->+Array<T>{
++++var+arr+=+array
++++let+element+=+arr.removeAtIndex(fromIndex)
++++arr.insert(element,+atIndex:+toIndex)

++++return+arr
}|4422648|这里需要var+arr，因为您不能在不将输入参数指定为in-out的情况下更改它。然而，在我们的例子中，我们得到了一个没有副作用的纯函数，在我看来，这更容易推理。然后你可以这样叫它：|offset|length|style|CODE|4422649|let+arr+=+[1,2,3,4]
rearrange(arr,+fromIndex:+2,+toIndex:+0)+//[3,1,2,4]|4422650|entityMap^0|0|0|0|0|0|0|0|0|0|4|3|8|3|R|6|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|16|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|18|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|19|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1D|8|@$W|1E|X|1F|Y|Z]|$W|1G|X|1H|Y|Z]|$W|1I|X|1J|Y|Z]]|9|@]|A|$]]|$1|10|3|11|5|D|7|1K|8|@]|9|@]|A|$E|F]]|$1|12|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]]|13|$]]

<h2>Swift 3.0+:</h2>
<pre><code>let element = arr.remove(at: 3)
arr.insert(element, at: 2)
</code></pre>
and in function form:
<pre><code>func rearrange&lt;T&gt;(array: Array&lt;T&gt;, fromIndex: Int, toIndex: Int) -&gt; Array&lt;T&gt;{
 var arr = array
 let element = arr.remove(at: fromIndex)
 arr.insert(element, at: toIndex)

 return arr
}
</code></pre>
<h2>Swift 2.0:</h2>
This puts 3 into position 4.
<pre><code>let element = arr.removeAtIndex(3)
arr.insert(element, atIndex: 2)
</code></pre>
You can even make a general function:
<pre><code>func rearrange&lt;T&gt;(array: Array&lt;T&gt;, fromIndex: Int, toIndex: Int) -&gt; Array&lt;T&gt;{
 var arr = array
 let element = arr.removeAtIndex(fromIndex)
 arr.insert(element, atIndex: toIndex)

 return arr
}
</code></pre>
The <code>var</code> <code>arr</code> is needed here, because you can't mutate the input parameter without specifying it to be <code>in-out</code>. In our case however we get a pure functions with no side effects, which is a lot easier to reason with, in my opinion.
You could then call it like this:
<pre><code>let arr = [1,2,3,4]
rearrange(arr, fromIndex: 2, toIndex: 0) //[3,1,2,4]
</code></pre>

blocks|key|4422591|text|狮子座的小贴士不错。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4422592|对于Swift+3：|4422593|extension+Array+{++
++++mutating+func+rearrange(from:+Int,+to:+Int)+{
++++++++insert(remove(at:+from),+at:+to)
++++}
}

var+myArray+=+[1,2,3,4]
myArray.rearrange(from:+1,+to:+2)+++
print(myArray)|code-block|syntax|javascript|4422594|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

nice tip from Leo.

for Swift 3: 

<pre><code>extension Array { 
 mutating func rearrange(from: Int, to: Int) {
 insert(remove(at: from), at: to)
 }
}

var myArray = [1,2,3,4]
myArray.rearrange(from: 1, to: 2) 
print(myArray)
</code></pre>

blocks|key|4422603|text|var+arr+=+["one",+"two",+"three",+"four",+"five"]

//+Swap+elements+at+index:+2+and+3
print(arr)
arr.swapAt(2,+3)
print(arr)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4422604|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>var arr = ["one", "two", "three", "four", "five"]

// Swap elements at index: 2 and 3
print(arr)
arr.swapAt(2, 3)
print(arr)
</code></pre>

blocks|key|4422836|text|Swift+4.2|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4422837|extension+Array+where+Element:+Equatable+{
++++mutating+func+move(_+item:+Element,+to+newIndex:+Index)+{
++++++++if+let+index+=+index(of:+item)+{
++++++++++++move(at:+index,+to:+newIndex)
++++++++}
++++}

++++mutating+func+bringToFront(item:+Element)+{
++++++++move(item,+to:+0)
++++}

++++mutating+func+sendToBack(item:+Element)+{
++++++++move(item,+to:+endIndex-1)
++++}
}

extension+Array+{
++++mutating+func+move(at+index:+Index,+to+newIndex:+Index)+{
++++++++insert(remove(at:+index),+at:+newIndex)
++++}
}|code-block|syntax|javascript|4422838|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|$]]

<h2>Swift 4.2</h2>

<pre><code>extension Array where Element: Equatable {
 mutating func move(_ item: Element, to newIndex: Index) {
 if let index = index(of: item) {
 move(at: index, to: newIndex)
 }
 }

 mutating func bringToFront(item: Element) {
 move(item, to: 0)
 }

 mutating func sendToBack(item: Element) {
 move(item, to: endIndex-1)
 }
}

extension Array {
 mutating func move(at index: Index, to newIndex: Index) {
 insert(remove(at: index), at: newIndex)
 }
}
</code></pre>

blocks|key|4422692|text|我们可以使用交换方法来交换数组中的项：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4422693|var+arr+=+["one",+"two",+"three",+"four",+"five"]

//+Swap+elements+at+index:+2+and+3
print(arr)
swap(&arr[2],+&arr[3])
print(arr)|code-block|syntax|javascript|4422694|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|$]]

We can use swap method to swap items in an array :

<pre><code>var arr = ["one", "two", "three", "four", "five"]

// Swap elements at index: 2 and 3
print(arr)
swap(&amp;arr[2], &amp;arr[3])
print(arr)
</code></pre>

blocks|key|4422876|text|@ian已经提供了很好的解决方案，但是当数组变得越界时，它会崩溃，还增加了对此的检查|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4422877|extension+Array+where+Element:+Equatable+{
++++public+mutating+func+move(_+element:+Element,+to+newIndex:+Index)+{
++++++++if+let+oldIndex:+Int+=+index(of:+element)+{
++++++++++++self.move(from:+oldIndex,+to:+newIndex)
++++++++}
++++}

++++public+mutating+func+moveToFirst(item:+Element)+{
++++++++self.move(item,+to:+0)
++++}

++++public+mutating+func+move(from+oldIndex:+Index,+to+newIndex:+Index)+{
++++++++//+won't+rebuild+array+and+will+be+super+efficient.
++++++++if+oldIndex+==+newIndex+{+return+}
++++++++//+Index+out+of+bound+handle+here
++++++++if+newIndex+>=+self.count+{+return+}
++++++++//+Don't+work+for+free+and+use+swap+when+indices+are+next+to+each+other+-+this
++++++++if+abs(newIndex+-+oldIndex)+==+1+{+return+self.swapAt(oldIndex,+newIndex)+}
++++++++//+Remove+at+old+index+and+insert+at+new+location
++++++++self.insert(self.remove(at:+oldIndex),+at:+newIndex)
++++}
}|code-block|syntax|javascript|4422878|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|$]]

@ian has provided good solution but it will be crash when array become out of bound added check for that too

<pre><code>extension Array where Element: Equatable {
 public mutating func move(_ element: Element, to newIndex: Index) {
 if let oldIndex: Int = index(of: element) {
 self.move(from: oldIndex, to: newIndex)
 }
 }

 public mutating func moveToFirst(item: Element) {
 self.move(item, to: 0)
 }

 public mutating func move(from oldIndex: Index, to newIndex: Index) {
 // won't rebuild array and will be super efficient.
 if oldIndex == newIndex { return }
 // Index out of bound handle here
 if newIndex &gt;= self.count { return }
 // Don't work for free and use swap when indices are next to each other - this
 if abs(newIndex - oldIndex) == 1 { return self.swapAt(oldIndex, newIndex) }
 // Remove at old index and insert at new location
 self.insert(self.remove(at: oldIndex), at: newIndex)
 }
}
</code></pre>

blocks|key|4422566|text|swift中没有用于阵列的移动功能。你可以从索引处移除一个对象，然后使用'insert‘将它放入你最喜欢的索引中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4422567|var+swiftarray+=+[1,2,3,4]
let+myobject+=+swiftarray.removeAtIndex(1)+//+2+is+the+object+at+1st+index
let+myindex+=+3
swiftarray.insert(myobject,+atIndex:+myindex)+//+if+you+want+to+insert+the++++object+to+a+particular+index+here+it+is+3
swiftarray.append(myobject)+//+if+you+want+to+move+the+object+to+last+index|code-block|syntax|javascript|4422568|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|$]]

There is no move functionality in swift for arrays. you can take an object at an index by removing it from there and place it in your favourite index by using 'insert'

<pre><code>var swiftarray = [1,2,3,4]
let myobject = swiftarray.removeAtIndex(1) // 2 is the object at 1st index
let myindex = 3
swiftarray.insert(myobject, atIndex: myindex) // if you want to insert the object to a particular index here it is 3
swiftarray.append(myobject) // if you want to move the object to last index
</code></pre>

blocks|key|4422761|text|下面是一个解决方案，其中的函数既可以就地更改数组，也可以返回更改后的数组：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4422762|extension+Array+{
++++func+rearranged(from+fromIndex:+Int,+to+toIndex:+Int)+->+[Element]+{
++++++++var+arr+=+self
++++++++let+element+=+arr.remove(at:+fromIndex)
++++++++
++++++++if+toIndex+>=+self.count+{
++++++++++++arr.append(element)
++++++++}+else+{
++++++++++++arr.insert(element,+at:+toIndex)
++++++++}
++++++++return+arr
++++}
++++
++++mutating+func+rearrange(from+fromIndex:+Int,+to+toIndex:+Int)+{
++++++++let+element+=+self.remove(at:+fromIndex)
++++++++if+toIndex+>=+self.count+{
++++++++++++self.append(element)
++++++++}+else+{
++++++++++++self.insert(element,+at:+toIndex)
++++++++}
++++}
}|code-block|syntax|javascript|4422763|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|$]]

Here's a solution with functions to both change the array in-place and to return a changed array:
<pre><code>extension Array {
 func rearranged(from fromIndex: Int, to toIndex: Int) -&gt; [Element] {
 var arr = self
 let element = arr.remove(at: fromIndex)
 
 if toIndex &gt;= self.count {
 arr.append(element)
 } else {
 arr.insert(element, at: toIndex)
 }
 return arr
 }
 
 mutating func rearrange(from fromIndex: Int, to toIndex: Int) {
 let element = self.remove(at: fromIndex)
 if toIndex &gt;= self.count {
 self.append(element)
 } else {
 self.insert(element, at: toIndex)
 }
 }
}
</code></pre>

blocks|key|4422817|text|高效的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4422818|extension+Array+
{
++++mutating+func+move(from+sourceIndex:+Int,+to+destinationIndex:+Int)
++++{
++++++++guard
++++++++++++sourceIndex+!=+destinationIndex
++++++++++++&&+Swift.min(sourceIndex,+destinationIndex)+>=+0
++++++++++++&&+Swift.max(sourceIndex,+destinationIndex)+<+count
++++++++else+{
++++++++++++return
++++++++}

++++++++let+direction+=+sourceIndex+<+destinationIndex+?+1+:+-1
++++++++var+sourceIndex+=+sourceIndex

++++++++repeat+{
++++++++++++let+nextSourceIndex+=+sourceIndex+%2B+direction
++++++++++++swapAt(sourceIndex,+nextSourceIndex)
++++++++++++sourceIndex+=+nextSourceIndex
++++++++}
++++++++while+sourceIndex+!=+destinationIndex
++++}
}|code-block|syntax|javascript|4422819|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|$]]

Efficient solution:

<pre><code>extension Array 
{
 mutating func move(from sourceIndex: Int, to destinationIndex: Int)
 {
 guard
 sourceIndex != destinationIndex
 &amp;&amp; Swift.min(sourceIndex, destinationIndex) &gt;= 0
 &amp;&amp; Swift.max(sourceIndex, destinationIndex) &lt; count
 else {
 return
 }

 let direction = sourceIndex &lt; destinationIndex ? 1 : -1
 var sourceIndex = sourceIndex

 repeat {
 let nextSourceIndex = sourceIndex + direction
 swapAt(sourceIndex, nextSourceIndex)
 sourceIndex = nextSourceIndex
 }
 while sourceIndex != destinationIndex
 }
}
</code></pre>

blocks|key|4422741|text|func+adjustIndex(_+index:+Int,+forRemovalAt+removed:+Int)+->+Int+{
++++return+index+<=+removed+?+index+:+index+-+1
}

extension+Array
{
++++mutating+func+move(from+oldIndex:+Index,+to+newIndex:+Index)+{
++++++++insert(remove(at:+oldIndex),+at:+adjustIndex(newIndex,+forRemovalAt:+oldIndex))
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4422742|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>func adjustIndex(_ index: Int, forRemovalAt removed: Int) -&gt; Int {
 return index &lt;= removed ? index : index - 1
}

extension Array
{
 mutating func move(from oldIndex: Index, to newIndex: Index) {
 insert(remove(at: oldIndex), at: adjustIndex(newIndex, forRemovalAt: oldIndex))
 }
}
</code></pre>

blocks|key|4422914|text|函数(不是快速的而是通用的..查找/删除/插入)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4422915|func+c_move_to(var+array:Array,var+from:Int,var+to:Int):

++++var+val+=+array[from]
++++array.remove(from)
++++array.insert(to,val)
++++return+array|code-block|syntax|javascript|4422916|使用方法：|4422917|print("MOVE+0+to+3++[1,2,3,4,5]"++,+c_move_to([1,2,3,4,5],0,3))
print("MOVE+1+to+2++[1,2,3,4,5]"++,+c_move_to([1,2,3,4,5],1,2))+|4422918|吐出来：|4422919|MOVE+0+to+3++[1,2,3,4,5][2,+3,+4,+1,+5]
MOVE+1+to+2++[1,2,3,4,5][1,+3,+2,+4,+5]|4422920|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Function(not swift but universal.. lookup/remove/insert):

<pre><code>func c_move_to(var array:Array,var from:Int,var to:Int):

 var val = array[from]
 array.remove(from)
 array.insert(to,val)
 return array
</code></pre>

How to use:

<pre><code>print("MOVE 0 to 3 [1,2,3,4,5]" , c_move_to([1,2,3,4,5],0,3))
print("MOVE 1 to 2 [1,2,3,4,5]" , c_move_to([1,2,3,4,5],1,2)) 
</code></pre>

spits out:

<pre><code>MOVE 0 to 3 [1,2,3,4,5][2, 3, 4, 1, 5]
MOVE 1 to 2 [1,2,3,4,5][1, 3, 2, 4, 5]
</code></pre>

blocks|key|4422955|text|这个解决方案怎么样？要更改的元素和要更改的元素已经更改。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4422956|//+Extenstion

extension+Array+where+Element:+Equatable+{
++mutating+func+change(_+element:+Element,+to+newIndex:+Index)+{
++++if+let+firstIndex+=+self.firstIndex(of:+element)+{
++++++self.insert(element,+at:+0)
++++++self.remove(at:+firstIndex+%2B+1)
++++}
++}
}

//+Example

var+testArray+=+["a",+"b",+"c",+"EE",+"d"]
testArray.change("EE",+to:+0)

//+-->+Result
//+["EE",+"a",+"b",+"c",+"d"]|code-block|syntax|javascript|4422957|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|$]]

How about this solution?
The element to be changed and the element to be changed have been changed.
<pre><code>// Extenstion

extension Array where Element: Equatable {
 mutating func change(_ element: Element, to newIndex: Index) {
 if let firstIndex = self.firstIndex(of: element) {
 self.insert(element, at: 0)
 self.remove(at: firstIndex + 1)
 }
 }
}

// Example

var testArray = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;EE&quot;, &quot;d&quot;]
testArray.change(&quot;EE&quot;, to: 0)

// --&gt; Result
// [&quot;EE&quot;, &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;]
</code></pre>

Consider the array <code>[1,2,3,4]</code>. How can I rearrange the array item to new position. 

For example: 

<code>put 3 into position 4 [1,2,4,3]</code>

<code>put 4 in to position 1 [4,1,2,3]</code>

<code>put 2 into position 3 [1,3,2,4]</code>.

How to rearrange item of an array to new position in Swift?

考虑数组[1,2,3,4]。如何将数组项重新排列到新位置。例如：put 3 into position 4 [1,2,4,3]put 4 in to position 1 [4,1,2,3]put 2 into position 3 [1,3,2,4]。

问如何在Swift中将数组的项重新排列到新位置？
EN

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Swift中将数组的项重新排列到新位置？EN

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Swift中将数组的项重新排列到新位置？
EN