Restricted JavaScript Array Pop Polyfill not working

Question

I'm creating a few specific functions for a compiler I'm working on, But certain restrictions within the compiler's nature will prevent me from using native JavaScript methods like Array.prototype.pop() to perform array pops...

So I decided to try and write some rudimentary pseudo-code to try and mimic the process, and then base my final function off the pseudo-code... But my tests seem to fail... based on the compiler's current behavior, it will only allow me to use array.length, array element assignments and that's about it... My code is below...

pop2 = function(arr) {
 if(arr.length>0){
 for(var w=undefined,x=[],y=0,z=arr.length;y<=z;y++){
 y+1<z?(x[y]=arr[y]):(w=arr[y],arr=x);
 }
 }
 return w;
}
Arr = [-1,0,1,2];
// Testing...
console.log(pop2(Arr)); // undefined... should be 2
console.log(Arr); // [-1,0,1,2]... should be [-1,0,1]

I'm trying to mimic the nature of the pop function but can't seem to put my finger on what's causing the function to still provide undefined and the original array... undefined should only return if an initial empty array is sent, just like you would expect with a [].pop() call...

Anyone have any clues as to how I can tailor this code to mimic the pop correctly?

And while I have heard that arr.splice(array.length-1,1)[0]; may work... the compiler is currently not capable of determining splice or similar methods... Is it possible to do it using a variation of my code?

Thanks in advance...

Answer 1

You're really over-thinking [].pop(). As defined in the specs, the process for [].pop() is:

1. Get the length of the array
2. If the length is 0
   1. return undefined
3. If length is more than 0
   1. Get the item at length - 1
   2. Reduce array.length by 1
   3. Return item.

(... plus a few things that the JavaScript engine needs to do behind the scenes like call ToObject on the array or ensure the length is an unsigned 32-bit integer.)

This can be done with a function as simple as the one below, there's not even a need for a loop.

function pop(array) {
 var length = array.length,
 item;
 if (length > 0) {
 item = array[length - 1];
 array.length -= 1;
 }
 return item;
}

Edit

I'm assuming that the issue with the compiler is that Array.prototype.pop isn't understood at all. Re-reading your post, it looks like arrays have a pop method, but the compiler can't work out whether the variable is an array or not. In that case, an even simpler version of this function would be this:

function pop(array) {
 return Array.prototype.pop.call(array);
}

Try that first as it'll be slightly faster and more robust, if it works. It's also the pattern for any other array method that you may need to use.

Answer 2

With this modification, it works:

http://jsfiddle.net/vxxfxvpL/1/

pop2 = function(arr) {
 if(arr.length>0){
 for(var w=undefined,x=[],y=0,z=arr.length;y<=z;y++){
 if(y+1<z) {
 (x[y]=arr[y]);
 } else { 
 (w=arr[y],arr=x);
 break;
 }
 }
 }
 return w;
}
Arr = [-1,0,1,2];
// Testing...
console.log(pop2(Arr)); // 2

The problem now is to remove the last element. You should construct the original array again without last element. You will have problems with this because you can't modify the original array. That's why this tasks are maded with prototype (Array.prototype.pop2 maybe can help you)