La préservation des espaces dans une chaîne de caractères comme argument de ligne de commande

Je suis confronté à un petit problème ici, j'ai envie de passer une chaîne de caractères contenant des espaces , à un autre programme, tel que l'ensemble de la chaîne est traitée comme un argument de ligne de commande.

En bref je veux exécuter une commande de la structure suivante par le biais d'un shell bash script:
command_name -un arg1 -b arg2 -c "arg avec des espaces ici"

Mais pas n'importe comment j'essaie, les espaces ne sont pas conservées dans la chaîne, et est segmenté par défaut. Une solution s'il vous plaît,

edit: C'est la partie principale de mon script:

#!/bin/bash

#-------- BLACKRAY CONFIG ---------------#
# Make sure the current user is in the sudoers list
# Running all instances with sudo

BLACKRAY_BIN_PATH='/opt/blackray/bin' 
BLACKRAY_LOADER_DEF_PATH='/home/crozzfire'
BLACKRAY_LOADER_DEF_NAME='load.xml'
BLACKRAY_CSV_PATH='/home/crozzfire'
BLACKRAY_END_POINT='default -p 8890'
OUT_FILE='/tmp/out.log'

echo "The current binary path is $BLACKRAY_BIN_PATH"


# Starting the blackray 0.9.0 server
sudo "$BLACKRAY_BIN_PATH/blackray_start"

# Starting the blackray loader utility
BLACKRAY_INDEX_CMD="$BLACKRAY_BIN_PATH/blackray_loader -c $BLACKRAY_LOADER_DEF_PATH/$BLACKRAY_LOADER_DEF_NAME -d $BLACKRAY_CSV_PATH -e "\"$BLACKRAY_END_POINT\"""

sudo time $BLACKRAY_INDEX_CMD -a $OUT_FILE

#--------- END BLACKRAY CONFIG ---------#

