collect data from channel while waiting for command to complete its execution in golang

I am starting and a command execution which triggers a service which sends results on a channel (resChan), now i have to collect the results that i receive on this channel while command is executing, i don't have the len of how much data objects will arrive on resChan.

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

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

//start command
cmd.start()

//here if length of resChan is known it works else it keeps waiting for resChan
for {
  result <- resChan
  //do some operation on result
}

//wait for command
cmd.wait()

return result;

<!-- end snippet -->

Also the resChan is not closed, there is only way to stop data collection that is when command execution stops.

If I understood correctly you could listen to the results concurrently and collect them for later use, something like (Playground):

func main() {
	cmd := &command{
		ResChan: make(chan int),
		done:    make(chan struct{}),
	}
	collector := &collector{
        // We use the command's channel to get the values
		ch:   cmd.ResChan,
		done: make(chan struct{}),
	}

	collector.collect()
	cmd.start()
	cmd.wait()
	collector.stop()
	fmt.Println(collector.Results)
}

type collector struct {
	ch      chan int
	Results []int
	done    chan struct{}
}

func (c *collector) collect() {
	go func() {
		for {
			// The select will block until either of the channels receives a value
			// it will always execute one case at the time (sequential execution).
			// That's why we don't need to lock the slice to modify it
			select {
			case v := <-c.ch:
				c.Results = append(c.Results, v)
			case <-c.done:
				return
			}
		}
	}()
}

func (c *collector) stop() {
	// Send a signal into the channel to stop the collection of results
	c.done <- struct{}{}
}

type command struct {
	ResChan chan int
	done    chan struct{}
}

func (c *command) start() {
	go func() {
		// The command gets the results and sends them 
        // into the channel to be consumed by the user
		for i := 0; i < 10; i++ {
			c.ResChan <- i
		}
		// Other executions take place and once they 
        // finish we send the signal to the wait command
		time.Sleep(time.Second)
		c.done <- struct{}{}
	}()
}

func (c *command) wait() {
	// Blocks until something is sent to the done channel
	<-c.done
}

collector.collect() and cmd.start() will be executing concurrently and sharing values by communicating through the ResChan channel. You don't need to know the results length.

if you want chan can be done by time tick
just like :

type msg struct {
}

func main() {
	// time tick : 10s
	t := time.NewTicker(time.Duration(5) * time.Second)
	ch := make(chan msg)
	select {
	case <-ch:
		// do something you want
	case <-t.C:
		// done
		fmt.Println(" have done by tick")
	}
	fmt.Println("end")
}

or if you want to have another channel to close

	ch := make(chan msg)
	doneCh := make(chan done)
	for {
		select {
		case <-ch:
			// do something you want
		case <-doneCh:
			// done
			fmt.Println(" have done by another channel")
			break
		}
	}
	fmt.Println("end")

or this

type msg struct {
	Done bool
	// and another msg you want
}

	ch := make(chan msg)
	for {
		msg := <-ch
		if msg.Done {
			break
		}
	}
	fmt.Println("end")

my English is not good, so I may have mistake for understandings or descriptions ：）

try this

	//start command
cmd.start()
//here if length of resChan is known it works else it keeps waiting for resChan
for {
select {
case result :=<- resChan
//your op here
}
}
//wait for command
cmd.wait()
return result;