जवाबों:
आपको केवल एक अस्थायी चर की आवश्यकता है।
var b = list[y];
list[y] = list[x];
list[x] = b;
हमारे बेल्ट के तहत ES6 को अपनाने के साथ 10 साल बाद शीर्ष उत्तर को अपहृत करना संपादित करें :
सरणी को देखते हुए arr = [1,2,3,4], आप मानों को एक पंक्ति में स्वैप कर सकते हैं जैसे अब:
[arr[0], arr[1]] = [arr[1], arr[0]];यह एरे का उत्पादन करेगा [2,1,3,4]। यह विनाशकारी कार्य है ।
[ list[y], list[x] ] = [ list[x], list[y] ];
[arr[0], arr[1]] = [arr[1], arr[0]]केवल [2, 1]शेष सरणी के बिना उत्पादन करें
यदि आप एक ही अभिव्यक्ति चाहते हैं, तो देशी जावास्क्रिप्ट का उपयोग करते हुए, याद रखें कि एक ब्याह ऑपरेशन से वापसी मूल्य में वह तत्व (एस) होता है जिसे हटा दिया गया था।
var A = [1, 2, 3, 4, 5, 6, 7, 8, 9], x= 0, y= 1;
A[x] = A.splice(y, 1, A[x])[0];
alert(A); // alerts "2,1,3,4,5,6,7,8,9"संपादित करें:
[0]के रूप में अभिव्यक्ति के अंत में आवश्यक है Array.splice()रिटर्न एक सरणी, और इस स्थिति में हम लौटे सरणी में एक तत्व की आवश्यकता है।
यह ठीक लगता है ...।
var b = list[y];
list[y] = list[x];
list[x] = b;हावेर का उपयोग करना
var b = list[y];इसका मतलब है कि एक बी वेरिएबल बाकी स्कोप के लिए मौजूद होने वाला है। यह संभावित रूप से मेमोरी रिसाव को जन्म दे सकता है। गैर-जरूरी, लेकिन फिर भी बचने के लिए बेहतर है।
हो सकता है कि इसे Array.prototype.swap में डालने का एक अच्छा विचार हो
Array.prototype.swap = function (x,y) {
var b = this[x];
this[x] = this[y];
this[y] = b;
return this;
}जिसे इस प्रकार कहा जा सकता है:
list.swap( x, y )यह मेमोरी लीक और DRY दोनों से बचने का एक साफ तरीका है ।
Array.prototype.swap = function (x,y) { if (x >= 0 && x < this.length && y >= 0 && y < this.length) { var b = this[x]; this[x] = this[y]; this[y] = b; } return this; };
मेटाफ़िल्टर के कुछ यादृच्छिक व्यक्ति के अनुसार , "जावास्क्रिप्ट के हाल के संस्करणों से आप स्वैप (अन्य चीजों के बीच) बहुत अधिक करीने से कर सकते हैं:"
[ list[x], list[y] ] = [ list[y], list[x] ];मेरे त्वरित परीक्षणों से पता चला कि यह पायथन कोड जावास्क्रिप्ट के संस्करण में बहुत अच्छा काम करता है जो वर्तमान में "Google Apps स्क्रिप्ट" (".gs") में उपयोग किया जाता है। काश, आगे के परीक्षणों से पता चलता है कि यह कोड एक "अनट्रीफर्ड रेफरेंसर्रर: अवैध बाएं हाथ का काम" देता है। जावास्क्रिप्ट के किसी भी संस्करण में (".js") का उपयोग Google Chrome संस्करण 24.0.1312.57 मीटर है।
ठीक है, आपको दोनों मूल्यों को बफर करने की आवश्यकता नहीं है - केवल एक:
var tmp = list[x];
list[x] = list[y];
list[y] = tmp;आप निम्नलिखित तरीके से तत्वों को स्वैप कर सकते हैं:
list[x] = [list[y],list[y]=list[x]][0]निम्नलिखित उदाहरण देखें:
list = [1,2,3,4,5]
list[1] = [list[3],list[3]=list[1]][0]
//list is now [1,4,3,2,5]नोट: यह नियमित चर के लिए उसी तरह काम करता है
var a=1,b=5;
a = [b,b=a][0][list[x], list[y]] = [list[y], list[x]];।
this[0] > this[1] && (this[0] = [this[1],this[1]=this[0]][0]);
संख्यात्मक मानों के साथ आप बिटवेअर एक्सोर का उपयोग करके एक अस्थायी चर से बच सकते हैं
list[x] = list[x] ^ list[y];
list[y] = list[y] ^ list[x];
list[x] = list[x] ^ list[y];या एक अंकगणितीय योग (यह देखते हुए कि यह केवल तभी काम करता है यदि x + y डेटा प्रकार के अधिकतम मूल्य से कम हो)
list[x] = list[x] + list[y];
list[y] = list[x] - list[y];
list[x] = list[x] - list[y];list[y] = list[x] - list[x];बस के बराबर नहीं है list[y] = 0;?
यह तब नहीं था जब प्रश्न पूछा गया था, लेकिन ES2015 ने सरणी विनाशकारी की शुरुआत की, जिससे आप इसे इस प्रकार लिख सकते हैं:
let a = 1, b = 2;
// a: 1, b: 2
[a, b] = [b, a];
// a: 2, b: 1[list[x], list[y]] = [list[y], list[x]];
सरणी के दो लगातार तत्वों को स्वैप करने के लिए
array.splice(IndexToSwap,2,array[IndexToSwap+1],array[IndexToSwap]);Http://www.greywyvern.com/?post=265 से डाइजेस्ट करें
var a = 5, b = 9;
b = (a += b -= a) - b;
alert([a, b]); // alerts "9, 5"swap(a, b)फ़ंक्शन में लपेटते हैं, तो आपको पठनीयता के बारे में चिंता करने की आवश्यकता नहीं है।
Destructuring_assignment के बारे में क्या
var arr = [1, 2, 3, 4]
[arr[index1], arr[index2]] = [arr[index2], arr[index1]]जिसे बढ़ाया भी जा सकता है
[src order elements] => [dest order elements]तीसरे चर को परिभाषित करने की आवश्यकता के बिना इस तरह के समाधान पर विचार करें:
function swap(arr, from, to) {
arr.splice(from, 1, arr.splice(to, 1, arr[from])[0]);
}
var letters = ["a", "b", "c", "d", "e", "f"];
swap(letters, 1, 4);
console.log(letters); // ["a", "e", "c", "d", "b", "f"]नोट: आप सरणी लंबाई के लिए उदाहरण के लिए अतिरिक्त चेक जोड़ना चाह सकते हैं। यह समाधान परिवर्तनशील है, इसलिए swapफ़ंक्शन को एक नए सरणी को वापस करने की आवश्यकता नहीं है, यह सिर्फ सरणी में पारित होने पर उत्परिवर्तन करता है।
arr.splice(from, 1, arr.splice(to, 1, ...arr[from]))
आप इस तरह की एक साधारण पहचान फ़ंक्शन का उपयोग करके किसी भी संख्या में वस्तुओं या शाब्दिकों की अदला-बदली कर सकते हैं:
var swap = function (x){return x};
b = swap(a, a=b);
c = swap(a, a=b, b=c);आपकी समस्या के लिए:
var swap = function (x){return x};
list[y] = swap(list[x], list[x]=list[y]);यह जावास्क्रिप्ट में काम करता है क्योंकि यह अतिरिक्त तर्क स्वीकार करता है, भले ही वे घोषित या उपयोग न किए गए हों। असाइनमेंट a=bआदि, aफ़ंक्शन में पारित होने के बाद होता है।
list[y] = (function(x){return x})(list[x],list[x]=list[y]);:। या, यदि आप ईएस 6 (जेएस के अगले संस्करण) में रुचि रखते हैं, तो यह बेहद आसान है [list[x], list[y]] = [list[y], list[x]:। मुझे खुशी है कि वे जावास्क्रिप्ट के अगले संस्करण में कुछ अधिक कार्यात्मक और वर्ग-आधारित पहलुओं को जोड़ रहे हैं।
[list[y], list[x]] = [list[x], list[y]];कोई अस्थायी चर की आवश्यकता है!
मैं बस फोन करने के बारे में सोच रहा था list.reverse()।
लेकिन तब मुझे एहसास हुआ कि यह स्वैप के रूप में तभी काम करेगा list.length = x + y + 1।
मैंने इस आशय के विभिन्न आधुनिक जावास्क्रिप्ट निर्माणों पर ध्यान दिया है, जिसमें मानचित्र और मानचित्र भी शामिल हैं , लेकिन दुख की बात है कि कोई भी ऐसा कोड नहीं है जो इस पुराने जमाने के लूप-आधारित निर्माण की तुलना में अधिक कॉम्पैक्ट या तेज था:
function multiswap(arr,i0,i1) {/* argument immutable if string */
if (arr.split) return multiswap(arr.split(""), i0, i1).join("");
var diff = [];
for (let i in i0) diff[i0[i]] = arr[i1[i]];
return Object.assign(arr,diff);
}
Example:
var alphabet = "abcdefghijklmnopqrstuvwxyz";
var [x,y,z] = [14,6,15];
var output = document.getElementsByTagName("code");
output[0].innerHTML = alphabet;
output[1].innerHTML = multiswap(alphabet, [0,25], [25,0]);
output[2].innerHTML = multiswap(alphabet, [0,25,z,1,y,x], [25,0,x,y,z,3]);<table>
<tr><td>Input:</td> <td><code></code></td></tr>
<tr><td>Swap two elements:</td> <td><code></code></td></tr>
<tr><td>Swap multiple elements: </td> <td><code></code></td></tr>
</table>var a = [1,2,3,4,5], b=a.length;
for (var i=0; i<b; i++) {
a.unshift(a.splice(1+i,1).shift());
}
a.shift();
//a = [5,4,3,2,1];यहाँ i1 में एक कॉम्पैक्ट वर्जन स्वैप वैल्यू है जो i2 के साथ अरेस्ट है
arr.slice(0,i1).concat(arr[i2],arr.slice(i1+1,i2),arr[i1],arr.slice(i2+1))यहाँ एक भिन्नता है जो पहले जाँचता है कि क्या सूचकांक सरणी में मौजूद है:
Array.prototype.swapItems = function(a, b){
if( !(a in this) || !(b in this) )
return this;
this[a] = this.splice(b, 1, this[a])[0];
return this;
}thisयदि सूचकांक मौजूद नहीं है, तो यह वर्तमान में वापस आ जाएगा , लेकिन आप आसानी से विफल होने पर व्यवहार को संशोधित कर सकते हैं
बस इसके मज़े के लिए, किसी भी अतिरिक्त चर का उपयोग किए बिना एक और तरीका होगा:
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
// swap index 0 and 2
arr[arr.length] = arr[0]; // copy idx1 to the end of the array
arr[0] = arr[2]; // copy idx2 to idx1
arr[2] = arr[arr.length-1]; // copy idx1 to idx2
arr.length--; // remove idx1 (was added to the end of the array)
console.log( arr ); // -> [3, 2, 1, 4, 5, 6, 7, 8, 9]संक्षिप्तता के लिए, यहाँ एक बदसूरत वन-लाइनर संस्करण है, जो केवल उस संक्षिप्त और स्लाइसिंग की तुलना में थोड़ा कम बदसूरत है। स्वीकृत उत्तर वास्तव में जाने का तरीका और अधिक पठनीय तरीका है।
दिया हुआ:
var foo = [ 0, 1, 2, 3, 4, 5, 6 ];यदि आप दो सूचकांकों (ए और बी) के मूल्यों को स्वैप करना चाहते हैं; तो यह करना होगा:
foo.splice( a, 1, foo.splice(b,1,foo[a])[0] );उदाहरण के लिए, यदि आप 3 और 5 को स्वैप करना चाहते हैं, तो आप इसे इस तरह से कर सकते हैं:
foo.splice( 3, 1, foo.splice(5,1,foo[3])[0] );या
foo.splice( 5, 1, foo.splice(3,1,foo[5])[0] );दोनों एक ही परिणाम देते हैं:
console.log( foo );
// => [ 0, 1, 2, 5, 4, 3, 6 ]#splicehatersarepunks :)
यदि आप ES5 में अस्थायी चर का उपयोग नहीं करना चाहते हैं, तो यह सरणी तत्वों को स्वैप करने का एक तरीका है।
var swapArrayElements = function (a, x, y) {
if (a.length === 1) return a;
a.splice(y, 1, a.splice(x, 1, a[y])[0]);
return a;
};
swapArrayElements([1, 2, 3, 4, 5], 1, 3); //=> [ 1, 4, 3, 2, 5 ]a.spliceहटाए गए तत्वों के साथ एक सरणी के रूप में 2 नए सरणियां बना रहे हैं । developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
इस फ़ंक्शन को आज़माएं ...
$(document).ready(function () {
var pair = [];
var destinationarray = ['AAA','BBB','CCC'];
var cityItems = getCityList(destinationarray);
for (var i = 0; i < cityItems.length; i++) {
pair = [];
var ending_point = "";
for (var j = 0; j < cityItems[i].length; j++) {
pair.push(cityItems[i][j]);
}
alert(pair);
console.log(pair)
}
});
function getCityList(inputArray) {
var Util = function () {
};
Util.getPermuts = function (array, start, output) {
if (start >= array.length) {
var arr = array.slice(0);
output.push(arr);
} else {
var i;
for (i = start; i < array.length; ++i) {
Util.swap(array, start, i);
Util.getPermuts(array, start + 1, output);
Util.swap(array, start, i);
}
}
}
Util.getAllPossiblePermuts = function (array, output) {
Util.getPermuts(array, 0, output);
}
Util.swap = function (array, from, to) {
var tmp = array[from];
array[from] = array[to];
array[to] = tmp;
}
var output = [];
Util.getAllPossiblePermuts(inputArray, output);
return output;
}<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>var arr = [1, 2];
arr.splice(0, 2, arr[1], arr[0]);
console.log(arr); //[2, 1]ES6 का उपयोग करना कर इसे इस तरह से करना संभव है ...
सोचिए आपके पास हैं ये 2 सरण ...
const a = ["a", "b", "c", "d", "e"];
const b = [5, 4, 3, 2, 1];और आप पहले मूल्यों को बदलना चाहते हैं:
const [a0] = a;
a[0] = b[0];
b[0] = a0;और मूल्य:
a; //[5, "b", "c", "d", "e"]
b; //["a", 4, 3, 2, 1]Array.prototype.swap = function(a, b) {
var temp = this[a];
this[a] = this[b];
this[b] = temp;
};उपयोग:
var myArray = [0,1,2,3,4...];
myArray.swap(4,1);Arrayप्रोटोटाइप को विस्तारित करना उस चीज का हिस्सा नहीं था जो इसके लिए कहा गया था - यह अच्छा होने से अधिक भ्रमित कर सकता है।
अगर केवल पहले और अंतिम तत्वों की अदला-बदली की जरूरत है:
array.unshift( array.pop() );[1, 2, 3] => [3, 1, 2]बजाय [1, 2, 3] => [3, 2, 1]।
a = [b, b = a][0];जैसा कि @Jan द्वारा बताया गया है हालांकि मैं अभी भी खुद को अस्थायी चर दृष्टिकोण का उपयोग कर पाता हूं क्योंकि यह क्रॉस-लैंग्वेज (जैसे C / C ++) है ) और पहला दृष्टिकोण जो आमतौर पर मेरे दिमाग में आता है।