Désolé, mais vous avez trop peu d'informations. Ce shell utilisez-vous (bash, ksh, csh, ...)? Pouvez-vous dire quelle commande vous essayez d'exécuter? Si c'est un standard de l'utilitaire UNIX, pouvez-vous dire sa version?
script bash. Ok, voici ce que j'essaie de faire: .... BLACKRAY_END_POINT="default-p 8890" .... CMD="$BLACKRAY_BIN_PATH/blackray_loader -c $BLACKRAY_LOADER_DEF_PATH/$BLACKRAY_LOADER_DEF_NAME -d $BLACKRAY_CSV_PATH -e \"$BLACKRAY_END_POINT\"" ... Maintenant, je veux exécuter la commande ci-dessus tels que $BLACKRAY_END_POINT est considéré comme une seule chaîne et ne pas se faire sous forme de jeton. $BLACKRAY_END_POINT est une chaîne de caractères contenant des espaces bash, et la divise en des termes différents. Je veux préserver les espaces et passer l'ensemble de la chaîne comme un seul argument.
Inconnu, rencontrer barre oblique-double-quote (\"). Barre oblique-double-quote, rencontrer des inconnus.

OriginalL'auteur crozzfire | 2009-10-12

5

Vous rencontrez ce problème parce que vous magasin de la commande dans une variable, puis le développer plus tard; à moins qu'il y a une bonne raison pour ce faire, ne pas:
```
sudo time $BLACKRAY_BIN_PATH/blackray_loader -c $BLACKRAY_LOADER_DEF_PATH/$BLACKRAY_LOADER_DEF_NAME -d $BLACKRAY_CSV_PATH -e "$BLACKRAY_END_POINT" -a $OUT_FILE
```
Si vous avez vraiment besoin de stocker la commande et l'utiliser plus tard, il y a plusieurs options; le bash-hackers.org wiki a une une bonne page sur le sujet. Il me semble plus utile ici est de mettre la commande dans un tableau plutôt qu'une simple variable:
```
BLACKRAY_INDEX_CMD=($BLACKRAY_BIN_PATH/blackray_loader -c $BLACKRAY_LOADER_DEF_PATH/$BLACKRAY_LOADER_DEF_NAME -d $BLACKRAY_CSV_PATH -e "$BLACKRAY_END_POINT")

sudo time "${BLACKRAY_INDEX_CMD[@]}" -a $OUT_FILE
```
Cela évite toute confusion entre les espaces de séparation-les mots et les espaces à l'intérieur des mots, car les mots ne sont pas séparés par des espaces, ils sont en séparer les éléments de la matrice. L'expansion de la gamme dans le double-quotes avec le [@] suffixe conserve cette structure.

(BTW, une autre option serait d'utiliser échappé devis plutôt comme vous êtes en train de faire, puis exécutez la commande avec eval. Ne pas le faire; c'est une bonne façon de présenter bizarre d'analyse de bugs.)

Fonctionne pour moi, merci!

OriginalL'auteur Gordon Davisson
3

J'ai une suggestion:
```
# iterate through the passed arguments, save them to new properly quoted ARGS string
while [ -n "$1" ]; do
   ARGS="$ARGS '$1'"
   shift
done

# invoke the command with properly quoted arguments
my_command $ARGS
```
Cela ne fonctionne pas du tout: le shell traite des devis avant d'augmenter les variables, donc si il y a des citations dans la variable de valeurs qu'ils ne sont pas traités comme les guillemets, juste en caractères réguliers. En gros, c'est trop tard pour avoir l'effet voulu. Ce qui se passe réellement, c'est qu'ils sont passés à la commande dans le cadre de l'argumentation, qui n'est pas ce que vous voulez.

OriginalL'auteur Pavel
1

vous avez probablement besoin d'entourer l'argument par des guillemets (par exemple, "${6}").

OP suivantes commentaire, il doit être "$BLACKRAY_END_POINT"

Essayé. Mais encore, il faut juste "par défaut", et non pas l'ensemble de la chaîne 🙁
Remplacez -e \"$BLACKRAY_END_POINT\"" "\"$BLACKRAY_END_POINT\"". Vous avez besoin d' "" pour échapper à des espaces dans votre script, et d'autres \"\" pour échapper à des espaces lorsque la commande est exécutée
toujours pas de chance, il faut--> "par défaut comme l'arg maintenant (extra ouvrez les guillemets). pour la course je suis à l'aide de: sudo $CMD-a $OUT_FILE . Si je remplace $CMD "$CMD" , il me donne aucun fichier ou répertoire de l'erreur.

OriginalL'auteur dimba
1

Modifier:

Essayer:
```
BLACKRAY_END_POINT="'default -p 8890'"
```
ou
```
BLACKRAY_END_POINT='"default -p 8890"'
```
ou
```
BLACKRAY_END_POINT="default\ -p\ 8890"
```
ou
```
BLACKRAY_END_POINT='default\ -p\ 8890'
```
et
```
BLACKRAY_INDEX_CMD="$BLACKRAY_BIN_PATH/blackray_loader -c $BLACKRAY_LOADER_DEF_PATH/$BLACKRAY_LOADER_DEF_NAME -d $BLACKRAY_CSV_PATH -e $BLACKRAY_END_POINT"
```
Réponse originale à cette question:

Est blackray_loader un script shell?

Voici une démonstration de ce que vous avez à traiter de cette question à la fois lors de la spécification du paramètre et lors de la manipulation:

Un fichier texte appelé "test.txt" (y compris les numéros de ligne):
```
1 two words
2 two        words
3 two
4 words
```
Un script appelé "spacetest":
```
#!/bin/bash
echo "No quotes in script"
echo $1
grep $1 test.txt
echo

echo "With quotes in script"
echo "$1"
grep "$1" test.txt
echo
```
De l'exécution avec ./spacetest "two--------words" (remplacez les tirets par des espaces):
```
No quotes in script
two words
grep: words: No such file or directory
test.txt:1 two words
test.txt:2 two        words
test.txt:3 two

With quotes in script
two        words
2 two        words
```
Vous pouvez voir que dans le "Pas de guillemets" de la section, il a essayé de faire grep two words test.txt qui a interprété "les mots" en tant que nom de fichier, en plus de "test.txt". Aussi, le echo abandonné les espaces supplémentaires.

Lorsque le paramètre est cité, comme dans la deuxième section, grep vu comme un argument (y compris les espaces supplémentaires) et traitées correctement. Et echo préservé le places supplémentaires.

J'ai utilisé les espaces supplémentaires, par le chemin, simplement à l'aide à la démonstration.

D'accord. Mais dans mon cas, je ne suis pas la réussite de tous les arguments de mon script bash, au lieu de cela je suis coder en dur un argument(avec des espaces) qui doit être transmis à une commande. Cette commande (blackray_loader) est appelé dans mon script bash. J'ai juste besoin de préserver l'argument de l'url et de le passer comme un ensemble de la chaîne.
C'est exactement ce que je suis à démontrer. Dans le script ci-dessus, grep est un stand-in pour votre blackray_loader. Votre commande vous devez gérer correctement les paramètres. Toutefois le modifier pour une autre chose à essayer.

OriginalL'auteur Dennis Williamson
0

Ci-dessous est mon exemple de redémarrage d'un script via exec su UTILISATEUR ou exec su - UTILISATEUR. Il accueille:
- appelé à partir d'un chemin d'accès relatif ou répertoire de travail courant
- des espaces dans le nom du script et des arguments
- simples et doubles-guillemets dans les arguments, sans fou s'échappe comme: \\"
```
#
# This script should always be run-as a specific user
#
user=jimbob
if [ $(whoami) != "$user" ]; then
  exec su -c "'$(readlink -f "$0")' $(printf " %q" "$@")" - $user
  exit $?
fi
```
OriginalL'auteur Wiseguy
-1

Un post sur d'autres blog m'a sauvé de ce espaces problème: http://logbuffer.wordpress.com/2010/09/23/bash-scripting-preserve-whitespaces-in-variables/

Par défaut, les espaces sont trimed:
```
bash> VAR1="abc        def    gh ijk"
bash> echo $VAR1
abc def gh ijk
bash>
```
"La cause de ce comportement, c'est la variable shell $IFS (Internal Field Separator), qui est par défaut à l'espace, la tabulation et le retour à la ligne.
Afin de préserver l'ensemble des espaces vous devez définir l'IFS à quelque chose de différent"

Avec FI de contournement:
```
bash> IFS='%'
bash> echo $VAR1
abc        def    gh ijk
bash>unset IFS
bash>
```
Il fonctionne à merveille pour ma commande de cas:
```
su - user1 -c 'test -r "'${filepath}'"; ....'
```
Espère que cette aide.

Arrêter la propagation retardée hacks, s'il vous plaît. Vous êtes montrant clairement que vous ne comprenez pas l'importance de citations. Par défaut, les espaces sont trimed: FAUX. Sans les guillemets, vous allez en vertu de couper un mot et un nom de fichier extensions. Guérir avec des guillemets: VAR1="abc def gh ijk"; echo "$VAR1". Maintenant, il fonctionne. Aussi, comment voulez-vous expliquer ce qui se passe dans le cas d'un générique: VAR1='*'; echo $VAR1 vs VAR1='*'; echo "$VAR1"? Même avec votre IFS chose, vous obtiendrez le même résultat horrible: IFS=%; VAR1='*'; echo $VAR1. Il suffit d'utiliser plus de citations. Période.
Pouvez-vous m'expliquer pourquoi filepath est trimed dans ce cas : 'test -r "'${nom_fichier}'" ' ?
Vous devez comprendre comment les devis des travaux. Il n'y a pas d'emboîtements pour les citations. Je vais prendre votre commande complète: su - user1 -c 'test -r "'${filepath}'";'. Si filepath contient des espaces, par exemple, filepath='a b', puis, lorsque vous ne su - user1 -c 'test -r "'${filepath}'";', bash sera élargi pour les mots suivants: su, -, user1, -c, test -r "a, b";. Pas ce que vous voulez. Avec IFS=% semble qu'il fonctionne, mais il va échouer si filepath contient des caractères génériques ou le symbole % ou le symbole " (ou autres globules).
En Bash, il y a la %q format modificateur de printf qui peuvent vous aider avec votre cas: printf -v filepath_escaped '%q' "$filepath"; su - user1 -c "test -r $filepath_escaped".

OriginalL'auteur Kloe2378231

Vous devez vous connecter pour publier un commentaire.