Array.prototype.reduce() is perfect for tasks like this: performing aggregate operations (such as min, max, avg, etc.) on an array and returning a single result:

myArray.reduce(function(prev, curr) {
    return prev.Cost < curr.Cost ? prev : curr;
});

...or you can define the inner function using ES6 function syntax:

myArray.reduce((prev, curr) => prev.Cost < curr.Cost ? prev : curr);

If you want to be clever, you can attach this to the Array prototype:

Array.prototype.hasMin = function(attrib) {
    return (this.length && this.reduce(function(prev, curr){ 
        return prev[attrib] < curr[attrib] ? prev : curr; 
    })) || null;
 }

Now you simply say:

myArray.hasMin('ID')  // result:  {"ID": 1, "Cost": 200}
myArray.hasMin('Cost')    // result: {"ID": 3, "Cost": 50}
myEmptyArray.hasMin('ID')   // result: null

Note that if you plan to use this, it lacks full checks for every scenario. It may fail when passing an array of primitive types or checking for non-existing properties within objects. This version is a bit more cumbersome but includes those checks:

Array.prototype.hasMin = function(attrib) {
    const checker = (o, i) => typeof(o) === 'object' && o[i]
    return (this.length && this.reduce(function(prev, curr){
        const prevOk = checker(prev, attrib);
        const currOk = checker(curr, attrib);
        if (!prevOk && !currOk) return {};
        if (!prevOk) return curr;
        if (!currOk) return prev;
        return prev[attrib] < curr[attrib] ? prev : curr; 
    })) || null;
 }

Using the Math.min and Math.max functions:

var myArray = [
    { id: 1, cost: 200},
    { id: 2, cost: 1000},
    { id: 3, cost: 50},
    { id: 4, cost: 500}
]


var minCost = Math.min(...myArray.map(item => item.cost));
var maxCost = Math.max(...myArray.map(item => item.cost));

console.log("Lowest cost: " + minCost);
console.log("Highest cost: " + maxCost);

To organize your array in ascending order, utilize the sort method.

myArray.sort(function (a, b) {
    return a.Value - b.Value
})

var smallest = myArray[0],
    largest = myArray[myArray.length - 1]

Utilize built-in Math functions and extract specific values using map.

Check out this live demo on jsbin:

https://jsbin.com/necosu/1/edit?js,console

var myArray = [{
    "ID": 1,
    "Cost": 200
  }, {
    "ID": 2,
    "Cost": 1000
  }, {
    "ID": 3,
    "Cost": 50
  }, {
    "ID": 4,
    "Cost": 500
  }],

  min = Math.min.apply(null, myArray.map(function(item) {
    return item.Cost;
  })),
  max = Math.max.apply(null, myArray.map(function(item) {
    return item.Cost;
  }));

console.log('min', min);//50
console.log('max', max);//1000

UPDATE:

If you prefer ES6 syntax:

var min = Math.min.apply(null, myArray.map(item => item.Cost)),
    max = Math.max.apply(null, myArray.map(item => item.Cost));

Attempt (a represents an array, f is the field to compare)

let maximum= (a,f)=> a.reduce((m,x)=> m[f]>x[f] ? m:x);
let minimum= (a,f)=> a.reduce((m,x)=> m[f]<x[f] ? m:x);

let maximum= (a,f)=> a.reduce((m,x)=> m[f]>x[f] ? m:x);
let minimum= (a,f)> a.reduce((m,x)=> m[f]<x[f] ? m:x);

// TESTING

var sampleArray = [
    {"ID": 1, "Cost": 200},
    {"ID": 2, "Cost": 1000},
    {"ID": 3, "Cost": 50},
    {"ID": 4, "Cost": 500}
]

console.log('Maximum Cost', maximum(sampleArray, 'Cost'));
console.log('Minimum Cost', minimum(sampleArray, 'Cost'));

console.log('Maximum ID', maximum(sampleArray, 'ID'));
console.log('Minimum ID', minimum(sampleArray, 'ID'));

In my opinion, the solution provided by Rob W is definitely the correct one (+1). However, if you're looking for a more "clever" approach, here's something you could try:

var myArray = 
[
    {"ID": 1, "Cost": 200},
    {"ID": 2, "Cost": 1000},
    {"ID": 3, "Cost": 50},
    {"ID": 4, "Cost": 500}
]

function finder(cmp, arr, attr) {
    var val = arr[0][attr];
    for(var i=1;i<arr.length;i++) {
        val = cmp(val, arr[i][attr])
    }
    return val;
}

alert(finder(Math.max, myArray, "Cost"));
alert(finder(Math.min, myArray, "Cost"));

Alternatively, if your data structure is deeply nested, you can take a more functional approach like this:

var myArray = 
[
    {"ID": 1, "Cost": { "Wholesale":200, Retail: 250 }},
    {"ID": 2, "Cost": { "Wholesale":1000, Retail: 1010 }},
    {"ID": 3, "Cost": { "Wholesale":50, Retail: 300 }},
    {"ID": 4, "Cost": { "Wholesale":500, Retail: 1050 }}
]

function finder(cmp, arr, getter) {
    var val = getter(arr[0]);
    for(var i=1;i<arr.length;i++) {
        val = cmp(val, getter(arr[i]))
    }
    return val;
}

alert(finder(Math.max, myArray, function(x) { return x.Cost.Wholesale; }));
alert(finder(Math.min, myArray, function(x) { return x.Cost.Retail; }));

These functions could easily be adapted into more specific and useful forms through currying.

dedicated to Max

Find the maximum value in myArray by Cost property:
Math.max.apply(Math, myArray.map(a => a.Cost));

