strings.LastIndexByte — letztes Vorkommen eines Bytes

Die Signatur ist identisch aufgebaut zu IndexByte, nur dass die Suchrichtung umgekehrt verläuft. Der Rückgabewert ist ein Byte-Offset im Bereich [0, len(s)-1] oder -1.

func LastIndexByte(s string, c byte) int

Wichtig: der Parameter c ist vom Typ byte (Alias für uint8), nicht rune. Damit ist die Funktion auf den Wertebereich 0..255 festgenagelt und kann konzeptionell nur Single-Byte-Werte finden — selbst wenn der Eingabestring viele Multi-Byte-Codepoints enthält.

Die Implementation läuft vom letzten Byte rückwärts durch den String und gibt den ersten gefundenen Treffer-Offset zurück. Sobald ein Match vorliegt, bricht die Schleife ab — bei Trennern, die typischerweise nahe am Stringende stehen, ist das deutlich schneller als ein LastIndex mit Substring-Suche.

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "a.b.c.d.txt"
	fmt.Println(strings.LastIndexByte(s, '.'))
	fmt.Println(strings.LastIndexByte(s, 'a'))
	fmt.Println(strings.LastIndexByte(s, 'z'))
}

7
0
-1

Der erste Aufruf landet beim Punkt vor txt an Position 7 — die drei vorgelagerten Punkte werden ignoriert. Der zweite Aufruf zeigt, dass auch ein einziges Vorkommen ganz am Anfang gefunden wird, weil der Reverse-Scan den gesamten String durchläuft, wenn nötig. Der dritte Aufruf demonstriert das -1-Sentinel.

Dieselbe Falle wie bei IndexByte: bei Multi-Byte-UTF-8 sucht LastIndexByte ein einzelnes Byte, nicht einen Codepoint. Ein deutscher Umlaut wie ä belegt in UTF-8 zwei Bytes (0xC3 0xA4), und ein Aufruf mit einem dieser einzelnen Bytes liefert zwar einen Offset, der aber keinem sinnvollen Zeichen entspricht.

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "Straße — Maßstab"

	// 'ß' ist KEIN Byte, sondern zwei Bytes (0xC3 0x9F).
	// Die naive Suche trifft willkürlich auf das erste Byte:
	fmt.Println(strings.LastIndexByte(s, 0xC3))

	// Korrekt: per LastIndex mit String-Repräsentation der Rune.
	fmt.Println(strings.LastIndex(s, string('ß')))
}

12
12

Der erste Wert ist nur deshalb sinnvoll, weil 0xC3 zufällig das Lead-Byte beider ß ist — in echten Suchen führt das schnell zu kaputten Offsets mitten in einem Codepoint. Für alles oberhalb von 0x7F ist LastIndex(s, string(r)) die saubere Variante, weil sie die vollständige UTF-8-Sequenz matched.

Auf einem leeren String gibt es nichts zu finden, und das Sentinel -1 ist die einzig konsistente Antwort. Der gesuchte Byte-Wert spielt keine Rolle.

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.LastIndexByte("", '.'))
	fmt.Println(strings.LastIndexByte("", 0))
}

-1
-1

Das deckt sich mit dem Verhalten aller Index*-Varianten in strings und macht die -1-Prüfung zum Standard-Idiom, bevor der Rückgabewert als Offset verwendet wird.

Die drei Funktionen lassen sich entlang zweier Achsen unterscheiden: Suchrichtung und Mustertyp. LastIndexByte ist die spezialisierte Kombination aus rückwärts und Single-Byte.

Faustregel: ASCII-Trenner am Stringende — LastIndexByte. Multi-Byte-Codepoint oder mehrere Zeichen — LastIndex mit explizitem String.

Der klassische Anwendungsfall ist das Abspalten einer Dateiendung. Da der letzte Punkt typischerweise nur wenige Bytes vor dem Stringende steht, ist der Reverse-Scan praktisch in O(1) erledigt und allokationsfrei.

package main

import (
	"fmt"
	"strings"
)

func ext(name string) string {
	i := strings.LastIndexByte(name, '.')
	if i < 0 {
		return ""
	}
	return name[i:]
}

func main() {
	fmt.Printf("%q\n", ext("report.final.pdf"))
	fmt.Printf("%q\n", ext("archive.tar.gz"))
	fmt.Printf("%q\n", ext("Makefile"))
}

".pdf"
".gz"
""

Für portable Pfade ist path/filepath.Ext allerdings die robustere Wahl, weil es Plattform-Trenner berücksichtigt und Edge-Cases wie führende Punkte sauber behandelt. LastIndexByte ist ideal, wenn man bewusst auf der Byte-Ebene operiert — etwa in einem Tokenizer oder Logfile-Parser, wo filepath semantisch fehl am Platz wäre.

Beim tail-artigen Lesen eines Buffers will man oft schnell den Anfang der letzten Zeile finden, ohne den gesamten Buffer in Zeilen aufzuteilen. Der Reverse-Scan nach \n löst das in einem einzigen Aufruf.

package main

import (
	"fmt"
	"strings"
)

func lastLine(buf string) string {
	// Trailing-Newline ignorieren, falls vorhanden.
	buf = strings.TrimRight(buf, "\n")
	i := strings.LastIndexByte(buf, '\n')
	if i < 0 {
		return buf
	}
	return buf[i+1:]
}

func main() {
	log := "2026-05-22 INFO  start\n2026-05-22 WARN  retry\n2026-05-22 ERROR fail\n"
	fmt.Printf("%q\n", lastLine(log))
}

"2026-05-22 ERROR fail"

Der Trick mit TrimRight macht den Algorithmus tolerant gegenüber einem optionalen Trailing-Newline — typischer Sonderfall in Logdateien. Der eigentliche Suchaufruf bleibt ein einziger Reverse-Scan, der bei kurzen letzten Zeilen praktisch sofort terminiert.

Weiterführende Ressourcen

Externe Quellen

• strings.LastIndexByte
• strings.IndexByte
• filepath.Ext

Verwandte Artikel

• strings-Paket — Übersicht
• strings.IndexByte — erstes Byte-Vorkommen
• strings.LastIndex — letztes Substring-Vorkommen