[{"data":1,"prerenderedAt":3336},["ShallowReactive",2],{"page-\u002Fgo\u002F07-arrays-slices-and-strings":3},{"id":4,"title":5,"body":6,"description":3329,"extension":3330,"meta":3331,"navigation":87,"path":3332,"seo":3333,"stem":3334,"__hash__":3335},"content\u002Fgo\u002F07-arrays-slices-and-strings.md","07 — Arrays, Slices & Strings",{"type":7,"value":8,"toc":3324},"minimark",[9,13,18,3170,3308,3312,3320],[10,11,5],"h1",{"id":12},"_07-arrays-slices-strings",[14,15,17],"h2",{"id":16},"array-vs-slice-the-type-distinction","Array vs Slice — The Type Distinction",[19,20,22,393,397],"code-wrapper",{"language":21},"go",[23,24,28],"pre",{"className":25,"code":26,"language":21,"meta":27,"style":27},"language-go shiki shiki-themes github-light github-dark","\u002F\u002F ┌──────────────────────────────────────────────────────────────────────┐\n\u002F\u002F │ Array                          │ Slice                               │\n\u002F\u002F │ ────────────────────────────── │ ─────────────────────────────────── │\n\u002F\u002F │ [3]int — length is IN the type │ []int — length is dynamic           │\n\u002F\u002F │ Value type (copied on assign)  │ Reference-ish (header copied)       │\n\u002F\u002F │ Fixed size, stack-allocated    │ Header {ptr, len, cap}, heap data   │\n\u002F\u002F │ Rarely used directly            │ Go's primary list type              │\n\u002F\u002F └──────────────────────────────────────────────────────────────────────┘\n\n\u002F\u002F Arrays — length is part of the type:\nvar a [3]int         \u002F\u002F [0 0 0] — zero value, stack-allocated\nb := [3]int{1, 2, 3}\nc := [...]int{4, 5}  \u002F\u002F [2]int — length inferred\n\n\u002F\u002F ❌ ANTI-PATTERN: passing arrays by value (copies the whole array)\nfunc badSum(arr [1000]int) int {  \u002F\u002F copies 8000 bytes on every call\n    total := 0\n    for _, v := range arr { total += v }\n    return total\n}\n\n\u002F\u002F ✅ CORRECT: pass a slice (copies only the 24-byte header)\nfunc goodSum(arr []int) int {\n    total := 0\n    for _, v := range arr { total += v }\n    return total\n}\n\n\u002F\u002F When to use arrays: fixed-size collections known at compile time\n\u002F\u002F   — SHA-256 hash: [32]byte\n\u002F\u002F   — UUID: [16]byte\n\u002F\u002F   — RGB color: [3]uint8\n\u002F\u002F   — Matrix math: [4][4]float64\n","",[29,30,31,40,46,52,58,64,70,76,82,89,95,119,156,189,194,200,237,248,271,280,285,290,296,320,329,346,353,358,363,369,375,381,387],"code",{"__ignoreMap":27},[32,33,36],"span",{"class":34,"line":35},"line",1,[32,37,39],{"class":38},"sdCPZ","\u002F\u002F ┌──────────────────────────────────────────────────────────────────────┐\n",[32,41,43],{"class":34,"line":42},2,[32,44,45],{"class":38},"\u002F\u002F │ Array                          │ Slice                               │\n",[32,47,49],{"class":34,"line":48},3,[32,50,51],{"class":38},"\u002F\u002F │ ────────────────────────────── │ ─────────────────────────────────── │\n",[32,53,55],{"class":34,"line":54},4,[32,56,57],{"class":38},"\u002F\u002F │ [3]int — length is IN the type │ []int — length is dynamic           │\n",[32,59,61],{"class":34,"line":60},5,[32,62,63],{"class":38},"\u002F\u002F │ Value type (copied on assign)  │ Reference-ish (header copied)       │\n",[32,65,67],{"class":34,"line":66},6,[32,68,69],{"class":38},"\u002F\u002F │ Fixed size, stack-allocated    │ Header {ptr, len, cap}, heap data   │\n",[32,71,73],{"class":34,"line":72},7,[32,74,75],{"class":38},"\u002F\u002F │ Rarely used directly            │ Go's primary list type              │\n",[32,77,79],{"class":34,"line":78},8,[32,80,81],{"class":38},"\u002F\u002F └──────────────────────────────────────────────────────────────────────┘\n",[32,83,85],{"class":34,"line":84},9,[32,86,88],{"emptyLinePlaceholder":87},true,"\n",[32,90,92],{"class":34,"line":91},10,[32,93,94],{"class":38},"\u002F\u002F Arrays — length is part of the type:\n",[32,96,98,102,106,110,113,116],{"class":34,"line":97},11,[32,99,101],{"class":100},"svdQ7","var",[32,103,105],{"class":104},"ssxIu"," a [",[32,107,109],{"class":108},"snvgF","3",[32,111,112],{"class":104},"]",[32,114,115],{"class":100},"int",[32,117,118],{"class":38},"         \u002F\u002F [0 0 0] — zero value, stack-allocated\n",[32,120,122,125,128,131,133,135,137,140,143,146,149,151,153],{"class":34,"line":121},12,[32,123,124],{"class":104},"b ",[32,126,127],{"class":100},":=",[32,129,130],{"class":104}," [",[32,132,109],{"class":108},[32,134,112],{"class":104},[32,136,115],{"class":100},[32,138,139],{"class":104},"{",[32,141,142],{"class":108},"1",[32,144,145],{"class":104},", ",[32,147,148],{"class":108},"2",[32,150,145],{"class":104},[32,152,109],{"class":108},[32,154,155],{"class":104},"}\n",[32,157,159,162,164,166,169,171,173,175,178,180,183,186],{"class":34,"line":158},13,[32,160,161],{"class":104},"c ",[32,163,127],{"class":100},[32,165,130],{"class":104},[32,167,168],{"class":100},"...",[32,170,112],{"class":104},[32,172,115],{"class":100},[32,174,139],{"class":104},[32,176,177],{"class":108},"4",[32,179,145],{"class":104},[32,181,182],{"class":108},"5",[32,184,185],{"class":104},"}  ",[32,187,188],{"class":38},"\u002F\u002F [2]int — length inferred\n",[32,190,192],{"class":34,"line":191},14,[32,193,88],{"emptyLinePlaceholder":87},[32,195,197],{"class":34,"line":196},15,[32,198,199],{"class":38},"\u002F\u002F ❌ ANTI-PATTERN: passing arrays by value (copies the whole array)\n",[32,201,203,206,210,213,217,219,222,224,226,229,231,234],{"class":34,"line":202},16,[32,204,205],{"class":100},"func",[32,207,209],{"class":208},"sIsaT"," badSum",[32,211,212],{"class":104},"(",[32,214,216],{"class":215},"sCrzJ","arr",[32,218,130],{"class":104},[32,220,221],{"class":108},"1000",[32,223,112],{"class":104},[32,225,115],{"class":100},[32,227,228],{"class":104},") ",[32,230,115],{"class":100},[32,232,233],{"class":104}," {  ",[32,235,236],{"class":38},"\u002F\u002F copies 8000 bytes on every call\n",[32,238,240,243,245],{"class":34,"line":239},17,[32,241,242],{"class":104},"    total ",[32,244,127],{"class":100},[32,246,247],{"class":108}," 0\n",[32,249,251,254,257,259,262,265,268],{"class":34,"line":250},18,[32,252,253],{"class":100},"    for",[32,255,256],{"class":104}," _, v ",[32,258,127],{"class":100},[32,260,261],{"class":100}," range",[32,263,264],{"class":104}," arr { total ",[32,266,267],{"class":100},"+=",[32,269,270],{"class":104}," v }\n",[32,272,274,277],{"class":34,"line":273},19,[32,275,276],{"class":100},"    return",[32,278,279],{"class":104}," total\n",[32,281,283],{"class":34,"line":282},20,[32,284,155],{"class":104},[32,286,288],{"class":34,"line":287},21,[32,289,88],{"emptyLinePlaceholder":87},[32,291,293],{"class":34,"line":292},22,[32,294,295],{"class":38},"\u002F\u002F ✅ CORRECT: pass a slice (copies only the 24-byte header)\n",[32,297,299,301,304,306,308,311,313,315,317],{"class":34,"line":298},23,[32,300,205],{"class":100},[32,302,303],{"class":208}," goodSum",[32,305,212],{"class":104},[32,307,216],{"class":215},[32,309,310],{"class":104}," []",[32,312,115],{"class":100},[32,314,228],{"class":104},[32,316,115],{"class":100},[32,318,319],{"class":104}," {\n",[32,321,323,325,327],{"class":34,"line":322},24,[32,324,242],{"class":104},[32,326,127],{"class":100},[32,328,247],{"class":108},[32,330,332,334,336,338,340,342,344],{"class":34,"line":331},25,[32,333,253],{"class":100},[32,335,256],{"class":104},[32,337,127],{"class":100},[32,339,261],{"class":100},[32,341,264],{"class":104},[32,343,267],{"class":100},[32,345,270],{"class":104},[32,347,349,351],{"class":34,"line":348},26,[32,350,276],{"class":100},[32,352,279],{"class":104},[32,354,356],{"class":34,"line":355},27,[32,357,155],{"class":104},[32,359,361],{"class":34,"line":360},28,[32,362,88],{"emptyLinePlaceholder":87},[32,364,366],{"class":34,"line":365},29,[32,367,368],{"class":38},"\u002F\u002F When to use arrays: fixed-size collections known at compile time\n",[32,370,372],{"class":34,"line":371},30,[32,373,374],{"class":38},"\u002F\u002F   — SHA-256 hash: [32]byte\n",[32,376,378],{"class":34,"line":377},31,[32,379,380],{"class":38},"\u002F\u002F   — UUID: [16]byte\n",[32,382,384],{"class":34,"line":383},32,[32,385,386],{"class":38},"\u002F\u002F   — RGB color: [3]uint8\n",[32,388,390],{"class":34,"line":389},33,[32,391,392],{"class":38},"\u002F\u002F   — Matrix math: [4][4]float64\n",[14,394,396],{"id":395},"slice-header-the-memory-model","Slice Header — The Memory Model",[19,398,399,683,690],{"language":21},[23,400,402],{"className":25,"code":401,"language":21,"meta":27,"style":27},"\u002F\u002F A slice is a 3-word header (24 bytes on 64-bit):\n\u002F\u002F\n\u002F\u002F   ┌──────────┬──────────┬──────────┐\n\u002F\u002F   │ ptr      │ len      │ cap      │\n\u002F\u002F   │ 8 bytes │ 8 bytes │ 8 bytes │\n\u002F\u002F   └──────────┴──────────┴──────────┘\n\u002F\u002F        ↓\n\u002F\u002F   [elem0][elem1][elem2]...[elemN-1]  ← underlying array (heap)\n\u002F\u002F\n\u002F\u002F ptr: points to the first element in the underlying array\n\u002F\u002F len: number of elements VISIBLE (the slice can see)\n\u002F\u002F cap: number of elements from ptr to the end of the underlying array\n\ntype sliceHeader struct {\n    data unsafe.Pointer  \u002F\u002F pointer to underlying array\n    len  int             \u002F\u002F visible length\n    cap  int             \u002F\u002F capacity (from data to end of array)\n}\n\n\u002F\u002F Passing a slice to a function copies the HEADER (24 bytes), not the data.\n\u002F\u002F The function can modify elements (shared array) but can't change the\n\u002F\u002F caller's len\u002Fcap (the header is copied by value).\n\nfunc modifySlice(s []int) {\n    s[0] = 99          \u002F\u002F ✅ modifies the shared underlying array — caller sees it\n    s = append(s, 1)    \u002F\u002F ✅ modifies the LOCAL copy of the header — caller does NOT see the append\n    _ = s\n}\n\nfunc main() {\n    s := []int{1, 2, 3}\n    modifySlice(s)\n    fmt.Println(s)  \u002F\u002F [99 2 3] — s[0] changed, but len is still 3 (append not visible)\n}\n",[29,403,404,409,414,419,424,429,434,439,444,448,453,458,463,467,480,497,507,517,521,525,530,535,540,544,563,583,604,614,618,622,632,656,664,678],{"__ignoreMap":27},[32,405,406],{"class":34,"line":35},[32,407,408],{"class":38},"\u002F\u002F A slice is a 3-word header (24 bytes on 64-bit):\n",[32,410,411],{"class":34,"line":42},[32,412,413],{"class":38},"\u002F\u002F\n",[32,415,416],{"class":34,"line":48},[32,417,418],{"class":38},"\u002F\u002F   ┌──────────┬──────────┬──────────┐\n",[32,420,421],{"class":34,"line":54},[32,422,423],{"class":38},"\u002F\u002F   │ ptr      │ len      │ cap      │\n",[32,425,426],{"class":34,"line":60},[32,427,428],{"class":38},"\u002F\u002F   │ 8 bytes │ 8 bytes │ 8 bytes │\n",[32,430,431],{"class":34,"line":66},[32,432,433],{"class":38},"\u002F\u002F   └──────────┴──────────┴──────────┘\n",[32,435,436],{"class":34,"line":72},[32,437,438],{"class":38},"\u002F\u002F        ↓\n",[32,440,441],{"class":34,"line":78},[32,442,443],{"class":38},"\u002F\u002F   [elem0][elem1][elem2]...[elemN-1]  ← underlying array (heap)\n",[32,445,446],{"class":34,"line":84},[32,447,413],{"class":38},[32,449,450],{"class":34,"line":91},[32,451,452],{"class":38},"\u002F\u002F ptr: points to the first element in the underlying array\n",[32,454,455],{"class":34,"line":97},[32,456,457],{"class":38},"\u002F\u002F len: number of elements VISIBLE (the slice can see)\n",[32,459,460],{"class":34,"line":121},[32,461,462],{"class":38},"\u002F\u002F cap: number of elements from ptr to the end of the underlying array\n",[32,464,465],{"class":34,"line":158},[32,466,88],{"emptyLinePlaceholder":87},[32,468,469,472,475,478],{"class":34,"line":191},[32,470,471],{"class":100},"type",[32,473,474],{"class":208}," sliceHeader",[32,476,477],{"class":100}," struct",[32,479,319],{"class":104},[32,481,482,485,488,491,494],{"class":34,"line":196},[32,483,484],{"class":104},"    data ",[32,486,487],{"class":208},"unsafe",[32,489,490],{"class":104},".",[32,492,493],{"class":208},"Pointer",[32,495,496],{"class":38},"  \u002F\u002F pointer to underlying array\n",[32,498,499,502,504],{"class":34,"line":202},[32,500,501],{"class":104},"    len  ",[32,503,115],{"class":100},[32,505,506],{"class":38},"             \u002F\u002F visible length\n",[32,508,509,512,514],{"class":34,"line":239},[32,510,511],{"class":104},"    cap  ",[32,513,115],{"class":100},[32,515,516],{"class":38},"             \u002F\u002F capacity (from data to end of array)\n",[32,518,519],{"class":34,"line":250},[32,520,155],{"class":104},[32,522,523],{"class":34,"line":273},[32,524,88],{"emptyLinePlaceholder":87},[32,526,527],{"class":34,"line":282},[32,528,529],{"class":38},"\u002F\u002F Passing a slice to a function copies the HEADER (24 bytes), not the data.\n",[32,531,532],{"class":34,"line":287},[32,533,534],{"class":38},"\u002F\u002F The function can modify elements (shared array) but can't change the\n",[32,536,537],{"class":34,"line":292},[32,538,539],{"class":38},"\u002F\u002F caller's len\u002Fcap (the header is copied by value).\n",[32,541,542],{"class":34,"line":298},[32,543,88],{"emptyLinePlaceholder":87},[32,545,546,548,551,553,556,558,560],{"class":34,"line":322},[32,547,205],{"class":100},[32,549,550],{"class":208}," modifySlice",[32,552,212],{"class":104},[32,554,555],{"class":215},"s",[32,557,310],{"class":104},[32,559,115],{"class":100},[32,561,562],{"class":104},") {\n",[32,564,565,568,571,574,577,580],{"class":34,"line":331},[32,566,567],{"class":104},"    s[",[32,569,570],{"class":108},"0",[32,572,573],{"class":104},"] ",[32,575,576],{"class":100},"=",[32,578,579],{"class":108}," 99",[32,581,582],{"class":38},"          \u002F\u002F ✅ modifies the shared underlying array — caller sees it\n",[32,584,585,588,590,593,596,598,601],{"class":34,"line":348},[32,586,587],{"class":104},"    s ",[32,589,576],{"class":100},[32,591,592],{"class":208}," append",[32,594,595],{"class":104},"(s, ",[32,597,142],{"class":108},[32,599,600],{"class":104},")    ",[32,602,603],{"class":38},"\u002F\u002F ✅ modifies the LOCAL copy of the header — caller does NOT see the append\n",[32,605,606,609,611],{"class":34,"line":355},[32,607,608],{"class":104},"    _ ",[32,610,576],{"class":100},[32,612,613],{"class":104}," s\n",[32,615,616],{"class":34,"line":360},[32,617,155],{"class":104},[32,619,620],{"class":34,"line":365},[32,621,88],{"emptyLinePlaceholder":87},[32,623,624,626,629],{"class":34,"line":371},[32,625,205],{"class":100},[32,627,628],{"class":208}," main",[32,630,631],{"class":104},"() {\n",[32,633,634,636,638,640,642,644,646,648,650,652,654],{"class":34,"line":377},[32,635,587],{"class":104},[32,637,127],{"class":100},[32,639,310],{"class":104},[32,641,115],{"class":100},[32,643,139],{"class":104},[32,645,142],{"class":108},[32,647,145],{"class":104},[32,649,148],{"class":108},[32,651,145],{"class":104},[32,653,109],{"class":108},[32,655,155],{"class":104},[32,657,658,661],{"class":34,"line":383},[32,659,660],{"class":208},"    modifySlice",[32,662,663],{"class":104},"(s)\n",[32,665,666,669,672,675],{"class":34,"line":389},[32,667,668],{"class":104},"    fmt.",[32,670,671],{"class":208},"Println",[32,673,674],{"class":104},"(s)  ",[32,676,677],{"class":38},"\u002F\u002F [99 2 3] — s[0] changed, but len is still 3 (append not visible)\n",[32,679,681],{"class":34,"line":680},34,[32,682,155],{"class":104},[14,684,686,689],{"id":685},"append-growth-strategy-and-the-reassignment-rule",[29,687,688],{},"append"," — Growth Strategy and the Reassignment Rule",[19,691,692,965,970],{"language":21},[23,693,695],{"className":25,"code":694,"language":21,"meta":27,"style":27},"\u002F\u002F When len \u003C cap: append writes to the existing array, increments len.\n\u002F\u002F When len == cap: append allocates a NEW larger array, copies old elements,\n\u002F\u002F                  appends the new element, and returns a NEW header.\n\n\u002F\u002F ❌ ANTI-PATTERN: not reassigning the result of append\nfunc appendBad(s []int, x int) {\n    append(s, x)  \u002F\u002F result is LOST — s is unchanged\n    \u002F\u002F if append grew the slice, the new array is orphaned (memory leak)\n}\n\n\u002F\u002F ✅ CORRECT: always reassign\nfunc appendGood(s []int, x int) []int {\n    return append(s, x)  \u002F\u002F returns the (possibly new) header\n}\n\n\u002F\u002F ─── Go's growth strategy (runtime\u002Fslice.go) ───\n\u002F\u002F   - For small slices (cap \u003C 256): doubles the capacity\n\u002F\u002F   - For large slices (cap >= 256): grows by ~1.25x + 192 bytes\n\u002F\u002F   - This balances allocation frequency vs. memory waste\n\u002F\u002F\n\u002F\u002F   newcap := old.cap * 2          (if old.cap \u003C 256)\n\u002F\u002F   newcap := old.cap + old.cap\u002F4 + 192  (if old.cap >= 256)\n\u002F\u002F\n\u002F\u002F Pre-allocate when you know the size to avoid this entirely:\nfunc preAlloc(n int) []int {\n    s := make([]int, 0, n)  \u002F\u002F one allocation, zero reallocations\n    for i := 0; i \u003C n; i++ {\n        s = append(s, i)    \u002F\u002F stays within cap — no reallocation\n    }\n    return s\n}\n",[29,696,697,702,707,712,716,721,746,757,762,766,770,775,803,814,818,822,827,832,837,842,846,851,856,860,865,885,909,935,950,955,961],{"__ignoreMap":27},[32,698,699],{"class":34,"line":35},[32,700,701],{"class":38},"\u002F\u002F When len \u003C cap: append writes to the existing array, increments len.\n",[32,703,704],{"class":34,"line":42},[32,705,706],{"class":38},"\u002F\u002F When len == cap: append allocates a NEW larger array, copies old elements,\n",[32,708,709],{"class":34,"line":48},[32,710,711],{"class":38},"\u002F\u002F                  appends the new element, and returns a NEW header.\n",[32,713,714],{"class":34,"line":54},[32,715,88],{"emptyLinePlaceholder":87},[32,717,718],{"class":34,"line":60},[32,719,720],{"class":38},"\u002F\u002F ❌ ANTI-PATTERN: not reassigning the result of append\n",[32,722,723,725,728,730,732,734,736,738,741,744],{"class":34,"line":66},[32,724,205],{"class":100},[32,726,727],{"class":208}," appendBad",[32,729,212],{"class":104},[32,731,555],{"class":215},[32,733,310],{"class":104},[32,735,115],{"class":100},[32,737,145],{"class":104},[32,739,740],{"class":215},"x",[32,742,743],{"class":100}," int",[32,745,562],{"class":104},[32,747,748,751,754],{"class":34,"line":72},[32,749,750],{"class":208},"    append",[32,752,753],{"class":104},"(s, x)  ",[32,755,756],{"class":38},"\u002F\u002F result is LOST — s is unchanged\n",[32,758,759],{"class":34,"line":78},[32,760,761],{"class":38},"    \u002F\u002F if append grew the slice, the new array is orphaned (memory leak)\n",[32,763,764],{"class":34,"line":84},[32,765,155],{"class":104},[32,767,768],{"class":34,"line":91},[32,769,88],{"emptyLinePlaceholder":87},[32,771,772],{"class":34,"line":97},[32,773,774],{"class":38},"\u002F\u002F ✅ CORRECT: always reassign\n",[32,776,777,779,782,784,786,788,790,792,794,796,799,801],{"class":34,"line":121},[32,778,205],{"class":100},[32,780,781],{"class":208}," appendGood",[32,783,212],{"class":104},[32,785,555],{"class":215},[32,787,310],{"class":104},[32,789,115],{"class":100},[32,791,145],{"class":104},[32,793,740],{"class":215},[32,795,743],{"class":100},[32,797,798],{"class":104},") []",[32,800,115],{"class":100},[32,802,319],{"class":104},[32,804,805,807,809,811],{"class":34,"line":158},[32,806,276],{"class":100},[32,808,592],{"class":208},[32,810,753],{"class":104},[32,812,813],{"class":38},"\u002F\u002F returns the (possibly new) header\n",[32,815,816],{"class":34,"line":191},[32,817,155],{"class":104},[32,819,820],{"class":34,"line":196},[32,821,88],{"emptyLinePlaceholder":87},[32,823,824],{"class":34,"line":202},[32,825,826],{"class":38},"\u002F\u002F ─── Go's growth strategy (runtime\u002Fslice.go) ───\n",[32,828,829],{"class":34,"line":239},[32,830,831],{"class":38},"\u002F\u002F   - For small slices (cap \u003C 256): doubles the capacity\n",[32,833,834],{"class":34,"line":250},[32,835,836],{"class":38},"\u002F\u002F   - For large slices (cap >= 256): grows by ~1.25x + 192 bytes\n",[32,838,839],{"class":34,"line":273},[32,840,841],{"class":38},"\u002F\u002F   - This balances allocation frequency vs. memory waste\n",[32,843,844],{"class":34,"line":282},[32,845,413],{"class":38},[32,847,848],{"class":34,"line":287},[32,849,850],{"class":38},"\u002F\u002F   newcap := old.cap * 2          (if old.cap \u003C 256)\n",[32,852,853],{"class":34,"line":292},[32,854,855],{"class":38},"\u002F\u002F   newcap := old.cap + old.cap\u002F4 + 192  (if old.cap >= 256)\n",[32,857,858],{"class":34,"line":298},[32,859,413],{"class":38},[32,861,862],{"class":34,"line":322},[32,863,864],{"class":38},"\u002F\u002F Pre-allocate when you know the size to avoid this entirely:\n",[32,866,867,869,872,874,877,879,881,883],{"class":34,"line":331},[32,868,205],{"class":100},[32,870,871],{"class":208}," preAlloc",[32,873,212],{"class":104},[32,875,876],{"class":215},"n",[32,878,743],{"class":100},[32,880,798],{"class":104},[32,882,115],{"class":100},[32,884,319],{"class":104},[32,886,887,889,891,894,897,899,901,903,906],{"class":34,"line":348},[32,888,587],{"class":104},[32,890,127],{"class":100},[32,892,893],{"class":208}," make",[32,895,896],{"class":104},"([]",[32,898,115],{"class":100},[32,900,145],{"class":104},[32,902,570],{"class":108},[32,904,905],{"class":104},", n)  ",[32,907,908],{"class":38},"\u002F\u002F one allocation, zero reallocations\n",[32,910,911,913,916,918,921,924,927,930,933],{"class":34,"line":355},[32,912,253],{"class":100},[32,914,915],{"class":104}," i ",[32,917,127],{"class":100},[32,919,920],{"class":108}," 0",[32,922,923],{"class":104},"; i ",[32,925,926],{"class":100},"\u003C",[32,928,929],{"class":104}," n; i",[32,931,932],{"class":100},"++",[32,934,319],{"class":104},[32,936,937,940,942,944,947],{"class":34,"line":360},[32,938,939],{"class":104},"        s ",[32,941,576],{"class":100},[32,943,592],{"class":208},[32,945,946],{"class":104},"(s, i)    ",[32,948,949],{"class":38},"\u002F\u002F stays within cap — no reallocation\n",[32,951,952],{"class":34,"line":365},[32,953,954],{"class":104},"    }\n",[32,956,957,959],{"class":34,"line":371},[32,958,276],{"class":100},[32,960,613],{"class":104},[32,962,963],{"class":34,"line":377},[32,964,155],{"class":104},[966,967,969],"h3",{"id":968},"the-aliasing-trap","The aliasing trap",[19,971,972,1235,1245],{"language":21},[23,973,975],{"className":25,"code":974,"language":21,"meta":27,"style":27},"func aliasingTrap() {\n    s := make([]int, 3, 5)  \u002F\u002F [0 0 0], cap 5 — room for 2 more without realloc\n    t := s                   \u002F\u002F t shares the SAME underlying array\n\n    t = append(t, 42)        \u002F\u002F len(t)=4, still within cap 5 — writes to shared array\n    fmt.Println(s)           \u002F\u002F [0 0 0] — len(s) is still 3, but...\n    fmt.Println(s[:4])       \u002F\u002F [0 0 0 42] — the 42 is in s's underlying array!\n\n    \u002F\u002F When append EXCEEDS capacity, a new array is allocated:\n    t = append(t, 99)        \u002F\u002F len(t)=5, still within cap 5\n    t = append(t, 100)       \u002F\u002F len(t)=6, cap exceeded → NEW array allocated\n    \u002F\u002F Now t points to a new array; s still points to the old one.\n    \u002F\u002F s is [0 0 0 42 99] (cap 5), t is [0 0 0 42 99 100] (new array, new cap)\n}\n\n\u002F\u002F ✅ Full-slice expression to prevent aliasing: s[low:high:max]\n\u002F\u002F   — sets the capacity to (max - low), forcing append to reallocate\nfunc noAliasing() {\n    s := make([]int, 3, 5)\n    t := s[:2:2]  \u002F\u002F cap = 2 (not 5) — append(t, x) MUST allocate a new array\n    t = append(t, 42)\n    fmt.Println(s)  \u002F\u002F [0 0 0] — s's underlying array untouched\n}\n",[29,976,977,986,1012,1025,1029,1049,1061,1078,1082,1087,1105,1124,1129,1134,1138,1142,1147,1152,1161,1184,1206,1220,1231],{"__ignoreMap":27},[32,978,979,981,984],{"class":34,"line":35},[32,980,205],{"class":100},[32,982,983],{"class":208}," aliasingTrap",[32,985,631],{"class":104},[32,987,988,990,992,994,996,998,1000,1002,1004,1006,1009],{"class":34,"line":42},[32,989,587],{"class":104},[32,991,127],{"class":100},[32,993,893],{"class":208},[32,995,896],{"class":104},[32,997,115],{"class":100},[32,999,145],{"class":104},[32,1001,109],{"class":108},[32,1003,145],{"class":104},[32,1005,182],{"class":108},[32,1007,1008],{"class":104},")  ",[32,1010,1011],{"class":38},"\u002F\u002F [0 0 0], cap 5 — room for 2 more without realloc\n",[32,1013,1014,1017,1019,1022],{"class":34,"line":48},[32,1015,1016],{"class":104},"    t ",[32,1018,127],{"class":100},[32,1020,1021],{"class":104}," s                   ",[32,1023,1024],{"class":38},"\u002F\u002F t shares the SAME underlying array\n",[32,1026,1027],{"class":34,"line":54},[32,1028,88],{"emptyLinePlaceholder":87},[32,1030,1031,1033,1035,1037,1040,1043,1046],{"class":34,"line":60},[32,1032,1016],{"class":104},[32,1034,576],{"class":100},[32,1036,592],{"class":208},[32,1038,1039],{"class":104},"(t, ",[32,1041,1042],{"class":108},"42",[32,1044,1045],{"class":104},")        ",[32,1047,1048],{"class":38},"\u002F\u002F len(t)=4, still within cap 5 — writes to shared array\n",[32,1050,1051,1053,1055,1058],{"class":34,"line":66},[32,1052,668],{"class":104},[32,1054,671],{"class":208},[32,1056,1057],{"class":104},"(s)           ",[32,1059,1060],{"class":38},"\u002F\u002F [0 0 0] — len(s) is still 3, but...\n",[32,1062,1063,1065,1067,1070,1072,1075],{"class":34,"line":72},[32,1064,668],{"class":104},[32,1066,671],{"class":208},[32,1068,1069],{"class":104},"(s[:",[32,1071,177],{"class":108},[32,1073,1074],{"class":104},"])       ",[32,1076,1077],{"class":38},"\u002F\u002F [0 0 0 42] — the 42 is in s's underlying array!\n",[32,1079,1080],{"class":34,"line":78},[32,1081,88],{"emptyLinePlaceholder":87},[32,1083,1084],{"class":34,"line":84},[32,1085,1086],{"class":38},"    \u002F\u002F When append EXCEEDS capacity, a new array is allocated:\n",[32,1088,1089,1091,1093,1095,1097,1100,1102],{"class":34,"line":91},[32,1090,1016],{"class":104},[32,1092,576],{"class":100},[32,1094,592],{"class":208},[32,1096,1039],{"class":104},[32,1098,1099],{"class":108},"99",[32,1101,1045],{"class":104},[32,1103,1104],{"class":38},"\u002F\u002F len(t)=5, still within cap 5\n",[32,1106,1107,1109,1111,1113,1115,1118,1121],{"class":34,"line":97},[32,1108,1016],{"class":104},[32,1110,576],{"class":100},[32,1112,592],{"class":208},[32,1114,1039],{"class":104},[32,1116,1117],{"class":108},"100",[32,1119,1120],{"class":104},")       ",[32,1122,1123],{"class":38},"\u002F\u002F len(t)=6, cap exceeded → NEW array allocated\n",[32,1125,1126],{"class":34,"line":121},[32,1127,1128],{"class":38},"    \u002F\u002F Now t points to a new array; s still points to the old one.\n",[32,1130,1131],{"class":34,"line":158},[32,1132,1133],{"class":38},"    \u002F\u002F s is [0 0 0 42 99] (cap 5), t is [0 0 0 42 99 100] (new array, new cap)\n",[32,1135,1136],{"class":34,"line":191},[32,1137,155],{"class":104},[32,1139,1140],{"class":34,"line":196},[32,1141,88],{"emptyLinePlaceholder":87},[32,1143,1144],{"class":34,"line":202},[32,1145,1146],{"class":38},"\u002F\u002F ✅ Full-slice expression to prevent aliasing: s[low:high:max]\n",[32,1148,1149],{"class":34,"line":239},[32,1150,1151],{"class":38},"\u002F\u002F   — sets the capacity to (max - low), forcing append to reallocate\n",[32,1153,1154,1156,1159],{"class":34,"line":250},[32,1155,205],{"class":100},[32,1157,1158],{"class":208}," noAliasing",[32,1160,631],{"class":104},[32,1162,1163,1165,1167,1169,1171,1173,1175,1177,1179,1181],{"class":34,"line":273},[32,1164,587],{"class":104},[32,1166,127],{"class":100},[32,1168,893],{"class":208},[32,1170,896],{"class":104},[32,1172,115],{"class":100},[32,1174,145],{"class":104},[32,1176,109],{"class":108},[32,1178,145],{"class":104},[32,1180,182],{"class":108},[32,1182,1183],{"class":104},")\n",[32,1185,1186,1188,1190,1193,1195,1198,1200,1203],{"class":34,"line":282},[32,1187,1016],{"class":104},[32,1189,127],{"class":100},[32,1191,1192],{"class":104}," s[:",[32,1194,148],{"class":108},[32,1196,1197],{"class":104},":",[32,1199,148],{"class":108},[32,1201,1202],{"class":104},"]  ",[32,1204,1205],{"class":38},"\u002F\u002F cap = 2 (not 5) — append(t, x) MUST allocate a new array\n",[32,1207,1208,1210,1212,1214,1216,1218],{"class":34,"line":287},[32,1209,1016],{"class":104},[32,1211,576],{"class":100},[32,1213,592],{"class":208},[32,1215,1039],{"class":104},[32,1217,1042],{"class":108},[32,1219,1183],{"class":104},[32,1221,1222,1224,1226,1228],{"class":34,"line":292},[32,1223,668],{"class":104},[32,1225,671],{"class":208},[32,1227,674],{"class":104},[32,1229,1230],{"class":38},"\u002F\u002F [0 0 0] — s's underlying array untouched\n",[32,1232,1233],{"class":34,"line":298},[32,1234,155],{"class":104},[14,1236,1238,1241,1242],{"id":1237},"copy-and-slicesclone",[29,1239,1240],{},"copy"," and ",[29,1243,1244],{},"slices.Clone",[19,1246,1247,1521,1527],{"language":21},[23,1248,1250],{"className":25,"code":1249,"language":21,"meta":27,"style":27},"\u002F\u002F copy copies min(len(dst), len(src)) elements — no aliasing.\nfunc copyDemo() {\n    src := []int{1, 2, 3, 4, 5}\n    dst := make([]int, 3)\n    n := copy(dst, src)    \u002F\u002F 3 — copies 3 elements\n    fmt.Println(dst)      \u002F\u002F [1 2 3]\n\n    \u002F\u002F Copy a sub-slice:\n    dst2 := make([]int, 5)\n    copy(dst2[1:], src)   \u002F\u002F dst2 = [0 1 2 3 4]\n    _ = dst2\n}\n\n\u002F\u002F Go 1.21+ slices.Clone — creates an independent copy:\nimport \"slices\"\nfunc cloneDemo() {\n    original := []int{1, 2, 3}\n    copy := slices.Clone(original)  \u002F\u002F new underlying array\n    copy[0] = 99\n    fmt.Println(original)  \u002F\u002F [1 2 3] — unaffected\n    fmt.Println(copy)      \u002F\u002F [99 2 3]\n}\n",[29,1251,1252,1257,1266,1299,1318,1334,1346,1350,1355,1374,1390,1399,1403,1407,1412,1427,1436,1461,1480,1494,1505,1517],{"__ignoreMap":27},[32,1253,1254],{"class":34,"line":35},[32,1255,1256],{"class":38},"\u002F\u002F copy copies min(len(dst), len(src)) elements — no aliasing.\n",[32,1258,1259,1261,1264],{"class":34,"line":42},[32,1260,205],{"class":100},[32,1262,1263],{"class":208}," copyDemo",[32,1265,631],{"class":104},[32,1267,1268,1271,1273,1275,1277,1279,1281,1283,1285,1287,1289,1291,1293,1295,1297],{"class":34,"line":48},[32,1269,1270],{"class":104},"    src ",[32,1272,127],{"class":100},[32,1274,310],{"class":104},[32,1276,115],{"class":100},[32,1278,139],{"class":104},[32,1280,142],{"class":108},[32,1282,145],{"class":104},[32,1284,148],{"class":108},[32,1286,145],{"class":104},[32,1288,109],{"class":108},[32,1290,145],{"class":104},[32,1292,177],{"class":108},[32,1294,145],{"class":104},[32,1296,182],{"class":108},[32,1298,155],{"class":104},[32,1300,1301,1304,1306,1308,1310,1312,1314,1316],{"class":34,"line":54},[32,1302,1303],{"class":104},"    dst ",[32,1305,127],{"class":100},[32,1307,893],{"class":208},[32,1309,896],{"class":104},[32,1311,115],{"class":100},[32,1313,145],{"class":104},[32,1315,109],{"class":108},[32,1317,1183],{"class":104},[32,1319,1320,1323,1325,1328,1331],{"class":34,"line":60},[32,1321,1322],{"class":104},"    n ",[32,1324,127],{"class":100},[32,1326,1327],{"class":208}," copy",[32,1329,1330],{"class":104},"(dst, src)    ",[32,1332,1333],{"class":38},"\u002F\u002F 3 — copies 3 elements\n",[32,1335,1336,1338,1340,1343],{"class":34,"line":66},[32,1337,668],{"class":104},[32,1339,671],{"class":208},[32,1341,1342],{"class":104},"(dst)      ",[32,1344,1345],{"class":38},"\u002F\u002F [1 2 3]\n",[32,1347,1348],{"class":34,"line":72},[32,1349,88],{"emptyLinePlaceholder":87},[32,1351,1352],{"class":34,"line":78},[32,1353,1354],{"class":38},"    \u002F\u002F Copy a sub-slice:\n",[32,1356,1357,1360,1362,1364,1366,1368,1370,1372],{"class":34,"line":84},[32,1358,1359],{"class":104},"    dst2 ",[32,1361,127],{"class":100},[32,1363,893],{"class":208},[32,1365,896],{"class":104},[32,1367,115],{"class":100},[32,1369,145],{"class":104},[32,1371,182],{"class":108},[32,1373,1183],{"class":104},[32,1375,1376,1379,1382,1384,1387],{"class":34,"line":91},[32,1377,1378],{"class":208},"    copy",[32,1380,1381],{"class":104},"(dst2[",[32,1383,142],{"class":108},[32,1385,1386],{"class":104},":], src)   ",[32,1388,1389],{"class":38},"\u002F\u002F dst2 = [0 1 2 3 4]\n",[32,1391,1392,1394,1396],{"class":34,"line":97},[32,1393,608],{"class":104},[32,1395,576],{"class":100},[32,1397,1398],{"class":104}," dst2\n",[32,1400,1401],{"class":34,"line":121},[32,1402,155],{"class":104},[32,1404,1405],{"class":34,"line":158},[32,1406,88],{"emptyLinePlaceholder":87},[32,1408,1409],{"class":34,"line":191},[32,1410,1411],{"class":38},"\u002F\u002F Go 1.21+ slices.Clone — creates an independent copy:\n",[32,1413,1414,1417,1421,1424],{"class":34,"line":196},[32,1415,1416],{"class":100},"import",[32,1418,1420],{"class":1419},"sJ6F3"," \"",[32,1422,1423],{"class":208},"slices",[32,1425,1426],{"class":1419},"\"\n",[32,1428,1429,1431,1434],{"class":34,"line":202},[32,1430,205],{"class":100},[32,1432,1433],{"class":208}," cloneDemo",[32,1435,631],{"class":104},[32,1437,1438,1441,1443,1445,1447,1449,1451,1453,1455,1457,1459],{"class":34,"line":239},[32,1439,1440],{"class":104},"    original ",[32,1442,127],{"class":100},[32,1444,310],{"class":104},[32,1446,115],{"class":100},[32,1448,139],{"class":104},[32,1450,142],{"class":108},[32,1452,145],{"class":104},[32,1454,148],{"class":108},[32,1456,145],{"class":104},[32,1458,109],{"class":108},[32,1460,155],{"class":104},[32,1462,1463,1466,1468,1471,1474,1477],{"class":34,"line":250},[32,1464,1465],{"class":104},"    copy ",[32,1467,127],{"class":100},[32,1469,1470],{"class":104}," slices.",[32,1472,1473],{"class":208},"Clone",[32,1475,1476],{"class":104},"(original)  ",[32,1478,1479],{"class":38},"\u002F\u002F new underlying array\n",[32,1481,1482,1485,1487,1489,1491],{"class":34,"line":273},[32,1483,1484],{"class":104},"    copy[",[32,1486,570],{"class":108},[32,1488,573],{"class":104},[32,1490,576],{"class":100},[32,1492,1493],{"class":108}," 99\n",[32,1495,1496,1498,1500,1502],{"class":34,"line":282},[32,1497,668],{"class":104},[32,1499,671],{"class":208},[32,1501,1476],{"class":104},[32,1503,1504],{"class":38},"\u002F\u002F [1 2 3] — unaffected\n",[32,1506,1507,1509,1511,1514],{"class":34,"line":287},[32,1508,668],{"class":104},[32,1510,671],{"class":208},[32,1512,1513],{"class":104},"(copy)      ",[32,1515,1516],{"class":38},"\u002F\u002F [99 2 3]\n",[32,1518,1519],{"class":34,"line":292},[32,1520,155],{"class":104},[14,1522,1524,1526],{"id":1523},"slices-package-go-121-production-slice-operations",[29,1525,1423],{}," Package (Go 1.21+) — Production Slice Operations",[19,1528,1529,1980,1984],{"language":21},[23,1530,1532],{"className":25,"code":1531,"language":21,"meta":27,"style":27},"import \"slices\"\n\nfunc slicesPkg() {\n    s := []int{3, 1, 4, 1, 5, 9, 2, 6}\n\n    \u002F\u002F Sorting (generic — works with any ordered type):\n    slices.Sort(s)                      \u002F\u002F [1 1 2 3 4 5 6 9]\n    slices.SortStableFunc(s, func(a, b int) int { return a - b })\n\n    \u002F\u002F Searching (sorted slice required):\n    idx, found := slices.BinarySearch(s, 5)  \u002F\u002F idx=5, found=true\n\n    \u002F\u002F Insert at index:\n    s = slices.Insert(s, 0, 0)  \u002F\u002F insert 0 at front: [0 1 1 2 3 4 5 6 9]\n\n    \u002F\u002F Delete range [low, high):\n    s = slices.Delete(s, 0, 2)  \u002F\u002F remove indices 0,1: [1 2 3 4 5 6 9]\n\n    \u002F\u002F Delete by predicate:\n    s = slices.DeleteFunc(s, func(v int) bool { return v \u003C 3 })\n\n    \u002F\u002F Contains:\n    if slices.Contains(s, 5) { \u002F* ... *\u002F }\n\n    \u002F\u002F Reverse (in place):\n    slices.Reverse(s)\n\n    \u002F\u002F Max\u002FMin (ordered):\n    largest := slices.Max(s)\n    smallest := slices.Min(s)\n\n    \u002F\u002F Compact (remove consecutive duplicates — like Unix uniq):\n    dupes := []int{1, 1, 2, 2, 2, 3}\n    compact := slices.Compact(dupes)  \u002F\u002F [1 2 3]\n    _ = compact\n}\n",[29,1533,1534,1544,1548,1557,1603,1607,1612,1626,1668,1672,1677,1698,1702,1707,1731,1735,1740,1764,1768,1773,1815,1819,1824,1847,1851,1856,1865,1869,1874,1888,1902,1906,1911,1948,1965,1975],{"__ignoreMap":27},[32,1535,1536,1538,1540,1542],{"class":34,"line":35},[32,1537,1416],{"class":100},[32,1539,1420],{"class":1419},[32,1541,1423],{"class":208},[32,1543,1426],{"class":1419},[32,1545,1546],{"class":34,"line":42},[32,1547,88],{"emptyLinePlaceholder":87},[32,1549,1550,1552,1555],{"class":34,"line":48},[32,1551,205],{"class":100},[32,1553,1554],{"class":208}," slicesPkg",[32,1556,631],{"class":104},[32,1558,1559,1561,1563,1565,1567,1569,1571,1573,1575,1577,1579,1581,1583,1585,1587,1589,1592,1594,1596,1598,1601],{"class":34,"line":54},[32,1560,587],{"class":104},[32,1562,127],{"class":100},[32,1564,310],{"class":104},[32,1566,115],{"class":100},[32,1568,139],{"class":104},[32,1570,109],{"class":108},[32,1572,145],{"class":104},[32,1574,142],{"class":108},[32,1576,145],{"class":104},[32,1578,177],{"class":108},[32,1580,145],{"class":104},[32,1582,142],{"class":108},[32,1584,145],{"class":104},[32,1586,182],{"class":108},[32,1588,145],{"class":104},[32,1590,1591],{"class":108},"9",[32,1593,145],{"class":104},[32,1595,148],{"class":108},[32,1597,145],{"class":104},[32,1599,1600],{"class":108},"6",[32,1602,155],{"class":104},[32,1604,1605],{"class":34,"line":60},[32,1606,88],{"emptyLinePlaceholder":87},[32,1608,1609],{"class":34,"line":66},[32,1610,1611],{"class":38},"    \u002F\u002F Sorting (generic — works with any ordered type):\n",[32,1613,1614,1617,1620,1623],{"class":34,"line":72},[32,1615,1616],{"class":104},"    slices.",[32,1618,1619],{"class":208},"Sort",[32,1621,1622],{"class":104},"(s)                      ",[32,1624,1625],{"class":38},"\u002F\u002F [1 1 2 3 4 5 6 9]\n",[32,1627,1628,1630,1633,1635,1637,1639,1642,1644,1647,1649,1651,1653,1656,1659,1662,1665],{"class":34,"line":78},[32,1629,1616],{"class":104},[32,1631,1632],{"class":208},"SortStableFunc",[32,1634,595],{"class":104},[32,1636,205],{"class":100},[32,1638,212],{"class":104},[32,1640,1641],{"class":215},"a",[32,1643,145],{"class":104},[32,1645,1646],{"class":215},"b",[32,1648,743],{"class":100},[32,1650,228],{"class":104},[32,1652,115],{"class":100},[32,1654,1655],{"class":104}," { ",[32,1657,1658],{"class":100},"return",[32,1660,1661],{"class":104}," a ",[32,1663,1664],{"class":100},"-",[32,1666,1667],{"class":104}," b })\n",[32,1669,1670],{"class":34,"line":84},[32,1671,88],{"emptyLinePlaceholder":87},[32,1673,1674],{"class":34,"line":91},[32,1675,1676],{"class":38},"    \u002F\u002F Searching (sorted slice required):\n",[32,1678,1679,1682,1684,1686,1689,1691,1693,1695],{"class":34,"line":97},[32,1680,1681],{"class":104},"    idx, found ",[32,1683,127],{"class":100},[32,1685,1470],{"class":104},[32,1687,1688],{"class":208},"BinarySearch",[32,1690,595],{"class":104},[32,1692,182],{"class":108},[32,1694,1008],{"class":104},[32,1696,1697],{"class":38},"\u002F\u002F idx=5, found=true\n",[32,1699,1700],{"class":34,"line":121},[32,1701,88],{"emptyLinePlaceholder":87},[32,1703,1704],{"class":34,"line":158},[32,1705,1706],{"class":38},"    \u002F\u002F Insert at index:\n",[32,1708,1709,1711,1713,1715,1718,1720,1722,1724,1726,1728],{"class":34,"line":191},[32,1710,587],{"class":104},[32,1712,576],{"class":100},[32,1714,1470],{"class":104},[32,1716,1717],{"class":208},"Insert",[32,1719,595],{"class":104},[32,1721,570],{"class":108},[32,1723,145],{"class":104},[32,1725,570],{"class":108},[32,1727,1008],{"class":104},[32,1729,1730],{"class":38},"\u002F\u002F insert 0 at front: [0 1 1 2 3 4 5 6 9]\n",[32,1732,1733],{"class":34,"line":196},[32,1734,88],{"emptyLinePlaceholder":87},[32,1736,1737],{"class":34,"line":202},[32,1738,1739],{"class":38},"    \u002F\u002F Delete range [low, high):\n",[32,1741,1742,1744,1746,1748,1751,1753,1755,1757,1759,1761],{"class":34,"line":239},[32,1743,587],{"class":104},[32,1745,576],{"class":100},[32,1747,1470],{"class":104},[32,1749,1750],{"class":208},"Delete",[32,1752,595],{"class":104},[32,1754,570],{"class":108},[32,1756,145],{"class":104},[32,1758,148],{"class":108},[32,1760,1008],{"class":104},[32,1762,1763],{"class":38},"\u002F\u002F remove indices 0,1: [1 2 3 4 5 6 9]\n",[32,1765,1766],{"class":34,"line":250},[32,1767,88],{"emptyLinePlaceholder":87},[32,1769,1770],{"class":34,"line":273},[32,1771,1772],{"class":38},"    \u002F\u002F Delete by predicate:\n",[32,1774,1775,1777,1779,1781,1784,1786,1788,1790,1793,1795,1797,1800,1802,1804,1807,1809,1812],{"class":34,"line":282},[32,1776,587],{"class":104},[32,1778,576],{"class":100},[32,1780,1470],{"class":104},[32,1782,1783],{"class":208},"DeleteFunc",[32,1785,595],{"class":104},[32,1787,205],{"class":100},[32,1789,212],{"class":104},[32,1791,1792],{"class":215},"v",[32,1794,743],{"class":100},[32,1796,228],{"class":104},[32,1798,1799],{"class":100},"bool",[32,1801,1655],{"class":104},[32,1803,1658],{"class":100},[32,1805,1806],{"class":104}," v ",[32,1808,926],{"class":100},[32,1810,1811],{"class":108}," 3",[32,1813,1814],{"class":104}," })\n",[32,1816,1817],{"class":34,"line":287},[32,1818,88],{"emptyLinePlaceholder":87},[32,1820,1821],{"class":34,"line":292},[32,1822,1823],{"class":38},"    \u002F\u002F Contains:\n",[32,1825,1826,1829,1831,1834,1836,1838,1841,1844],{"class":34,"line":298},[32,1827,1828],{"class":100},"    if",[32,1830,1470],{"class":104},[32,1832,1833],{"class":208},"Contains",[32,1835,595],{"class":104},[32,1837,182],{"class":108},[32,1839,1840],{"class":104},") { ",[32,1842,1843],{"class":38},"\u002F* ... *\u002F",[32,1845,1846],{"class":104}," }\n",[32,1848,1849],{"class":34,"line":322},[32,1850,88],{"emptyLinePlaceholder":87},[32,1852,1853],{"class":34,"line":331},[32,1854,1855],{"class":38},"    \u002F\u002F Reverse (in place):\n",[32,1857,1858,1860,1863],{"class":34,"line":348},[32,1859,1616],{"class":104},[32,1861,1862],{"class":208},"Reverse",[32,1864,663],{"class":104},[32,1866,1867],{"class":34,"line":355},[32,1868,88],{"emptyLinePlaceholder":87},[32,1870,1871],{"class":34,"line":360},[32,1872,1873],{"class":38},"    \u002F\u002F Max\u002FMin (ordered):\n",[32,1875,1876,1879,1881,1883,1886],{"class":34,"line":365},[32,1877,1878],{"class":104},"    largest ",[32,1880,127],{"class":100},[32,1882,1470],{"class":104},[32,1884,1885],{"class":208},"Max",[32,1887,663],{"class":104},[32,1889,1890,1893,1895,1897,1900],{"class":34,"line":371},[32,1891,1892],{"class":104},"    smallest ",[32,1894,127],{"class":100},[32,1896,1470],{"class":104},[32,1898,1899],{"class":208},"Min",[32,1901,663],{"class":104},[32,1903,1904],{"class":34,"line":377},[32,1905,88],{"emptyLinePlaceholder":87},[32,1907,1908],{"class":34,"line":383},[32,1909,1910],{"class":38},"    \u002F\u002F Compact (remove consecutive duplicates — like Unix uniq):\n",[32,1912,1913,1916,1918,1920,1922,1924,1926,1928,1930,1932,1934,1936,1938,1940,1942,1944,1946],{"class":34,"line":389},[32,1914,1915],{"class":104},"    dupes ",[32,1917,127],{"class":100},[32,1919,310],{"class":104},[32,1921,115],{"class":100},[32,1923,139],{"class":104},[32,1925,142],{"class":108},[32,1927,145],{"class":104},[32,1929,142],{"class":108},[32,1931,145],{"class":104},[32,1933,148],{"class":108},[32,1935,145],{"class":104},[32,1937,148],{"class":108},[32,1939,145],{"class":104},[32,1941,148],{"class":108},[32,1943,145],{"class":104},[32,1945,109],{"class":108},[32,1947,155],{"class":104},[32,1949,1950,1953,1955,1957,1960,1963],{"class":34,"line":680},[32,1951,1952],{"class":104},"    compact ",[32,1954,127],{"class":100},[32,1956,1470],{"class":104},[32,1958,1959],{"class":208},"Compact",[32,1961,1962],{"class":104},"(dupes)  ",[32,1964,1345],{"class":38},[32,1966,1968,1970,1972],{"class":34,"line":1967},35,[32,1969,608],{"class":104},[32,1971,576],{"class":100},[32,1973,1974],{"class":104}," compact\n",[32,1976,1978],{"class":34,"line":1977},36,[32,1979,155],{"class":104},[14,1981,1983],{"id":1982},"zero-allocation-stringbyte-patterns","Zero-Allocation String\u002FByte Patterns",[19,1985,1986,2436,2440],{"language":21},[23,1987,1989],{"className":25,"code":1988,"language":21,"meta":27,"style":27},"\u002F\u002F ─── strings.Builder — amortized O(n) concatenation ───\nfunc buildString(parts []string) string {\n    \u002F\u002F Estimate total length to pre-grow (avoids reallocations):\n    total := 0\n    for _, p := range parts { total += len(p) }\n\n    var b strings.Builder\n    b.Grow(total)  \u002F\u002F pre-allocate — one allocation, no reallocations\n    for _, p := range parts {\n        b.WriteString(p)\n    }\n    return b.String()  \u002F\u002F zero-copy: returns the internal buffer directly\n}\n\n\u002F\u002F ─── bytes.Buffer — mutable byte buffer (for byte-level work) ───\nfunc buildBytes(parts [][]byte) []byte {\n    var buf bytes.Buffer\n    for _, p := range parts {\n        buf.Write(p)  \u002F\u002F Write([]byte) — no string conversion\n    }\n    return buf.Bytes()  \u002F\u002F returns the internal slice (alias, not a copy)\n}\n\n\u002F\u002F ─── unsafe zero-copy string ↔ []byte (Go 1.20+ — advanced) ───\n\u002F\u002F import \"unsafe\"\nfunc unsafeZeroCopy() {\n    s := \"hello\"\n    \u002F\u002F Get a []byte that shares s's memory — ZERO allocation:\n    b := unsafe.Slice(unsafe.StringData(s), len(s))\n    \u002F\u002F ⚠️ b shares the string's read-only memory. NEVER modify b —\n    \u002F\u002F it would corrupt the read-only string table and cause crashes.\n    \u002F\u002F Only use this for READ-ONLY operations (hashing, comparison).\n\n    \u002F\u002F The reverse: []byte → string without copying:\n    b2 := []byte{'w', 'o', 'r', 'l', 'd'}\n    s2 := unsafe.String(&b2[0], len(b2))\n    \u002F\u002F ⚠️ s2 aliases b2's memory. Modifying b2 after this corrupts s2.\n    \u002F\u002F Only safe if b2 is never modified after this point.\n    _ = s2\n}\n",[29,1990,1991,1996,2019,2024,2032,2054,2058,2074,2088,2101,2112,2116,2132,2136,2140,2145,2168,2183,2195,2209,2213,2228,2232,2236,2241,2246,2255,2264,2269,2297,2302,2307,2312,2316,2321,2380,2409,2415,2421,2431],{"__ignoreMap":27},[32,1992,1993],{"class":34,"line":35},[32,1994,1995],{"class":38},"\u002F\u002F ─── strings.Builder — amortized O(n) concatenation ───\n",[32,1997,1998,2000,2003,2005,2008,2010,2013,2015,2017],{"class":34,"line":42},[32,1999,205],{"class":100},[32,2001,2002],{"class":208}," buildString",[32,2004,212],{"class":104},[32,2006,2007],{"class":215},"parts",[32,2009,310],{"class":104},[32,2011,2012],{"class":100},"string",[32,2014,228],{"class":104},[32,2016,2012],{"class":100},[32,2018,319],{"class":104},[32,2020,2021],{"class":34,"line":48},[32,2022,2023],{"class":38},"    \u002F\u002F Estimate total length to pre-grow (avoids reallocations):\n",[32,2025,2026,2028,2030],{"class":34,"line":54},[32,2027,242],{"class":104},[32,2029,127],{"class":100},[32,2031,247],{"class":108},[32,2033,2034,2036,2039,2041,2043,2046,2048,2051],{"class":34,"line":60},[32,2035,253],{"class":100},[32,2037,2038],{"class":104}," _, p ",[32,2040,127],{"class":100},[32,2042,261],{"class":100},[32,2044,2045],{"class":104}," parts { total ",[32,2047,267],{"class":100},[32,2049,2050],{"class":208}," len",[32,2052,2053],{"class":104},"(p) }\n",[32,2055,2056],{"class":34,"line":66},[32,2057,88],{"emptyLinePlaceholder":87},[32,2059,2060,2063,2066,2069,2071],{"class":34,"line":72},[32,2061,2062],{"class":100},"    var",[32,2064,2065],{"class":104}," b ",[32,2067,2068],{"class":208},"strings",[32,2070,490],{"class":104},[32,2072,2073],{"class":208},"Builder\n",[32,2075,2076,2079,2082,2085],{"class":34,"line":78},[32,2077,2078],{"class":104},"    b.",[32,2080,2081],{"class":208},"Grow",[32,2083,2084],{"class":104},"(total)  ",[32,2086,2087],{"class":38},"\u002F\u002F pre-allocate — one allocation, no reallocations\n",[32,2089,2090,2092,2094,2096,2098],{"class":34,"line":84},[32,2091,253],{"class":100},[32,2093,2038],{"class":104},[32,2095,127],{"class":100},[32,2097,261],{"class":100},[32,2099,2100],{"class":104}," parts {\n",[32,2102,2103,2106,2109],{"class":34,"line":91},[32,2104,2105],{"class":104},"        b.",[32,2107,2108],{"class":208},"WriteString",[32,2110,2111],{"class":104},"(p)\n",[32,2113,2114],{"class":34,"line":97},[32,2115,954],{"class":104},[32,2117,2118,2120,2123,2126,2129],{"class":34,"line":121},[32,2119,276],{"class":100},[32,2121,2122],{"class":104}," b.",[32,2124,2125],{"class":208},"String",[32,2127,2128],{"class":104},"()  ",[32,2130,2131],{"class":38},"\u002F\u002F zero-copy: returns the internal buffer directly\n",[32,2133,2134],{"class":34,"line":158},[32,2135,155],{"class":104},[32,2137,2138],{"class":34,"line":191},[32,2139,88],{"emptyLinePlaceholder":87},[32,2141,2142],{"class":34,"line":196},[32,2143,2144],{"class":38},"\u002F\u002F ─── bytes.Buffer — mutable byte buffer (for byte-level work) ───\n",[32,2146,2147,2149,2152,2154,2156,2159,2162,2164,2166],{"class":34,"line":202},[32,2148,205],{"class":100},[32,2150,2151],{"class":208}," buildBytes",[32,2153,212],{"class":104},[32,2155,2007],{"class":215},[32,2157,2158],{"class":104}," [][]",[32,2160,2161],{"class":100},"byte",[32,2163,798],{"class":104},[32,2165,2161],{"class":100},[32,2167,319],{"class":104},[32,2169,2170,2172,2175,2178,2180],{"class":34,"line":239},[32,2171,2062],{"class":100},[32,2173,2174],{"class":104}," buf ",[32,2176,2177],{"class":208},"bytes",[32,2179,490],{"class":104},[32,2181,2182],{"class":208},"Buffer\n",[32,2184,2185,2187,2189,2191,2193],{"class":34,"line":250},[32,2186,253],{"class":100},[32,2188,2038],{"class":104},[32,2190,127],{"class":100},[32,2192,261],{"class":100},[32,2194,2100],{"class":104},[32,2196,2197,2200,2203,2206],{"class":34,"line":273},[32,2198,2199],{"class":104},"        buf.",[32,2201,2202],{"class":208},"Write",[32,2204,2205],{"class":104},"(p)  ",[32,2207,2208],{"class":38},"\u002F\u002F Write([]byte) — no string conversion\n",[32,2210,2211],{"class":34,"line":282},[32,2212,954],{"class":104},[32,2214,2215,2217,2220,2223,2225],{"class":34,"line":287},[32,2216,276],{"class":100},[32,2218,2219],{"class":104}," buf.",[32,2221,2222],{"class":208},"Bytes",[32,2224,2128],{"class":104},[32,2226,2227],{"class":38},"\u002F\u002F returns the internal slice (alias, not a copy)\n",[32,2229,2230],{"class":34,"line":292},[32,2231,155],{"class":104},[32,2233,2234],{"class":34,"line":298},[32,2235,88],{"emptyLinePlaceholder":87},[32,2237,2238],{"class":34,"line":322},[32,2239,2240],{"class":38},"\u002F\u002F ─── unsafe zero-copy string ↔ []byte (Go 1.20+ — advanced) ───\n",[32,2242,2243],{"class":34,"line":331},[32,2244,2245],{"class":38},"\u002F\u002F import \"unsafe\"\n",[32,2247,2248,2250,2253],{"class":34,"line":348},[32,2249,205],{"class":100},[32,2251,2252],{"class":208}," unsafeZeroCopy",[32,2254,631],{"class":104},[32,2256,2257,2259,2261],{"class":34,"line":355},[32,2258,587],{"class":104},[32,2260,127],{"class":100},[32,2262,2263],{"class":1419}," \"hello\"\n",[32,2265,2266],{"class":34,"line":360},[32,2267,2268],{"class":38},"    \u002F\u002F Get a []byte that shares s's memory — ZERO allocation:\n",[32,2270,2271,2274,2276,2279,2282,2285,2288,2291,2294],{"class":34,"line":365},[32,2272,2273],{"class":104},"    b ",[32,2275,127],{"class":100},[32,2277,2278],{"class":104}," unsafe.",[32,2280,2281],{"class":208},"Slice",[32,2283,2284],{"class":104},"(unsafe.",[32,2286,2287],{"class":208},"StringData",[32,2289,2290],{"class":104},"(s), ",[32,2292,2293],{"class":208},"len",[32,2295,2296],{"class":104},"(s))\n",[32,2298,2299],{"class":34,"line":371},[32,2300,2301],{"class":38},"    \u002F\u002F ⚠️ b shares the string's read-only memory. NEVER modify b —\n",[32,2303,2304],{"class":34,"line":377},[32,2305,2306],{"class":38},"    \u002F\u002F it would corrupt the read-only string table and cause crashes.\n",[32,2308,2309],{"class":34,"line":383},[32,2310,2311],{"class":38},"    \u002F\u002F Only use this for READ-ONLY operations (hashing, comparison).\n",[32,2313,2314],{"class":34,"line":389},[32,2315,88],{"emptyLinePlaceholder":87},[32,2317,2318],{"class":34,"line":680},[32,2319,2320],{"class":38},"    \u002F\u002F The reverse: []byte → string without copying:\n",[32,2322,2323,2326,2328,2330,2332,2334,2337,2340,2342,2344,2346,2349,2351,2353,2355,2358,2360,2362,2364,2367,2369,2371,2373,2376,2378],{"class":34,"line":1967},[32,2324,2325],{"class":104},"    b2 ",[32,2327,127],{"class":100},[32,2329,310],{"class":104},[32,2331,2161],{"class":100},[32,2333,139],{"class":104},[32,2335,2336],{"class":1419},"'",[32,2338,2339],{"class":108},"w",[32,2341,2336],{"class":1419},[32,2343,145],{"class":104},[32,2345,2336],{"class":1419},[32,2347,2348],{"class":108},"o",[32,2350,2336],{"class":1419},[32,2352,145],{"class":104},[32,2354,2336],{"class":1419},[32,2356,2357],{"class":108},"r",[32,2359,2336],{"class":1419},[32,2361,145],{"class":104},[32,2363,2336],{"class":1419},[32,2365,2366],{"class":108},"l",[32,2368,2336],{"class":1419},[32,2370,145],{"class":104},[32,2372,2336],{"class":1419},[32,2374,2375],{"class":108},"d",[32,2377,2336],{"class":1419},[32,2379,155],{"class":104},[32,2381,2382,2385,2387,2389,2391,2393,2396,2399,2401,2404,2406],{"class":34,"line":1977},[32,2383,2384],{"class":104},"    s2 ",[32,2386,127],{"class":100},[32,2388,2278],{"class":104},[32,2390,2125],{"class":208},[32,2392,212],{"class":104},[32,2394,2395],{"class":100},"&",[32,2397,2398],{"class":104},"b2[",[32,2400,570],{"class":108},[32,2402,2403],{"class":104},"], ",[32,2405,2293],{"class":208},[32,2407,2408],{"class":104},"(b2))\n",[32,2410,2412],{"class":34,"line":2411},37,[32,2413,2414],{"class":38},"    \u002F\u002F ⚠️ s2 aliases b2's memory. Modifying b2 after this corrupts s2.\n",[32,2416,2418],{"class":34,"line":2417},38,[32,2419,2420],{"class":38},"    \u002F\u002F Only safe if b2 is never modified after this point.\n",[32,2422,2424,2426,2428],{"class":34,"line":2423},39,[32,2425,608],{"class":104},[32,2427,576],{"class":100},[32,2429,2430],{"class":104}," s2\n",[32,2432,2434],{"class":34,"line":2433},40,[32,2435,155],{"class":104},[14,2437,2439],{"id":2438},"performance-pre-allocation-benchmark","Performance — Pre-allocation Benchmark",[19,2441,2442,2725,2729,2847,2851,3007,3011],{"language":21},[23,2443,2445],{"className":25,"code":2444,"language":21,"meta":27,"style":27},"\u002F\u002F benchmark_test.go\nfunc BenchmarkAppendNoPrealloc(b *testing.B) {\n    b.ReportAllocs()\n    for n := 0; n \u003C b.N; n++ {\n        s := []int{}            \u002F\u002F starts nil, grows via append\n        for i := 0; i \u003C 1000; i++ {\n            s = append(s, i)\n        }\n    }\n}\n\u002F\u002F Result: ~1000 allocs\u002Fop (one per reallocation cycle)\n\u002F\u002F         ~8000 B\u002Fop\n\nfunc BenchmarkAppendPrealloc(b *testing.B) {\n    b.ReportAllocs()\n    for n := 0; n \u003C b.N; n++ {\n        s := make([]int, 0, 1000)  \u002F\u002F one allocation, capacity for all\n        for i := 0; i \u003C 1000; i++ {\n            s = append(s, i)  \u002F\u002F stays within cap — zero reallocations\n        }\n    }\n}\n\u002F\u002F Result: 1 alloc\u002Fop (the initial make)\n\u002F\u002F         ~8000 B\u002Fop\n\u002F\u002F ~10x fewer allocations, same memory — the allocation overhead is the win\n",[29,2446,2447,2452,2476,2486,2509,2525,2550,2562,2567,2571,2575,2580,2585,2589,2610,2618,2638,2663,2685,2699,2703,2707,2711,2716,2720],{"__ignoreMap":27},[32,2448,2449],{"class":34,"line":35},[32,2450,2451],{"class":38},"\u002F\u002F benchmark_test.go\n",[32,2453,2454,2456,2459,2461,2463,2466,2469,2471,2474],{"class":34,"line":42},[32,2455,205],{"class":100},[32,2457,2458],{"class":208}," BenchmarkAppendNoPrealloc",[32,2460,212],{"class":104},[32,2462,1646],{"class":215},[32,2464,2465],{"class":100}," *",[32,2467,2468],{"class":208},"testing",[32,2470,490],{"class":104},[32,2472,2473],{"class":208},"B",[32,2475,562],{"class":104},[32,2477,2478,2480,2483],{"class":34,"line":48},[32,2479,2078],{"class":104},[32,2481,2482],{"class":208},"ReportAllocs",[32,2484,2485],{"class":104},"()\n",[32,2487,2488,2490,2493,2495,2497,2500,2502,2505,2507],{"class":34,"line":54},[32,2489,253],{"class":100},[32,2491,2492],{"class":104}," n ",[32,2494,127],{"class":100},[32,2496,920],{"class":108},[32,2498,2499],{"class":104},"; n ",[32,2501,926],{"class":100},[32,2503,2504],{"class":104}," b.N; n",[32,2506,932],{"class":100},[32,2508,319],{"class":104},[32,2510,2511,2513,2515,2517,2519,2522],{"class":34,"line":60},[32,2512,939],{"class":104},[32,2514,127],{"class":100},[32,2516,310],{"class":104},[32,2518,115],{"class":100},[32,2520,2521],{"class":104},"{}            ",[32,2523,2524],{"class":38},"\u002F\u002F starts nil, grows via append\n",[32,2526,2527,2530,2532,2534,2536,2538,2540,2543,2546,2548],{"class":34,"line":66},[32,2528,2529],{"class":100},"        for",[32,2531,915],{"class":104},[32,2533,127],{"class":100},[32,2535,920],{"class":108},[32,2537,923],{"class":104},[32,2539,926],{"class":100},[32,2541,2542],{"class":108}," 1000",[32,2544,2545],{"class":104},"; i",[32,2547,932],{"class":100},[32,2549,319],{"class":104},[32,2551,2552,2555,2557,2559],{"class":34,"line":72},[32,2553,2554],{"class":104},"            s ",[32,2556,576],{"class":100},[32,2558,592],{"class":208},[32,2560,2561],{"class":104},"(s, i)\n",[32,2563,2564],{"class":34,"line":78},[32,2565,2566],{"class":104},"        }\n",[32,2568,2569],{"class":34,"line":84},[32,2570,954],{"class":104},[32,2572,2573],{"class":34,"line":91},[32,2574,155],{"class":104},[32,2576,2577],{"class":34,"line":97},[32,2578,2579],{"class":38},"\u002F\u002F Result: ~1000 allocs\u002Fop (one per reallocation cycle)\n",[32,2581,2582],{"class":34,"line":121},[32,2583,2584],{"class":38},"\u002F\u002F         ~8000 B\u002Fop\n",[32,2586,2587],{"class":34,"line":158},[32,2588,88],{"emptyLinePlaceholder":87},[32,2590,2591,2593,2596,2598,2600,2602,2604,2606,2608],{"class":34,"line":191},[32,2592,205],{"class":100},[32,2594,2595],{"class":208}," BenchmarkAppendPrealloc",[32,2597,212],{"class":104},[32,2599,1646],{"class":215},[32,2601,2465],{"class":100},[32,2603,2468],{"class":208},[32,2605,490],{"class":104},[32,2607,2473],{"class":208},[32,2609,562],{"class":104},[32,2611,2612,2614,2616],{"class":34,"line":196},[32,2613,2078],{"class":104},[32,2615,2482],{"class":208},[32,2617,2485],{"class":104},[32,2619,2620,2622,2624,2626,2628,2630,2632,2634,2636],{"class":34,"line":202},[32,2621,253],{"class":100},[32,2623,2492],{"class":104},[32,2625,127],{"class":100},[32,2627,920],{"class":108},[32,2629,2499],{"class":104},[32,2631,926],{"class":100},[32,2633,2504],{"class":104},[32,2635,932],{"class":100},[32,2637,319],{"class":104},[32,2639,2640,2642,2644,2646,2648,2650,2652,2654,2656,2658,2660],{"class":34,"line":239},[32,2641,939],{"class":104},[32,2643,127],{"class":100},[32,2645,893],{"class":208},[32,2647,896],{"class":104},[32,2649,115],{"class":100},[32,2651,145],{"class":104},[32,2653,570],{"class":108},[32,2655,145],{"class":104},[32,2657,221],{"class":108},[32,2659,1008],{"class":104},[32,2661,2662],{"class":38},"\u002F\u002F one allocation, capacity for all\n",[32,2664,2665,2667,2669,2671,2673,2675,2677,2679,2681,2683],{"class":34,"line":250},[32,2666,2529],{"class":100},[32,2668,915],{"class":104},[32,2670,127],{"class":100},[32,2672,920],{"class":108},[32,2674,923],{"class":104},[32,2676,926],{"class":100},[32,2678,2542],{"class":108},[32,2680,2545],{"class":104},[32,2682,932],{"class":100},[32,2684,319],{"class":104},[32,2686,2687,2689,2691,2693,2696],{"class":34,"line":273},[32,2688,2554],{"class":104},[32,2690,576],{"class":100},[32,2692,592],{"class":208},[32,2694,2695],{"class":104},"(s, i)  ",[32,2697,2698],{"class":38},"\u002F\u002F stays within cap — zero reallocations\n",[32,2700,2701],{"class":34,"line":282},[32,2702,2566],{"class":104},[32,2704,2705],{"class":34,"line":287},[32,2706,954],{"class":104},[32,2708,2709],{"class":34,"line":292},[32,2710,155],{"class":104},[32,2712,2713],{"class":34,"line":298},[32,2714,2715],{"class":38},"\u002F\u002F Result: 1 alloc\u002Fop (the initial make)\n",[32,2717,2718],{"class":34,"line":322},[32,2719,2584],{"class":38},[32,2721,2722],{"class":34,"line":331},[32,2723,2724],{"class":38},"\u002F\u002F ~10x fewer allocations, same memory — the allocation overhead is the win\n",[14,2726,2728],{"id":2727},"tips-tricks","💡 Tips & Tricks",[2730,2731,2732,2751,2768,2784,2798,2817],"ul",{},[2733,2734,2735,2739,2740,2743,2744,2747,2748,2750],"li",{},[2736,2737,2738],"strong",{},"Performance",": ",[29,2741,2742],{},"make([]T, 0, capacity)"," when you know the eventual size — pre-allocating avoids repeated reallocations. The zero in ",[29,2745,2746],{},"make([]T, 0, n)"," means \"don't pre-fill with zero values I'll overwrite\"; the ",[29,2749,876],{}," means \"reserve space for n elements.\"",[2733,2752,2753,2756,2757,2760,2761,2764,2765,2767],{},[2736,2754,2755],{},"Safety",": use the full-slice expression ",[29,2758,2759],{},"s[low:high:max]"," when you need to prevent aliasing — ",[29,2762,2763],{},"s[:2:2]"," forces ",[29,2766,688],{}," to allocate a new array, so the caller's underlying array is never modified.",[2733,2769,2770,2739,2773,2776,2777,2780,2781,2783],{},[2736,2771,2772],{},"Idiom",[29,2774,2775],{},"slices.Clone(s)"," (Go 1.21+) is the clear way to make an independent copy — ",[29,2778,2779],{},"make([]T, len(s)); copy(...)"," is verbose. ",[29,2782,1244],{}," allocates a new array and copies all elements.",[2733,2785,2786,2739,2788,2791,2792,2794,2795,2797],{},[2736,2787,2738],{},[29,2789,2790],{},"strings.Builder.Grow(total)"," before writing — estimate the total size and pre-grow. Without ",[29,2793,2081],{},", the builder doubles its buffer, causing log(n) reallocations. One ",[29,2796,2081],{}," call can eliminate all of them.",[2733,2799,2800,2739,2802,2805,2806,2809,2810,2813,2814,490],{},[2736,2801,2772],{},[29,2803,2804],{},"bytes.Equal(a, b)"," is faster than ",[29,2807,2808],{},"string(a) == string(b)"," — it compares bytes directly without allocating string conversions. Same for ",[29,2811,2812],{},"bytes.Compare"," vs ",[29,2815,2816],{},"strings.Compare",[2733,2818,2819,2822,2823,2826,2827,2829,2830,2833,2834,2837,2838,2840,2841,2843,2844,490],{},[2736,2820,2821],{},"Debug",": the slice aliasing trap — ",[29,2824,2825],{},"t := s; t = append(t, x)"," may modify ",[29,2828,555],{},"'s underlying array if ",[29,2831,2832],{},"t","'s append stays within ",[29,2835,2836],{},"cap(s)",". If you need ",[29,2839,2832],{}," independent, use ",[29,2842,2775],{}," or the full-slice expression ",[29,2845,2846],{},"s[:len(s):len(s)]",[14,2848,2850],{"id":2849},"️-edge-cases-gotchas","⚠️ Edge Cases & Gotchas",[2730,2852,2853,2885,2903,2915,2933,2942,2952,2968,2979],{},[2733,2854,2855,2739,2858,2861,2862,2865,2866,2869,2870,2873,2874,2877,2878,2873,2881,2884],{},[2736,2856,2857],{},"nil slice vs empty slice",[29,2859,2860],{},"var s []int"," (nil, ",[29,2863,2864],{},"s == nil"," true) vs ",[29,2867,2868],{},"s := []int{}"," (non-nil, empty). ",[29,2871,2872],{},"json.Marshal(nil)"," → ",[29,2875,2876],{},"null","; ",[29,2879,2880],{},"json.Marshal([]int{})",[29,2882,2883],{},"[]",". APIs may treat these differently.",[2733,2886,2887,2739,2892,2873,2895,2898,2899,2902],{},[2736,2888,2889,2891],{},[29,2890,688],{}," to nil slice works",[29,2893,2894],{},"var s []int; s = append(s, 1)",[29,2896,2897],{},"[1]",". No need to ",[29,2900,2901],{},"make"," first.",[2733,2904,2905,2739,2911,2914],{},[2736,2906,2907,2908,2910],{},"Always reassign ",[29,2909,688],{},"'s result",[29,2912,2913],{},"append(s, x)"," returns a new header (possibly pointing to a new array). If you don't reassign, the growth is lost and the new array is leaked.",[2733,2916,2917,2739,2923,2926,2927,2929,2930,2932],{},[2736,2918,2919,2922],{},[29,2920,2921],{},"range"," captures len at start",[29,2924,2925],{},"for i, v := range s"," evaluates ",[29,2928,555],{}," once; appending to ",[29,2931,555],{}," inside the loop doesn't extend iteration.",[2733,2934,2935,2938,2939,490],{},[2736,2936,2937],{},"Removing while ranging forward skips elements",": indices shift after removal. Build a new slice, iterate backwards, or use ",[29,2940,2941],{},"slices.DeleteFunc",[2733,2943,2944,2951],{},[2736,2945,2946,2813,2949],{},[29,2947,2948],{},"make([]T, n)",[29,2950,2746],{},": first gives len n (n zeros); second gives len 0, cap n (empty, ready for n appends). Use the second for \"collect n items.\"",[2733,2953,2954,2960,2961,2963,2964,2967],{},[2736,2955,2956,2959],{},[29,2957,2958],{},"strings.Builder.String()"," doesn't copy",": returns the internal buffer directly (zero-copy, safe because strings are immutable). Don't call ",[29,2962,2202],{}," after ",[29,2965,2966],{},"String()"," — it panics.",[2733,2969,2970,2978],{},[2736,2971,2972,2974,2975],{},[29,2973,1240],{}," returns ",[29,2976,2977],{},"min(len(dst), len(src))",": useful when dst is smaller than src — you know exactly how many elements were copied.",[2733,2980,2981,2739,2986,2989,2990,2993,2994,2996,2997,3000,3001,3004,3005,490],{},[2736,2982,2983,2985],{},[29,2984,688],{}," with multiple slices",[29,2987,2988],{},"s = append(s, other...)"," spreads ",[29,2991,2992],{},"other"," into ",[29,2995,555],{},". If ",[29,2998,2999],{},"cap(s) - len(s) \u003C len(other)",", append reallocates once. Pre-grow: ",[29,3002,3003],{},"s = slices.Grow(s, len(other))"," then ",[29,3006,688],{},[14,3008,3010],{"id":3009},"quick-quiz","🧠 Quick Quiz",[19,3012,3013,3166],{"language":21},[23,3014,3016],{"className":25,"code":3015,"language":21,"meta":27,"style":27},"func grow(s []int) []int {\n    s = append(s, 1)\n    s = append(s, 2)\n    s = append(s, 3)\n    return s\n}\n\nfunc main() {\n    s := make([]int, 0, 2)\n    t := grow(s)\n    fmt.Println(s, t)\n    fmt.Println(cap(s), cap(t))\n}\n",[29,3017,3018,3039,3053,3067,3081,3087,3091,3095,3103,3125,3135,3144,3162],{"__ignoreMap":27},[32,3019,3020,3022,3025,3027,3029,3031,3033,3035,3037],{"class":34,"line":35},[32,3021,205],{"class":100},[32,3023,3024],{"class":208}," grow",[32,3026,212],{"class":104},[32,3028,555],{"class":215},[32,3030,310],{"class":104},[32,3032,115],{"class":100},[32,3034,798],{"class":104},[32,3036,115],{"class":100},[32,3038,319],{"class":104},[32,3040,3041,3043,3045,3047,3049,3051],{"class":34,"line":42},[32,3042,587],{"class":104},[32,3044,576],{"class":100},[32,3046,592],{"class":208},[32,3048,595],{"class":104},[32,3050,142],{"class":108},[32,3052,1183],{"class":104},[32,3054,3055,3057,3059,3061,3063,3065],{"class":34,"line":48},[32,3056,587],{"class":104},[32,3058,576],{"class":100},[32,3060,592],{"class":208},[32,3062,595],{"class":104},[32,3064,148],{"class":108},[32,3066,1183],{"class":104},[32,3068,3069,3071,3073,3075,3077,3079],{"class":34,"line":54},[32,3070,587],{"class":104},[32,3072,576],{"class":100},[32,3074,592],{"class":208},[32,3076,595],{"class":104},[32,3078,109],{"class":108},[32,3080,1183],{"class":104},[32,3082,3083,3085],{"class":34,"line":60},[32,3084,276],{"class":100},[32,3086,613],{"class":104},[32,3088,3089],{"class":34,"line":66},[32,3090,155],{"class":104},[32,3092,3093],{"class":34,"line":72},[32,3094,88],{"emptyLinePlaceholder":87},[32,3096,3097,3099,3101],{"class":34,"line":78},[32,3098,205],{"class":100},[32,3100,628],{"class":208},[32,3102,631],{"class":104},[32,3104,3105,3107,3109,3111,3113,3115,3117,3119,3121,3123],{"class":34,"line":84},[32,3106,587],{"class":104},[32,3108,127],{"class":100},[32,3110,893],{"class":208},[32,3112,896],{"class":104},[32,3114,115],{"class":100},[32,3116,145],{"class":104},[32,3118,570],{"class":108},[32,3120,145],{"class":104},[32,3122,148],{"class":108},[32,3124,1183],{"class":104},[32,3126,3127,3129,3131,3133],{"class":34,"line":91},[32,3128,1016],{"class":104},[32,3130,127],{"class":100},[32,3132,3024],{"class":208},[32,3134,663],{"class":104},[32,3136,3137,3139,3141],{"class":34,"line":97},[32,3138,668],{"class":104},[32,3140,671],{"class":208},[32,3142,3143],{"class":104},"(s, t)\n",[32,3145,3146,3148,3150,3152,3155,3157,3159],{"class":34,"line":121},[32,3147,668],{"class":104},[32,3149,671],{"class":208},[32,3151,212],{"class":104},[32,3153,3154],{"class":208},"cap",[32,3156,2290],{"class":104},[32,3158,3154],{"class":208},[32,3160,3161],{"class":104},"(t))\n",[32,3163,3164],{"class":34,"line":158},[32,3165,155],{"class":104},[3167,3168,3169],"p",{},"What's printed?",[3171,3172,3173,3177,3184,3192,3195,3226,3243,3251,3278,3281,3286],"details",{},[3174,3175,3176],"summary",{},"Answer",[3167,3178,3179,1241,3181,3183],{},[29,3180,555],{},[29,3182,2832],{}," likely share the same underlying array:",[23,3185,3190],{"className":3186,"code":3188,"language":3189},[3187],"language-text","[] [1 2 3]\n2 4\n","text",[29,3191,3188],{"__ignoreMap":27},[3167,3193,3194],{},"Wait — let's trace it:",[3196,3197,3198,3204,3210,3216],"ol",{},[2733,3199,3200,3203],{},[29,3201,3202],{},"s := make([]int, 0, 2)"," — len 0, cap 2",[2733,3205,3206,3209],{},[29,3207,3208],{},"s = append(s, 1)"," — len 1, cap 2 (within capacity, writes to shared array)",[2733,3211,3212,3215],{},[29,3213,3214],{},"s = append(s, 2)"," — len 2, cap 2 (within capacity)",[2733,3217,3218,3221,3222,3225],{},[29,3219,3220],{},"s = append(s, 3)"," — len 3 > cap 2 → ",[2736,3223,3224],{},"new array allocated",", cap grows to 4",[3167,3227,3228,3229,3231,3232,3235,3236,3238,3239,3242],{},"After step 4, ",[29,3230,555],{}," (inside ",[29,3233,3234],{},"grow",") points to a NEW array. The original ",[29,3237,555],{}," (in ",[29,3240,3241],{},"main",") still points to the old array with cap 2.",[3167,3244,3245,3246,1241,3248,3250],{},"But the old array has ",[29,3247,142],{},[29,3249,148],{}," written to it (from steps 2-3). So:",[2730,3252,3253,3268],{},[2733,3254,3255,3257,3258,3260,3261,3263,3264,3267],{},[29,3256,3241],{},"'s ",[29,3259,555],{}," = ",[29,3262,2883],{}," (len 0, but the underlying array has ",[32,3265,3266],{},"1, 2",")",[2733,3269,3270,3257,3272,3260,3274,3277],{},[29,3271,3234],{},[29,3273,2832],{},[29,3275,3276],{},"[1, 2, 3]"," (new array, cap 4)",[3167,3279,3280],{},"Output:",[23,3282,3284],{"className":3283,"code":3188,"language":3189},[3187],[29,3285,3188],{"__ignoreMap":27},[3167,3287,3288,3289,3291,3292,3294,3295,3257,3297,3299,3300,3257,3302,3304,3305,3307],{},"The key insight: ",[29,3290,3234],{}," receives a copy of the slice header. The first two appends modify the shared underlying array (visible to ",[29,3293,3241],{}," if it slices further), but the third append triggers a reallocation — ",[29,3296,3234],{},[29,3298,555],{}," now points to a new array, while ",[29,3301,3241],{},[29,3303,555],{}," still points to the old one. The returned ",[29,3306,2832],{}," is the new header.",[14,3309,3311],{"id":3310},"whats-next","📚 What's Next",[3167,3313,3314,3315,3319],{},"→ ",[1641,3316,3318],{"href":3317},"\u002Fgo\u002F08-maps","08 — Maps"," — hash map internals, concurrency safety, the comma-ok idiom, and the non-addressable value trap.",[3321,3322,3323],"style",{},"html pre.shiki code .sdCPZ, html code.shiki .sdCPZ{--shiki-default:#6A737D;--shiki-github-dark:#6A737D}html pre.shiki code .svdQ7, html code.shiki .svdQ7{--shiki-default:#D73A49;--shiki-github-dark:#F97583}html pre.shiki code .ssxIu, html code.shiki .ssxIu{--shiki-default:#24292E;--shiki-github-dark:#E1E4E8}html pre.shiki code .snvgF, html code.shiki .snvgF{--shiki-default:#005CC5;--shiki-github-dark:#79B8FF}html pre.shiki code .sIsaT, html code.shiki .sIsaT{--shiki-default:#6F42C1;--shiki-github-dark:#B392F0}html pre.shiki code .sCrzJ, html code.shiki .sCrzJ{--shiki-default:#E36209;--shiki-github-dark:#FFAB70}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .github-dark .shiki span {color: var(--shiki-github-dark);background: var(--shiki-github-dark-bg);font-style: var(--shiki-github-dark-font-style);font-weight: var(--shiki-github-dark-font-weight);text-decoration: var(--shiki-github-dark-text-decoration);}html.github-dark .shiki span {color: var(--shiki-github-dark);background: var(--shiki-github-dark-bg);font-style: var(--shiki-github-dark-font-style);font-weight: var(--shiki-github-dark-font-weight);text-decoration: var(--shiki-github-dark-text-decoration);}html pre.shiki code .sJ6F3, html code.shiki .sJ6F3{--shiki-default:#032F62;--shiki-github-dark:#9ECBFF}",{"title":27,"searchDepth":42,"depth":42,"links":3325},[3326,3327,3328],{"id":16,"depth":42,"text":17},{"id":395,"depth":42,"text":396},{"id":3310,"depth":42,"text":3311},"Slice header memory layout, append growth strategy, aliasing and full-slice expressions, the slices package, and zero-allocation string\u002Fbyte patterns.","md",{},"\u002Fgo\u002F07-arrays-slices-and-strings",{"title":5,"description":3329},"go\u002F07-arrays-slices-and-strings","0LJMIXTFljiVIXf0HUGsTqy5qv2xa-zPkE9Zk1X7oJ0",1789924648328]