Sort list of array linked objects by keys and values





.everyoneloves__top-leaderboard:empty,.everyoneloves__mid-leaderboard:empty,.everyoneloves__bot-mid-leaderboard:empty{ margin-bottom:0;
}







3












$begingroup$


I have this sample data:



let trips = [
{
from: "DEN",
to: "JFK"
},
{
from: "SEA",
to: "DEN"
},
{
from: 'JFK',
to: 'SEA'
},
];


and my origin is 'JFK', I want to sort the list by how I have traveled. So for instance, this should be the end result:



let trips = [
{
from: 'JFK',
to: 'SEA'
},
{
from: "SEA",
to: "DEN"
},
{
from: "DEN",
to: "JFK"
},
];


My solution works but it's not very well written, but I tried!



function sortByLinked(trips, origin = 'JFK') {
let sortedArray = ;

let first = trips.filter(trip => trip.from === origin)[0];
sortedArray.push(first);

for(var i = 0; i < trips.length; i++) {
if(sortedArray[0].to === trips[i].from) {
sortedArray.push(trips[i]);
}
}

for(var i = 0; i < trips.length; i++) {
if(sortedArray[1].to === trips[i].from) {
sortedArray.push(trips[i]);
}
}

return sortedArray;
}

sortByLinked(trips)









share|improve this question











$endgroup$



migrated from stackoverflow.com 4 hours ago


This question came from our site for professional and enthusiast programmers.


















  • $begingroup$
    is it like the origin and final destination always the same? and how many intermediate trips are going to be present?
    $endgroup$
    – karthick
    5 hours ago










  • $begingroup$
    Is from unique for all elements?
    $endgroup$
    – Taplar
    5 hours ago










  • $begingroup$
    @karthick yes the origin and final should be the same.
    $endgroup$
    – Shivam Bhalla
    4 hours ago










  • $begingroup$
    @Taplar yes from is unique
    $endgroup$
    – Shivam Bhalla
    4 hours ago










  • $begingroup$
    The task you want to perform is a simple kind of topological sorting.
    $endgroup$
    – 200_success
    3 hours ago


















3












$begingroup$


I have this sample data:



let trips = [
{
from: "DEN",
to: "JFK"
},
{
from: "SEA",
to: "DEN"
},
{
from: 'JFK',
to: 'SEA'
},
];


and my origin is 'JFK', I want to sort the list by how I have traveled. So for instance, this should be the end result:



let trips = [
{
from: 'JFK',
to: 'SEA'
},
{
from: "SEA",
to: "DEN"
},
{
from: "DEN",
to: "JFK"
},
];


My solution works but it's not very well written, but I tried!



function sortByLinked(trips, origin = 'JFK') {
let sortedArray = ;

let first = trips.filter(trip => trip.from === origin)[0];
sortedArray.push(first);

for(var i = 0; i < trips.length; i++) {
if(sortedArray[0].to === trips[i].from) {
sortedArray.push(trips[i]);
}
}

for(var i = 0; i < trips.length; i++) {
if(sortedArray[1].to === trips[i].from) {
sortedArray.push(trips[i]);
}
}

return sortedArray;
}

sortByLinked(trips)









share|improve this question











$endgroup$



migrated from stackoverflow.com 4 hours ago


This question came from our site for professional and enthusiast programmers.


















  • $begingroup$
    is it like the origin and final destination always the same? and how many intermediate trips are going to be present?
    $endgroup$
    – karthick
    5 hours ago










  • $begingroup$
    Is from unique for all elements?
    $endgroup$
    – Taplar
    5 hours ago










  • $begingroup$
    @karthick yes the origin and final should be the same.
    $endgroup$
    – Shivam Bhalla
    4 hours ago










  • $begingroup$
    @Taplar yes from is unique
    $endgroup$
    – Shivam Bhalla
    4 hours ago










  • $begingroup$
    The task you want to perform is a simple kind of topological sorting.
    $endgroup$
    – 200_success
    3 hours ago














3












3








3





$begingroup$


I have this sample data:



let trips = [
{
from: "DEN",
to: "JFK"
},
{
from: "SEA",
to: "DEN"
},
{
from: 'JFK',
to: 'SEA'
},
];


and my origin is 'JFK', I want to sort the list by how I have traveled. So for instance, this should be the end result:



let trips = [
{
from: 'JFK',
to: 'SEA'
},
{
from: "SEA",
to: "DEN"
},
{
from: "DEN",
to: "JFK"
},
];


My solution works but it's not very well written, but I tried!



function sortByLinked(trips, origin = 'JFK') {
let sortedArray = ;

let first = trips.filter(trip => trip.from === origin)[0];
sortedArray.push(first);

for(var i = 0; i < trips.length; i++) {
if(sortedArray[0].to === trips[i].from) {
sortedArray.push(trips[i]);
}
}

for(var i = 0; i < trips.length; i++) {
if(sortedArray[1].to === trips[i].from) {
sortedArray.push(trips[i]);
}
}

return sortedArray;
}

sortByLinked(trips)









share|improve this question











$endgroup$




I have this sample data:



let trips = [
{
from: "DEN",
to: "JFK"
},
{
from: "SEA",
to: "DEN"
},
{
from: 'JFK',
to: 'SEA'
},
];


and my origin is 'JFK', I want to sort the list by how I have traveled. So for instance, this should be the end result:



let trips = [
{
from: 'JFK',
to: 'SEA'
},
{
from: "SEA",
to: "DEN"
},
{
from: "DEN",
to: "JFK"
},
];


My solution works but it's not very well written, but I tried!



function sortByLinked(trips, origin = 'JFK') {
let sortedArray = ;

let first = trips.filter(trip => trip.from === origin)[0];
sortedArray.push(first);

for(var i = 0; i < trips.length; i++) {
if(sortedArray[0].to === trips[i].from) {
sortedArray.push(trips[i]);
}
}

for(var i = 0; i < trips.length; i++) {
if(sortedArray[1].to === trips[i].from) {
sortedArray.push(trips[i]);
}
}

return sortedArray;
}

sortByLinked(trips)






javascript algorithm sorting graph






share|improve this question















share|improve this question













share|improve this question




share|improve this question








edited 3 hours ago









200_success

131k17157422




131k17157422










asked 5 hours ago









Shivam BhallaShivam Bhalla

1875




1875




migrated from stackoverflow.com 4 hours ago


This question came from our site for professional and enthusiast programmers.









migrated from stackoverflow.com 4 hours ago