dedicated to min

Find the minimum value in myArray by Cost property:
Math.min.apply(Math, myArray.map(a => a.Cost));

To accomplish this task, you can utilize the minBy and maxBy functions provided by lodash.

Refer to Lodash's minBy and maxBy documentation for more details

_.minBy(array, [iteratee=_.identity])

_.maxBy(array, [iteratee=_.identity])

These methods require an iteratee function that is called for each element in the array to determine how the value should be ranked. The iteratee function takes one argument: (value).

Solution

var myArray = [
    {"ID": 1, "Cost": 200},
    {"ID": 2, "Cost": 1000},
    {"ID": 3, "Cost": 50},
    {"ID": 4, "Cost": 500}
]

const minimumCostItem = _.minBy(myArray, "Cost");

console.log("Minimum cost item: ", minimumCostItem);

// To find the maximum with a custom iteratee
const maximumCostItem = _.maxBy(myArray, function(entry) {
  return entry["Cost"];
});

console.log("Maximum cost item: ", maximumCostItem);

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.js"></script>

To find an efficient and modern solution, one can take advantage of the reduce function in JavaScript. By using this method, it is possible to iterate through the array while keeping track of the current minimum and maximum values, resulting in optimal performance with just a single iteration.

let [min, max] = myArray.reduce(([prevMin, prevMax], {Cost})=>
   [Math.min(prevMin, Cost), Math.max(prevMax, Cost)], [Infinity, -Infinity]);

Here's a demonstration:

var myArray = [
    {"ID": 1, "Cost": 200},
    {"ID": 2, "Cost": 1000},
    {"ID": 3, "Cost": 50},
    {"ID": 4, "Cost": 500}
]
let [min, max] = myArray.reduce(([prevMin, prevMax], {Cost})=>
   [Math.min(prevMin, Cost), Math.max(prevMax, Cost)], [Infinity, -Infinity]);
console.log("Min cost:", min);
console.log("Max cost:", max);

Discover the power of Array.prototype.reduce() by utilizing comparator functions to identify the minimum, maximum, or other elements in an array.

var items = [
  { name : 'Grapes', count : 5 },
  { name : 'Pineapple', count : 12 },
  { name : 'Watermelon', count : 6 },
  { name : 'Kiwi', count : 7 }
];

function findItemBy(arr, key, comparatorFn) {
  return arr.reduce(function(prev, curr, index, arr) { 
    return comparatorFn.call(arr, prev[key], curr[key]) ? prev : curr; 
  });
}

function compareMin(prev, curr) {
  return prev < curr;
}

function compareMax(prev, curr) {
  return prev > curr;
}

document.body.innerHTML  = 'Minimum: ' + findItemBy(items, 'count', compareMin).name + '<br />';
document.body.innerHTML += 'Maximum: ' + findItemBy(items, 'count', compareMax).name;

This solution offers a more efficient approach

    let myArray = [
    {"ID": 1, "Cost": 200},
    {"ID": 2, "Cost": 1000},
    {"ID": 3, "Cost": 50},
    {"ID": 4, "Cost": 500}
    ]
    let lowestCost = myArray[0].Cost;
    let highestCost = myArray[0].Cost;

    myArray.forEach(function (item, index) {
      if(index > 0) {
        if(item.Cost < lowestCost){
          lowestCost = item.Cost;
        }
        if(item.Cost > highestCost) {
          highestCost = item.Cost;
        }
      }
    });
    console.log('The lowest cost is' , lowestCost);
    console.log('The highest cost is' , highestCost);

Expanding on the earlier solution provided by Tristan Reid and implementing ES6 features, a new function can be created that takes a callback as an argument. This callback will contain the operator to be applied on the values of prev and curr:

const compareValues = (array, key, callback) => array.reduce((prev, curr) =>
    (callback(prev[key], curr[key]) ? prev : curr), {})[key];

    // Removing [key] will return the entire object

This function can then be used simply by calling it with:

const minCost = compareValues(myData, 'Cost', (a, b) => a < b);
const maxCost = compareValues(myData, 'Cost', (a, b) => a > b);

There are two approaches to solving the problem, both of which have been explained above. However, the performance test was missing so let's complete that.

1. Using native JavaScript
2. First sort the object, then it becomes easy to get the minimum and maximum from the sorted object.

I also tested the performance of both approaches

You can also run and test the performance... Happy coding (:

// Approach 1 

var myArray = [
    {"ID": 1, "Cost": 200},
    {"ID": 2, "Cost": 1000},
    {"ID": 3, "Cost": 50},
    {"ID": 4, "Cost": 500}
]

var t1 = performance.now();;

let max=Math.max.apply(Math, myArray.map(i=>i.Cost))

let min=Math.min.apply(Math, myArray.map(i=>i.Cost))

var t2   = performance.now();;

console.log("Native function took " + (t2 - t1) + " milliseconds.");

console.log("Max Value:"+max)
console.log("Min Value:"+min)

//  Approach 2:


function sortFunc (a, b) {
    return a.Cost - b.Cost
} 

var s1 = performance.now();;
sortedArray=myArray.sort(sortFunc)


var minBySortArray = sortedArray[0],
    maxBySortArray = sortedArray[myArray.length - 1]
    
var s2   = performance.now();;
 console.log("Sorting function took  " + (s2 - s1) + " milliseconds.");  
console.log("Max Value By Sorting Array :"+max)
console.log("Min Value By Sorting Array:"+min)

highestValue = totalAVG.reduce(function (a, b) { return Math.max(a, b)}, -Infinity);

lowestValue = totalAVG.reduce(function (a, b) {return Math.min(a, b)}, Infinity);