Javascript object array into a string?

As has been mentioned, you can take advantage of the fact that referencing a property of an object can be done using both dot and array notation.

Taking this a bit further, not only can you simplify access to the incoming unit, you can also reduce the rest of your code quite a bit further.

First, by changing your markup slightly, all of the entry fields ID's will have the same pattern "txt" + key.toLowerCase():

<input type='text' size='8' id='txtt'/>

Initialize an object of highLow values with a predefined magnitude (T doesn't have one):

var highLow = {
    T:    {},
    Psat: {magnitude: 100000},
    vf:   {magnitude: 10000000},
    vg:   {magnitude: 100000},
    hf:   {magnitude: 10000},
    hg:   {magnitude: 100},
    hfg:  {magnitude: 100}
};

Then the rest of your interpolate function can be modified to look something like this:

// Note 1: Started loop at 2 to avoid undefined array values
// Note 2: the redundant loops could be reduced by calculating T first
function interpolate(myval, unit) {
    var key, cur, factor;

    var highLow = {/*see above*/};

    for (var i = 2; i < SatWaterMetric.length; i++) {
        if (myval < SatWaterMetric[i][unit]) {
            for (key in highLow) {
                highLow[key].low = SatWaterMetric[i - 2][key];
                highLow[key].high = SatWaterMetric[i - 1][key];
            }

            factor = (myval - highLow.T.low) / (highLow.T.high - highLow.T.low);

            for (key in highLow) {
                cur = highLow[key];

                // This is T
                if (!cur.magnitude) {
                    cur.result = myval;
                } else {
                    cur.result = (1 * cur.low) + (1 * factor * (cur.high - cur.low));
                }
            }
            break;
        }
    }

    for (key in highLow) {
        cur = highLow[key];
        $('#txt' + key.toLowerCase()).val(Math.round(cur.result * (cur.magnitude || 1)) / (cur.magnitude || 1));
    }
}

Demo jsFiddle

Version 2: This version removes the redundant looping from the previous example by refactoring the display calculation and assigning it directly to the associated highLow key and calculating the final display value inline.

Demo jsFiddle

Code:

// Generates a result for display using the provided magnitude to 
// format the calculated value.
function calcFn(T, factor, low, high, magnitude) {
    var retVal = (1 * low) + (1 * factor * (high - low));

    return Math.round(retVal * (magnitude || 1)) / (magnitude || 1);
}

var highLow = {
    // Initializing T with a calc function that just returns the passed in value
    // This makes the calc/display loop much simpler
    T:    { calc:   function(T) { return T; }, 
            factor: function(T, low, high) { return (T - low) / (high - low); } },

    // All other metrics will use calcFn
    Psat: { magnitude:   100000, calc: calcFn },
    vf:   { magnitude: 10000000, calc: calcFn },
    vg:   { magnitude:   100000, calc: calcFn },
    hf:   { magnitude:    10000, calc: calcFn },
    hg:   { magnitude:      100, calc: calcFn },
    hfg:  { magnitude:      100, calc: calcFn }
};

// Note: Started loop at 2 to avoid undefined array values
function interpolate(myval, unit) {
    var key, cur, factor, result, high, low;

    for (var i = 2; i < SatWaterMetric.length; i++) {
        if (myval < SatWaterMetric[i][unit]) {
            // T is in slot 0
            factor = highLow.T.factor(myval, SatWaterMetric[i - 2].T, SatWaterMetric[i - 1].T);

            // Now we can simply loop through all metrics using the assigned calc function to 
            // generate a result for display.
            for(key in highLow) {
                cur    = highLow[key];
                low    = SatWaterMetric[i - 2][key];
                high   = SatWaterMetric[i - 1][key];
                result = cur.calc(myval, factor, low, high, cur.magnitude);

                $('#txt' + key.toLowerCase()).val(result);
            }

            break;
        }
    }
}