This question came from our site for professional and enthusiast programmers.














  • $begingroup$
    is it like the origin and final destination always the same? and how many intermediate trips are going to be present?
    $endgroup$
    – karthick
    5 hours ago










  • $begingroup$
    Is from unique for all elements?
    $endgroup$
    – Taplar
    5 hours ago










  • $begingroup$
    @karthick yes the origin and final should be the same.
    $endgroup$
    – Shivam Bhalla
    4 hours ago










  • $begingroup$
    @Taplar yes from is unique
    $endgroup$
    – Shivam Bhalla
    4 hours ago










  • $begingroup$
    The task you want to perform is a simple kind of topological sorting.
    $endgroup$
    – 200_success
    3 hours ago


















  • $begingroup$
    is it like the origin and final destination always the same? and how many intermediate trips are going to be present?
    $endgroup$
    – karthick
    5 hours ago










  • $begingroup$
    Is from unique for all elements?
    $endgroup$
    – Taplar
    5 hours ago










  • $begingroup$
    @karthick yes the origin and final should be the same.
    $endgroup$
    – Shivam Bhalla
    4 hours ago










  • $begingroup$
    @Taplar yes from is unique
    $endgroup$
    – Shivam Bhalla
    4 hours ago










  • $begingroup$
    The task you want to perform is a simple kind of topological sorting.
    $endgroup$
    – 200_success
    3 hours ago
















$begingroup$
is it like the origin and final destination always the same? and how many intermediate trips are going to be present?
$endgroup$
– karthick
5 hours ago




$begingroup$
is it like the origin and final destination always the same? and how many intermediate trips are going to be present?
$endgroup$
– karthick
5 hours ago












$begingroup$
Is from unique for all elements?
$endgroup$
– Taplar
5 hours ago




$begingroup$
Is from unique for all elements?
$endgroup$
– Taplar
5 hours ago












$begingroup$
@karthick yes the origin and final should be the same.
$endgroup$
– Shivam Bhalla
4 hours ago




$begingroup$
@karthick yes the origin and final should be the same.
$endgroup$
– Shivam Bhalla
4 hours ago












$begingroup$
@Taplar yes from is unique
$endgroup$
– Shivam Bhalla
4 hours ago




$begingroup$
@Taplar yes from is unique
$endgroup$
– Shivam Bhalla
4 hours ago












$begingroup$
The task you want to perform is a simple kind of topological sorting.
$endgroup$
– 200_success
3 hours ago




$begingroup$
The task you want to perform is a simple kind of topological sorting.
$endgroup$
– 200_success
3 hours ago










3 Answers
3






active

oldest

votes


















3












$begingroup$

Your solution only works if there's exactly 3 trips. After you find the first trip, put it at the front of the array and then find each subsequent one but instead of using a for loop like you're doing there are other ways to find the next trip like using Array.map() or Array.filter().



Here's one way to sort it in place and can handle any number of trips greater than 1.






function sortByLinked(trips, origin = 'JFK') {

// this will be useful
function swap(array, index1, index2){
let temp = array[index1];
array[index1] = array[index2];
array[index2] = temp;
}

// find first one
let first = trips.filter(trip => trip.from === origin)[0];

// put him in the front of the list
swap(trips, trips.map(trip => trip.from).indexOf(first.from), 0);

// sort it in place
for(let i=1; i<trips.length; i++){
swap(trips, i, trips.map(trip => trip.from).indexOf(trips[i-1].to));
}
}








share|improve this answer










New contributor




matthewlam.js is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.






$endgroup$













  • $begingroup$
    Because ecmascript-6 is used here: "Two variables values can be swapped in one destructuring expression."
    $endgroup$
    – Sᴀᴍ Onᴇᴌᴀ
    4 hours ago





















2












$begingroup$

It would be good if your function could work for more than 3 trips.



And for larger chains of trips it becomes important to make it efficient. It is not efficient to search for the next trip by scanning the whole array. This will make the solution have O(n²) time complexity. So I would suggest creating a Map first, so that you can access a trip by its from property in constant time:






function sortByLinked(trips, origin = "JFK") {
const map = new Map(trips.map(trip => [trip.from, trip]));
const result = ;
for (let trip; trip = map.get(origin); origin = trip.to) {
result.push(trip);
map.delete(origin);
}
return result;
}

const trips = [{from: "DEN",to: "JFK"},{from: "SEA",to: "DEN"},{from: 'JFK', to: 'SEA'}];
const sorted = sortByLinked(trips, "JFK");
console.log(sorted);








share|improve this answer









