Pourquoi la tranche « s[lo:hi] » de Go exclut-elle l'élément à l'index « hi » ?

Pourquoi Go Slice s[lo:hi] se termine-t-il à l'élément hi-1 ?

L'expression Go slice s[lo:hi] crée une tranche contenant des éléments de l'index lo à l'index hi-1 inclus. Ce comportement s'explique par plusieurs principes de conception :

Arithmétique des pointeurs

Dans Go, les tranches sont implémentées comme des pointeurs vers le tableau sous-jacent. L'utilisation de tableaux indexés 0 et d'un découpage inclusif-exclusif permet une arithmétique de pointeur simple. L'élément à l'index i dans la tranche est simplement l'élément pointé par le pointeur de la tranche plus i.

Longueur de la tranche

La longueur d'une tranche Go est également la position à laquelle trancher il. Cela signifie que arr[0:len(arr)] renvoie arr lui-même. Cette propriété est pratique pour extraire des données d'une tranche après une opération de lecture ou d'écriture.

Indices sans chevauchement

Le découpage inclusif-exclusif garantit que les sous-tranches contiguës d'un tableau ne se chevauchent pas. Par exemple, si arr = [1, 2, 3, 4], alors arr[0:2] = [1, 2], arr[2:4] = [3, 4] et arr[0:4] = arr. Cette propriété simplifie les opérations qui nécessitent un partitionnement ou une manipulation de sous-tranches.

Exemple

Considérez le code Go suivant :

func consecutiveSlices(ints []int) [][]int {
    ret := make([][]int, 0)
    i, j := 0, 1
    for j < len(ints) {
        if ints[j] != ints[j-1] + 1 {
            ret = append(ret, ints[i:j])
            i = j
        }
    }
    ret = append(ret, ints[i:j])
    return ret
}

Cette fonction divise une tranche d'entiers en sous-tranches consécutives basées sur la différence entre chaque élément et son prédécesseur. La technique de découpage inclusif-exclusif permet une mise en œuvre plus simple et plus efficace par rapport à l'utilisation du découpage inclusif-inclusif.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!