## Manuell

Einer der folgenden Punkte trifft zu:

- Verwendung des Installationsskripts:
    ```sh
    # Überprüfen Sie immer den Inhalt des Skripts, bevor Sie es ausführen!
    $ curl --proto '=https' --tlsv1.2 -LsSf https://github.com/skim-rs/skim/releases/latest/download/skim-installer.sh | sh
    ```
- Verwendung der Binärdatei: Laden Sie einfach [die sk-ausführbare Datei](https://github.com/skim-rs/skim/releases) direkt herunter.
- Installation von [crates.io](https://crates.io/): `cargo install skim`
- Manuelle Erstellung:
    ```sh
    $ git clone --depth 1 [email protected]:skim-rs/skim.git ~/.skim
    $ cd ~/.skim
    $ cargo build --release
    $ # Fügen Sie die resultierende `target/release/sk`-ausführbare Datei zu Ihrem PATH hinzu
    ```

Sie haben dann Zugriff auf:

- Die Manpage, die Sie entweder in den richtigen Pfad schreiben oder mit `man --local-file <(sk --man)` ausführen können
- Die Shell-Vervollständigungen (und optionale Tastenkombinationen) mit `source <(sk --shell \<shell> \[--shell-bindings])`, siehe unten für Details

# Verwendung

Skim kann entweder als allgemeiner Filter (ähnlich wie `grep`) oder als interaktive
Schnittstelle zum Ausführen von Befehlen verwendet werden.

## Als Vim-Plugin (unter neovim, siehe [fzf-lua](https://github.com/ibhagwan/fzf-lua) mit dem skim-Profil)

Über vim-plug (empfohlen):

Installieren Sie skim, dann:```vim
Plug 'skim-rs/skim'

Dieser letzte Befehl ermöglicht es dir, Dateien mit der Erweiterung „.rs“ auszuwählen und öffnet
deine Auswahl in Vim – ein großer Zeitersparnis für Entwickler!

## Als interaktive Oberfläche

`skim` kann andere Befehle dynamisch aufrufen. Normalerweise möchtest du es
mit [grep](https://www.gnu.org/software/grep/),
[ack](https://github.com/petdance/ack2),
[ag](https://github.com/ggreer/the_silver_searcher) oder
[rg](https://github.com/BurntSushi/ripgrep) integrieren, um Inhalte in einem
Projektverzeichnis zu durchsuchen:```sh
# works with grep
sk --ansi -i -c 'grep -rI --color=always --line-number {q} .'
# works with ack
sk --ansi -i -c 'ack --color {q}'
# works with ag
sk --ansi -i -c 'ag --color {q}'
# works with rg
sk --ansi -i -c 'rg --color=always --line-number {q}'

#### Option 2: In einer Datei speichern, die beim Shell-Start automatisch geladen wird```sh
# For bash, add to ~/.bashrc
echo 'source <(sk --shell bash)' >> ~/.bashrc  # Or save to ~/.bash_completion

# For zsh, add to ~/.zshrc
sk --shell zsh > ~/.zfunc/_sk  # Create ~/.zfunc directory and add to fpath in ~/.zshrc

# For fish, add to ~/.config/fish/completions/
sk --shell fish > ~/.config/fish/completions/sk.fish

Sie können dynamisch in den `regex`-Modus wechseln, indem Sie `Strg-R` (Modus rotieren) drücken.

## Exit-Code

| Exit-Code | Bedeutung                            |
|-----------|--------------------------------------|
| 0         | Normal beendet                       |
| 1         | Keine Übereinstimmung gefunden       |
| 130       | Durch Strg-C/Strg-G/ESC usw. abgebrochen |

# Mit `skim` kompatible Tools

Diese Tools sind mit `skim` kompatibel oder zielen darauf ab, es zu sein:

## [fzf-lua neovim-Plugin](https://github.com/ibhagwan/fzf-lua)

Ein [neovim](https://neovim.io)-Plugin, das die Verwendung von fzf und skim zur Navigation durch Ihren Code ermöglicht.

Installieren Sie es mit Ihrem Paketmanager, wie in der README beschrieben. Zum Beispiel mit `lazy.nvim`:```lua
{
  "ibhagwan/fzf-lua",
  -- enable `sk` support instead of the default `fzf`
  opts = {'skim'}
}

## [sqlite-Erweiterung](https://github.com/tzachar/sqlite_skim)

Ein ladbares `sqlite`-Modul, das eine `skim_score`-Funktion in SQL-Abfragen
ermöglicht.

# Anpassung

Die Dokumentation hier ist nur eine Vorschau; bitte lesen Sie die Manpage (`man sk`) für eine vollständige
Liste der Optionen.

## Tastenbelegung

Geben Sie die Bindungen als kommagetrennte Paare an (keine Leerzeichen erlaubt). Zum Beispiel:```sh
sk --bind 'alt-a:select-all,alt-d:deselect-all'

Skim respektiert auch die Umgebungsvariable `NO_COLOR`. Setzen Sie sie auf einen beliebigen Wert und `sk` (sowie viele andere Terminal-Anwendungen) deaktivieren die gesamte farbige Ausgabe. Weitere Details finden Sie unter [no-color.org](https://no-color.org/).

### Verfügbare Basis-Farbschemata

Skim wird mit mehreren integrierten Farbschemata ausgeliefert, die Sie als Ausgangspunkt verwenden können:```sh
sk --color=dark      # Default dark theme (256 colors)
sk --color=light     # Light theme (256 colors)
sk --color=16        # Simple 16-color theme
sk --color=bw        # Minimal black & white theme (no colors, just styles)
sk --color=none      # Minimal black & white theme (no colors, no styles)
sk --color=molokai   # Molokai-inspired theme (256 colors)

Farben können auf verschiedene Weise angegeben werden:

- ANSI-Farben (0-255): `sk --color=fg:232,bg:255`
- RGB-Hexwerte: `sk --color=fg:#FF0000` (roter Text)

### Verfügbare Optionen zur Farbanpassung

Die folgenden UI-Elemente können angepasst werden:

| Element            | Beschreibung                                 | Beispiel                        |
|--------------------|---------------------------------------------|--------------------------------|
| `fg`               | Vordergrundfarbe für normalen Text          | `--color=fg:232`               |
| `bg`               | Hintergrundfarbe für normalen Text          | `--color=bg:255`               |
| `matched`          | Übereinstimmender Text in Suchergebnissen   | `--color=matched:108`          |
| `matched_bg`       | Hintergrund des übereinstimmenden Texts     | `--color=matched_bg:0`         |
| `current`          | Vordergrundfarbe der aktuellen Zeile        | `--color=current:254`          |
| `current_bg`       | Hintergrundfarbe der aktuellen Zeile        | `--color=current_bg:236`       |
| `current_match`    | Übereinstimmender Text in der aktuellen Zeile | `--color=current_match:151`    |
| `current_match_bg` | Hintergrund des übereinstimmenden Texts in der aktuellen Zeile | `--color=current_match_bg:236` |
| `spinner`          | Farbe des Fortschrittsanzeigers             | `--color=spinner:148`          |
| `info`             | Farbe der Informationszeile                 | `--color=info:144`             |
| `prompt`           | Farbe der Eingabeaufforderung               | `--color=prompt:110`           |
| `cursor`           | Cursorfarbe                                 | `--color=cursor:161`           |
| `selected`         | Farbe der Markierung ausgewählter Elemente  | `--color=selected:168`         |
| `header`           | Farbe des Kopfzeilentexts                   | `--color=header:109`           |
| `border`           | Rahmenfarbe für Vorschau/Layout             | `--color=border:59`            |

### Beispiele```sh
# Use light theme but change the current line background
sk --color=light,current_bg:24

# Custom theme with multiple colors
sk --color=dark,matched:#00FF00,current:#FFFFFF,current_bg:#000080

# High contrast theme
sk --color=fg:232,bg:255,matched:160,current:255,current_bg:20

### Wie funktioniert es?

![Wie Skims interaktiver Modus funktioniert](https://assets.kitploit.com/production/public/readmes/54416/5895df8cd6dbe8dfe20cafd1bf0b23fd690191710c00f811e110aba228b32a35/a7b995846d08eb2aa7f351371b38a9a35261eb393632363f62c6a67785f4038e-display-v1.webp)

- Skim akzeptiert zwei Arten von Quellen: Befehlsausgabe oder gepipte Eingabe
- Skim hat zwei Arten von Eingabeaufforderungen: Eine Abfrageaufforderung zur Angabe des Abfragemusters und eine
    Befehlsaufforderung zur Angabe der „Argumente“ des Befehls
- `-c` wird verwendet, um den auszuführenden Befehl anzugeben und standardmäßig auf `SKIM_DEFAULT_COMMAND` gesetzt
- `-i` weist Skim an, die Befehlsaufforderung beim Start zu öffnen, die standardmäßig `c>` anzeigt.

Um die vom Befehl zurückgegebenen Ergebnisse weiter einzugrenzen, drücken Sie
`Ctrl-Q`, um den interaktiven Modus umzuschalten.

## Ausführen externer Programme

Sie können Tastenkombinationen konfigurieren, um externe Prozesse zu starten, ohne Skim zu verlassen (`execute`, `execute-silent`).```sh
# Press F1 to open the file with less without leaving skim
# Press CTRL-Y to copy the line to clipboard and aborts skim (requires pbcopy)
sk --bind 'f1:execute(less -f {}),ctrl-y:execute-silent(echo {} | pbcopy)+abort'

(Beachten Sie, dass [preview.sh](https://github.com/junegunn/fzf.vim/blob/master/bin/preview.sh) ein Skript ist, das den Kontext anhand von Dateiname:Zeilen:Spalten ausgibt)

Sie erhalten dann Folgendes:

![Vorschau-Demo](https://assets.kitploit.com/production/public/readmes/54416/b89dd1e40297ffc3fa4684c4a6d5dc9506c0eafdb881d4cea079ff843f1a271a/84156872f39354a97241078491506fee9f9962eda6628161f94f6f36ec2c79f9-display-v1.webp)

### Wie funktioniert das?

Wenn der Vorschau-Befehl über die Option `--preview` angegeben wird, ersetzt skim das
`{}` durch die aktuell hervorgehobene Zeile, die in einfache Anführungszeichen gesetzt wird, ruft den
Befehl auf, um die Ausgabe zu erhalten, und zeigt die Ausgabe im Vorschaufenster an.

Manchmal benötigen Sie nicht die gesamte Zeile, um den Befehl auszuführen. In diesem Fall
können Sie `{}`, `{1..}`, `{..3}` oder `{1..5}` verwenden, um die Felder auszuwählen. Die
Syntax wird im Abschnitt [Feldunterstützung](#filds-support) erläutert.

Schließlich möchten Sie möglicherweise die Position des Vorschaufensters mit `--preview-window` konfigurieren:
- `--preview-window up:30%`, um das Fenster oben mit einer Höhe von
    30 % der Gesamthöhe von skim zu platzieren.
- `--preview-window left:10:wrap`, um anzugeben, dass `wrap` es dem Vorschaufenster
    ermöglicht, die Ausgabe des Vorschau-Befehls umzubrechen.
- `--preview-window wrap:hidden`, um das Vorschaufenster beim Start auszublenden; später
    kann es durch die Aktion `toggle-preview` angezeigt werden.

## Feldunterstützung

Normalerweise müssen nur Plugin-Benutzer dies verstehen.

Sie haben beispielsweise die Datenquelle mit dem Format:```sh
<filename>:<line number>:<column number>

_Hinweis zu Features_:
    - das `cli`-Feature ist erforderlich, um skim als CLI zu verwenden; es *sollte* nicht benötigt werden, wenn es als Bibliothek verwendet wird.

### Grundlegende Verwendung

Versuchen Sie dann, dieses einfache Beispiel auszuführen:```rust
extern crate skim;
use skim::prelude::*;
use std::io::Cursor;

pub fn main() {
    let options = SkimOptionsBuilder::default()
        .height("50%")
        .multi(true)
        .build()
        .unwrap();

    let input = "aaaaa\nbbbb\nccc".to_string();

    // `SkimItemReader` is a helper to turn any `BufRead` into a stream of `SkimItem`
    // `SkimItem` was implemented for `AsRef<str>` by default
    let item_reader = SkimItemReader::default();
    let items = item_reader.of_bufread(Cursor::new(input));

    // `run_with` would read and show items from the stream
    let selected_items = Skim::run_with(&options, Some(items))
        .map(|out| out.selected_items)
        .unwrap_or_else(|| Vec::new());

    for item in selected_items.iter() {
        println!("{}", item.output());
    }
}

Du kannst es in deine `.bashrc` oder `.zshrc` einfügen, wenn du möchtest, dass es standardmäßig verwendet wird.

## Einige Dateien werden im Vim-Plugin nicht angezeigt

Wenn du das Vim-Plugin verwendest und den Befehl `:SK` ausführst, kann es sein, dass einige
deiner Dateien nicht angezeigt werden.

Wie in [#3](https://github.com/skim-rs/skim/issues/3) beschrieben, wird im Vim-
Plugin `SKIM_DEFAULT_COMMAND` standardmäßig auf den Befehl gesetzt:```vim
let $SKIM_DEFAULT_COMMAND = "git ls-tree -r --name-only HEAD || rg --files || ag -l -g \"\" || find ."

Innerhalb der VM ist das Projektverzeichnis unter `C:\vagrant` eingebunden:```powershell
cd C:\vagrant
cargo build
cargo test

# Fehlerbehebung

Um zu diagnostizieren, was passiert, können Sie die Umgebungsvariable `SKIM_LOG` oder das Flag `--log-level` auf `debug` oder sogar `trace` setzen und die Umgebungsvariable `SKIM_LOG_FILE` oder das Flag `--log-file` auf einen Pfad setzen. Sie können diese Protokolle dann während oder nach der Ausführung lesen, um besser zu verstehen, was passiert. Zögern Sie nicht, diese Protokolle zu einem Issue hinzuzufügen, wenn Sie Hilfe benötigen.

## Probleme mit Zeilenumbrüchen bei nix, FreeBSD, termux

Wenn Sie Anzeigeprobleme wie diese feststellen:```bash
$ for n in {1..10}; do echo "$n"; done | sk
  0/10 0/0.> 10/10  10  9  8  7  6  5  4  3  2> 1

# Benchmarks

## Interaktiver Benchmark (`cli`)

Der `cli`-Benchmark testet skim (oder eine beliebige kompatible Binärdatei) gegen andere Versionen oder fzf, indem er die interaktive Oberfläche in einer tmux-Sitzung ausführt und die Statuszeile abfragt, bis die Anzahl der Treffer stabil bleibt. Dies ist keineswegs eine präzise oder narrensichere Messung, hat aber den zusätzlichen Vorteil, dass er gegen `fzf` benchmarkt und Ressourcenmetriken (Spitzen-RSS und CPU) liefert.```sh
cargo bench --bench cli -- run                              # defaults: sk, 1 M items, query "test"
cargo bench --bench cli -- run sk -n 500000 -q foo              # bare name resolved via $PATH
cargo bench --bench cli -- run ./old/sk ./new/sk -r 5           # compare two binaries, 5 runs each
cargo bench --bench cli -- run sk -f input.txt -q search        # use an existing file
cargo bench --bench cli -- generate -f testdata.txt -n 2000000       # generate input file and exit
cargo bench --bench cli -- run sk --perf                            # record perf data (auto-named file)
cargo bench --bench cli -- run sk --strace                            # record strace data (auto-named file)
cargo bench --bench cli -- run sk -p perf.data                 # record perf data to perf.data
cargo bench --bench cli -- run sk -j                            # JSON output
cargo bench --bench cli -- run sk -r 3 -- --tiebreak=index     # pass extra flags to sk