Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

я хочу в cobra golang сделать требование: (у меня 4 флага a b c d) обязан быть задан: a…

  1. User

    я хочу в cobra golang сделать требование: (у меня 4 флага a b c d) обязан быть задан: a или хотя бы один из b c d, как это сделать

  2. Assistant

    Для реализации такого требования в библиотеке Cobra на Go, вам нужно будет написать кастомную проверку для флагов после их обхода. Ваша логика будет заключаться в том, чтобы проверить, задан ли флаг a, или хотя бы один из флагов b, c или d.

    Вот пример кода, который показывает, как это сделать:

    package main
    
    import (
    	"fmt"
    	"os"
    
    	"github.com/spf13/cobra"
    )
    
    func main() {
    	var a bool
    	var b bool
    	var c bool
    	var d bool
    
    	var rootCmd = &cobra.Command{
    		Use:   "myapp",
    		Short: "My application does something",
    		RunE: func(cmd *cobra.Command, args []string) error {
    			if !a && !b && !c && !d {
    				return fmt.Errorf("flag -a must be set or at least one of -b, -c, -d must be set")
    			}
    			return nil
    		},
    	}
    
    	rootCmd.Flags().BoolVarP(&a, "a", "A", false, "Flag A")
    	rootCmd.Flags().BoolVarP(&b, "b", "B", false, "Flag B")
    	rootCmd.Flags().BoolVarP(&c, "c", "C", false, "Flag C")
    	rootCmd.Flags().BoolVarP(&d, "d", "D", false, "Flag D")
    
    	if err := rootCmd.Execute(); err != nil {
    		fmt.Println(err)
    		os.Exit(1)
    	}
    }
    

    Объяснение кода:

    1. Мы задаем четыре флага: a, b, c, и d.
    2. В RunE функции, которая выполняется при запуске команды, мы проверяем условия:
      • Если a не установлен (!a), и все b, c, d также не установлены (!b, !c, !d), тогда возвращаем ошибку.
    3. Если условие не выполняется, просто возвращаем nil, и программа завершится успешно.

    Вы можете запустить этот код и проверить его работу, указывая различные комбинации флагов при запуске.

  3. User

    нет, сделай это через MarkRequired

  4. Assistant

    В библиотеке Cobra у вас нет возможности использовать MarkRequired для сложных условий, таких как "а или хотя бы один из b, c, d". Однако вы можете использовать MarkRequired в сочетании с кастомной логикой для проверки флагов после вызова Execute.

    Вот пример, как добиться этого с использованием MarkRequired и некоторой логики в RunE:

    package main
    
    import (
    	"fmt"
    	"os"
    
    	"github.com/spf13/cobra"
    )
    
    func main() {
    	var a bool
    	var b bool
    	var c bool
    	var d bool
    
    	var rootCmd = &cobra.Command{
    		Use:   "myapp",
    		Short: "My application does something",
    		RunE: func(cmd *cobra.Command, args []string) error {
    			if !a && !b && !c && !d {
    				return fmt.Errorf("flag -a must be set or at least one of -b, -c, -d must be set")
    			}
    			return nil
    		},
    	}
    
    	// Определяем флаги
    	rootCmd.Flags().BoolVarP(&a, "a", "A", false, "Flag A")
    	rootCmd.Flags().BoolVarP(&b, "b", "B", false, "Flag B")
    	rootCmd.Flags().BoolVarP(&c, "c", "C", false, "Flag C")
    	rootCmd.Flags().BoolVarP(&d, "d", "D", false, "Flag D")
    
    	// Отметим флаг -a как обязательный
    	if err := rootCmd.MarkFlagRequired("a"); err != nil {
    		fmt.Println(err)
    		os.Exit(1)
    	}
    
    	if err := rootCmd.Execute(); err != nil {
    		fmt.Println(err)
    		os.Exit(1)
    	}
    }
    

    В приведённом выше примере MarkFlagRequired используется для обозначения флага -a как обязательного. Однако, для удовлетворения вашего условия "или хотя бы один из b, c, d" вам всё равно нужно будет добавить пользовательскую проверку в RunE.

    Если необходимо требовать, чтобы либо флаг -a был установлен, либо хотя бы один из -b, -c или -d, вы не сможете сделать это, используя MarkRequired, так как MarkRequired работает только для одного флага. Поэтому необходимо выполнять логику проверки в RunE, как показано в предыдущем ответе.

  5. User

    теперь у меня есть только 2 флага, a и b, как мне указать что один из них должен быть указан через markrequired

  6. Assistant

    Выглядит так, что вы хотите заставить пользователя указать хотя бы один из двух флагов (a или b) при помощи MarkFlagRequired. Однако, в Cobra, как и в большинстве библиотек командной строки, MarkFlagRequired можно использовать только для каждого отдельного флага, и что-нибудь вроде "укажите хотя бы один из двух" напрямую не поддерживается.

    Но вы можете сделать это, добавив логику проверки в RunE, как и в предыдущих примерах. Однако, если вы все же хотите указать, какие флаги являются обязательными с помощью MarkRequired для каждого флага, вы можете сделать следующее:

    package main
    
    import (
    	"fmt"
    	"os"
    
    	"github.com/spf13/cobra"
    )
    
    func main() {
    	var a bool
    	var b bool
    
    	var rootCmd = &cobra.Command{
    		Use:   "myapp",
    		Short: "My application does something",
    		RunE: func(cmd *cobra.Command, args []string) error {
    			if !a && !b {
    				return fmt.Errorf("either flag -a or -b must be set")
    			}
    			return nil
    		},
    	}
    
    	// Определяем флаги
    	rootCmd.Flags().BoolVarP(&a, "a", "A", false, "Flag A")
    	rootCmd.Flags().BoolVarP(&b, "b", "B", false, "Flag B")
    
    	// Поскольку флажков должно быть как минимум 1, мы не можем сделать их оба обязательными
    	// Вместо этого просто используем логику проверки в RunE
    	if err := rootCmd.MarkFlagRequired("a"); err != nil {
    		fmt.Println(err)
    		os.Exit(1)
    	}
    	if err := rootCmd.MarkFlagRequired("b"); err != nil {
    		fmt.Println(err)
    		os.Exit(1)
    	}
    
    	if err := rootCmd.Execute(); err != nil {
    		fmt.Println(err)
    		os.Exit(1)
    	}
    }
    

    Пояснения:

    1. Логика проверки: В RunE функции поместите условие, которое проверяет, установлен ли хотя бы один из флагов a или b.
    2. Использование MarkRequired: Вы можете использовать MarkRequired, но это не будет работать так, как вы ожидаете, поскольку если a будет обязательным, то вам придется передавать его всегда.

    Таким образом, за счет логики внутри RunE, вы осуществляете контроль за вводом, чтобы убедиться, что хотя бы один из двух флагов указан.

    Этот подход является наиболее практичным способом решения вашей задачи в текущей архитектуре Cobra.

  7. User

    а как же MarkFlagsOneRequired

  8. Assistant

    В библиотеке Cobra, начиная с версии 1.2.0, действительно появилась функция MarkFlagsOneRequired, которая позволяет вам легко указать, что хотя бы один из нескольких флагов должен быть указан. Это позволяет избежать необходимости ручной проверки в функции RunE и делает ваш код более чистым.

    Вот пример, как использовать MarkFlagsOneRequired для вашего случая с флагами a и b:

    package main
    
    import (
    	"fmt"
    	"os"
    
    	"github.com/spf13/cobra"
    )
    
    func main() {
    	var a bool
    	var b bool
    
    	var rootCmd = &cobra.Command{
    		Use:   "myapp",
    		Short: "My application does something",
    		Run: func(cmd *cobra.Command, args []string) {
    			fmt.Println("Running with flags:")
    			fmt.Printf("a: %v, b: %v\n", a, b)
    		},
    	}
    
    	// Определяем флаги
    	rootCmd.Flags().BoolVarP(&a, "a", "A", false, "Flag A")
    	rootCmd.Flags().BoolVarP(&b, "b", "B", false, "Flag B")
    
    	// Указываем, что должен быть обязательным хотя бы один флаг из a или b
    	if err := rootCmd.MarkFlagsOneRequired("a", "b"); err != nil {
    		fmt.Println(err)
    		os.Exit(1)
    	}
    
    	if err := rootCmd.Execute(); err != nil {
    		fmt.Println(err)
    		os.Exit(1)
    	}
    }
    

    Объяснение кода:

    • Используется rootCmd.Flags().BoolVarP для добавления флагов a и b.
    • Функция MarkFlagsOneRequired принимает список флагов и требует, чтобы хотя бы один из них был установлен при запуске.

    Теперь, если вы запустите вашу программу без указания хотя бы одного из флагов -a или -b, Cobra автоматически выведет сообщение об ошибке, информируя о том, что необходимо указать один из этих флагов.

  9. User

    а если теперь флаг a персистентный, а b нет

  10. Assistant

    Если вы хотите сделать флаг a персистентным, а флаг b — нет, вы можете использовать метод PersistentFlags() на вашей команде. Персистентные флаги будут доступны для данной команды и всех её подкоманд.

    Вот, как это можно сделать:

    package main
    
    import (
    	"fmt"
    	"os"
    
    	"github.com/spf13/cobra"
    )
    
    func main() {
    	var a bool
    	var b bool
    
    	var rootCmd = &cobra.Command{
    		Use:   "myapp",
    		Short: "My application does something",
    		Run: func(cmd *cobra.Command, args []string) {
    			fmt.Println("Running with flags:")
    			fmt.Printf("a: %v, b: %v\n", a, b)
    		},
    	}
    
    	// Определяем флаги
    	rootCmd.PersistentFlags().BoolVarP(&a, "a", "A", false, "Persistent Flag A")
    	rootCmd.Flags().BoolVarP(&b, "b", "B", false, "Flag B")
    
    	// Указываем, что должен быть обязательным хотя бы один флаг из a или b
    	if err := rootCmd.MarkFlagsOneRequired("a", "b"); err != nil {
    		fmt.Println(err)
    		os.Exit(1)
    	}
    
    	if err := rootCmd.Execute(); err != nil {
    		fmt.Println(err)
    		os.Exit(1)
    	}
    }
    

    Объяснение:

    1. Персистентные флаги: Флаг a определяется с использованием PersistentFlags(), что делает его доступным для данной команды и всех подкоманд. Флаг b определяется с использованием Flags(), что делает его доступным только для этой команды.
    2. Обязательность флагов: Используя MarkFlagsOneRequired, вы указываете, что хотя бы один из флагов a или b должен быть указан при запуске вашей команды.

    Важно:

    • Так как флаг a является персистентным, если вы его укажете на родительской команде, он будет доступен для всех подкоманд, которые наследуют его.
    • Если необходимо, чтобы b был не персистентным и присутствовал только в данной команде, всё сделано правильно.

    Теперь, когда вы запускаете вашу программу, если вы укажете флаг -A (персистентный) на других подкомандах, он будет там доступен. А флаг -B будет доступен только на уровне текущей команды.

  11. User

    флаг а персистентный и указывается в root cmd

    а флаг б обычный указывается в дочерней команде

    команды описаны в разных файлах.

    я запускаю такой код и ловлю ошибку:

    func init() { Cmd.Flags().StringVar(&externalID, "externalId", "", "ID объекта в системе услуги") Cmd.Flags().Int64Var(&serviceID, "serviceId", 0, "ID сервиса из которого идет событие") Cmd.Flags().Int64Var(&userID, "userId", 0, "ID пользователя") Cmd.MarkFlagsOneRequired("direct", "externalId", "serviceId", "userId") }

    panic: Failed to find flag "direct" and mark it as being in a one-required flag group

    флаг direct указан в другом файле: rootCmd.PersistentFlags().StringVarP(&directInput, "direct", "d", "", "Ввод сообщения с помощью JSON")

  12. Assistant

    Ваше описание проблемы указывает на то, что вы пытаетесь пометить флаг direct, который был определен на уровне корневой команды (rootCmd) как обязательный для дочерней команды, где он не доступен. Флаги, добавленные с использованием PersistentFlags(), не могут быть доступны в дочерних командах напрямую через их имя, поскольку MarkFlagsOneRequired ищет флаги только в контексте ситуации, в которой они были определены.

    Для решения этой проблемы вам нужно использовать PersistentFlags() в дочерней команде, чтобы пометить флаг direct как необходимый. Либо же, в дочерней команде, в init() функцию, где вы хотите использовать MarkFlagsOneRequired, необходимо проверять наличие флага direct через Root().PersistentFlags(), однако это не лучший подход, так как он делает код менее читабельным.

    Вместо этого, вот как можно организовать ваш код для правильного использования:

    Пример

    В файле с rootCmd

    package main
    
    import (
    	"fmt"
    
    	"github.com/spf13/cobra"
    )
    
    var directInput string
    
    var rootCmd = &cobra.Command{
    	Use:   "myapp",
    	Short: "My application does something",
    	Run: func(cmd *cobra.Command, args []string) {
    		fmt.Println("Root command executed.")
    	},
    }
    
    func init() {
    	rootCmd.PersistentFlags().StringVarP(&directInput, "direct", "d", "", "Ввод сообщения с помощью JSON")
    
    	// Здесь вы можете пометить флаги как необходимые для корневой команды, если это нужно
    }
    
    func main() {
    	if err := rootCmd.Execute(); err != nil {
    		fmt.Println(err)
    	}
    }
    

    В файле с дочерней командой

    package main
    
    import (
    	"fmt"
    	"github.com/spf13/cobra"
    )
    
    // Определение дочерней команды
    var Cmd = &cobra.Command{
    	Use:   "child",
    	Short: "Child command that requires flags",
    	Run: func(cmd *cobra.Command, args []string) {
    		fmt.Println("Child command executed.")
    	},
    }
    
    var externalID string
    var serviceID int64
    var userID int64
    
    func init() {
    	Cmd.Flags().StringVar(&externalID, "externalId", "", "ID объекта в системе услуги")
    	Cmd.Flags().Int64Var(&serviceID, "serviceId", 0, "ID сервиса из которого идет событие")
    	Cmd.Flags().Int64Var(&userID, "userId", 0, "ID пользователя")
    
    	// Теперь используем MarkFlagsOneRequired с флагами из дочерней команды
    	if err := Cmd.MarkFlagsOneRequired("externalId", "serviceId", "userId"); err != nil {
    		fmt.Println(err)
    	}
    }
    
    func init() {
    	rootCmd.AddCommand(Cmd)
    }
    

    Объяснения:

    1. Персистентные флаги: Вы определили флаг direct как персистентный в rootCmd. Теперь он доступен во всех дочерних командах.
    2. Дочерняя команда: В дочерней команде вы определяете свои собственные флаги и помечаете их как необходимые с помощью MarkFlagsOneRequired, но не пытайтесь ссылаться на флаг direct, так как он не является частью этой команды.
    3. Корректная инициализация команды: Убедитесь, что дочерняя команда добавляется к корневой с помощью rootCmd.AddCommand(Cmd).

    Таким образом, когда вы запускаете команду, она будет проверять наличие указанных флагов для дочерней команды и не потеряете доступ к флагу direct в дочерних командах, так как он будет доступен через корневую команду.

  13. User

    мне нужно сделать так, что если указан флаг direct, дочерние флаги уакзываться не могут

  14. Assistant

    Чтобы реализовать зависимость между флагами (в этом случае — чтобы флаг direct блокировал использование дочерних флагов), можно использовать пользовательскую проверку внутри функции RunE или Run. Вы можете проверять, установлен ли флаг direct, и в зависимости от этого разрешать или запрещать использование других флагов.

    Пример реализации

    Вот как это можно сделать:

    В файле с rootCmd

    package main
    
    import (
    	"fmt"
    	"github.com/spf13/cobra"
    )
    
    var directInput string
    
    var rootCmd = &cobra.Command{
    	Use:   "myapp",
    	Short: "My application does something",
    }
    
    func init() {
    	rootCmd.PersistentFlags().StringVarP(&directInput, "direct", "d", "", "Ввод сообщения с помощью JSON")
    }
    
    func main() {
    	if err := rootCmd.Execute(); err != nil {
    		fmt.Println(err)
    	}
    }
    

    В файле с дочерней командой

    package main
    
    import (
    	"fmt"
    	"github.com/spf13/cobra"
    )
    
    // Определение дочерней команды
    var Cmd = &cobra.Command{
    	Use:   "child",
    	Short: "Child command that requires flags",
    	Run: func(cmd *cobra.Command, args []string) {
    		// Проверка флага "direct"
    		if cmd.Root().PersistentFlags().Changed("direct") {
    			fmt.Println("Error: The --direct flag cannot be used with child flags.")
    			return
    		}
    
    		// Если все проверки пройдены, выполнить логику дочерней команды
    		fmt.Println("Child command executed.")
    	},
    }
    
    var externalID string
    var serviceID int64
    var userID int64
    
    func init() {
    	Cmd.Flags().StringVar(&externalID, "externalId", "", "ID объекта в системе услуги")
    	Cmd.Flags().Int64Var(&serviceID, "serviceId", 0, "ID сервиса из которого идет событие")
    	Cmd.Flags().Int64Var(&userID, "userId", 0, "ID пользователя")
    
    	// Пометим обязательные флаги для дочерней команды
    	if err := Cmd.MarkFlagsRequired("externalId", "serviceId", "userId"); err != nil {
    		fmt.Println(err)
    	}
    
    	rootCmd.AddCommand(Cmd)
    }
    

    Объяснение кода:

    1. Проверка флага: В функции Run дочерней команды вы проверяете, был ли установлен флаг direct, используя cmd.Root().PersistentFlags().Changed("direct"). Это позволяет вам узнать, установлен ли этот персистентный флаг. Если установлен, печатается сообщение об ошибке и выполнение дочерней команды останавливается.

    2. Пометка обязательных флагов: Обратите внимание, что пометка флагов как обязательных может остаться, и вы можете добавить дополнительные проверки, чтобы удостовериться, что при использовании дочерней команды либо используются обязательные флаги, либо флаг direct установлен (но в таком случае его использовать нельзя).

    Теперь вы можете управлять тем, когда можно использовать флаги в дочерней команде, в зависимости от наличия флага direct.

  15. User

    а как сделать условие: Если указан глобальный флаг, локальные флаги указаны быть не могут?

  16. Assistant

    Чтобы реализовать логику, в которой если задан глобальный флаг, локальные флаги не могут быть указаны, вы можете использовать механизм проверки в функции Run или RunE дочерней команды. При этом вам нужно будет проверять, установлен ли глобальный флаг, и если он установлен, то проверять, заданы ли любые локальные флаги. Если это так, вы можете вернуть сообщение об ошибке.

    Вот пример, как это можно сделать:

    Пример реализации

    В файле с rootCmd

    package main
    
    import (
    	"fmt"
    	"github.com/spf13/cobra"
    )
    
    var directInput string
    
    var rootCmd = &cobra.Command{
    	Use:   "myapp",
    	Short: "My application does something",
    }
    
    func init() {
    	rootCmd.PersistentFlags().StringVarP(&directInput, "direct", "d", "", "Ввод сообщения с помощью JSON")
    }
    
    func main() {
    	if err := rootCmd.Execute(); err != nil {
    		fmt.Println(err)
    	}
    }
    

    В файле с дочерней командой

    package main
    
    import (
    	"fmt"
    	"github.com/spf13/cobra"
    )
    
    // Определение дочерней команды
    var Cmd = &cobra.Command{
    	Use:   "child",
    	Short: "Child command that requires flags",
    	Run: func(cmd *cobra.Command, args []string) {
    		// Проверяем, установлен ли глобальный флаг "direct"
    		if cmd.Root().PersistentFlags().Changed("direct") {
    			// Проверяем локальные флаги
    			if cmd.Flags().Changed("externalId") || cmd.Flags().Changed("serviceId") || cmd.Flags().Changed("userId") {
    				fmt.Println("Error: The --direct flag cannot be used with child flags.")
    				return
    			}
    		}
    
    		// Исполняем логику дочерней команды
    		fmt.Println("Child command executed.")
    	},
    }
    
    var externalID string
    var serviceID int64
    var userID int64
    
    func init() {
    	Cmd.Flags().StringVar(&externalID, "externalId", "", "ID объекта в системе услуги")
    	Cmd.Flags().Int64Var(&serviceID, "serviceId", 0, "ID сервиса из которого идет событие")
    	Cmd.Flags().Int64Var(&userID, "userId", 0, "ID пользователя")
    
    	// Пометим обязательные флаги для дочерней команды, если нужно
    	if err := Cmd.MarkFlagsRequired("externalId", "serviceId", "userId"); err != nil {
    		fmt.Println(err)
    	}
    
    	rootCmd.AddCommand(Cmd)
    }
    

    Объяснение кода:

    1. Проверка глобального флага: В функции Run дочерней команды вы проверяете, установлен ли глобальный флаг direct, с помощью cmd.Root().PersistentFlags().Changed("direct").

    2. Проверка локальных флагов: Если глобальный флаг установлен, вы потом проверяете, заданы ли локальные флаги, используя cmd.Flags().Changed(...). Если один из локальных флагов установлен, выводится сообщение об ошибке.

    3. Обработка логики команды: Если всё в порядке, вы можете продолжить выполнение логики дочерней команды.

    Таким образом, ваша программа будет корректно реагировать на использование флагов, обеспечивая, что если глобальный флаг --direct установлен, локальные флаги не должны быть указаны.

  17. User

    можно ли сделать это удобнее ?

    cmd.MarkFlagsOneRequired("direct", "externalId", "serviceId", "userId") cmd.MarkFlagsMutuallyExclusive("direct", "externalId") cmd.MarkFlagsMutuallyExclusive("direct", "serviceId") cmd.MarkFlagsMutuallyExclusive("direct", "userId")

  18. Assistant

    Да, вместо использования нескольких вызовов MarkFlagsMutuallyExclusive, вы можете использовать один вызов MarkFlagsOneRequired вместе с MarkFlagsMutuallyExclusive, чтобы задать их в одной группе. Однако Cobra не поддерживает множественные группы взаимного исключения напрямую с помощью одного вызова, поэтому вам все равно потребуется несколько вызовов, если вы хотите сделать это более удобно и читаемо.

    Тем не менее, у вас есть варианты, чтобы упростить код, например, выделить логику взаимного исключения в функцию или использовать массив для группировки флагов. Вот как это можно сделать:

    Вариант с помощью функции для коллективной проверки

    Вы можете написать вспомогательную функцию для группировки логики:

    package main
    
    import (
    	"fmt"
    	"github.com/spf13/cobra"
    )
    
    var directInput string
    
    var rootCmd = &cobra.Command{
    	Use:   "myapp",
    	Short: "My application does something",
    }
    
    func init() {
    	rootCmd.PersistentFlags().StringVarP(&directInput, "direct", "d", "", "Ввод сообщения с помощью JSON")
    }
    
    func main() {
    	if err := rootCmd.Execute(); err != nil {
    		fmt.Println(err)
    	}
    }
    
    var Cmd = &cobra.Command{
    	Use:   "child",
    	Short: "Child command with flag conditions",
    	Run: func(cmd *cobra.Command, args []string) {
    		// Здесь вы можете прочитать флаги и выполнять нужные проверки
    		if cmd.Root().PersistentFlags().Changed("direct") {
    			// Если установлен флаг direct, локальные флаги не могут быть установлены
    			if cmd.Flags().Changed("externalId") || cmd.Flags().Changed("serviceId") || cmd.Flags().Changed("userId") {
    				fmt.Println("Error: --direct flag cannot be used with local flags.")
    				return
    			}
    		}
    
    		fmt.Println("Child command executed with valid flags.")
    	},
    }
    
    var externalID string
    var serviceID int64
    var userID int64
    
    func init() {
    	Cmd.Flags().StringVar(&externalID, "externalId", "", "ID объекта в системе услуги")
    	Cmd.Flags().Int64Var(&serviceID, "serviceId", 0, "ID сервиса из которого идет событие")
    	Cmd.Flags().Int64Var(&userID, "userId", 0, "ID пользователя")
    
    	// Пометим необходимые флаги
    	if err := Cmd.MarkFlagsOneRequired("externalId", "serviceId", "userId"); err != nil {
    		fmt.Println(err)
    	}
    
    	// Вызов функции для нанесения взаимного исключения
    	markMutuallyExclusiveFlags(Cmd, "direct", "externalId", "serviceId", "userId")
    
    	rootCmd.AddCommand(Cmd)
    }
    
    // Функция для маркировки флагов как взаимно исключающих
    func markMutuallyExclusiveFlags(cmd *cobra.Command, flags ...string) {
    	for i := 0; i < len(flags); i++ {
    		for j := i + 1; j < len(flags); j++ {
    			if err := cmd.MarkFlagsMutuallyExclusive(flags[i], flags[j]); err != nil {
    				fmt.Println(err)
    			}
    		}
    	}
    }
    

    Объяснение:

    1. Функция markMutuallyExclusiveFlags: Эта функция позволяет вам передавать список флагов, для которых нужно установить взаимное исключение. Она использует вложенный цикл, чтобы сопоставить все пары флагов и применить MarkFlagsMutuallyExclusive на них.

    2. Упрощенная инициализация: Теперь в вашем init коде дочерней команды вы просто вызываете вашу вспомогательную функцию, вместо того чтобы повторять вызов MarkFlagsMutuallyExclusive для каждой пары.

    Таким образом, этот подход делает код более чистым и удобным для изменения, поскольку вам нужно будет изменять только список флагов в одной функции.