// encode the tags
    tags := encodeMetadata(node.Metadata)
    tags = append(tags, encodeEndpoints(s.Endpoints)...)
    tags = append(tags, encodeVersion(s.Version)...)

    var regTCPCheck bool
    var regInterval time.Duration


    var options registry.RegisterOptions
    for _, o := range opts {
        o(&options)
    }
    
    // 如果 consul 组件上下文不为空且包含 consul_tcp_check 配置，则设置通过 TCP 进行健康检查
    if c.opts.Context != nil {
        if tcpCheckInterval, ok := c.opts.Context.Value("consul_tcp_check").(time.Duration); ok {
                regTCPCheck = true
                regInterval = tcpCheckInterval
        }
    }


    ...


    // 如果服务已经注册并匹配到则对其进行健康检查，如果通过则不再重新注册服务节点信息
    if ok && v == h {
        // 如果 options.TTL = 0
        if options.TTL == time.Duration(0) {
            // 确保服务节点没有被 Consul 删除
            if time.Since(lastChecked) <= getDeregisterTTL(regInterval) {
                return nil
            }
            // 检查服务节点是否健康，如果健康并且与传入 node.id 相匹配则表示不需要进行注册
            services, _, err := c.Client.Health().Checks(s.Name, c.queryOptions)
            if err == nil {
                for _, v := range services {
                    if v.ServiceID == node.Id {
                        return nil
                    }
                }
            }
        } else {
            // 如果 options.TTL > 0，则调用 Consul 代理 API 更新健康检查 TTL，
            // 调用成功则不再注册服务节点，不成功则不能确保服务状态，故而重新注册
            if err := c.Client.Agent().PassTTL("service:"+node.Id, ""); err == nil {
                return nil
            }
        }
    }


    ...


    var check *consul.AgentServiceCheck


    if regTCPCheck {
        // 如果是通过 TCP 进行健康检查，则通过 regInterval 设置 TTL
        deregTTL := getDeregisterTTL(regInterval)
        // 然后初始化健康检查接口数据
        check = &consul.AgentServiceCheck{
            TCP:                            fmt.Sprintf("%s:%d", node.Address, node.Port),
            Interval:                       fmt.Sprintf("%v", regInterval),
            DeregisterCriticalServiceAfter: fmt.Sprintf("%v", deregTTL),
        }
    } else if options.TTL > time.Duration(0) {
        // 如果 options.TTL 大于0，则通过 TTL 进行健康检查，通过该值设置 TTL
        deregTTL := getDeregisterTTL(options.TTL)
        // 然后初始化健康检查接口数据
        check = &consul.AgentServiceCheck{
            TTL:                            fmt.Sprintf("%v", options.TTL),
            DeregisterCriticalServiceAfter: fmt.Sprintf("%v", deregTTL),
        }
    }


    ...


    // 如果 TTL = 0，直接返回
    if options.TTL == time.Duration(0) {
        return nil
    }


    // 如果 TTL > 0，则服务注册后重新设置 TTL
    return c.Client.Agent().PassTTL("service:"+node.Id, "")

    func (c *consulRegistry) Deregister(s *registry.Service) error {
        if len(s.Nodes) == 0 {
                return errors.New("Require at least one node")
        }
            
        // delete our hash and time check of the service
        c.Lock()
        delete(c.register, s.Name)
        delete(c.lastChecked, s.Name)
        c.Unlock()
            
        node := s.Nodes[0]
        return c.Client.Agent().ServiceDeregister(node.Id)
    }

    // ServiceDeregister is used to deregister a service with
    // the local agent
    func (a *Agent) ServiceDeregister(serviceID string) error {
        r := a.c.newRequest("PUT", "/v1/agent/service/deregister/"+serviceID)
        _, resp, err := requireOK(a.c.doRequest(r))
        if err != nil {
               return err
        }
        resp.Body.Close()
        return nil
    }