Es6 में एक सरणी के अंतिम तत्व को प्राप्त करने के लिए विनाशकारी

Question

कॉफ़ीस्क्रिप्ट में यह सीधा है:

coffee> a = ['a', 'b', 'program']
[ 'a', 'b', 'program' ]
coffee> [_..., b] = a
[ 'a', 'b', 'program' ]
coffee> b
'program'

क्या es6 कुछ इसी तरह की अनुमति देता है?

> const [, b] = [1, 2, 3]                              
'use strict'                                           
> b  // it got the second element, not the last one!                      
2                                                      
> const [...butLast, last] = [1, 2, 3]          
SyntaxError: repl: Unexpected token (1:17)                                                                                                                                                        
> 1 | const [...butLast, last] = [1, 2, 3]                                                                                                                                                        
    |                  ^                                                                                                                                                                          
    at Parser.pp.raise (C:\Users\user\AppData\Roaming\npm\node_modules\babel\node_modules\babel-core\node_modules\babylon\lib\parser\location.js:24:13)                                           

बेशक मैं इसे es5 तरह से कर सकता हूं -

const a = b[b.length - 1]

लेकिन शायद यह एक त्रुटि से बंद होने का खतरा है। क्या संहार ही विनाश की अंतिम वस्तु हो सकती है?

Comments

क्यों हर कोई सोचता है कि ES6 सब कुछ बदल देता है और xyz करने के लिए कुछ नया वाक्यविन्यास है?

— फेलिक्स क्लिंग

@FelixKling प्रश्न विशेष रूप ...से es6 के व्यवहार के बारे में है , विशेष रूप से यह कि इसे केवल अंतिम चीज के रूप में इस्तेमाल किया जा सकता है जब विनाश या एक पैरामीटर सूची में। यह संभावित रूप से किसी व्यक्ति के लिए कॉफ़ीसेस्क्रिप्ट से es6 में आने वाला है और इस प्रकार यह प्रश्न संभावित रूप से उपयोगी है।

— जॉर्ज सिम्स

इसका मतलब यह है कि [1,2,3].slice(-1)आप के अलावा भी विनाशकारी नहीं कर सकते [1,2,3].slice(0, -1)। ये सामान्य ऑपरेशन हैं। ES6 विनाश किसी तरह एक मजाक है!

— पटकथा

@ कोई भी वैध कारण नहीं है - अनंत पुनरावृत्तियों को संभालने के लिए।

— जॉर्ज सिम्स

पहले पैरामीटर के काम न करने के कारण बहुत बुरा आराम। अच्छा रहा होगा ... यहाँ कुछ जवाबों का उपयोग कर एक jsperf है jsperf.com/destructure-last/1

— Shanimal

Answer 1

ईएस 6/2015 में यह संभव नहीं है। मानक सिर्फ इसके लिए प्रदान नहीं करता है।

जैसा कि आप कल्पना में देख सकते हैं , FormalParameterListया तो हो सकता है:

• ए FunctionRestParameter
• a FormalsList(पैरामीटर्स की एक सूची)
• a FormalsList, उसके बाद aFunctionRestParameter

FunctionRestParameterमापदंडों का पालन करने के बाद प्रदान नहीं किया जाता है।

Answer 2

console.log('last', [1, 3, 4, 5].slice(-1));
console.log('second_to_last', [1, 3, 4, 5].slice(-2));

Comments

अच्छा सरल गैर-उत्परिवर्ती समाधान।

— जैक स्टीम

@ शनीमल निर्भर करता है, मुझे popतेजी से संस्करण मिल रहे हैं (ओएस एक्स, क्रोम 68)।

— डेव न्यूटन

@Dave न्यूटन लेकिन पॉप () उत्परिवर्तन का कारण बनता है

— एंटोनियो पेंटानो

@AntonioPantano हाँ, यह कॉपी को बदल देता है। प्वाइंट था या नहीं यह तेजी से एक दिया नहीं है।

— डेव न्यूटन

Answer 3

मेरा मानना ​​है कि ES6 कम से कम उस के साथ मदद कर सकता है:

[...arr].pop()

यह देखते हुए कि आपकी सरणी (गिरफ्तार) अपरिभाषित नहीं है और एक चलने योग्य तत्व (हाँ, यहां तक ​​कि काम भी !!), इसे अंतिम तत्व को वापस करना चाहिए। खाली सरणी के लिए इसे हटा दें और यह इसे बदल नहीं सकता है। यह एक मध्यवर्ती सरणी बनाता है..लेकिन जिसकी लागत ज्यादा नहीं होनी चाहिए।

आपका उदाहरण तब इस तरह दिखेगा:

  console.log(  [...['a', 'b', 'program']].pop() );

Comments

उह, यह काफी बुरा है, यहां तक .slice(-1)[0]कि थोड़ा कम बुरा है, या var [last]=arr.slice().reverse()एक और बदसूरत है अगर आपको ज़रूरत है

— ca

