මෙන්න මේ දක්වා මගේ ජාවාස්ක්‍රිප්ට් කේතය:

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"අතර එසේ නම්, ඒ වෙනුවට තුන්වන සිට අවසාන අයිතමය අල්ලා ගන්න.

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

ඔබේ සේවාදායකය "index.html" සහ "inDEX.htML" සඳහා එකම ගොනුවක් සේවය කරන අවස්ථාවකදී ඔබටද භාවිතා කළ හැකිය : .toLowerCase().

හැකි නම්, ඔබට මෙම සේවාදායකයේ පැත්තක් කිරීම ගැන සලකා බැලීමට අවශ්‍ය විය හැකිය: එය පිරිසිදු වන අතර JS නොමැති පුද්ගලයින් සඳහා වැඩ කරනු ඇත.

අඩුපාඩුවක් තිබේදැයි විශ්වාස නැත, නමුත් මෙය තරමක් සංක්ෂිප්තව පෙනේ:

arr.slice(-1)[0] 

හෝ

arr.slice(-1).pop()

undefinedඅරාව හිස් නම් දෙකම නැවත පැමිණේ .

Array.pop භාවිතා කරන්න :

var lastItem = anArray.pop();

වැදගත් : මෙය අවසාන අංගය නැවත ලබා දෙන අතර එය අරාවෙන් ඉවත් කරයි

@ චයිගුයි විසින් පළ කරන ලද දේවල කෙටි අනුවාදය:

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

-1 දර්ශකය කියවීම undefinedදැනටමත් ලබා දෙයි.

සංස්කරණය කරන්න:

මේ දිනවල මනාපය මොඩියුල භාවිතා කිරීම හා මූලාකෘතිය ස්පර්ශ කිරීමෙන් හෝ ගෝලීය නාම අවකාශයක් භාවිතා කිරීමෙන් වැළකී සිටීමයි.

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

විකල්ප දෙකක් නම්:

var last = arr[arr.length - 1]

හෝ

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

පළමුවැන්න වේගවත් ය, නමුත් දෙවැන්න වඩා හොඳ පෙනුමක්

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

මුල් 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 

"පිරිසිදු" ES6 මාර්ගය (IMO) වනුයේ:

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

මෙම mutating මගහැරෙන fooලෙස, .pop()අපි පැතිරීම ක්රියාකරු භාවිතා නොවේ නම්, හැකිව තිබුණි.
ඒක කිව්වේ, මම කැමතියි foo.slice(-1)[0]විසඳුමට කැමතියි .

මම array.pop()දර්ශක වලට වඩා භාවිතා කිරීමට කැමතියි .

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

මේ ආකාරයට ඔබ සැමවිටම index.html ට පෙර මූලද්‍රව්‍යය ලබා ගනී (ඔබේ අරාව සැපයීමෙන් එක් අයිතමයක් ලෙස index.html හුදකලා වී ඇත). සටහන: අරාවෙහි අවසාන අංග ඔබට අහිමි වනු ඇත.

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

-1 සමඟ ඇති Array.prototype.slice මුල් අරාවේ අවසාන අයිතමය පමණක් අඩංගු නව අරා නිර්මාණය කිරීමට භාවිතා කළ හැකිය, එවිට ඔබට එම නව අරාවේ පළමු අයිතමය භාවිතා කරමින් විචල්‍යයක් නිර්මාණය කිරීම සඳහා විනාශ කිරීමේ පැවරුම භාවිතා කළ හැකිය .

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

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

Negative ණ අගයන් සහිත පෙති ක්‍රමය භාවිතා කිරීමෙන් අරාවෙහි අවසාන අයිතමය ලබා ගත හැකිය .

ඔබ එය ගැන වැඩි විස්තර දැනගන්න මෙතන පතුලේ.

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

පොප් () භාවිතා කිරීමෙන් ඔබගේ අරාව වෙනස් වනු ඇත, එය සැමවිටම හොඳ අදහසක් නොවේ.

ඔබට මෙම රටාව භාවිතා කළ හැකිය ...

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

