sd

sd - s y d

sd es una CLI intuitiva para buscar y reemplazar.

El tono

¿Por qué utilizarlo sobre otras herramientas existentes?

Expresiones regulares indoloras. sd utiliza la sintaxis de expresiones regulares que ya conoce de JavaScript y Python. Olvídese de lidiar con las peculiaridades de sed o awk : sea productivo de inmediato.

Modo literal de cadena. Búsqueda y reemplazo sin expresiones regulares. No más barras invertidas ni recordar qué caracteres son especiales y deben escaparse.

Fácil de leer, fácil de escribir. Las expresiones de buscar y reemplazar están divididas, lo que las hace fáciles de leer y escribir. No más problemas con barras abiertas y escapadas.

Valores predeterminados inteligentes y de sentido común. Los valores predeterminados siguen el sentido común y están diseñados para el uso diario típico.

Comparación con sed

Mientras que sed hace mucho más, sd se centra en hacer una sola cosa y hacerlo bien. A continuación se muestran algunos ejemplos cuidadosamente seleccionados en los que sd brilla.

Sintaxis más simple para reemplazar todas las ocurrencias:

• sd: sd before after
• sed: sed s/before/after/g

Reemplace las nuevas líneas con comas:

• sd: sd 'n' ','
• sed: sed ':a;N;$!ba;s/n/,/g'

Extrayendo cosas de cadenas que contienen barras:

• sd: echo "sample with /path/" | sd '.*(/.*/)' '$1'

• sed: echo "sample with /path/" | sed -E 's/.*(\/.*\/)/1/g'

  Con sed, puedes hacerlo mejor con un delimitador diferente, pero aún así es complicado:

  echo "sample with /path/" | sed -E 's|.*(/.*/)|1|g'

Modificación in situ de archivos:

• sd: sd before after file.txt

• sed: sed -i -e 's/before/after/g' file.txt

  Con sed, debes recordar usar -e o, de lo contrario, algunas plataformas considerarán que el siguiente argumento es un sufijo de respaldo.

Puntos de referencia

Reemplazo simple en ~1,5 gigabytes de JSON

hyperfine --warmup 3 --export-markdown out.md 
  ' sed -E "s/"/ ' " ' " ' /g" *.json > /dev/null ' 
  ' sed    "s/"/ ' " ' " ' /g" *.json > /dev/null ' 
  ' sd     """ " ' " ' " ' "   *.json > /dev/null '

Dominio	Medio]	Mín....Máx. [s]
sed -E "s/"/'/g" *.json > /dev/null	2,338 ± 0,008	2.332…2.358
sed "s/"/'/g" *.json > /dev/null	2,365 ± 0,009	2.351…2.378
sd """ "'" *.json > /dev/null	0,997 ± 0,006	0,987…1,007

Resultado: ~2,35 veces más rápido

Reemplazo de expresiones regulares en un archivo json de ~55M :

hyperfine --warmup 3 --export-markdown out.md 
  ' sed -E "s:(w+):11:g"    dump.json > /dev/null ' 
  ' sed    "s:(w+):11:g" dump.json > /dev/null ' 
  ' sd     "(w+)" "$1$1"      dump.json > /dev/null '

Dominio	Medio]	Mín....Máx. [s]
sed -E "s:(w+):11:g" dump.json > /dev/null	11,315 ± 0,215	11.102…11.725
sed "s:(w+):11:g" dump.json > /dev/null	11,239 ± 0,208	11.057…11.762
sd "(w+)" "$1$1" dump.json > /dev/null	0,942 ± 0,004	0,936…0,951

Resultado: ~11,93 veces más rápido

Instalación

Instale a través de cargo con cargo install sd o mediante varios administradores de paquetes

Guía rápida

1. Modo literal de cadena . De forma predeterminada, las expresiones se tratan como expresiones regulares. Utilice -F o --fixed-strings para deshabilitar expresiones regulares.

    > echo ' lots((([]))) of special chars ' | sd -F ' ((([]))) ' ' '
   lots of special chars

2. Uso básico de expresiones regulares : recortemos algunos espacios en blanco al final

    > echo ' lorem ipsum 23   ' | sd ' s+$ ' ' '
   lorem ipsum 23

3. Grupos de captura

   Grupos de captura indexados:

    > echo ' cargo +nightly watch ' | sd ' (w+)s++(w+)s+(w+) ' ' cmd: $1, channel: $2, subcmd: $3 '
   cmd: cargo, channel: nightly, subcmd: watch

   Grupos de captura con nombre:

    > echo " 123.45 " | sd ' (?P<dollars>d+).(?P<cents>d+) ' ' $dollars dollars and $cents cents '
   123 dollars and 45 cents

   En el improbable caso de que encuentre ambigüedades, resuélvalas usando ${var} en lugar de $var . He aquí un ejemplo:

    > echo ' 123.45 ' | sd ' (?P<dollars>d+).(?P<cents>d+) ' ' $dollars_dollars and $cents_cents '
    and
   
   > echo ' 123.45 ' | sd ' (?P<dollars>d+).(?P<cents>d+) ' ' ${dollars}_dollars and ${cents}_cents '
   123_dollars and 45_cents

4. Buscar y reemplazar en un archivo

    > sd ' window.fetch ' ' fetch ' http.js

   Eso es todo. El archivo se modifica in situ.

   Para obtener una vista previa de los cambios:

    > sd -p ' window.fetch ' ' fetch ' http.js

5. Buscar y reemplazar en todo el proyecto

   Este ejemplo utiliza fd.

   La buena y antigua filosofía Unix al rescate.

   fd --type file --exec sd ' from "react" ' ' from "preact" '

   Lo mismo, pero con copias de seguridad (considere el control de versiones).

   fd --type file --exec cp {} {}.bk ; --exec sd ' from "react" ' ' from "preact" '

Casos extremos

sd interpretará cada argumento que comience con - como una bandera (potencialmente desconocida). Se respeta la convención común de usar -- para señalar el final de las banderas:

$ echo " ./hello foo " | sd " foo " " -w "
error: Found argument ' -w ' which wasn ' t expected, or isn ' t valid in this context

USAGE:
    sd [OPTIONS] < find > < replace-with > [files]...

For more information try --help
$ echo " ./hello foo " | sd " foo " -- " -w "
./hello -w
$ echo " ./hello --foo " | sd -- " --foo " " -w "
./hello -w

Escapar de caracteres especiales

Para escapar del carácter $ , use $$ :

❯ echo " foo " | sd ' foo ' ' $$bar '
$bar