How do connectively sort 2 arrays in a 2 dimensional array?

I have this 2d Array in JavaScript:

['Daniela', 'Jonas', 'Simon', 'Vincent']
['0', '3', '0', '4']

in which the numbers stand for the amount of guesses the user took to guess a random number.
and i want it to look like this:

['Jonas', 'Vincent', 'Simon', 'Daniela']
['3', '4', '0', '0']

so basically, sorted by the numbers from lowest to highest (except 0 since the user didnt finish his run), but the names sorted accordingly to the numbers.

How (if) is this possible?

I tried sorting it like normally like a 2d Array and it didnt work, i tried splitting the different array and sorting them manually but then i dont know how to sort them connectively.

If you like to keep arrays, you could take an array of indices, sort by the values and map finally both arrays with the indices.

<!-- begin snippet: js hide: false console: true babel: false -->
<!-- language: lang-js -->
let names = ['Daniela', 'Jonas', 'Simon', 'Vincent'],
values = ['0', '3', '0', '4'],
indices = [...values.keys()].sort((a, b) =>
(+values[a] || Number.MAX_VALUE) - (+values[b] || Number.MAX_VALUE)
);

[names, values] = [names, values].map(a => indices.map(i => a[i]));

console.log(...names);
console.log(...values);

<!-- end snippet -->

Map the original array into pairs like [['0', 'Daniela'], ...]. Then sort by the number, treating zero as a special case that will always be last in the sort. Then use reduce to map the pairs back into the original 2D array format.

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

const arr = [['Daniela', 'Jonas', 'Simon', 'Vincent'],
             ['0', '3', '0', '4']]

console.log(arr[0].map((e,i)=>[arr[1][i],e])
  .sort(([a],[b])=>((a==0)-(b==0) || a-b))
  .reduce((a,[x,y])=>(a[0].push(y),a[1].push(x),a),[[],[]]))

<!-- end snippet -->

As suggested by @Roko, an array of objects is preferred in this particular situation as it helps making a sorting function much easier.

However, if that is not at all possible we can zip them manually:

const zipped = users.map(
  (user, index) => ({ name: user, guesses: Number(guesses[index]) })
);

Then, we sort them based on their guesses. Note how I use Infinity as the sorting value if user.guesses === 0.

zipped.sort(
  (user1, user2) => (user1.guesses || Infinity) - (user2.guesses || Infinity)
);

However, how the order of users who did not complete the test was not specified. Hence, their order are assumed to be preserved.

Try it (I separated zipped back to two arrays, just in case you need them):
<!-- begin snippet: js hide: true console: true babel: false -->

<!-- language: lang-js -->

const users = ['Daniela', 'Jonas', 'Simon', 'Vincent'];
const guesses = ['0', '3', '0', '4'];

const zipped = users.map(
  (user, index) => ({ name: user, guesses: Number(guesses[index]) })
);

zipped.sort(
  (user1, user2) => (user1.guesses || Infinity) - (user2.guesses || Infinity)
);

console.log(zipped);

const [sortedUsers, sortedGuesses] = zipped.reduce(
  ([sortedUsers, sortedGuesses], currentUser) => [
    [...sortedUsers, currentUser.name],
    [...sortedGuesses, currentUser.guesses],
  ], [[], []]
);

console.log(sortedUsers, sortedGuesses);

<!-- end snippet -->

This is a perfect use case for the zip function:

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

let zip = (...a) => a[0].map((_, i) => a.map(r => r[i]))

//

let names = ['Daniela', 'Jonas', 'Simon', 'Vincent']
let scores = [0, 3, 0, 4]

let temp = zip(scores, names);
temp.sort((x, y) => (x[0] || Infinity) - (y[0] || Infinity));
[scores, names] = zip(...temp);

console.log(...names)
console.log(...scores)

<!-- end snippet -->

An efficient sorting method, without creating new arrays and objects.
Minimum runtime.

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

const names = ['Daniela', 'Jonas', 'Simon', 'Vincent'];
const numbers = ['0', '3', '0', '4'];
for (let i = 1; i < names.length; i++) {
    for (let j = i - 1; j >= 0; j--) {
        if (numbers[j] > numbers[j + 1] && +numbers[j + 1] || !+numbers[j]) {
            [names[j], names[j + 1]] = [names[j + 1], names[j]];
            [numbers[j], numbers[j + 1]] = [numbers[j + 1], numbers[j]];
        } else {
            break;
        }
    }
}
console.log(...names);

<!-- end snippet -->