එය වෙනුවට අවසරයෙන් කියවන අතර, එය වෙනත් විසඳුම් වඩා අඩු කාර්යක්ෂම වේ එසේ නමුත් එය විය පාහේ කවදාවත් මතක තබා එය නව මාලාවක් නිර්මාණය වූ ඔබගේ ඉල්ලුම් කාර්ය සාධන භාධකයක්.

මෙම ප්‍රශ්නය දීර් time කාලයක් තිස්සේ පැවතුනි, එබැවින් කිසිවෙකු පුදුමයට පත්වන්නේ a ට පසු අවසාන අංගය නැවත තැබීම ගැන නොවේ pop().

arr.pop()හරියටම කාර්යක්ෂම arr[arr.length-1]වන අතර දෙකම එකම වේගයකි arr.push().

එමනිසා, ඔබට එයින් ගැලවිය හැකිය:

--- සංස්කරණය කරන ලදි [ තල්ලු කිරීමට පෙර thePopනොවන බව පරීක්ෂා කරන්න undefined] ---

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

--- අවසන් කරන්න ---

මේ දක්වා අඩු කළ හැකි (එකම වේගය [සංස්කරණය කරන්න: නමුත් අනාරක්ෂිතයි!]):

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

මෙය දෙගුණයක් මන්දගාමී වේ arr[arr.length-1], නමුත් ඔබට දර්ශකයක් සමඟ සම්බන්ධ වීමට අවශ්‍ය නැත. එය ඕනෑම දිනයක රත්රන් වටිනවා.

මම උත්සාහ කළ විසඳුම් අතර, සහ ක්‍රියාත්මක කිරීමේ කාල ඒකකයේ (ETU) ගුණකයන්ගෙන් arr[arr.length-1]:

[ක්‍රමය] .............. [ETUs 5 elems] ... [ETU elems මිලියනය]

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 :)

අවසාන විකල්ප තුන, [...arr].pop()අරාවෙහි ප්‍රමාණය වැඩි වන විට, වඩාත් නරක අතට හැරේ. මගේ යන්ත්‍රයේ මතක සීමාවන් නොමැති යන්ත්‍රයක, [...arr].pop()බොහෝ විට එය 120: 1 අනුපාතය වැනි දෙයක් පවත්වා ගනී. එහෙත්, සම්පත් සම්පතකට කිසිවෙකු කැමති නැත.

කෙනෙකුට අවසාන අංගය එකවර ලබා ගැනීමට අවශ්‍ය නම්, ඔහු / ඇය භාවිතා කළ හැකිය Array#splice():

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

මෙන්න, බෙදීම් මූලද්රව්ය අරාව තුළ ගබඩා කිරීම අවශ්ය නොවේ, පසුව අවසාන මූලද්රව්යය වෙත යන්න. අවසාන අංගය ලබා ගැනීම එකම පරමාර්ථය නම්, මෙය භාවිතා කළ යුතුය.

සටහන: මෙය මුල් අරාව එහි අවසාන අංගය ඉවත් කිරීමෙන් වෙනස් කරයි . අන්තිම මූලද්‍රව්‍යය splice(-1,1)මතු වන pop()ශ්‍රිතයක් ලෙස සිතන්න .

කාර්ය සාධනය

අද 2020.05.16 මැක් ඕස් සියෙරා v10.13.6 හි ක්‍රෝම් v81.0, සෆාරි v13.1 සහ ෆයර්ෆොක්ස් v76.0 මත තෝරාගත් විසඳුම් පරීක්ෂා කරමි.

නිගමන

• arr[arr.length-1] ()) වේගවත්ම හරස් බ්‍රව්සර් විසඳුමක් ලෙස නිර්දේශ කෙරේ
• විකෘති ද්‍රාවණය arr.pop()(A) සහ වෙනස් කළ නොහැකි _.last(arr)(L) වේගවත් වේ
• I, J විසඳුම් දිගු නූල් සඳහා මන්දගාමී වේ
• H, K (jQuery) විසඳුම් සියලු බ්‍රව්සර්වල මන්දගාමී වේ

