Golang中如何检查字段是否包含"A"、"b"或"C"

Golang中如何检查字段是否包含"A"、“b"或"C” 你好，

我正在尝试创建一个函数，用于检查字段中是否包含“A”、“B”或“C”计划，如果包含，则计划支付字段不应为空；如果计划字段为空，则返回错误。请问你能帮我实现这个功能吗？

12 回复

到目前为止你尝试了什么？

更多关于Golang中如何检查字段是否包含"A"、"b"或"C"的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


也许像这样？

是 infoline 还是 infofile，选一个吧 🙂

如果 plan 是一个字符串，你可以轻松地使用 strings 包（例如 Contains、Count 等函数）。

如果方案名称确实是单个字母的字符串，虽然这很值得怀疑，但也是有可能的。

A B C d 是计划 变量来自 infofile 结构体 因为 infofile 有一个结构体

jabbson:

这完全没有解释清楚，它到底是什么类型的数据

数据是字符串。

infoline 是一个结构体名称，plan 是一个字段名。

我认为直接这样做更简单：

func (in infofile) vplanO() error {
    if  strings.Contains("ABCD", in.plan) {
      return nil
    }
	return errors.New("plan doesn't exist")
}

Yo_94: A B C d are the plans

这完全没有解释清楚，它是什么类型的数据？

Yo_94: variable comes from the infofile struct

编译器无法凭空猜测，除非它是一个全局变量（实际上不应该有全局变量），你指的是 in.plan 而不是 plan 吗？

Yo_94: because infofile has a struct

那么 infofile 是什么？

引用上方已撤回的帖子：

func (in *infofile) vplanO() (string, string) { 
    if (in.plan) != (A || A || C ||D) { 
        return "Error", fmt.Sprintf("Invalid plan %s", plan) 
    } 
    return "", "" 
}

这些 A || A || C || D 是什么？ 返回语句末尾的 plan 变量是从哪里来的？ 为什么 infofile 是以指针形式传递的？ infofile 到底是什么？

无论如何，这是你在找的东西吗（当然不是字面意思，而是这个想法本身）？

package main

import (
	"errors"
	"fmt"
)

type infofile struct {
	plan string
}

func (in infofile) vplanO() error {
	for _, e := range []string{"A", "B", "C", "D"} {
		if in.plan == e {
			return nil
		}
	}
	return errors.New("plan doesn't exist")
}

func main() {

	infos := []infofile{
		infofile{"A"},
		infofile{"Z"},
	}

	for _, e := range infos {
		err := e.vplanO()
		if err != nil {
			fmt.Printf("Infofile: %+v, err: %s\n", e, err)
			continue
		}
		fmt.Printf("Infofile: %+v is good\n", e)
	}
}

或者你是想检查计划是否以这些字母之一结尾（或开头）？

在Golang中，你可以通过以下方式实现字段检查逻辑：

package main

import (
	"errors"
	"fmt"
	"strings"
)

type PaymentRequest struct {
	Plan        string
	PlanPayment string
}

func validatePayment(req PaymentRequest) error {
	// 检查计划字段是否包含A、B或C（不区分大小写）
	plan := strings.ToUpper(req.Plan)
	containsABC := strings.Contains(plan, "A") || 
		strings.Contains(plan, "B") || 
		strings.Contains(plan, "C")

	if containsABC {
		// 如果包含A/B/C，检查计划支付字段是否为空
		if req.PlanPayment == "" {
			return errors.New("计划支付字段不能为空")
		}
	}
	
	// 如果计划字段为空，返回错误
	if req.Plan == "" {
		return errors.New("计划字段不能为空")
	}
	
	return nil
}

func main() {
	// 测试用例
	testCases := []PaymentRequest{
		{Plan: "Plan A", PlanPayment: "100"},
		{Plan: "Plan B", PlanPayment: ""},
		{Plan: "Plan C", PlanPayment: "200"},
		{Plan: "Plan D", PlanPayment: ""},
		{Plan: "", PlanPayment: "300"},
		{Plan: "plan a", PlanPayment: ""}, // 测试小写
		{Plan: "PLAN B", PlanPayment: "150"}, // 测试大写
	}

	for i, req := range testCases {
		err := validatePayment(req)
		if err != nil {
			fmt.Printf("测试 %d 失败: %v\n", i+1, err)
		} else {
			fmt.Printf("测试 %d 成功\n", i+1)
		}
	}
}

如果你需要更灵活的匹配模式（比如完整单词匹配而不是部分匹配），可以使用正则表达式：

package main

import (
	"errors"
	"fmt"
	"regexp"
)

func validatePaymentRegex(req PaymentRequest) error {
	// 使用正则表达式匹配包含A、B或C的计划
	pattern := `(?i).*(A|B|C).*`
	matched, _ := regexp.MatchString(pattern, req.Plan)

	if matched {
		if req.PlanPayment == "" {
			return errors.New("计划支付字段不能为空")
		}
	}
	
	if req.Plan == "" {
		return errors.New("计划字段不能为空")
	}
	
	return nil
}

第一个实现使用strings.Contains()进行简单直接的检查，第二个实现使用正则表达式提供更灵活的匹配方式。两者都处理了大小写不敏感的情况。

回到顶部