मुझे लगा कि यह पोस्ट ES6 / ES2015 के बारे में है, नहीं? लेकिन मुझे आपका आखिरी टुकड़ा विशेष रूप से पसंद है। कैसे दो के संयोजन के बारे में var [last] = arr.slice(-1):;)

— जूते का

मेरा पसंदीदा तरीका हैObject.defineProperty(Array.prototype, -1, { get() {return this[this.length - 1] } }); [1,2,3][-1]

— caub

यद्यपि यह काम करता है यह उत्परिवर्ती है और मूल सरणी से आइटम को निकालता है। कई परिदृश्यों में आदर्श नहीं।

— गावकिलब्राइड

@GavKilbride यह नहीं करता है। उदाहरण वही है [].concat(arr).pop();जो म्यूट नहीं करता है arr।

— दान

Answer 4

आप जो चाहते हैं, उसके करीब पहुंचने के लिए आप उल्टे सरणी को नष्ट कर सकते हैं।

const [a, ...rest] = ['a', 'b', 'program'].reverse();
  
document.body.innerHTML = 
    "<pre>"
    + "a: " + JSON.stringify(a) + "\n\n"
    + "rest: " + JSON.stringify(rest.reverse())
    + "</pre>";

Comments

होशियार। से बेहतर है const last = ['bbb', 'uuu', 'iii'].slice(-1);? प्रदर्शन के मामले में?

— वडोरेक्वेस्ट

.slice(-1)तकनीकी रूप से तेजी से होता है, लेकिन यह आप दोनों पिछले आइटम और एक कॉल, जिनमें से एक फायदा है में subarray नहीं देता ...सूचक जब destructuring। दो बार उलटफेर का प्रदर्शन हिट माना जाता है जब लंबे समय तक सरणियों पर उपयोग किया जाता है, लेकिन एक छोटी स्क्रिप्ट के लिए संभवतः सुविधा के लायक है? लेकिन आप आसानी से बस के रूप में let a = array.slice(-1), rest = array.slice(0,array.length-2)अगर आप अभी भी ES5 में oneliner चाहता था, कि ~ 4% तेजी से हो सकता है। jsperf.com/last-array-splat

— मिक्स

Answer 5

एक और तरीका है:

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

Comments

@isakbob yeap, यहाँ आप हैं

— Den Kerny

पढ़ने के लिए मुश्किल है, या शायद यह सिर्फ मेरा मस्तिष्क है

— वेब जूल

यह कई प्रॉप्स का उपयोग करने में मददगार हो सकता है, इसलिए हाँ, इसका सिर्फ आपका, xd xd xd

— डेन कर्नी

Answer 6

जरूरी नहीं कि करने का सबसे अच्छा तरीका हो। लेकिन संदर्भ के आधार पर एक बहुत ही सुंदर तरीका होगा:

const myArray = ['one', 'two', 'three'];
const theOneIWant = [...myArray].pop();

console.log(theOneIWant); // 'three'
console.log(myArray.length); //3

Comments

मैं इस समाधान में किसी भी लालित्य नहीं दिख रहा है, लेकिन वैसे भी पहले से ही @shoesel तैनात यह

— Bergi

Answer 7

const arr = ['a', 'b', 'c']; // => [ 'a', 'b', 'c' ]

const {
  [arr.length - 1]: last
} = arr;

console.log(last); // => 'c'

Comments

हां, मुझे यह उपयोगी लगता है जब पहले से ही अन्य विनाशकारी काम कर रहा हूं। अपने आप से यह क्लासिक समाधान के रूप में पढ़ने के लिए आसान नहीं है।

— andhamm

Answer 8

यह काम करना चाहिए:

const [lastone] = myArray.slice(-1);

Answer 9

आप इस हैक की कोशिश कर सकते हैं:

let a = ['a', 'b', 'program'];
let [last] = a.reverse();
a.reverse();
console.log(last);

Answer 10

निश्चित रूप से, सवाल जावास्क्रिप्ट एरर्स के लिए विनाशकारी होने के बारे में है , और हम जानते हैं कि विनाशकारी असाइनमेंट का उपयोग करके एक सरणी का अंतिम आइटम होना संभव नहीं है, इसे अपरिवर्तनीय करने का एक तरीका है , निम्नलिखित देखें:

const arr = ['a', 'b', 'c', 'last'];

~~~
const arrDepth = arr.length - 1;

const allExceptTheLast = arr.filter( (dep, index) => index !== arrDepth && dep );
const [ theLastItem ] = arr.filter( (dep, index) => index === arrDepth && dep );

हम arrवैरिएबल को म्यूट नहीं करते हैं, लेकिन फिर भी सभी ऐर मेंबर को अंतिम आइटम के अलावा एरे के रूप में रखते हैं और अंतिम आइटम को अलग से रखते हैं।

Answer 11

let a = [1,2,3]
let [b] = [...a].reverse()

Answer 12

विनाशकारी तरीका नहीं है लेकिन मदद कर सकता है। जावास्क्रिप्ट प्रलेखन और रिवर्स विधि के अनुसार यह कोशिश की जा सकती है:

const reversed = array1.reverse();
let last_item = reversed[0]