馒头的技术博客

子网掩码（Subnet Mask）是计算机网络中的一个重要概念，它用于区分 IP 地址中的网络部分和主机部分。子网掩码是一个 32 位的二进制数字，通常以四组十进制数字表示，每组数字之间用点号分隔。例如，255.255.255.0 是一个常见的子网掩码。
（同一个网络地址可以互相通讯，同属一个局域网(LAN)）

问：IPv4 地址: 172.30.208.1 子网掩码 : 255.255.240.0 可以有多少个子网多少个设备？
子网掩码 255.255.240.0 转换为二进制是 11111111.11111111.11110000.00000000。在这个二进制表示中，前 20 位是网络部分，剩下的 12 位是主机部分。这意味着子网掩码有 20 位是 1，12 位是 0。
(ps:网络地址20+主机地址12)

计算子网数量：

子网数量取决于子网掩码中主机部分的位数。
在这个例子中，主机部分有 12 位。
子网数量 = 2^12=4096。

计算每个子网中的设备数量：

每个子网中的设备数量取决于子网掩码中主机部分的位数。
在这个例子中，主机部分有 12 位。
每个子网的设备数量 = 2^12−2=40942 (减去 2 是因为网络地址和广播地址不能被设备使用）。
因此，使用子网掩码 255.255.240.0 的 IPv4 地址 172.30.208.1 可以有 4096 个子网，每个子网可以有 4094 个设备。

package main

import (
    "context"
    "github.com/segmentio/kafka-go"
    "gotribe-admin/pkg/util"
    "log"
)

func main() {
    type DoOrderEvent struct {
        ShopID int `json:"shop_id"`
        Uid    int `json:"uid"`
    }
    data := DoOrderEvent{
        ShopID: 10086,
        Uid:    44,
    }
    w := &kafka.Writer{
        Addr:        kafka.TCP("localhost:9092"),
        Topic:       "order_event",
        MaxAttempts: 3,
        Async:       true, //异步发送消息 提高效率
        BatchSize:   10,   //批量发送消息
        //WriteTimeout:  3,

        RequiredAcks: kafka.RequireAll, // 表示所有副本节点都确认消息后才返回
        // RequireNone (0)  fire-and-forget, do not wait for acknowledgements from the
        //  RequireOne  (1)  wait for the leader to acknowledge the writes
        //  RequireAll  (-1) wait for the full ISR to acknowledge the writes

        //Completion: ,表示消息发送完成后的回调函数
        AllowAutoTopicCreation: true, //否允许自动创建主题

    }
    err := w.WriteMessages(context.Background(), kafka.Message{
        Key:        []byte(util.UUID()),
        Value:      []byte(util.Struct2Json(data)),
        WriterData: data,
    })
    if err != nil {
        log.Fatal("failed to write messages:", err)
    }

    // 关闭生产者
    if err := w.Close(); err != nil {
        log.Fatal("failed to close writer:", err)
    }

    //启用消费者
    go func() {
        kafka.NewConsumerGroup(kafka.ConsumerGroupConfig{})
        r := kafka.NewReader(kafka.ReaderConfig{
            Brokers:  []string{"localhost:9092"},
            Topic:    "order_event",
            GroupID:  "consumer_order_sec",
            MinBytes: 10e3, // 10KB
            MaxBytes: 10e6, // 10MB
        })
        defer r.Close()
        for {
            //m, err := r.ReadMessage(c) //阻塞获取消息 如果是消费组消费 自动提交偏移量
            m, err := r.FetchMessage(c) //获取消息 如果是消费组消费 不自动提交偏移量  需要手动提交 Consumer Lag
            if err != nil {
                log.Fatal("failed to read message:", err)
            }
            log.Printf("message at offset %d: %s = %s\n", m.Offset, string(m.Key), string(m.Value))
            if err := r.CommitMessages(c, m); err != nil {
                log.Fatal("bad commit message: ", err)
            }

        }

    }()
    select {}

}

var policies []model.RoleAct
policies6 := &[]model.RoleAct{}
fmt.Printf("初始化 policies %+v", policies) //分配了零值+内存地址
fmt.Printf("初始化 policies %+v", policies6) //分配了零值+内存地址

var policies2 *[]model.RoleAct //nil没有被初始化 没有分配内存地址
fmt.Printf("没有初始化 policies2 %+v\n", policies2)
policies2 = &[]model.RoleAct{}
fmt.Printf("初始化 policies2 %+v\n", *policies2) //解引用看到  分配了零值+内存地址
//为什么要强调这个，因为有些方法 是必须给内存地址的，比如
//grom 中find方法必须给内存地址的
list:=&[]model.RoleAct{}
DB.Find(list).Error

1.打印多维数组

var data= [3][2]string{}
fmt.Printf("%#v\n", data))

[3][2]string{[2]string{"", ""}, [2]string{"", ""}, [2]string{"", ""}}

2.字母转int strconv.Atoi() alphabetic to int
int转字母 strconv.Itoa() int to alphabetic

3.time 常用方法

time.Now().Unix() 获取时间戳 
time.Now().AddDate(years int, months int, days int) 增加时间
time.Now().Format("2006-01-02 15:04:05")  //格式化时间

4.以下返回值是一样的

func getX2X3(a int) (int, int) {
    return a * 2, a * 3
}
func getX2X32(a int) (a2 int, a3 int) {
    a2 = a * 2
    a3 = a * 3
    return
}

CREATE USER '用户名'@'localhost' IDENTIFIED BY '密码';#如果是本地用户可用localhost，如果想让该用户可以从任意 远程主机登陆，可以使用通配符%
GRANT all privileges ON 数据库.* TO '用户名'@'localhost'; #授权
FLUSH PRIVILEGES;#刷新权限