Use map instead of forEach and drop the parenthesis and the curly braces in the lambda:

var userNames = objectArr.map(o => o.userName).join(', ');

Probably like this:

  const result = item.map(it => ({
      name: it.name,
      syllabi: it.syllabus.map(s => s.name).join(', ')
    }));

https://jsfiddle.net/ernmtcgj/

Before join you need map array

const array = [
    { a: '1', b: '2' },
    { a: '3', b: '4' },
];

const result = array.map(_ => _.a).join(', ');

console.log(result);

If you want to map objects to something (in this case a property). I think Array.prototype.map is what you're looking for if you want to code functionally.

(fiddle)

If you want to support older browsers, that are not ES5 compliant you can shim it (there is a polyfill on the MDN page above). Another alternative would be to use underscorejs's pluck method:

var users = [
      {name: "Joe", age: 22},
      {name: "Kevin", age: 24},
      {name: "Peter", age: 21}
    ];
var result = _.pluck(users,'name').join(",")

Here is a version that works with both readonly and mutable tuples types and a separator.

type Join<
  TElements,
  TSeparator extends string,
> = TElements extends Readonly<[infer First, ...infer Rest]>
  ? Rest extends ReadonlyArray<string>
    ? First extends string
      ? `${First}${Rest extends [] ? '' : TSeparator}${Join<Rest, TSeparator>}`
      : never
    : never
  : '';

type MutableTuple = ["a", "b", "c"];
type MutableTupleJoined = Join<MutableTuple, " | ">;
//   ^? "a | b | c"

type ReadonlyTuple = readonly ["a", "b", "c"];
type ReadonlyTupleJoined = Join<ReadonlyTuple, " | ">;
//   ^? "a | b | c"

A readonly type often comes from const assertions e.g.

const tuple = ["a", "b", "c"] as const;
type Joined = Join<typeof tuple, " | ">;

When inlining the tuple type, it is usually mutable e.g.

type Joined = Join<["a", "b", "c"], " | ">;

Since you want a single string out of this, and not an array, you will want to use Array.forEach to concatenate onto an existing string object, like so:

let outStr = '';

array.forEach((ele, idx) => 
    outStr += `${ele.key}: ${ele.text}${idx < array.length ? '' : ', '}`
);

You could also use Array.map like the folks in the comments above suggested, but you will need to join the result to produce a single string at the end.