किसी सरणी में अंतिम आइटम प्राप्त करें

Question

यहाँ मेरा जावास्क्रिप्ट कोड अब तक है:

var linkElement = document.getElementById("BackButton");
var loc_array = document.location.href.split('/');
var newT = document.createTextNode(unescape(capWords(loc_array[loc_array.length-2]))); 
linkElement.appendChild(newT);

वर्तमान में यह URL से सरणी में अंतिम से अंतिम आइटम लेता है। हालाँकि, मैं सरणी में अंतिम आइटम के लिए एक चेक करना चाहता हूं "index.html"और यदि हां, तो इसके बजाय तीसरे से अंतिम आइटम को पकड़ो।

Answer 1

if (loc_array[loc_array.length - 1] === 'index.html') {
   // do something
} else {
   // something else
}

इस घटना में कि आपका सर्वर "index.html" और "inDEX.htML" के लिए एक ही फ़ाइल परोसता है, आप भी इसका उपयोग कर सकते हैं .toLowerCase():।

हालाँकि, यदि संभव हो तो आप इस सर्वर-साइड को करने पर विचार कर सकते हैं: यह क्लीनर होगा और जेएस के बिना लोगों के लिए काम करेगा।

Answer 2

निश्चित नहीं है कि क्या कोई कमी है, लेकिन यह काफी संक्षिप्त है:

arr.slice(-1)[0] 

या

arr.slice(-1).pop()

undefinedसरणी खाली होने पर दोनों वापस आ जाएंगे ।

Comments

विनाशकारी का उपयोग करना बहुत अच्छा है:const [lastItem] = arr.slice(-1)

— diachedelic

@diachedelic यह सबसे चालाक तरीका है! बहुत बढ़िया!

— ट्रूफा

.pop()अंतिम तत्व को हटाता है जो मूल सरणी को संशोधित करता है। यह केवल उस मूल्य को प्राप्त करने के समान नहीं है।

— बद्रीश

@Badrush स्लाइस () एक एकल तत्व की एक प्रति के साथ नई सरणी बनाता है, और पॉप केवल उस प्रतिलिपि को संशोधित करता है। मूल सरणी

— अप्रकाशित

लेकिन आपको नए सरणियों को बनाने से बचना चाहिए जब तक कि इस कोड को अक्सर नहीं कहा जाता है। अन्यथा यह कचरा संग्रह पर एक अतिरिक्त दबाव डालेगा, और / या ब्राउज़र को अधिक मेमोरी का उपयोग करेगा।

— mvmn

Answer 3

Array.pop का उपयोग करें :

var lastItem = anArray.pop();

महत्वपूर्ण : यह अंतिम तत्व देता है और इसे सरणी से निकालता है

Answer 4

@Chaiguy ने जो पोस्ट किया है उसका एक छोटा संस्करण:

Array.prototype.last = function() {
    return this[this.length - 1];
}

-1 इंडेक्स रिटर्न पढ़ना undefined पहले से ही।

संपादित करें:

इन दिनों वरीयता मॉड्यूल का उपयोग करने और प्रोटोटाइप को छूने या वैश्विक नाम स्थान का उपयोग करने से बचने के लिए प्रतीत होती है।

export function last(array) {
    return array[array.length - 1];
}

Comments

यदि यह स्पष्ट नहीं है कि यह वास्तव में कैसे उपयोग किया जाना है, तो यहां एक उदाहरण है var lastItem = [3,2,1,5].last();:। का मान lastItemहै 5।

— user128216

यह उत्तर सही है और बहुत साफ है, लेकिन (!!!) जावास्क्रिप्ट का उपयोग करते हुए अंगूठे का एक नियम है Do NOT modify objects you Do NOT own। यह कई कारणों से खतरनाक है, जैसे कि 1. आपकी टीम में काम करने वाले अन्य डेवलपर भ्रमित हो सकते हैं क्योंकि यह विधि मानक नहीं है। पुस्तकालयों में किसी भी अद्यतन के साथ या यहां तक ​​कि कम या उच्च ECMAScript संस्करण का उपयोग करने से यह आसानी से LOST प्राप्त कर सकता है!

