List data structures in JavaScript

In an exercise in the book Eloquent JavaScript I need to create a list data structure (as below) based on the array [1, 2, 3].

The tutorial JavaScript Data Structures - The Linked List shows how to do this, but I don't really understand the intention to create this.start and this.end variables inside the tutorial.

var list = {
  value: 1,
   rest: {
     value: 2,
      rest: {
        value: 3,
        rest: null
      }
   }
};

I tried to solve this via the code below.

function arrayToList(array){
  var list = { value:null, rest:null};
  for(i=0; i<array.length-1; i++)
     list.value = array[i];
     list.rest = list;
  return list;
}

This code gives me an infinite loop of array[0]. What's wrong with my code?

This tutorial shows how to do this but I don't really understand the intention to create this.start and this.end variables inside the tutorial.

The tutorial uses a List wrapper around that recursive structure with some helper methods. It says: "It is possible to avoid having to record the end of the list by performing a traverse of the entire list each time you need to access the end - but in most cases storing a reference to the end of the list is more economical."

This code gives me an infinite loop of array[0].

Not really, but it creates a circular reference with the line list.rest = list;. Probably the code that is outputting your list chokes on that.

What's wrong is with my code?

You need to create multiple objects, define the object literal inside the loop body instead of assigning to the very same object over and over! Also, you should access array[i] inside the loop instead of array[0] only:

function arrayToList(array){
    var list = null;
    for (var i=array.length-1; i>=0; i--)
        list = {value: array[i], rest:list};
    return list;
}

This particular data structure is more commonly called cons. Recursion is the most natural (not necessarily the most efficient) way to work with conses. First, let's define some helper functions (using LISP notation rather than "value/rest"):

function cons(car, cdr) { return [car, cdr] }
function car(a) { return a[0] }
function cdr(a) { return a[1] }

Now, to build a cons from an array, use the following recursive statement:

cons-from-array = cons [ first element, cons-from-array [ the rest ] ]

In Javascript:

function arrayToList(array) {
    if(!array.length)
        return null;
    return cons(array[0], arrayToList(array.slice(1)));
}

And the reverse function is similarly trivial:

function listToArray(list) {
    if(!list)
        return [];
    return [car(list)].concat(listToArray(cdr(list)));
}

function arrayToList (arr) {
    var list = null;
    for (var i = arr.length - 1; i >= 0; i--) {
        list = {
            value: arr[i],
            rest: list
        };
    }
    return list;
}

function prepend (elem, list) {
    return {
        value: elem,
        rest: list
    };
}

function listToArray (list) {
    var arr = [];
    for (var node = list; node; node = node.rest) {
        arr.push(node.value);
    }
    return arr;
}

function nth(list, num) {
  if (!list) {
    return undefined;
    } else if (num === 0) {
        return list.value;
    } else {
        return nth(list.rest, num - 1);
    }
}