Compare individual values of 2 multi-dimensional arrays in google script - arrays

Question

I have 2 multi-dimensional arrays that I'm trying to compare data against. While the length of the nested arrays may vary on a case-by-case basis, for each instance the lengths will be the same and mirrored between both arrays AND the first array[0] of each will contain the exact same info. The only thing that will/may vary is the order the headers may appear in array[0]. It may be
h1, h2, Id
in the first and
Id, h1, h2
in the second array.
Full Example
1st array
[ [ Header1 , Header2 , ID ] , [ dataA , dataB , 000 ] ]
2nd array
[ [ Header1 , Header2 , ID ] , [ dataA , dataB , 111 ] ]
Question
How can I parse, loop, split, whatever (still new to this) so that I can compare each values and put them all into a single array?
Result Wanted
[ [ oldHeader1 , oldHeader2 , oldID , newHeader1 , newHeader2 , newID ] , [ dataA , dataB , 000 , dataA , dataB , 111 ] ]
and yes, dataA and dataB should be the same from both sources. That is what I'm comparing against, the IDs of each are the only things that should be different. If dataA doesn't match but dataB does, I'd like to continue but add a logging. But that's a later step.
I've thought about looping through 1st array and taking each value, then looping through the 2nd value to see if that value exists. That would be all well and good but I can't seem to figure out how to .push that value and keep everything in order. These values are also being pulled from a sheet but I read that it is faster to generate an array and use Google's server to do the work rather than look at each cell, vlookup or find, return a result, ++ and iterate.
Any advice here would be great, thanks!
Here is the code I'm using to generate the 2 arrays I'm going to compare as an FYI. Maybe there's something here that I can modify? I call this function twice, with a file that contains source info and a file that contains destination info.
//This will take a sheet and an array of headers and return the subset in a new array
function grabColumnByHeader(headers,sheet,whichID) {
var initialArray = new Array(); //Array to store sheet data
var headerIndex = new Array(); //Blank array to house header index(es)
var outputArray = []; //Will be returned
var data = sheet.getDataRange(); //all data
var dataNumRows = data.getNumRows(); //number of rows
var dataNumCol = data.getNumColumns(); //number of columns
initialArray = sheet.getRange(1, 1, dataNumRows, dataNumCol).getValues();
//Get the index(es) of header(s). This is assuming that headers are in row 1
for (i = 0;i<1;++i){
for (j = 0;j<dataNumCol;++j){
//loop through headers var for each header
for (k = 0;k<headers.length;++k){
if(initialArray[i][j].toString().toUpperCase() == headers[k][i].toString().toUpperCase()) {
headerIndex.push(j);
}
}
}
}
//Using the array's indexes from headerIndex, loop through and grab values
//If coming from SOURCE file, prepend 'SOURCE_'
for (i = 0;i<dataNumRows;++i) {
outputArray[i] = [];
for (j = 0;j<headerIndex.length;++j) {
if (i == 0 && whichID == 'TRUE') {
outputArray[i][j] = 'SOURCE_' + initialArray[i][headerIndex[j]];
} else {
outputArray[i][j] = initialArray[i][headerIndex[j]];
}
}
}
//Logger.log(outputArray);
return outputArray;
}
Update
Here is the code I've been able to google fu together and use my basic knowledge. I realize that it is performing unnecessary loops and this is still a work in progress:
var tempArray = [];
var idIndex;
//get index of ID so it can be skipped in comparison
for (i=0;i<1;++i) {
for (j=0;j<newData[i].length;++j) {
if (newData[i][j].toString().toUpperCase() == 'ID') {
idIndex = j;
}
}
}
//Logger.log(idIndex);
for (i=0;i<newData.length;++i) {
tempArray[i] = [];
//if on headers, automatically concatenate and add to tempArray
if (i==0) {
tempArray[i] = newData[i].concat(oldData[i]);
}
else {
//Logger.log('newData['+i+']');
for (j=0;j<newData[i].length;++j) {
//for newData[i][j], begin looking in oldData
//if we're not comparing indexes then
if (j != idIndex) {
//Logger.log('newData['+i+']['+j+']');
//begin looping through the oldData arrays
for (k=0;k<oldData.length;++k){
//Logger.log('newData['+i+']['+j+'] == oldData['+k+']['+j+']');
if (newData[i][j] == oldData[k][j]) {
//NEED TO MAKE SURE HERE THAT ++j IS THE SAME TOO
tempArray[i] = newData[i].concat(oldData[k]);//continue on with j
break;
}
}
}
//continue through for(j)
}
}
//continue through for(i)
}
output.getRange(1, 1, tempArray.length, tempArray[0].length).setValues(tempArray);

Answer 1

Found my own answer after enough trial and error. May not be the way a pro would do it, but works for me:
var tempArray = []; //will be used for output
var sameArray = []; //will look like this [sameIndex,sameCount]
var sameIndex = ''; //will get the index number of match to be used when pushing to tempArray
var sameCount = 0; //if count is == my keys-ID then push to tempArray
//concat the headers, as this will be a constant
tempArray[0] = newData[0].concat(oldData[0]);
for (i=1;i<newData.length;++i) {
//reset variables after each [i]
//these are used to verify if my newData array and oldData array are the same
sameArray = [];
sameIndex = '';
sameCount = 0;
for (j=0;j<newData[i].length;++j) {
//for newData[i][j], begin looking in oldData
//we're not comparing our IDs because we know they'll be different
//pulled those out earlier and set to idIndex
if (j != idIndex) {
//begin looping through the oldData arrays
for (k=1;k<oldData.length;++k){
for (l=0;l<oldData[k].length;++l) {
if (l != idIndex) {
if (newData[i][j] == oldData[k][l]){
sameArray[0] = k;
sameArray[1] = ++sameCount;
}
}
}
}
}
//since looped through all of oldData array, check to see
//if the amount of matches in a single row were keyCount-1
//keyCount is my variables and we subtract 1 because not comaring IDs
if (sameArray[1] == keyCount-1) {
tempArray.push(newData[i].concat(oldData[sameArray[0]]));
} else {
//Will be used to catch indexes that didn't match
}
}
}
output.getRange(1, 1, tempArray.length, tempArray[0].length).setValues(tempArray);