— फरजाद वाईजेड

किसी को भी आश्चर्य हो रहा है, यह Array.forEach () को तोड़ता है। मैं अभी भी सहमत हूं कि प्रोटोटाइप को संशोधित करना वहां से सबसे बुरी बात नहीं है, लेकिन यह एक बुरा है।

— सिपाही रीड

Imo में संशोधन के साथ इतनी बड़ी समस्या नहीं है Array.prototype, लेकिन आपको इसका उपयोग करना चाहिए Object.assign(Array.prototype, 'last', { value: function () { … } });। नहीं तो संपत्ति असंख्य होगी।

— 39 黄

Answer 5

दो विकल्प हैं:

var last = arr[arr.length - 1]

या

var last = arr.slice(-1)[0]

पूर्व तेज है, लेकिन बाद वाला अच्छा लग रहा है

http://jsperf.com/slice-vs-length-1-arr

Answer 6

यहां बताया गया है कि मूल ARRAY पर इसका कोई प्रभाव नहीं है

a = [1,2,5,6,1,874,98,"abc"];
a.length; //returns 8 elements

यदि आप पॉप () का उपयोग करते हैं, तो यह आपके सरणी को संशोधित करेगा

a.pop();  // will return "abc" AND REMOVES IT from the array 
a.length; // returns 7

लेकिन आप इसका उपयोग कर सकते हैं ताकि मूल सरणी पर इसका कोई प्रभाव न हो :

a.slice(-1).pop(); // will return "abc" won't do modify the array 
                   // because slice creates a new array object 
a.length;          // returns 8; no modification and you've got you last element 

Comments

आपको स्लाइस (-1) .pop () करनी चाहिए, अन्यथा आप पूरे ऐरे को कॉपी करते हैं (आपको वास्तव में केवल अंतिम एलिमेंट को कॉपी करने की जरूरत है)।

— kritzikratzi

pop()उसके लिए कोई ज़रूरत नहीं है : बस करोarr.slice(-1)[0]

— क्रिस्टोफ़ मारोस

Answer 7

"सबसे साफ" ES6 रास्ता (IMO) होगा:

const foo = [1,2,3,4];
const bar = [...foo].pop();

इस से बचा जाता परिवर्तनशील foo, के रूप में .pop()होता था, अगर हम प्रसार ऑपरेटर इस्तेमाल किया नहीं था।
उस ने कहा, मुझे foo.slice(-1)[0]समाधान पसंद है ।

Comments

तुम भी सरणी destructuring इसे बनाने के लिए उपयोग कर सकते हैं और अधिक ); ES6 stackoverflow.com/a/46485581/31671

— एलेक्स

ध्यान दें कि यह समाधान संपूर्ण सरणी की एक प्रति निष्पादित करता है।

— ब्रेंडन एनेबल

यह उतना ही अपठनीय है, .slice(-1)[0]लेकिन यह धीमा है। साथ ही साथ उपयोग कर सकते हैं.slice

— 18:30

"साफ" वाक्य रचना के लिए पूरे सरणी को कॉपी करना मुझे मूर्खतापूर्ण लगता है। यह भी अच्छा नहीं लगता है

— जेमर जोन्स

Answer 8

मैं array.pop()अनुक्रमित की तुलना में उपयोग करना चाहते हैं।

while(loc_array.pop()!= "index.html"){
}
var newT = document.createTextNode(unescape(capWords(loc_array[loc_array.length])));

इस तरह से आप हमेशा index.html के तत्व को प्राप्त करते हैं (आपके सरणी को एक आइटम के रूप में अलग-अलग index.html प्रदान करते हैं)। नोट: आप अंतिम तत्वों को सरणी से खो देंगे, हालाँकि।

Answer 9