$endgroup$





















    1












    $begingroup$

    Code style




    • Use constants for variables that do not change. Eg const sortedArray = ;


    • Don't include the type in the name, Eg const sortedArray = ; can be Eg const sorted = ;



    • The default parameter in this case seams inappropriate as it is likely that "JFK" is not an origin in all calls to this function. If no origin is given one could assume that the first item in trips contains the origin. function sortByLinked(trips, origin = trips[0].from) { which will throw an error if trips is empty so the function should not be called with an empty trips array if you don't pass the from parameter.



      However in this example best to leave the default as undefined if not passed as that will return an empty array which is more fitting the input parameters.



    • The name sort is inappropriate as in JS it implies that the array be sorted in place, that all items be sorted (may not be possible).


    • You have declared i two times. As a var you should put the declaration at the top of the function and not in the for loop.


    • Rather than use Array.filter you can use Array.find. It will find the first instance.


    • Using for...of rather than for(;;) reduces the code complexity.


    • No point continuing the search inside the for loops when you have found a match. Use the break token to stop a loop early


    • Put a space between if and (


    • Don't forget to add the ; where appropriate. It is missing from the call sortByLinked(trips)


    • You call the origin origin and from this can get confusing. Keep the naming unambiguous. As the trip items use from then that would be the better name for the second input argument.



    Using the above points to modify your code we get



    function tripFrom(trips, from) {
    const sorted = ;
    const first = trips.find(trip => trip.from === from);
    sorted.push(first);

    for (const trip of trips) {
    if (first.to === trip.from) {
    sorted.push(trip);
    break;
    }
    }
    for (const trip of trips) {
    if (sorted[sorted.length - 1].to === trip.from) {
    sorted.push(trips);
    break;
    }
    }
    return sorted;
    }

    sortByLinked(trips, "JFK");


    This is still not a good solution. Its not at all DRY (don't repeat yourself) and is hard coded to a single use case.



    Improving the function.



    It can all be done within a single loop and work for any length array.



    To create the function we must add some constraints on the array trips and what to do when we encounter any problems.




    1. That the array trips contains objects that each have the property from and to that are correctly formatted static strings. The resulting array is erroneous or indeterminate if not so.

    2. That the array does not contain circular trips shorter than the array length.

    3. That a complete trip length is no longer than the array, or when a matching trip.to can not be found. The returned array can be 0 to trips.length in size.

    4. Locations are case sensitive.

    5. If there is more than one matching trip.from it is assumed that the first match in trips is the correct one. (It would be interesting to extract the longest possible trip from? or the shortest trip that returns to the origin?)


    Example



    function tripFrom(trips, from) {
    const result = ;
    while (result.length < trips.length) {
    const trip = trips.find(trip => trip.from === from);
    if (!trip) { break }
    from = trip.to;
    result.push(trip);
    }
    return result;
    }
    tripFrom(trips, "JFK");


    Or if it is known that the trip is the same length as the input array.



    function tripFrom(trips, from) {
    const res = ;
    while (res.length < trips.length) {
    from = (res[res.length] = trips.find(trip => trip.from === from)).to;
    }
    return res;
    }
    tripFrom(trips, "JFK");


    It is unclear if you want the array sorted in place. If that is a requirement then the above version can be modified to do that by simply copying the results array res to the trips array. You can empty an array by setting its length to zero. The spread ... operator in this case spreads the array items over the functions arguments trips.push(...res) thus pushing all the items to the array.



    function tripFrom(trips, from) {
    const res = ;
    while (res.length < trips.length) {
    from = (res[res.length] = trips.find(trip => trip.from === from)).to;
    }
    trips.length = 0;
    trips.push(...res);
    return trips;
    }
    tripFrom(trips, "JFK");





    share|improve this answer









    $endgroup$














      Your Answer






      StackExchange.ifUsing("editor", function () {
      StackExchange.using("externalEditor", function () {
      StackExchange.using("snippets", function () {
      StackExchange.snippets.init();
      });
      });
      }, "code-snippets");

      StackExchange.ready(function() {
      var channelOptions = {
      tags: "".split(" "),
      id: "196"
      };
      initTagRenderer("".split(" "), "".split(" "), channelOptions);

      StackExchange.using("externalEditor", function() {
      // Have to fire editor after snippets, if snippets enabled
      if (StackExchange.settings.snippets.snippetsEnabled) {
      StackExchange.using("snippets", function() {
      createEditor();
      });
      }
      else {
      createEditor();
      }
      });

      function createEditor() {
      StackExchange.prepareEditor({
      heartbeatType: 'answer',
      autoActivateHeartbeat: false,
      convertImagesToLinks: false,
      noModals: true,
      showLowRepImageUploadWarning: true,
      reputationToPostImages: null,
      bindNavPrevention: true,
      postfix: "",
      imageUploader: {
      brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
      contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
      allowUrls: true
      },
      onDemand: true,
      discardSelector: ".discard-answer"
      ,immediatelyShowMarkdownHelp:true
      });


      }
      });














      draft saved

      draft discarded


















      StackExchange.ready(
      function () {
      StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodereview.stackexchange.com%2fquestions%2f217351%2fsort-list-of-array-linked-objects-by-keys-and-values%23new-answer', 'question_page');
      }
      );

      Post as a guest















      Required, but never shown

























      3 Answers
      3






      active

      oldest

      votes








      3 Answers
      3






      active

      oldest

      votes









      active

      oldest

      votes






      active

      oldest

      votes









      3












      $begingroup$

      Your solution only works if there's exactly 3 trips. After you find the first trip, put it at the front of the array and then find each subsequent one but instead of using a for loop like you're doing there are other ways to find the next trip like using Array.map() or Array.filter().



      Here's one way to sort it in place and can handle any number of trips greater than 1.






      function sortByLinked(trips, origin = 'JFK') {

      // this will be useful
      function swap(array, index1, index2){
      let temp = array[index1];
      array[index1] = array[index2];
      array[index2] = temp;
      }

      // find first one
      let first = trips.filter(trip => trip.from === origin)[0];

      // put him in the front of the list
      swap(trips, trips.map(trip => trip.from).indexOf(first.from), 0);

      // sort it in place
      for(let i=1; i<trips.length; i++){
      swap(trips, i, trips.map(trip => trip.from).indexOf(trips[i-1].to));
      }
      }








      share|improve this answer










      New contributor




      matthewlam.js is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.






      $endgroup$













      • $begingroup$
        Because ecmascript-6 is used here: "Two variables values can be swapped in one destructuring expression."
        $endgroup$
        – Sᴀᴍ Onᴇᴌᴀ
        4 hours ago


















      3












      $begingroup$

      Your solution only works if there's exactly 3 trips. After you find the first trip, put it at the front of the array and then find each subsequent one but instead of using a for loop like you're doing there are other ways to find the next trip like using Array.map() or Array.filter().



      Here's one way to sort it in place and can handle any number of trips greater than 1.






      function sortByLinked(trips, origin = 'JFK') {

      // this will be useful
      function swap(array, index1, index2){
      let temp = array[index1];
      array[index1] = array[index2];
      array[index2] = temp;
      }

      // find first one
      let first = trips.filter(trip => trip.from === origin)[0];

      // put him in the front of the list
      swap(trips, trips.map(trip => trip.from).indexOf(first.from), 0);

      // sort it in place
      for(let i=1; i<trips.length; i++){
      swap(trips, i, trips.map(trip => trip.from).indexOf(trips[i-1].to));
      }
      }








      share|improve this answer










      New contributor




      matthewlam.js is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.






      $endgroup$













      • $begingroup$
        Because ecmascript-6 is used here: "Two variables values can be swapped in one destructuring expression."
        $endgroup$
        – Sᴀᴍ Onᴇᴌᴀ
        4 hours ago
















      3












      3








      3





      $begingroup$

      Your solution only works if there's exactly 3 trips. After you find the first trip, put it at the front of the array and then find each subsequent one but instead of using a for loop like you're doing there are other ways to find the next trip like using Array.map() or Array.filter().



      Here's one way to sort it in place and can handle any number of trips greater than 1.






      function sortByLinked(trips, origin = 'JFK') {

      // this will be useful
      function swap(array, index1, index2){
      let temp = array[index1];
      array[index1] = array[index2];
      array[index2] = temp;
      }

      // find first one
      let first = trips.filter(trip => trip.from === origin)[0];

      // put him in the front of the list
      swap(trips, trips.map(trip => trip.from).indexOf(first.from), 0);

      // sort it in place
      for(let i=1; i<trips.length; i++){
      swap(trips, i, trips.map(trip => trip.from).indexOf(trips[i-1].to));
      }
      }








      share|improve this answer










      New contributor




      matthewlam.js is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.






      $endgroup$



      Your solution only works if there's exactly 3 trips. After you find the first trip, put it at the front of the array and then find each subsequent one but instead of using a for loop like you're doing there are other ways to find the next trip like using Array.map() or Array.filter().



      Here's one way to sort it in place and can handle any number of trips greater than 1.






      function sortByLinked(trips, origin = 'JFK') {

      // this will be useful
      function swap(array, index1, index2){
      let temp = array[index1];
      array[index1] = array[index2];
      array[index2] = temp;
      }

      // find first one
      let first = trips.filter(trip => trip.from === origin)[0];

      // put him in the front of the list
      swap(trips, trips.map(trip => trip.from).indexOf(first.from), 0);

      // sort it in place
      for(let i=1; i<trips.length; i++){
      swap(trips, i, trips.map(trip => trip.from).indexOf(trips[i-1].to));
      }
      }








      function sortByLinked(trips, origin = 'JFK') {

      // this will be useful
      function swap(array, index1, index2){
      let temp = array[index1];
      array[index1] = array[index2];
      array[index2] = temp;
      }

      // find first one
      let first = trips.filter(trip => trip.from === origin)[0];

      // put him in the front of the list
      swap(trips, trips.map(trip => trip.from).indexOf(first.from), 0);

      // sort it in place
      for(let i=1; i<trips.length; i++){
      swap(trips, i, trips.map(trip => trip.from).indexOf(trips[i-1].to));
      }
      }





      function sortByLinked(trips, origin = 'JFK') {

      // this will be useful
      function swap(array, index1, index2){
      let temp = array[index1];
      array[index1] = array[index2];
      array[index2] = temp;
      }

      // find first one
      let first = trips.filter(trip => trip.from === origin)[0];

      // put him in the front of the list
      swap(trips, trips.map(trip => trip.from).indexOf(first.from), 0);

      // sort it in place
      for(let i=1; i<trips.length; i++){
      swap(trips, i, trips.map(trip => trip.from).indexOf(trips[i-1].to));
      }
      }






      share|improve this answer










      New contributor




      matthewlam.js is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.









      share|improve this answer



      share|improve this answer








      edited 4 hours ago









      Sᴀᴍ Onᴇᴌᴀ

      10.3k62168




      10.3k62168






      New contributor




      matthewlam.js is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.









      answered 4 hours ago









      matthewlam.jsmatthewlam.js

      311




      311




      New contributor




      matthewlam.js is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.





      New contributor





      matthewlam.js is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.






      matthewlam.js is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
      Check out our Code of Conduct.












      • $begingroup$
        Because ecmascript-6 is used here: "Two variables values can be swapped in one destructuring expression."
        $endgroup$
        – Sᴀᴍ Onᴇᴌᴀ
        4 hours ago




















      • $begingroup$
        Because ecmascript-6 is used here: "Two variables values can be swapped in one destructuring expression."
        $endgroup$
        – Sᴀᴍ Onᴇᴌᴀ
        4 hours ago


















      $begingroup$
      Because ecmascript-6 is used here: "Two variables values can be swapped in one destructuring expression."
      $endgroup$
      – Sᴀᴍ Onᴇᴌᴀ
      4 hours ago






      $begingroup$
      Because ecmascript-6 is used here: "Two variables values can be swapped in one destructuring expression."
      $endgroup$
      – Sᴀᴍ Onᴇᴌᴀ
      4 hours ago















      2












      $begingroup$

      It would be good if your function could work for more than 3 trips.



      And for larger chains of trips it becomes important to make it efficient. It is not efficient to search for the next trip by scanning the whole array. This will make the solution have O(n²) time complexity. So I would suggest creating a Map first, so that you can access a trip by its from property in constant time:






      function sortByLinked(trips, origin = "JFK") {
      const map = new Map(trips.map(trip => [trip.from, trip]));
      const result = ;
      for (let trip; trip = map.get(origin); origin = trip.to) {
      result.push(trip);
      map.delete(origin);
      }
      return result;
      }

      const trips = [{from: "DEN",to: "JFK"},{from: "SEA",to: "DEN"},{from: 'JFK', to: 'SEA'}];
      const sorted = sortByLinked(trips, "JFK");
      console.log(sorted);








      share|improve this answer









      $endgroup$


















        2












        $begingroup$

        It would be good if your function could work for more than 3 trips.



        And for larger chains of trips it becomes important to make it efficient. It is not efficient to search for the next trip by scanning the whole array. This will make the solution have O(n²) time complexity. So I would suggest creating a Map first, so that you can access a trip by its from property in constant time:






        function sortByLinked(trips, origin = "JFK") {
        const map = new Map(trips.map(trip => [trip.from, trip]));
        const result = ;
        for (let trip; trip = map.get(origin); origin = trip.to) {
        result.push(trip);
        map.delete(origin);
        }
        return result;
        }

        const trips = [{from: "DEN",to: "JFK"},{from: "SEA",to: "DEN"},{from: 'JFK', to: 'SEA'}];
        const sorted = sortByLinked(trips, "JFK");
        console.log(sorted);








        share|improve this answer









        $endgroup$
















          2












          2








          2





          $begingroup$

          It would be good if your function could work for more than 3 trips.



          And for larger chains of trips it becomes important to make it efficient. It is not efficient to search for the next trip by scanning the whole array. This will make the solution have O(n²) time complexity. So I would suggest creating a Map first, so that you can access a trip by its from property in constant time:






          function sortByLinked(trips, origin = "JFK") {
          const map = new Map(trips.map(trip => [trip.from, trip]));
          const result = ;
          for (let trip; trip = map.get(origin); origin = trip.to) {
          result.push(trip);
          map.delete(origin);
          }
          return result;
          }

          const trips = [{from: "DEN",to: "JFK"},{from: "SEA",to: "DEN"},{from: 'JFK', to: 'SEA'}];
          const sorted = sortByLinked(trips, "JFK");
          console.log(sorted);








          share|improve this answer









          $endgroup$



          It would be good if your function could work for more than 3 trips.



          And for larger chains of trips it becomes important to make it efficient. It is not efficient to search for the next trip by scanning the whole array. This will make the solution have O(n²) time complexity. So I would suggest creating a Map first, so that you can access a trip by its from property in constant time:






          function sortByLinked(trips, origin = "JFK") {
          const map = new Map(trips.map(trip => [trip.from, trip]));
          const result = ;
          for (let trip; trip = map.get(origin); origin = trip.to) {
          result.push(trip);
          map.delete(origin);
          }
          return result;
          }

          const trips = [{from: "DEN",to: "JFK"},{from: "SEA",to: "DEN"},{from: 'JFK', to: 'SEA'}];
          const sorted = sortByLinked(trips, "JFK");
          console.log(sorted);








          function sortByLinked(trips, origin = "JFK") {
          const map = new Map(trips.map(trip => [trip.from, trip]));
          const result = ;
          for (let trip; trip = map.get(origin); origin = trip.to) {
          result.push(trip);
          map.delete(origin);
          }
          return result;
          }

          const trips = [{from: "DEN",to: "JFK"},{from: "SEA",to: "DEN"},{from: 'JFK', to: 'SEA'}];
          const sorted = sortByLinked(trips, "JFK");
          console.log(sorted);





          function sortByLinked(trips, origin = "JFK") {
          const map = new Map(trips.map(trip => [trip.from, trip]));
          const result = ;
          for (let trip; trip = map.get(origin); origin = trip.to) {
          result.push(trip);
          map.delete(origin);
          }
          return result;
          }

          const trips = [{from: "DEN",to: "JFK"},{from: "SEA",to: "DEN"},{from: 'JFK', to: 'SEA'}];
          const sorted = sortByLinked(trips, "JFK");
          console.log(sorted);






          share|improve this answer












          share|improve this answer



          share|improve this answer










          answered 4 hours ago









          trincottrincot

          44937




          44937























              1












              $begingroup$

              Code style




              • Use constants for variables that do not change. Eg const sortedArray = ;


              • Don't include the type in the name, Eg const sortedArray = ; can be Eg const sorted = ;



              • The default parameter in this case seams inappropriate as it is likely that "JFK" is not an origin in all calls to this function. If no origin is given one could assume that the first item in trips contains the origin. function sortByLinked(trips, origin = trips[0].from) { which will throw an error if trips is empty so the function should not be called with an empty trips array if you don't pass the from parameter.



                However in this example best to leave the default as undefined if not passed as that will return an empty array which is more fitting the input parameters.



              • The name sort is inappropriate as in JS it implies that the array be sorted in place, that all items be sorted (may not be possible).


              • You have declared i two times. As a var you should put the declaration at the top of the function and not in the for loop.


              • Rather than use Array.filter you can use Array.find. It will find the first instance.


              • Using for...of rather than for(;;) reduces the code complexity.


              • No point continuing the search inside the for loops when you have found a match. Use the break token to stop a loop early


              • Put a space between if and (


              • Don't forget to add the ; where appropriate. It is missing from the call sortByLinked(trips)


              • You call the origin origin and from this can get confusing. Keep the naming unambiguous. As the trip items use from then that would be the better name for the second input argument.



              Using the above points to modify your code we get



              function tripFrom(trips, from) {
              const sorted = ;
              const first = trips.find(trip => trip.from === from);
              sorted.push(first);

              for (const trip of trips) {
              if (first.to === trip.from) {
              sorted.push(trip);
              break;
              }
              }
              for (const trip of trips) {
              if (sorted[sorted.length - 1].to === trip.from) {
              sorted.push(trips);
              break;
              }
              }
              return sorted;
              }

              sortByLinked(trips, "JFK");


              This is still not a good solution. Its not at all DRY (don't repeat yourself) and is hard coded to a single use case.



              Improving the function.



              It can all be done within a single loop and work for any length array.



              To create the function we must add some constraints on the array trips and what to do when we encounter any problems.




              1. That the array trips contains objects that each have the property from and to that are correctly formatted static strings. The resulting array is erroneous or indeterminate if not so.

              2. That the array does not contain circular trips shorter than the array length.

              3. That a complete trip length is no longer than the array, or when a matching trip.to can not be found. The returned array can be 0 to trips.length in size.

              4. Locations are case sensitive.

              5. If there is more than one matching trip.from it is assumed that the first match in trips is the correct one. (It would be interesting to extract the longest possible trip from? or the shortest trip that returns to the origin?)


              Example



              function tripFrom(trips, from) {
              const result = ;
              while (result.length < trips.length) {
              const trip = trips.find(trip => trip.from === from);
              if (!trip) { break }
              from = trip.to;
              result.push(trip);
              }
              return result;
              }
              tripFrom(trips, "JFK");


              Or if it is known that the trip is the same length as the input array.



              function tripFrom(trips, from) {
              const res = ;
              while (res.length < trips.length) {
              from = (res[res.length] = trips.find(trip => trip.from === from)).to;
              }
              return res;
              }
              tripFrom(trips, "JFK");


              It is unclear if you want the array sorted in place. If that is a requirement then the above version can be modified to do that by simply copying the results array res to the trips array. You can empty an array by setting its length to zero. The spread ... operator in this case spreads the array items over the functions arguments trips.push(...res) thus pushing all the items to the array.



              function tripFrom(trips, from) {
              const res = ;
              while (res.length < trips.length) {
              from = (res[res.length] = trips.find(trip => trip.from === from)).to;
              }
              trips.length = 0;
              trips.push(...res);
              return trips;
              }
              tripFrom(trips, "JFK");





              share|improve this answer









              $endgroup$


















                1












                $begingroup$

                Code style




                • Use constants for variables that do not change. Eg const sortedArray = ;


                • Don't include the type in the name, Eg const sortedArray = ; can be Eg const sorted = ;



                • The default parameter in this case seams inappropriate as it is likely that "JFK" is not an origin in all calls to this function. If no origin is given one could assume that the first item in trips contains the origin. function sortByLinked(trips, origin = trips[0].from) { which will throw an error if trips is empty so the function should not be called with an empty trips array if you don't pass the from parameter.



                  However in this example best to leave the default as undefined if not passed as that will return an empty array which is more fitting the input parameters.



                • The name sort is inappropriate as in JS it implies that the array be sorted in place, that all items be sorted (may not be possible).


                • You have declared i two times. As a var you should put the declaration at the top of the function and not in the for loop.


                • Rather than use Array.filter you can use Array.find. It will find the first instance.


                • Using for...of rather than for(;;) reduces the code complexity.


                • No point continuing the search inside the for loops when you have found a match. Use the break token to stop a loop early


                • Put a space between if and (


                • Don't forget to add the ; where appropriate. It is missing from the call sortByLinked(trips)


                • You call the origin origin and from this can get confusing. Keep the naming unambiguous. As the trip items use from then that would be the better name for the second input argument.



                Using the above points to modify your code we get



                function tripFrom(trips, from) {
                const sorted = ;
                const first = trips.find(trip => trip.from === from);
                sorted.push(first);

                for (const trip of trips) {
                if (first.to === trip.from) {
                sorted.push(trip);
                break;
                }
                }
                for (const trip of trips) {
                if (sorted[sorted.length - 1].to === trip.from) {
                sorted.push(trips);
                break;
                }
                }
                return sorted;
                }

                sortByLinked(trips, "JFK");


                This is still not a good solution. Its not at all DRY (don't repeat yourself) and is hard coded to a single use case.



                Improving the function.



                It can all be done within a single loop and work for any length array.



                To create the function we must add some constraints on the array trips and what to do when we encounter any problems.




                1. That the array trips contains objects that each have the property from and to that are correctly formatted static strings. The resulting array is erroneous or indeterminate if not so.

                2. That the array does not contain circular trips shorter than the array length.

                3. That a complete trip length is no longer than the array, or when a matching trip.to can not be found. The returned array can be 0 to trips.length in size.

                4. Locations are case sensitive.

                5. If there is more than one matching trip.from it is assumed that the first match in trips is the correct one. (It would be interesting to extract the longest possible trip from? or the shortest trip that returns to the origin?)


                Example



                function tripFrom(trips, from) {
                const result = ;
                while (result.length < trips.length) {
                const trip = trips.find(trip => trip.from === from);
                if (!trip) { break }
                from = trip.to;
                result.push(trip);
                }
                return result;
                }
                tripFrom(trips, "JFK");


                Or if it is known that the trip is the same length as the input array.



                function tripFrom(trips, from) {
                const res = ;
                while (res.length < trips.length) {
                from = (res[res.length] = trips.find(trip => trip.from === from)).to;
                }
                return res;
                }
                tripFrom(trips, "JFK");


                It is unclear if you want the array sorted in place. If that is a requirement then the above version can be modified to do that by simply copying the results array res to the trips array. You can empty an array by setting its length to zero. The spread ... operator in this case spreads the array items over the functions arguments trips.push(...res) thus pushing all the items to the array.



                function tripFrom(trips, from) {
                const res = ;
                while (res.length < trips.length) {
                from = (res[res.length] = trips.find(trip => trip.from === from)).to;
                }
                trips.length = 0;
                trips.push(...res);
                return trips;
                }
                tripFrom(trips, "JFK");





                share|improve this answer









                $endgroup$
















                  1












                  1








                  1





                  $begingroup$

                  Code style




                  • Use constants for variables that do not change. Eg const sortedArray = ;


                  • Don't include the type in the name, Eg const sortedArray = ; can be Eg const sorted = ;



                  • The default parameter in this case seams inappropriate as it is likely that "JFK" is not an origin in all calls to this function. If no origin is given one could assume that the first item in trips contains the origin. function sortByLinked(trips, origin = trips[0].from) { which will throw an error if trips is empty so the function should not be called with an empty trips array if you don't pass the from parameter.



                    However in this example best to leave the default as undefined if not passed as that will return an empty array which is more fitting the input parameters.



                  • The name sort is inappropriate as in JS it implies that the array be sorted in place, that all items be sorted (may not be possible).


                  • You have declared i two times. As a var you should put the declaration at the top of the function and not in the for loop.


                  • Rather than use Array.filter you can use Array.find. It will find the first instance.


                  • Using for...of rather than for(;;) reduces the code complexity.


                  • No point continuing the search inside the for loops when you have found a match. Use the break token to stop a loop early


                  • Put a space between if and (


                  • Don't forget to add the ; where appropriate. It is missing from the call sortByLinked(trips)


                  • You call the origin origin and from this can get confusing. Keep the naming unambiguous. As the trip items use from then that would be the better name for the second input argument.



                  Using the above points to modify your code we get



                  function tripFrom(trips, from) {
                  const sorted = ;
                  const first = trips.find(trip => trip.from === from);
                  sorted.push(first);

                  for (const trip of trips) {
                  if (first.to === trip.from) {
                  sorted.push(trip);
                  break;
                  }
                  }
                  for (const trip of trips) {
                  if (sorted[sorted.length - 1].to === trip.from) {
                  sorted.push(trips);
                  break;
                  }
                  }
                  return sorted;
                  }

                  sortByLinked(trips, "JFK");


                  This is still not a good solution. Its not at all DRY (don't repeat yourself) and is hard coded to a single use case.



                  Improving the function.



                  It can all be done within a single loop and work for any length array.



                  To create the function we must add some constraints on the array trips and what to do when we encounter any problems.




                  1. That the array trips contains objects that each have the property from and to that are correctly formatted static strings. The resulting array is erroneous or indeterminate if not so.

                  2. That the array does not contain circular trips shorter than the array length.

                  3. That a complete trip length is no longer than the array, or when a matching trip.to can not be found. The returned array can be 0 to trips.length in size.

                  4. Locations are case sensitive.

                  5. If there is more than one matching trip.from it is assumed that the first match in trips is the correct one. (It would be interesting to extract the longest possible trip from? or the shortest trip that returns to the origin?)


                  Example



                  function tripFrom(trips, from) {
                  const result = ;
                  while (result.length < trips.length) {
                  const trip = trips.find(trip => trip.from === from);
                  if (!trip) { break }
                  from = trip.to;
                  result.push(trip);
                  }
                  return result;
                  }
                  tripFrom(trips, "JFK");


                  Or if it is known that the trip is the same length as the input array.



                  function tripFrom(trips, from) {
                  const res = ;
                  while (res.length < trips.length) {
                  from = (res[res.length] = trips.find(trip => trip.from === from)).to;
                  }
                  return res;
                  }
                  tripFrom(trips, "JFK");


                  It is unclear if you want the array sorted in place. If that is a requirement then the above version can be modified to do that by simply copying the results array res to the trips array. You can empty an array by setting its length to zero. The spread ... operator in this case spreads the array items over the functions arguments trips.push(...res) thus pushing all the items to the array.



                  function tripFrom(trips, from) {
                  const res = ;
                  while (res.length < trips.length) {
                  from = (res[res.length] = trips.find(trip => trip.from === from)).to;
                  }
                  trips.length = 0;
                  trips.push(...res);
                  return trips;
                  }
                  tripFrom(trips, "JFK");





                  share|improve this answer









                  $endgroup$



                  Code style




                  • Use constants for variables that do not change. Eg const sortedArray = ;


                  • Don't include the type in the name, Eg const sortedArray = ; can be Eg const sorted = ;



                  • The default parameter in this case seams inappropriate as it is likely that "JFK" is not an origin in all calls to this function. If no origin is given one could assume that the first item in trips contains the origin. function sortByLinked(trips, origin = trips[0].from) { which will throw an error if trips is empty so the function should not be called with an empty trips array if you don't pass the from parameter.



                    However in this example best to leave the default as undefined if not passed as that will return an empty array which is more fitting the input parameters.



                  • The name sort is inappropriate as in JS it implies that the array be sorted in place, that all items be sorted (may not be possible).


                  • You have declared i two times. As a var you should put the declaration at the top of the function and not in the for loop.


                  • Rather than use Array.filter you can use Array.find. It will find the first instance.


                  • Using for...of rather than for(;;) reduces the code complexity.


                  • No point continuing the search inside the for loops when you have found a match. Use the break token to stop a loop early


                  • Put a space between if and (


                  • Don't forget to add the ; where appropriate. It is missing from the call sortByLinked(trips)


                  • You call the origin origin and from this can get confusing. Keep the naming unambiguous. As the trip items use from then that would be the better name for the second input argument.



                  Using the above points to modify your code we get



                  function tripFrom(trips, from) {
                  const sorted = ;
                  const first = trips.find(trip => trip.from === from);
                  sorted.push(first);

                  for (const trip of trips) {
                  if (first.to === trip.from) {
                  sorted.push(trip);
                  break;
                  }
                  }
                  for (const trip of trips) {
                  if (sorted[sorted.length - 1].to === trip.from) {
                  sorted.push(trips);
                  break;
                  }
                  }
                  return sorted;
                  }

                  sortByLinked(trips, "JFK");


                  This is still not a good solution. Its not at all DRY (don't repeat yourself) and is hard coded to a single use case.



                  Improving the function.



                  It can all be done within a single loop and work for any length array.



                  To create the function we must add some constraints on the array trips and what to do when we encounter any problems.




                  1. That the array trips contains objects that each have the property from and to that are correctly formatted static strings. The resulting array is erroneous or indeterminate if not so.

                  2. That the array does not contain circular trips shorter than the array length.

                  3. That a complete trip length is no longer than the array, or when a matching trip.to can not be found. The returned array can be 0 to trips.length in size.

                  4. Locations are case sensitive.

                  5. If there is more than one matching trip.from it is assumed that the first match in trips is the correct one. (It would be interesting to extract the longest possible trip from? or the shortest trip that returns to the origin?)


                  Example



                  function tripFrom(trips, from) {
                  const result = ;
                  while (result.length < trips.length) {
                  const trip = trips.find(trip => trip.from === from);
                  if (!trip) { break }
                  from = trip.to;
                  result.push(trip);
                  }
                  return result;
                  }
                  tripFrom(trips, "JFK");


                  Or if it is known that the trip is the same length as the input array.



                  function tripFrom(trips, from) {
                  const res = ;
                  while (res.length < trips.length) {
                  from = (res[res.length] = trips.find(trip => trip.from === from)).to;
                  }
                  return res;
                  }
                  tripFrom(trips, "JFK");


                  It is unclear if you want the array sorted in place. If that is a requirement then the above version can be modified to do that by simply copying the results array res to the trips array. You can empty an array by setting its length to zero. The spread ... operator in this case spreads the array items over the functions arguments trips.push(...res) thus pushing all the items to the array.



                  function tripFrom(trips, from) {
                  const res = ;
                  while (res.length < trips.length) {
                  from = (res[res.length] = trips.find(trip => trip.from === from)).to;
                  }
                  trips.length = 0;
                  trips.push(...res);
                  return trips;
                  }
                  tripFrom(trips, "JFK");






                  share|improve this answer












                  share|improve this answer



                  share|improve this answer










                  answered 40 mins ago









                  Blindman67Blindman67

                  9,3801622




                  9,3801622






























                      draft saved

                      draft discarded




















































                      Thanks for contributing an answer to Code Review Stack Exchange!


                      • Please be sure to answer the question. Provide details and share your research!

                      But avoid



                      • Asking for help, clarification, or responding to other answers.

                      • Making statements based on opinion; back them up with references or personal experience.


                      Use MathJax to format equations. MathJax reference.


                      To learn more, see our tips on writing great answers.




                      draft saved


                      draft discarded














                      StackExchange.ready(
                      function () {
                      StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodereview.stackexchange.com%2fquestions%2f217351%2fsort-list-of-array-linked-objects-by-keys-and-values%23new-answer', 'question_page');
                      }
                      );

                      Post as a guest















                      Required, but never shown





















































                      Required, but never shown














                      Required, but never shown












                      Required, but never shown







                      Required, but never shown

































                      Required, but never shown














                      Required, but never shown












                      Required, but never shown







                      Required, but never shown







                      Popular posts from this blog

                      Færeyskur hestur Heimild | Tengill | Tilvísanir | LeiðsagnarvalRossið - síða um færeyska hrossið á færeyskuGott ár hjá færeyska hestinum

                      He _____ here since 1970 . Answer needed [closed]What does “since he was so high” mean?Meaning of “catch birds for”?How do I ensure “since” takes the meaning I want?“Who cares here” meaningWhat does “right round toward” mean?the time tense (had now been detected)What does the phrase “ring around the roses” mean here?Correct usage of “visited upon”Meaning of “foiled rail sabotage bid”It was the third time I had gone to Rome or It is the third time I had been to Rome

                      Slayer Innehåll Historia | Stil, komposition och lyrik | Bandets betydelse och framgångar | Sidoprojekt och samarbeten | Kontroverser | Medlemmar | Utmärkelser och nomineringar | Turnéer och festivaler | Diskografi | Referenser | Externa länkar | Navigeringsmenywww.slayer.net”Metal Massacre vol. 1””Metal Massacre vol. 3””Metal Massacre Volume III””Show No Mercy””Haunting the Chapel””Live Undead””Hell Awaits””Reign in Blood””Reign in Blood””Gold & Platinum – Reign in Blood””Golden Gods Awards Winners”originalet”Kerrang! Hall Of Fame””Slayer Looks Back On 37-Year Career In New Video Series: Part Two””South of Heaven””Gold & Platinum – South of Heaven””Seasons in the Abyss””Gold & Platinum - Seasons in the Abyss””Divine Intervention””Divine Intervention - Release group by Slayer””Gold & Platinum - Divine Intervention””Live Intrusion””Undisputed Attitude””Abolish Government/Superficial Love””Release “Slatanic Slaughter: A Tribute to Slayer” by Various Artists””Diabolus in Musica””Soundtrack to the Apocalypse””God Hates Us All””Systematic - Relationships””War at the Warfield””Gold & Platinum - War at the Warfield””Soundtrack to the Apocalypse””Gold & Platinum - Still Reigning””Metallica, Slayer, Iron Mauden Among Winners At Metal Hammer Awards””Eternal Pyre””Eternal Pyre - Slayer release group””Eternal Pyre””Metal Storm Awards 2006””Kerrang! Hall Of Fame””Slayer Wins 'Best Metal' Grammy Award””Slayer Guitarist Jeff Hanneman Dies””Bullet-For My Valentine booed at Metal Hammer Golden Gods Awards””Unholy Aliance””The End Of Slayer?””Slayer: We Could Thrash Out Two More Albums If We're Fast Enough...””'The Unholy Alliance: Chapter III' UK Dates Added”originalet”Megadeth And Slayer To Co-Headline 'Canadian Carnage' Trek”originalet”World Painted Blood””Release “World Painted Blood” by Slayer””Metallica Heading To Cinemas””Slayer, Megadeth To Join Forces For 'European Carnage' Tour - Dec. 18, 2010”originalet”Slayer's Hanneman Contracts Acute Infection; Band To Bring In Guest Guitarist””Cannibal Corpse's Pat O'Brien Will Step In As Slayer's Guest Guitarist”originalet”Slayer’s Jeff Hanneman Dead at 49””Dave Lombardo Says He Made Only $67,000 In 2011 While Touring With Slayer””Slayer: We Do Not Agree With Dave Lombardo's Substance Or Timeline Of Events””Slayer Welcomes Drummer Paul Bostaph Back To The Fold””Slayer Hope to Unveil Never-Before-Heard Jeff Hanneman Material on Next Album””Slayer Debut New Song 'Implode' During Surprise Golden Gods Appearance””Release group Repentless by Slayer””Repentless - Slayer - Credits””Slayer””Metal Storm Awards 2015””Slayer - to release comic book "Repentless #1"””Slayer To Release 'Repentless' 6.66" Vinyl Box Set””BREAKING NEWS: Slayer Announce Farewell Tour””Slayer Recruit Lamb of God, Anthrax, Behemoth + Testament for Final Tour””Slayer lägger ner efter 37 år””Slayer Announces Second North American Leg Of 'Final' Tour””Final World Tour””Slayer Announces Final European Tour With Lamb of God, Anthrax And Obituary””Slayer To Tour Europe With Lamb of God, Anthrax And Obituary””Slayer To Play 'Last French Show Ever' At Next Year's Hellfst””Slayer's Final World Tour Will Extend Into 2019””Death Angel's Rob Cavestany On Slayer's 'Farewell' Tour: 'Some Of Us Could See This Coming'””Testament Has No Plans To Retire Anytime Soon, Says Chuck Billy””Anthrax's Scott Ian On Slayer's 'Farewell' Tour Plans: 'I Was Surprised And I Wasn't Surprised'””Slayer””Slayer's Morbid Schlock””Review/Rock; For Slayer, the Mania Is the Message””Slayer - Biography””Slayer - Reign In Blood”originalet”Dave Lombardo””An exclusive oral history of Slayer”originalet”Exclusive! Interview With Slayer Guitarist Jeff Hanneman”originalet”Thinking Out Loud: Slayer's Kerry King on hair metal, Satan and being polite””Slayer Lyrics””Slayer - Biography””Most influential artists for extreme metal music””Slayer - Reign in Blood””Slayer guitarist Jeff Hanneman dies aged 49””Slatanic Slaughter: A Tribute to Slayer””Gateway to Hell: A Tribute to Slayer””Covered In Blood””Slayer: The Origins of Thrash in San Francisco, CA.””Why They Rule - #6 Slayer”originalet”Guitar World's 100 Greatest Heavy Metal Guitarists Of All Time”originalet”The fans have spoken: Slayer comes out on top in readers' polls”originalet”Tribute to Jeff Hanneman (1964-2013)””Lamb Of God Frontman: We Sound Like A Slayer Rip-Off””BEHEMOTH Frontman Pays Tribute To SLAYER's JEFF HANNEMAN””Slayer, Hatebreed Doing Double Duty On This Year's Ozzfest””System of a Down””Lacuna Coil’s Andrea Ferro Talks Influences, Skateboarding, Band Origins + More””Slayer - Reign in Blood””Into The Lungs of Hell””Slayer rules - en utställning om fans””Slayer and Their Fans Slashed Through a No-Holds-Barred Night at Gas Monkey””Home””Slayer””Gold & Platinum - The Big 4 Live from Sofia, Bulgaria””Exclusive! Interview With Slayer Guitarist Kerry King””2008-02-23: Wiltern, Los Angeles, CA, USA””Slayer's Kerry King To Perform With Megadeth Tonight! - Oct. 21, 2010”originalet”Dave Lombardo - Biography”Slayer Case DismissedArkiveradUltimate Classic Rock: Slayer guitarist Jeff Hanneman dead at 49.”Slayer: "We could never do any thing like Some Kind Of Monster..."””Cannibal Corpse'S Pat O'Brien Will Step In As Slayer'S Guest Guitarist | The Official Slayer Site”originalet”Slayer Wins 'Best Metal' Grammy Award””Slayer Guitarist Jeff Hanneman Dies””Kerrang! Awards 2006 Blog: Kerrang! Hall Of Fame””Kerrang! Awards 2013: Kerrang! Legend”originalet”Metallica, Slayer, Iron Maien Among Winners At Metal Hammer Awards””Metal Hammer Golden Gods Awards””Bullet For My Valentine Booed At Metal Hammer Golden Gods Awards””Metal Storm Awards 2006””Metal Storm Awards 2015””Slayer's Concert History””Slayer - Relationships””Slayer - Releases”Slayers officiella webbplatsSlayer på MusicBrainzOfficiell webbplatsSlayerSlayerr1373445760000 0001 1540 47353068615-5086262726cb13906545x(data)6033143kn20030215029