Why ws.outQueue is need to check if the Channel is closed?

[AndrewYEEE]

Sorry I dont understand why ws.outQueue is need to check that Channel is closed ?
This will cause writePump closed but server.connections still retains the ws object (ws.connection still work).

And
Why doesn't ws.pingMessage need to check if the Channel closed unexpectedly?

func (server *Server) writePump(ws *WebSocket) {
   conn := ws.connection

   for {
   	select {
   	case data, ok := <-ws.outQueue:
   		_ = conn.SetWriteDeadline(time.Now().Add(server.timeoutConfig.WriteWait))
   		if !ok {
   			// Unexpected closed queue, should never happen
   			server.error(fmt.Errorf("output queue for socket %v was closed, forcefully closing", ws.id))
   			// Don't invoke cleanup


   			return      **//<===== will exit writePump(), but server.connections still retains the WS object  !!!**
   		}
   		// Send data
   		err := conn.WriteMessage(websocket.TextMessage, data)
   		if err != nil {
   			server.error(fmt.Errorf("write failed for %s: %w", ws.ID(), err))
   			// Invoking cleanup, as socket was forcefully closed
   			server.cleanupConnection(ws)
   			return
   		}
   		log.Debugf("written %d bytes to %s", len(data), ws.ID())
   	case ping := <-ws.pingMessage:

                      **// why don't need check channel closed unexpectedly?**

   		_ = conn.SetWriteDeadline(time.Now().Add(server.timeoutConfig.WriteWait))
   		err := conn.WriteMessage(websocket.PongMessage, ping)
   		if err != nil {
   			server.error(fmt.Errorf("write failed for %s: %w", ws.ID(), err))
   			// Invoking cleanup, as socket was forcefully closed
   			server.cleanupConnection(ws)
   			return
   		}
   		log.Debugf("pong sent to %s", ws.ID())
   		...

[AndrewYEEE]

I have the idea to remove ws object, but I couldn't prove whether the ws object obtained by server.connections[] is the same as the one to be removed.

func (server *Server) writePump(ws *WebSocket) {
   conn := ws.connection
   for {
   	select {
   	      case data, ok := <-ws.outQueue:


                    if !ok {
	                    // Unexpected closed queue, should never happen
	                    server.error(fmt.Errorf("output queue for socket %v was closed, forcefully closing", ws.id))
	                    // Don't invoke cleanup
	                    
	                    //delete chargepoint ws
	                    server.connMutex.Lock()
	                    if _, ok := server.connections[ws.id]; ok {
		                    delete(server.connections, ws.id)                   // is same?
		                    log.Infof("closed connection to %s", ws.ID())
		                    if server.disconnectedHandler != nil {
			                    server.disconnectedHandler(ws) 
		                    }
                            }
	                    server.connMutex.Unlock()
	                    
	                    return
                    }