मुझे लगता है कि यदि आप केवल हटाने के बिना तत्व प्राप्त करना चाहते हैं, तो यह अधिक सरल उपयोग है:

arr.slice(-1)[0]

नोट: यदि सरणी खाली है (उदाहरण के लिए []) तो यह वापस आ जाएगीundefined ।

वैसे ... मैं प्रदर्शन की जाँच नहीं किया है, लेकिन मुझे लगता है कि लिखने के लिए और अधिक सरल और साफ है

Comments

ध्यान दें कि ए) यह अंतिम मान नहीं लौटाता है, लेकिन अंतिम तत्व ( arr.slice(-1)[0] === arr[arr.length - 1]), और बी) के साथ एक सरणी यह धीमा है क्योंकि यह arrएक नए सरणी में प्रतिलिपि करता है ( प्रदर्शन मापने के लिए stackoverflow.com/a/51763533/2733244 देखें )।

— वार्टवार्ट

Answer 10

const [lastItem] = array.slice(-1);

Array.prototype.slice -1 के साथ एक नया ऐरे बनाने के लिए इस्तेमाल किया जा सकता है जिसमें मूल ऐरे का केवल अंतिम आइटम है, आप तब उस नए एरे के पहले आइटम का उपयोग करके एक चर बनाने के लिए विनाशकारी असाइनमेंट का उपयोग कर सकते हैं ।

const lotteryNumbers = [12, 16, 4, 33, 41, 22];
const [lastNumber] = lotteryNumbers.slice(-1);

console.log(lotteryNumbers.slice(-1));
// => [22]
console.log(lastNumber);
// => 22

Answer 11

किसी सरणी का अंतिम आइटम प्राप्त करना नकारात्मक मानों के साथ स्लाइस विधि का उपयोग करके प्राप्त किया जा सकता है ।

आप इसके बारे में अधिक जानकारी यहां नीचे दे सकते हैं।

var fileName = loc_array.slice(-1)[0];
if(fileName.toLowerCase() == "index.html")
{
  //your code...
}

पॉप () का उपयोग करने से आपकी सरणी बदल जाएगी, जो हमेशा एक अच्छा विचार नहीं है।

Comments

स्लाइस एक सरणी देता है, हालाँकि, इस उत्तर कीarr.slice(-1)[0] तरह उपयोग करें ।

— सेस टिम्मरमैन

यदि प्रदर्शन एक समस्या है, तो जान लें कि यह विधि array[array.length - 1] jsperf.com/get-last-item-from-array/13

— ब्रूनो पेरेस

Answer 12

आप इस पैटर्न का उपयोग कर सकते हैं ...

let [last] = arr.slice(-1);

हालांकि यह अच्छी तरह से पढ़ता है, लेकिन ध्यान रखें कि यह एक नया सरणी बनाता है इसलिए यह अन्य समाधानों की तुलना में कम कुशल है, लेकिन यह लगभग कभी भी आपके आवेदन की प्रदर्शन अड़चन नहीं होगा ।

Answer 13

यह प्रश्न लंबे समय से है, इसलिए मुझे आश्चर्य है कि किसी ने भी अंतिम तत्व को वापस डालने का उल्लेख नहीं किया है pop() ।

arr.pop()के रूप में बिल्कुल के रूप में कुशल है arr[arr.length-1], और दोनों के रूप में एक ही गति कर रहे हैंarr.push() ।

इसलिए, आप इससे दूर हो सकते हैं:

--- कार्य [जाँच करें कि धक्का देने से पहले thePopनहीं है undefined] ---

let thePop = arr.pop()
thePop && arr.push(thePop)

--- END EDIT ---

इसे कम किया जा सकता है (समान गति [EDIT: but unsafe!]):

arr.push(thePop = arr.pop())    //Unsafe if arr empty

यह दोगुनी धीमी है arr[arr.length-1], लेकिन आपको इंडेक्स के साथ सामान नहीं करना है। यह किसी भी दिन सोने के लायक है।

