string - simple - Concatenar todos los argumentos y envolverlos con comillas dobles

que significan las comillas en visual basic

Question

function foo() {
A=$@...
echo $A
}
foo bla "hello ppl"

Me gustaría que la salida fuera:
"bla" "hola gente"

¿Qué necesito hacer en lugar de los puntos suspensivos?

Answer 1

@msw tiene la idea correcta (arriba en los comentarios sobre la pregunta). Sin embargo, otra idea es imprimir argumentos con comillas: use la iteración implícita de printf :

foo() { printf ''"%s" '' "$@"; echo ""; }
foo bla "hello ppl"
# => "bla" "hello ppl"

Answer 2

La única solución en este momento que respeta las barras invertidas y las citas dentro del argumento:

$ concatenate() { printf "%q"" " "$@"; echo ""; }
$ concatenate arg1 "arg2" "weird arg3//////bbut/" legal!"
arg1 arg2 weird/ arg3//////bbut/"/ legal/!

Observe el "% q" ""

% q ARGUMENT se imprime en un formato que puede reutilizarse como entrada de shell, escapando de caracteres no imprimibles con la sintaxis POSIX $ '''' propuesta.

Los caracteres especiales ( / , /b retroceso, ...) serán interpretados por el programa receptor, incluso si no se muestran interpretados en la salida del terminal.

Vamos a probar:

# display.sh: Basic script to display the first 3 arguments passed
echo -e ''#!/bin/bash''"/n"''echo -e "/$1=""$1"; echo -e "/$2=""$2"; echo -e "/$3=""$3"; sleep 2;'' > display.sh
sudo chmod 755 display.sh
# Function to concatenate arguments as $ARGS
# and "evalutate" the command display.sh $ARGS
test_bash() { ARGS=$(concatenate "$@"); bash -c "./display.sh ""$ARGS"; }
# Test: Output is identical whatever the special characters
./display.sh arg1 arg2 arg3
test_bash arg1 arg2 arg3

Prueba más complicada:

./display.sh arg1 "arg2-1:Y/b-2:Y//b-3:Y///b-4:Y////b-5:Y/////b-6:Y//////b" "arg3-XY/bZ-/"-1:/-2://-3:///-4:////-5://///-6://////-"
test_bash arg1 "arg2-1:Y/b-2:Y//b-3:Y///b-4:Y////b-5:Y/////b-6:Y//////b" "arg3-XY/bZ-/"-1:/-2://-3:///-4:////-5://///-6://////-"

En display.sh , estamos usando echo -e lugar de solo echo o printf para interpretar los caracteres especiales. Esto es solo representativo si su programa llamado los interpreta.

-e permite la interpretación de escapes de barra invertida

Si -e está en efecto, se reconocen las siguientes secuencias:

• / barra invertida
• / una alerta (BEL)
• / b retroceso
• Etc.

NB: /b es el carácter de retroceso, por lo que borra Y en el ejemplo.

Tenga en cuenta que este ejemplo no debe reproducirse en código real:

• Es muy infrecuente concatenar argumentos, siempre use el parámetro posicional cuando sea posible.
• bash -c y screen -X DEBE aceptar varios argumentos, por lo que no es necesario usar concatenación: vea No puede usar la opción bash -c con argumentos después de la cadena de opción -c ). Solo tenga cuidado de pasar algo por $0 cuando use bash -c .

Gracias a la respuesta aceptada y Danny Hong responda en "¿Cómo escapar de la comilla doble dentro de una comilla doble?"

Answer 3

No se requiere bucle:

foo() { local saveIFS=$IFS; local IFS=''"''; local a="${*/#/ /"}"; echo "$a"/"; IFS=$saveIFS; }

No es necesario guardar IFS en este simple ejemplo, especialmente restaurarlo justo antes de que la función salga, debido al hecho de que se usa local . Sin embargo, lo incluí en caso de que otras cosas entren en la función que podría afectar un IFS modificado.

Ejecución de ejemplo:

$ foo a bcd "efg hij" k "lll mmm nnn " ooo " ppp qqq " rrr/ sss
"a" "bcd" "efg hij" "k" "lll mmm nnn " "ooo" " ppp qqq " "rrr sss"

Answer 4

Puede usar "$ @" para tratar cada parámetro como, bueno, un parámetro separado, y luego recorrer cada parámetro:

function foo() {
for i in "$@"
do
echo -n /"$i/"" "
done
echo
}
foo bla "hello ppl"

Answer 5

Use la sustitución de parámetros para agregar "como prefijo y sufijo:

function foo() {
A=("${@/#//"}")
A=("${A[@]/%//"}")
echo -e "${A[@]}"
}
foo bla "hello ppl" kkk ''ss ss''

Salida

"bla" "hello ppl" "kkk" "ss ss"

Answer 6

ninjalj tuvo la idea correcta, pero el uso de comillas fue extraño, en parte porque lo que solicita el OP no es realmente el mejor formato de salida para muchas tareas de shell. En realidad, no puedo averiguar cuál es la tarea prevista, pero:

function quote_args {
for i ; do
echo /""$i"/"
done
}

pone sus argumentos entre comillas uno por línea, que suele ser la mejor manera de alimentar a otros programas. Usted obtiene salida en una forma que no pidió:

$ quote_args this is/ a "test really"
"this"
"is a"
"test really"

pero se puede convertir fácilmente y este es el idioma que preferiría la mayoría de las invocaciones de shell:

$ echo `quote_args this is/ a "test really"`
"this" "is a" "test really"

pero a menos que esté pasando por otra eval , las citas adicionales probablemente arruinarán las cosas. Es decir, ls "is a file" listará el archivo is a file mientras

$ ls `quote_args is/ a/ file`

intentará enumerar "is , a y un file" que probablemente no desee.