Copy the original array. Generate a random number n between 1 and the length of the copy, then loop n times to get a random index from the copied array n times. That's where you get your "name" values. Make sure you splice the copied array each time to avoid duplicates:

Update:

I added a line to make a copy of the original array with Array.slice() before executing the rest of the code:

let array1 = ["mike", "ted","bill","mark"];
let arrCopy = array1.slice()

let ranIdx
let resArr = []
let ranLen = Math.floor(Math.random() * arrCopy.length) + 1

for(i=0; i < ranLen; i++){
   ranIdx = Math.floor(Math.random() * arrCopy.length)
   resArr.push(arrCopy.splice(ranIdx,1)[0])  
}

console.log(resArr)

Maybe like This:

  let array1 = ["mike", "ted","bill","mark"];

  function get_random_in_range(_min, _max) {
     _min = Math.ceil(_min);
     _max = Math.floor(_max);
    return Math.floor(Math.random() * (_max - _min + 1)) + _min;
  }

  function get_randoms(_arr){
  	var out = [];
  	var count_of_rnd_out = get_random_in_range(0, _arr.length-1);
  	for (var i = 0; i < count_of_rnd_out+1; i++) {
  		var rnd_el_index = get_random_in_range(0, _arr.length-1);
  		var rnd_el = _arr[rnd_el_index];
  		while(out.indexOf(rnd_el) >= 0) {    /* for exclude duplicates */
  		  rnd_el_index = get_random_in_range(0, _arr.length-1);
  		  rnd_el = _arr[rnd_el_index];
  	    }
  		out.push(rnd_el);
  	}
  	return out;
  }

  console.log(get_randoms(array1));

Perhaps this package could be useful

By using this code

cmb = Combinatorics.power(['a','b','c']);

It will generate all the combinations of the array. Then you could generate a number that is between 0 and the length of the array (inclusive) to select your random output.

I would write this atop a function that partially shuffles an array, returning a randomized choice of the first n elements from it. Furthermore, I would randomly choose the number of elements to pick. We could do it with boundaries ("pick from 1 to 3 elements from the list") or without ("pick from 1 to list.length elements").

Both of those options are shown here, with anyRandomSubset built atop randomSubset, which takes the boundaries. We could easily skip the intermediary if the boundaries are not needed.

Here is an implementation of this:

const {random, floor} = Math

const excluding = (i) => (xs) => 
  [... xs .slice (0, i), ... xs .slice (i + 1)]

const partialShuffle = (n) => (xs, i = floor(random () * xs .length)) =>
  n <= 0 || n > xs .length || xs .length == 0
    ? []
    : [xs[i], ... partialShuffle (n - 1) (excluding (i) (xs))]

const randomSubset = (lo, hi) => (xs) =>
  partialShuffle (floor (random () * (hi - lo + 1) + lo)) (xs)

const anyRandomSubset = (xs) => 
  randomSubset (1, xs .length) (xs)

for (var i = 0; i < 20; i++) {
  console .log (anyRandomSubset (["mike", "ted","bill","mark"]))
}

.as-console-wrapper {min-height: 100% !important; top: 0}

The partialShuffle is a variant of this complete shuffle function:

const shuffle = (xs, i = floor(random () * xs.length)) =>
  xs.length == 0
    ? []
    : [xs[i], ... shuffle (excluding (i) (xs))]

This is a recursive formulation of the most common true shuffle of an array, the Fisher-Yates algorithm. This recursive version would run into recursion-depth problems if we used it for a long array (or for a large n in our partial version above.) But it's probably fine for smallish arrays.

Note that partialShuffle and its helper function excluding are both useful utility functions. Only randomSubset and anyRandomSubset are specific to this problem.