Comment puis-je sortir d'une boucle For dans Go à partir d'une fonction externe ?

Casser une exécution de boucle For depuis l'extérieur : une solution de programmation Go

En programmation, il est souvent nécessaire d'avoir le contrôle sur le flux d'exécution , notamment lors de la gestion des boucles. En Go, on peut rencontrer des situations où une boucle for infinie doit être terminée à partir d'une source externe. Cet article aborde ce scénario spécifique en fournissant une solution complète.

Description du problème :

Considérons une boucle for infinie avec une étiquette, s'exécutant simultanément avec une fonction planifiée. L'objectif est de rompre la boucle lorsqu'une condition spécifique est remplie depuis la fonction planifiée. Vous trouverez ci-dessous un exemple d'une telle tentative, qui échoue en raison de limitations de portée :

<code class="go">package main

import (
  "fmt"
  "sync"
  "time"
)

func main() {
  count := 0
  var wg sync.WaitGroup
  wg.Add(1)
  t := time.NewTicker(time.Second * 1)

  go func() {
    for {
      fmt.Println("I will print every second", count)
      count++
      if count > 5 {
        break myLoop; // Issue due to scope error: 'myLoop' not visible
        wg.Done()
      }
      <-t.C
    }
  }()

  i := 1

  myLoop:
  for {
    fmt.Println("iteration", i)
    i++
  }

  wg.Wait()
  fmt.Println("I will execute at the end")
}

Solution :

Pour obtenir cette fonctionnalité souhaitée, nous utilisons un canal de signalisation . Voici une présentation étape par étape :

1. Créer un canal de signalisation :

Nous créons un canal de signalisation quit de type chan struct{}. Ce canal agit comme un signal indiquant le moment où la boucle doit se terminer.

<code class="go">quit := make(chan struct{})

2. Fermez le canal pour rompre le signal :

Lorsque la condition est remplie dans le cadre de la fonction programmée, nous fermons le canal de signalisation. Cela indique que la boucle for devrait se rompre.

<code class="go">go func() {
    for {
        fmt.Println("I will print every second", count)
        count++
        if count > 5 {
          close(quit)
          wg.Done()
          return
        }
        <-t.C
    }  
  }()</code>

3. Vérifiez la fermeture du canal pour briser la boucle :

Dans la boucle for, nous lisons le canal de signalisation à l'aide d'une instruction select. Lorsque le canal est fermé (signalant une rupture), l'exécution passe au bloc case <-quit:, rompant la boucle. Sinon, le cas par défaut exécute les itérations normalement.

<code class="go">myLoop:
  for {
    select {
    case <-quit:
      break myLoop
    default:
      fmt.Println("iteration", i)
      i++
    }
  }</code>

Cette solution nous permet effectivement de contrôler l'exécution d'une boucle depuis l'extérieur de son propre périmètre, permettant de terminer la boucle quand on le souhaite sans se soucier de limitations de la portée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!