मेरे द्वारा आजमाए गए समाधानों में से और निष्पादन समय इकाई (ETU) के गुणकों में arr[arr.length-1] :

[विधि] .............. [५ ईटीयू] ५ ईएमयू

arr[arr.length - 1]      ------> 1              -----> 1

let myPop = arr.pop()
arr.push(myPop)          ------> 2              -----> 2

arr.slice(-1).pop()      ------> 36             -----> 924  

arr.slice(-1)[0]         ------> 36             -----> 924  

[...arr].pop()           ------> 120            -----> ~21,000,000 :)

अंतिम तीन विकल्प, ESPECIALLY [...arr].pop(), सरणी के आकार बढ़ने के साथ बहुत खराब हो जाते हैं। मेरी मशीन की मेमोरी सीमाओं के बिना एक मशीन पर, [...arr].pop()संभवतः कुछ ऐसा बनाए रखता है जैसे कि यह 120: 1 अनुपात है। फिर भी, कोई भी संसाधन हॉग पसंद नहीं करता है।

Comments

यदि प्रारंभिक सरणी खाली हो सकती है, तो यह दृष्टिकोण गलत तरीके से परिणाम []देगा और इसे चालू कर दिया जाएगा [undefined]। आपको स्पष्ट undefinedजांच के साथ बैकवर्ड पुश की रक्षा करने की आवश्यकता है , जैसे कुछmyPop !== undefined && arr.push(myPop)

— dhilt

Answer 14

यदि कोई अंतिम तत्व एक बार में प्राप्त करना चाहता है, तो वह उपयोग कर सकता है Array#splice():

lastElement = document.location.href.split('/').splice(-1,1);

यहां, विभाजित तत्वों को किसी सरणी में संग्रहीत करने की आवश्यकता नहीं है, और फिर अंतिम तत्व पर पहुंचें। यदि अंतिम तत्व प्राप्त करना एकमात्र उद्देश्य है, तो इसका उपयोग किया जाना चाहिए।

नोट: यह मूल तत्व को उसके अंतिम तत्व को हटाकर बदल देता है। splice(-1,1)एक pop()फ़ंक्शन के रूप में सोचें जो अंतिम तत्व को पॉप करता है।

Comments

क्या यह अंतिम तत्व के बजाय अंतिम तत्व को सरणी में नहीं लौटाता है?

@tozazaburo एक ही बात नहीं है?

— अराम कोचरन

यह सरणी को संशोधित करता है। आप मूल सरणी को छोड़ने के लिए ब्याह (-1) के बजाय स्लाइस (-1) का उपयोग कर सकते हैं। @AramKocharyan नहीं इसकी तुलना ["hi"]बनाम "hi"।

— कृत्तिकरत्जी

Answer 15

उन लोगों के लिए जो ऐरे प्रोटोटाइप को ओवरलोड करने से नहीं डरते (और एन्यूमरेशन मास्किंग के साथ आपको नहीं होना चाहिए):

Object.defineProperty( Array.prototype, "getLast", {
    enumerable: false,
    configurable: false,
    writable: false,
    value: function() {
        return this[ this.length - 1 ];
    }
} );

Answer 16

jQuery इस बड़े करीने से हल करता है:

> $([1,2,3]).get(-1)
3
> $([]).get(-1)
undefined

Answer 17

मैं आमतौर पर अंडरस्कोर का उपयोग करता हूं , इसके साथ आप बस कर सकते हैं

if (_.last(loc_array) === 'index.html'){
  etc...
}

मेरे लिए वह शब्द अधिक अर्थपूर्ण है loc_array.slice(-1)[0]

Answer 18

यहाँ अधिक जावास्क्रिप्ट कला है यदि आप इसे खोजने के लिए यहां आए हैं

दूसरे उत्तर की भावना में जो इस्तेमाल किया गया था reduceRight(), लेकिन कम:

