@zhiyong0804/golang

# code_skill

#### 判断map的key是否存在并且使用key对应的value
```
  func updateUserOnLineStatus(msg proto.Message) {
  notifyMsg := &proto.UserStatusNotifyResp{}
  err := json.Unmarshal([]byte(msg.Data), notifyMsg)

  if err != nil {
    fmt.Println(util.GetFileLine(), "updateUserOnLineStatus json unmarshal failed", err)
    return
  }

  user, ok := onlineUserMap[notifyMsg.UserId]

  if !ok {
    user = &proto.UserInfo{
      UserId: notifyMsg.UserId,
    }
  }

  user.Status = notifyMsg.Status
  onlineUserMap[notifyMsg.UserId] = user
  outPutUserOnLine()
}
```

#### redis op
```
  func (p *RedisMgr) getUser(conn redis.Conn, userId string) (user *proto.UserInfo, err error) {
	res, err := redis.String(conn.Do("Hget", UserTable, userId))

	//star_coding
	//include key not exist and user not exsit
	if err != nil {
		fmt.Println("get User err ", err)
		if err == redis.ErrNil {
			err = proto.ErrUserNotExist
		}
		return
	}

	user = &proto.UserInfo{}
	err = json.Unmarshal([]byte(res), user)

	if err != nil {
		return
	}
	return
}

func (p *RedisMgr) Login(userId string, passwd string) (user *proto.UserInfo, err error) {
	fmt.Println(util.GetFileLine() + " redis handle login")

	conn := p.pool.Get()
	defer conn.Close()

	user, err = p.getUser(conn, userId)

	if err != nil {
		return
	}

	if user.UserId != userId || user.Passwd != passwd {
		err = proto.ErrInvalidPasswd
		return
	}

	user.Status = proto.ONLINE
	user.LastLogin = util.GetTodayDateTime()
	return
}

func (p *RedisMgr) Register(user *proto.UserInfo) (err error) {
	fmt.Println(util.GetFileLine() + " redis handle register")
	conn := p.pool.Get()
	defer conn.Close()

	if user == nil {
		fmt.Println(util.GetFileLine() + "invalid user")
		err = proto.ErrInvalidParams
		return
	}

	_, err = p.getUser(conn, user.UserId)

	//has exist
	if err == nil {
		err = proto.ErrUserExist
		return
	}

	//not unregister
	if err != proto.ErrUserNotExist {
		return
	}

	data, err := json.Marshal(user)

	if err != nil {
		return
	}
	_, err = conn.Do("HSet", UserTable, user.UserId, string(data))

	if err != nil {
		return
	}
	return
}
```

#### 省去写return
```
  func (m *Map) Delete(key interface{}) {
  read, _ := m.read.Load().(readOnly)
  e, ok := read.m[key]
  if !ok && read.amended {
    m.mu.Lock()
    read, _ = m.read.Load().(readOnly)
    e, ok = read.m[key]
    if !ok && read.amended {
      delete(m.dirty, key)
    }
    m.mu.Unlock()
  }
  if ok {
    e.delete()
  }
}
```