Using functional programming properly: how do I use .map() efficiently here?

I would just use the filter() method:

const hobbieList = ["Rock", "Pop", "Surf", "Blues", "Soccer"];
const hobbieTypes = ["music", "music", "sport", "music", "sport"];
console.log(hobbieList.filter((x, i) => hobbieTypes[i] === "music"));

As for your edit: I think that using filter() is much cleaner than map() (which you're actually using as forEach()). This might not be the fastest way, but it's definitely more functional.

What you seem to want to do is to group hobbies by type. What should the output of this grouping process be? Creating separate variables of lists of hobbies for each type is not very scalable. It's going to be better to create an object, whose keys are types, and whose values are lists of hobbies of that type:

hobbiesByType = {
  music: ["Rock", "Pop", "Blues"],
  sport: ["Surf", "Soccer"]
};

Now I can refer to all the music hobbies as hobbiesByType.music.

What should the input to this grouping process be? Currently you have two parallel arrays:

hobbieList = ["Rock", "Pop", "Surf", "Blues", "Soccer"];
hobbieTypes= ["music", "music", "sport", "music", "sport"];

but this is not the best way to represent this information. Any time I want to check something, I have to reference both arrays. I may have to iterate across them in parallel. It would be much better to have a single representation, and a usual approach would be an array of objects:

hobbies = [
  {name: "Rock", type: "music"},
  ...
];

Now let's think about how to do the grouping. You will find many examples and approaches here on SO. Here's a very basic one using for loops:

var hobbiesByType = {};

for (var i = 0; i < hobbies.length; i++) {
  var hobby = hobbies[i];
  var hobbyName = hobby.name;
  var hobbyType = hobby.type;
  if (!(hobbyType in hobbiesByType)) hobbiesByType[hobbyType] = [];
  hobbiesByType[hobbyType].push(hobby.name);
}

But you want to use "functional" array methods. The most compact form of the above would use reduce and go like this:

hobbiesByType = hobbies.reduce((result, hobby) => {
  if (!(hobby.type in result)) result[hobby.type] = [];
  result[hobby.type].push(hobby.name);
  return result;
}, {});

That's all ES5, not ES6. You could streamline it a bit using ES6 parameter destructuring:

hobbiesByType = hobbies.reduce((result, type, name}) => {
  (result[type] = result[type] || []).push(name);
  return result;
}, {});

However, rather than creating arrays of the name of the hobby under each type, it is likely to be better to create arrays of the hobby objects themselves. Then if hobbies ever contain additional information--skillLevel perhaps--then you easily can a access that from the grouped representation.

By the way, the singular form is "hobby", not "hobbie".

Using variant data as object keys would be a terrible misuse of objects. Instead, a Map would make a much better choice for your desired data.

A zip function in combination with Array.prototype.reduce will produce a very usable result

let hobbyList = ["Rock", "Pop", "Surf", "Blues", "Soccer"]
let hobbyTypes= ["music", "music", "sport", "music", "sport"]

const zip = ([x,...xs], [y,...ys]) => {
  if (x === undefined || y === undefined)
    return []
  else
    return [[x,y], ...zip(xs, ys)]
}

let result = zip(hobbyTypes, hobbyList).reduce((acc, [type, hobby]) => {
  if (acc.has(type))
    return acc.set(type, [...acc.get(type), hobby])
  else
    return acc.set(type, [hobby])
}, new Map())

console.log(result.get('music'))
// => [ 'Rock', 'Pop', 'Blues' ]

console.log(result.get('sport'))
// => [ 'Surf', 'Soccer' ]

If you really must use an object, though you really shouldn't be, you can do so using map.entries and Array.from.

Array.from(result.entries())
  .reduce((acc, [type, hobbies]) =>
    Object.assign(acc, { [type]: hobbies }), {})

// => { music: [ 'Rock', 'Pop', 'Blues' ], sport: [ 'Surf', 'Soccer' ] }

Map is used to convert something in something else and not to get element that match a condition. In this case you have to use a filter function.