[3, 2, 1, 5].reduceRight(a => a);

यह इस तथ्य पर निर्भर करता है कि, यदि आप एक प्रारंभिक मूल्य प्रदान नहीं करते हैं, तो बहुत ही अंतिम तत्व को प्रारंभिक एक के रूप में चुना जाता है ( यहां डंप की जांच करें) )। चूंकि कॉलबैक केवल प्रारंभिक मूल्य लौटाता रहता है, अंतिम तत्व वह होगा जिसे अंत में वापस लौटाया जाएगा।

खबरदार कि इसे जावास्क्रिप्ट कला माना जाना चाहिए और यह किसी भी तरह से नहीं है जिस तरह से मैं इसे करने की सलाह दूंगा, ज्यादातर क्योंकि यह ओ (एन) समय में चलता है, लेकिन यह भी क्योंकि यह पठनीयता को नुकसान पहुंचाता है।

और अब गंभीर जवाब के लिए

सबसे अच्छा तरीका जो मैं देख रहा हूं (यह देखते हुए कि आप इसे अधिक संक्षिप्त चाहते हैं array[array.length - 1]) यह है:

const last = a => a[a.length - 1];

तो बस समारोह का उपयोग करें:

last([3, 2, 1, 5])

यह फ़ंक्शन वास्तव में तब उपयोगी होता है जब आप एक अनाम सरणी के साथ काम कर रहे हों [3, 2, 1, 5], जैसा कि ऊपर इस्तेमाल किया गया है, अन्यथा आपको इसे दो बार इंस्टेंट करना होगा, जो अक्षम और बदसूरत होगा:

[3, 2, 1, 5][[3, 2, 1, 5].length - 1]

ओह।

उदाहरण के लिए, यहां एक ऐसी स्थिति है जहां आपके पास एक अनाम सरणी है और आपको एक चर को परिभाषित करना होगा, लेकिन आप last()इसके बजाय उपयोग कर सकते हैं :

last("1.2.3".split("."));

Answer 19

बस एक और विकल्प यहां डाल रहा हूं।

loc_array.splice(-1)[0] === 'index.html'

मुझे उपरोक्त दृष्टिकोण अधिक साफ और छोटा ऑनलाइनर मिला। कृपया, इसे आज़माने के लिए स्वतंत्र महसूस करें।

नोट: यह मूल सरणी को संशोधित करेगा, यदि आप इसे संशोधित नहीं करना चाहते हैं तो आप इसका उपयोग कर सकते हैं slice()

loc_array.slice(-1)[0] === 'index.html'

यह इंगित करने के लिए @VinayPai धन्यवाद ।

Comments

द्वारा टिप्पणी के अनुसार stackoverflow.com/users/510036/qix-monica-was-mistreated इस पोस्ट पर stackoverflow.com/questions/9050345/... पर और परीक्षण jsperf.com/last-array-element2 बेहद धीमी गति से है कि

— सुबाश

Answer 20

जावास्क्रिप्ट में किसी सरणी के अंतिम मान को खोजने के कई तरीके

• मूल सरणी को प्रभावित किए बिना

var arr = [1,2,3,4,5];

console.log(arr.slice(-1)[0])
console.log(arr[arr.length-1])
const [last] = [...arr].reverse();
console.log(last)
console.log(arr.reverse()[0])

• मूल सरणी को संशोधित करता है

var arr = [1,2,3,4,5];

console.log(arr.pop())
arr.push(5)
console.log(...arr.splice(-1));

• स्वयं सहायक विधि बनाकर

let arr = [1, 2, 3, 4, 5];

Object.defineProperty(arr, 'last', 
{ get: function(){
  return this[this.length-1];
 }
})

console.log(arr.last);

Comments

यदि आपका पहला उदाहरण जहां आप "मूल सरणी को प्रभावित किए बिना" बताते हैं और जैसा कि सुझाया गया है: console.log(arr.reverse()[0]) - बधाई हो, तो आपने मूल सरणी को संशोधित किया है।