විස්තර

විසඳුම් සඳහා මම අවස්ථා දෙකක් පරීක්ෂා කරමි:

• විකෘති: A , B , C ,

• වෙනස් කළ නොහැකි: ඩී , ඊ , එෆ් , ජී , එච් , අයි , ජේ (මගේ),

• බාහිර පුස්තකාල වලින් වෙනස් කළ නොහැකි: K , L , M ,

අවස්ථා දෙකක් සඳහා

• කෙටි නූල - අක්ෂර 10 - ඔබට පරීක්ෂණය ධාවනය කළ හැකිය මෙතැන
• දිගු නූල් - අක්ෂර 1M - ඔබට පරීක්ෂණය ධාවනය කළ හැකිය මෙතැන

function A(arr) {
  return arr.pop();
}

function B(arr) {  
  return arr.splice(-1,1);
}

function C(arr) {  
  return arr.reverse()[0]
}

function D(arr) {
  return arr[arr.length - 1];
}

function E(arr) {
  return arr.slice(-1)[0] ;
}

function F(arr) {
  let [last] = arr.slice(-1);
  return last;
}

function G(arr) {
  return arr.slice(-1).pop();
}

function H(arr) {
  return [...arr].pop();
}

function I(arr) {  
  return arr.reduceRight(a => a);
}

function J(arr) {  
  return arr.find((e,i,a)=> a.length==i+1);
}

function K(arr) {  
  return $(arr).get(-1);
}

function L(arr) {  
  return _.last(arr);
}

function M(arr) {  
  return _.nth(arr, -1);
}






// ----------
// TEST
// ----------

let loc_array=["domain","a","b","c","d","e","f","g","h","file"];

log = (f)=> console.log(`${f.name}: ${f([...loc_array])}`);

[A,B,C,D,E,F,G,H,I,J,K,L,M].forEach(f=> log(f));

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.min.js" integrity="sha256-VeNaFBVDhoX3H+gJ37DpT/nTuZTdjYro9yBruHjVmoQ=" crossorigin="anonymous"></script>

කෙටි වචන සඳහා Chrome සඳහා උදාහරණ ප්‍රති results ල

අරේ මූලාකෘතිය අධික ලෙස පැටවීමට බිය නොවන අය සඳහා (සහ ගණන් කිරීමේ ආවරණ සහිතව ඔබ එසේ නොවිය යුතුය):

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

මෙන්න ඔබ තව දුරටත් ජාවාස්ක්‍රිප්ට් කලාව සොයමින් පැමිණියේ නම්

භාවිතා කළ තවත් පිළිතුරක ආත්මය තුළ 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("."));

මම සාමාන්‍යයෙන් යටි ඉරි ලකුණු භාවිතා කරමි , එය ඔබට කළ හැකිය

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

මට නම් එය වඩා අර්ථාන්විත ය loc_array.slice(-1)[0]

jQuery මෙය පිළිවෙළකට විසඳයි:

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

තවත් විකල්පයක් මෙහි තැබීම පමණි.

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

ඉහත ප්‍රවේශය වඩාත් පිරිසිදු හා කෙටි ඔන්ලයින් බව මට පෙනී ගියේය. කරුණාකර, මෙය උත්සාහ කිරීමට නිදහස් හැඟීමක්.

සටහන: එය මුල් අරාව වෙනස් කරනු ඇත, ඔබට එය වෙනස් කිරීමට අවශ්‍ය නැතිනම් ඔබට භාවිතා කළ හැකිය slice()

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

මෙය පෙන්වා දීම ගැන in විනයයිපායිට ස්තූතියි .

ES6 වස්තු විනාශ කිරීම තවත් ක්‍රමයක්.

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

වස්තු විනාශ කිරීම භාවිතා කරමින් ඔබ අරේ වෙතින් දිග දේපල උපුටා ගනී. ඔබ විසින් මේ වන විටත් උපුටා ගන්නා යතුරක් භාවිතා තවත් ගතික යතුරක් නිර්මාණය [දිග-1] සහ එය ලබා දිය පසුගිය එකම යමින්,.

