golang map 관련

golang map 분석

map

map 초기 화

map 의 교체

map 의 기본 동작

map 의 병발 안전

map
map 키 값 이 맞 는 데이터 구 조 는 go 에서 map 의 key 는 매우 유연성 이 있 습 니 다. 모든 것 을 비교 작업 (=,! =) 할 수 있 는 유형 으로 key, 예 를 들 어 string, int, 지침 등 을 사용 할 수 있 습 니 다. 심지어 필요 할 때 하나의 struct 로 key (struct 안의 모든 변수 유형 을 비교 할 수 있어 야 합 니 다).주목 할 만 한 것 은 맵 이 무질서 하 다 는 것 이다. 맵 을 증강 for 순환 으로 교체 할 때 매번 의 순 서 는 무 작위 이 고 추가 코드 가 질서 있 는 순환 이 필요 하 다.
맵 초기 화
golang 에서 map 의 초기 화 는 매우 간단 합 니 다. map: var map1 map[type]type map 1 기본 nil 을 초기 화하 지 않 으 면 길이 가 0 입 니 다.내 장 된 함수 make 를 사용 하여 map 초기 화: key 가 기본 형식 일 때:

map1 := make(map[string]bool)
map1["BangBrother"] = true
map1["Chopin"] = false
fmt.Println(map1)

출력:

map[BangBrother:true Chopin:false]

key 가 struct 일 때:

	type student struct {//  struct
		name   string
		number int64
	}
	s1 := student{//   struct
		name:   "1",
		number: 1,
	}
	studentMap := make(map[student]int)
	//         
	studentMap[s1] = 1
	//       
	studentMap[student{
		name:   "2",
		number: 2,
	}] = 2
	fmt.Println(studentMap)

출력:

map[{1 1}:1 {2 2}:2]

student 라 는 struct 내 변 수 는 배열 이 나타 나 지 않 습 니 다. 절편 이라는 직접적 으로 비교 할 수 없 는 유형 입 니 다. 그렇지 않 으 면 컴 파일 러 가 잘못 보고 할 수 있 습 니 다. invalid map key type struct 를 비교 할 때 struct 안의 모든 변수의 값 을 일일이 비교 하고 다른 키 가 있 습 니 다. 그렇지 않 으 면 같은 key 입 니 다. student 의 참조 주소 와 무관 합 니 다.

	s1 := student{
		name:   "1",
		number: 1,
	}
	s2 := student{
		name:   "1",
		number: 1,
	}
	fmt.Printf("s1:%p
", &s1)
	fmt.Printf("s2:%p
", &s2)
	studentMap := make(map[student]int)
	studentMap[s1] = 1
	studentMap[s2] = 2
	fmt.Println(studentMap)

결과:

s1:0xc00009e440
s2:0xc00009e460
map[{1 1}:2]

서로 다른 student 이라도 값 이 같 으 면 같은 key 로 판단 되 어 그 값 을 덮어 쓰 는 것 을 알 수 있다.
맵 의 교체
go 언어 에서 기 존의 순환 이 없 으 면 고정된 순서 가 있 는 맵 을 얻 을 수 있 지만 고정된 순서 순환 을 실현 하 는 것 도 매우 간단 하 다.당신 이 안의 값 만 생각 하고 순 서 는 신경 쓰 지 않 을 때:

map1 := make(map[string]int)
map1["chopin"] = 23
map1["bang"] = 24
map1["brother"] = 25
for key, value := range map1 {
	fmt.Println(key, value)
}

이 때 인쇄 된 결과 순 서 는 무 작위 입 니 다.

1.                 2.
chopin 23          brother 25               
bang 24            chopin 23                
brother 25         bang 24

프로그램 이 실 행 될 때마다 고정된 순서 가 있 으 려 면 키 가 저 장 된 데이터 구 조 를 추가 로 유지 해 야 합 니 다.

	keys := make([]string, len(map1))
	count := 0
	for key := range map1 {
		keys[count] = key
		count++
	}
	for _, key := range keys {
		fmt.Println(key, map1[key])
	}

맵 의 기본 동작
어떤 키 가 존재 하 는 지 판단 하기: value, ok := map1[key] 여기 있 는 ok 이 true 라면 이 키 가 존재 하고 false 라면 존재 하지 않 으 며 value 는 nil 을 부여 합 니 다.키 에 따라 어떤 맵 기록 을 삭제 하면 내장 함수 delete 를 사용 할 수 있 습 니 다.

delete(map1, "chopin")

이 곳 은 할당 이 필요 하지 않 습 니 다. map 1 이 존재 하지 않 으 면 이 key 도 잘못 보고 하지 않 고 아무 일 도 발생 하지 않 습 니 다.
맵 의 병발 안전
map 는 동시 다발 상황 에서 안전 하지 않 습 니 다. 추가 적 인 지원 이 필요 합 니 다. 보통 sync. RWMutex 라 이브 러 리 로 동시 다발 적 인 안전성 문 제 를 해결 할 수 있 습 니 다.읽 을 때 읽 기 잠 금 사용 가능:

	var lock sync.RWMutex
	lock.RLock()
	temp:=map1["chopin"]
	lock.RUnlock()

맵 에 값 을 설정 할 때 자 물 쇠 를 쓸 수 있 습 니 다:

	lock.Lock()
	map1["chopin"] = 100
	lock.Unlock()

물론 보안 버 전의 map - > sync. Map 을 직접 사용 할 수 있 습 니 다. 주의해 야 할 것 은 sync. Map 은 make 로 초기 화 할 필요 가 없 으 며, 안에 있 는 방법 을 직접 호출 하면 됩 니 다.

	var syncMap sync.Map
	syncMap.Store("chopin", 123)//    
	syncMap.Store("bang", 100)
	// map         func(k,v interface{})bool
	//     false     ，  true    
	syncMap.Range(func(key interface{}, value interface{}) bool {
		fmt.Println(key, value)
		return true
	})
	fmt.Println(syncMap.Load("bang"))//  key  value
	syncMap.Delete("chopin")//  key  map  
	fmt.Println(syncMap.Load("chopin"))//      nil,false

출력 결과:

chopin 123
bang 100
100 true
<nil> false

주의해 야 할 것 은 Range (func (k, v interface {}) bool 이다. 이 함 수 는 키 마다 한 번 만 실행 되 지만, 임의의 키 의 값 을 동시에 저장 하거나 삭제 하면 Range 가 호출 하 는 동안 이 키 의 모든 맵 을 반영 할 수 있다.이 함수 의 결과 순 서 는 증강 for 순환 과 마찬가지 로 무 작위 입 니 다.더 많은 병행 작업 에 관심 이 있다 면 다른 사람의 문 서 를 보 러 갈 수 있다.맵 만 소개 합 니 다.