— रोको सी। बुल्जन

Answer 21

const lastElement = myArray[myArray.length - 1];

प्रदर्शन के दृष्टिकोण से यह सबसे अच्छा विकल्प है (~ arrice .slice (-1) की तुलना में ~ 1000 गुना तेज)।

Answer 22

व्यक्तिगत रूप से मैं kuporific / kritzikratzi द्वारा उत्तर को प्रस्तुत करना होगा। यदि आप नेस्टेड सरणियों के साथ काम कर रहे हैं, तो सरणी [array.length-1] विधि बहुत बदसूरत हो जाती है।

var array = [[1,2,3], [4,5,6], [7,8,9]]
​
array.slice(-1)[0]
​
//instead of 
​
array[array.length-1]
​
//Much easier to read with nested arrays
​
array.slice(-1)[0].slice(-1)[0]
​
//instead of
​
array[array.length-1][array[array.length-1].length-1]

Answer 23

ECMAScript प्रस्ताव चरण 1 में एक सरणी संपत्ति जोड़ने का सुझाव दिया गया है जो अंतिम तत्व लौटाएगा: प्रस्ताव-सरणी-अंतिम ।

वाक्य - विन्यास:

arr.lastItem // get last item
arr.lastItem = 'value' // set last item

arr.lastIndex // get last index

आप पॉलीफिल का उपयोग कर सकते हैं ।

प्रस्ताव लेखक: कीथ सर्केल ( चाय के शौकीन)

Answer 24

मूल आइटम से अंतिम आइटम को हटाने से रोकने के लिए जिसका आप उपयोग कर सकते हैं

Array.from(myArray).pop()

अधिकतर सभी ब्राउज़रों (ES6) का समर्थन

Comments

100.000 तत्वों या अधिक के बड़े सरणियों के साथ शुभकामनाएँ।

— सोल्डप्लाटा साकेतोस

Answer 25

आप एक last()फ़ंक्शन को Arrayप्रोटोटाइप में जोड़ सकते हैं ।

Array.prototype.last = function () {
    return this[this.length - 1];
};

Answer 26

आप जो भी उपयोग नहीं करते हैं reverse()!!!

कुछ उत्तर उल्लेख reverseकरते हैं, लेकिन इस तथ्य का उल्लेख नहीं करते हैं कि reverseमूल सरणी को संशोधित करता है, और (जैसा कि किसी अन्य भाषा या ढांचे में) कॉपी नहीं करता है।

var animals = ['dog', 'cat'];

animals.reverse()[0]
"cat"

animals.reverse()[0]
"dog"

animals.reverse()[1]
"dog"

animals.reverse()[1]
"cat"

यह डिबग करने के लिए सबसे खराब प्रकार का कोड हो सकता है!

Comments

यदि आप अपनी सरणी की उलटी प्रतिलिपि चाहते हैं , तो आप अब प्रसार ऑपरेटर का उपयोग कर सकते हैं। जैसे[...animals].reverse()

— जोश आर

आप केवल रिवर्स[1,3,4,5,"last"].slice().reverse()[0]

— मेडो

Answer 27

ES6 ऑब्जेक्ट विनाशकारी जाने का एक और तरीका है।

const {length, [length-1]: last}=[1,2,3,4,5]
console.log(last)

आप ऑब्जेक्ट विनाशकारी का उपयोग करके ऐरे से लंबाई की संपत्ति निकालते हैं। आप पहले से निकाले गए कुंजी का उपयोग करके एक और गतिशील कुंजी बनाते हैं [लंबाई -1] इसे अंतिम , सभी को एक पंक्ति में असाइन करते हैं ।

Comments

थोड़ा मुश्किल लेकिन चालाक।

— एड्रिन कास्टाग्लिओला

धन्यवाद, क्या आप बता सकते हैं कि यह वास्तव में क्या करता है?

— तरुण नागपाल

Answer 28