ජාවාස්ක්‍රිප්ට් හි අරාවක අවසාන අගය සොයා ගැනීමට විවිධ ක්‍රම

• මුල් අරාවට බලපෑම් නොකර

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);

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

කාර්ය සාධන දෘෂ්ටි කෝණයෙන් හොඳම විකල්පය මෙයයි (arr.slice (-1) ට වඩා times 1000 ගුණයක් වේගවත්).

ECMAScript යෝජනාවේ පළමු අදියරෙහි අරාව දේපලක් එක් කිරීමට යෝජනාවක් ඇත, එය අවසාන අංගය නැවත ලබා දෙනු ඇත: යෝජනාව-අරාව-අන්තිම .

වාක්‍ය ඛණ්ඩය:

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

arr.lastIndex // get last index

ඔබට පොලිෆිල් භාවිතා කළ හැකිය .

යෝජනා කතෘ: කීත් සර්කෙල් ( චයි ඔටෝ)

පුද්ගලිකව මම 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]

ඔබට භාවිතා කළ හැකි ප්‍රභව අරාවෙන් අවසන් අයිතමය ඉවත් කිරීම වැළැක්වීමට

Array.from(myArray).pop()

සියලුම බ්‍රව්සර් (ES6) සඳහා වැඩි වශයෙන් සහය දක්වයි

ඔබට මූලාකෘතියට last()ශ්‍රිතයක් එක් කළ හැකිය Array.

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

ඔබ එසේ කරන ඕනෑම දෙයක් පමණක් භාවිතා reverse()!!!

පිළිතුරු කිහිපයක සඳහන් reverseනමුත් reverseමුල් අරාව වෙනස් කරන කාරණය සඳහන් නොකරන්න (වෙනත් භාෂාවක හෝ රාමු වල මෙන්) පිටපතක් ලබා නොදේ.

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

animals.reverse()[0]
"cat"

animals.reverse()[0]
"dog"

animals.reverse()[1]
"dog"

animals.reverse()[1]
"cat"

නිදොස් කිරීම සඳහා නරකම ආකාරයේ කේතය මෙය විය හැකිය!

ඔබ නව එකතු කළ හැකි ය දේපල තරගයක වෙත වන පරමාදර්ශයක්Array ඒ සියල්ල අවස්ථා හරහා ප්රවේශ විය හැකි නිසා Array.

දේපලක වටිනාකම මෙන් ශ්‍රිතයක ප්‍රතිලාභ වටිනාකමට ප්‍රවේශ වීමට Getters ඔබට ඉඩ දෙයි. පා course මාලාවේ ශ්‍රිතයේ ප්‍රතිලාභ අගය අරාවේ අවසාන අගය වේ (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 හි ක්‍රියා නොකරයි.

සංස්කරණය කරන ලද්දේ:

මෑතකදී මම තවත් එක් විසඳුමක් ඉදිරිපත් කළෙමි, එය දැන් මගේ අවශ්‍යතා සඳහා හොඳම යැයි මම සිතමි:

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

ඉහත අර්ථ දැක්වීම බලපැවැත්වෙන පරිදි මට දැන් පැවසිය හැකිය:

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

"W" යන නම " එතීම" යන්නයි. මෙම එතීමට 'අන්තිම ()' හැර ඔබට තවත් ක්‍රම පහසුවෙන් එකතු කළ හැකි ආකාරය ඔබට දැක ගත හැකිය.

මම "මගේ අවශ්‍යතා සඳහා හොඳම" යැයි කියමි, මන්දයත් ඕනෑම ජාවාස්ක්‍රිප්ට් බිල්ට් වර්ගයකට එවැනි "උපකාරක ක්‍රම" පහසුවෙන් එක් කිරීමට මෙය මට ඉඩ සලසයි. මතකයට එන්නේ ලිස්ප් හි මෝටර් රථය () ​​සහ සීඩීආර් () ය.

මම හිතන්නේ පහසුම හා සුපිරි අකාර්යක්ෂම ක්‍රමය:

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