आप प्रोटोटाइप के लिए एक नया प्रॉपर्टी गेट्टर जोड़ सकते हैं ताकि यह सभी उदाहरणों के माध्यम से सुलभ होArrayArray ।

गेटर्स आपको किसी फ़ंक्शन के रिटर्न मान को एक्सेस करने की अनुमति देते हैं जैसे कि यह एक संपत्ति का मूल्य था। समारोह के अंतिम मान सरणी का अंतिम मान है (this[this.length - 1] ) ।

अंत में आप इसे एक ऐसी स्थिति में लपेटते हैं, जो यह lastजांचती है कि क्या -प्रॉपर्टी अभी भी है undefined(किसी अन्य स्क्रिप्ट द्वारा परिभाषित नहीं है जो उस पर भरोसा कर सकती है)।

if(typeof Array.prototype.last === 'undefined') {
    Object.defineProperty(Array.prototype, 'last', {
        get : function() {
            return this[this.length - 1];
        }
    });
}

// Now you can access it like
[1, 2, 3].last;            // => 3
// or
var test = [50, 1000];
alert(test.last);          // Says '1000'

IE। 8 में काम नहीं करता है।

Comments

Array.prototype.lastहमेशा होता है undefined? अगर क्रोम 36 के तहत काम नहीं कर रहा

— bryc

Answer 29

संपादित:

हाल ही में मैं एक और समाधान के साथ आया हूं जो मुझे लगता है कि मेरी जरूरतों के लिए सबसे अच्छा है:

function w(anArray) {
  return {
    last() {
      return anArray [anArray.length - 1];
    };
  };
}

प्रभाव में उपरोक्त परिभाषा के साथ अब मैं कह सकता हूं:

let last = w ([1,2,3]).last();
console.log(last) ; // -> 3

"W" नाम रैपर" के लिए है। आप देख सकते हैं कि कैसे आप आसानी से इस आवरण को 'अंतिम ()' के अलावा और अधिक तरीके जोड़ सकते हैं।

मैं कहता हूं "मेरी आवश्यकताओं के लिए सबसे अच्छा", क्योंकि यह मुझे आसानी से किसी भी जावास्क्रिप्ट में निर्मित प्रकार में अन्य "सहायक तरीकों" को जोड़ने की अनुमति देता है। उदाहरण के लिए लिस्प की कार () और cdr () क्या हैं।

Comments

एक आवरण का उपयोग क्यों करें? यदि आपको कोई wफ़ंक्शन कॉल करना है तो फ़ंक्शन को अंतिम आइटम वापस करें।

— फ्रीगेट

w([1,2,3]).lengthअपरिभाषित है। w([1,2,3])[1]अपरिभाषित है। मेरे लिए रैपर की तरह नहीं लगता। और एक सिंटैक्स त्रुटि है। आपके पास एक अतिरिक्त '' है। वर्ग आवरण (SutString वर्ग) लिखने के लिए stackoverflow.com/a/49725374/458321 देखें और उस आवरण को आबाद करने के लिए प्रतिबिंब का उपयोग करें। हालांकि, इम्हो, रैपर ओवरकिल हैं। एनकैप्सुलेशन का उपयोग करने के लिए बेहतर है, जैसे आपके पास लगभग है। return { arr: anArray, last() { return anArray[anArray.length - 1]; } };। इसके अलावा, डब्ल्यू रास्ता भी सामान्य है। कॉल ArrayW या कुछ और है।

— TamusJRoyce

Answer 30

मुझे लगता है कि सबसे आसान और सुपर अक्षम तरीका है:

var array = ['fenerbahce','arsenal','milan'];
var reversed_array = array.reverse(); //inverts array [milan,arsenal,fenerbahce]
console.log(reversed_array[0]) // result is "milan".

Comments

यह समाधान O (n) अधिक मेमोरी लेता है और O (n) समय लेता है। यह वास्तव में आदर्श समाधान नहीं है।

— 18-28 को hlin117