Comment faire pour supprimer le dernier caractère d'un grep bash sortie

COMPANY_NAME=`cat file.txt | grep "company_name" | cut -d '=' -f 2`

sorties à quelque chose comme ceci

"Abc Inc";

Ce que je veux faire, je veux supprimer la fin ";" ainsi. Comment puis-je le faire? Je suis un débutant à bash. Des idées ou des suggestions serait utile.

Même ici. cat/grep = grep.
Pour le problème à la main, il aurait été possible de résoudre avec juste grep: COMPANY_NAME=$(grep -Po '(?<=company_name=)"[^"]*"' file.txt)

InformationsquelleAutor liv2hak | 2011-02-22

bash grep

48

J'utiliserais sed 's/;$//'. par exemple:
```
COMPANY_NAME=`cat file.txt | grep "company_name" | cut -d '=' -f 2 | sed 's/;$//'`
```
- Ne pas abuser de cats. grep peut lire les fichiers, le saviez-vous? 😉
- Oui, je sais qu'il y a au moins deux façons d'éviter cat ici. Je l'ai laissé dans le chat afin d'éviter de changer la ligne de commande à partir de la question au-delà de ce qui était réellement nécessaire pour le faire fonctionner.
- Pas vraiment, dans tous les cas, il suffit de grep sans chat -v permet de masquer invisible (par exemple malveillants) caractères, unix.stackexchange.com/questions/202198/...
InformationsquelleAutor Laurence Gonsalves
60

Cela va supprimer le dernier caractère contenues dans votre COMPANY_NAME var, peu importe si elle est ou non un point-virgule:
```
echo "$COMPANY_NAME" | rev | cut -c 2- | rev
```
InformationsquelleAutor ztank1013
42
```
foo="hello world"
echo ${foo%?}
hello worl
```
- Je l'aime. Merci.
- C'est du bash, pas les autres canalisations de bidules.
- Je l'aime. Ajouter un supplément ? pour plus de caractères à être supprimé.
- Cela viens de faire ma journée parce que j'essayais de faire un rapide et sale liste de sites internet que nous avons eu les clés TLS pour. for L in `ls *key` ; do echo ${L%.key} ; done
InformationsquelleAutor grokster
23

J'utiliserais head --bytes -1, ou head -c-1 pour faire court.
```
COMPANY_NAME=`cat file.txt | grep "company_name" | cut -d '=' -f 2 | head --bytes -1`
```
head sorties seulement le début d'un ruisseau ou d'un fichier. Généralement, il compte le nombre de lignes, mais il peut être fait pour compter les caractères ou octets au lieu de cela. head --bytes 10 sera la sortie de la première dizaine de personnages, mais head --bytes -10 sera de sortie à tout sauf à la dernière de dix.

NB: vous pouvez avoir des problèmes si le dernier caractère est multi-octets, mais un point-virgule n'est pas

Je recommande cette solution sur sed ou cut parce que
- C'est exactement ce que head a été conçu pour faire, donc moins d'options de ligne de commande et facile à lire de commande
- Cela vous évite d'avoir à réfléchir sur les expressions régulières, qui sont cool/puissant mais souvent exagéré
- Il permet d'économiser votre machine d'avoir à réfléchir sur les expressions régulières, ce sera imperceptiblement plus rapide
- J'ai testé l'autre solution proposée, et il semble que le meilleur (et simple!) pour mon cas d'utilisation. Merci!
- sur OSX brew install coreutils ensuite, vous pouvez utiliser ghead -c-1
InformationsquelleAutor Aaron J Lang
11

Je crois que la façon la plus propre à la bande un caractère unique à partir d'une chaîne avec bash est:
```
echo ${COMPANY_NAME:: -1}
```
mais je n'ai pas été en mesure d'intégrer la commande grep pièce à l'intérieur des accolades, alors votre tâche devient un deux-doublure:
```
COMPANY_NAME=$(grep "company_name" file.txt); COMPANY_NAME=${COMPANY_NAME:: -1} 
```
Cette bande de n'importe quel caractère, point-virgule ou pas, mais pouvez vous débarrasser de la point-virgule spécifiquement, trop.
Pour supprimer TOUS les points-virgules, où ils peuvent tomber:
```
echo ${COMPANY_NAME/;/}
```
Pour supprimer uniquement un point-virgule à la fin:
```
echo ${COMPANY_NAME%;}
```
Ou, pour supprimer plusieurs points-virgules à partir de la fin:
```
echo ${COMPANY_NAME%%;}
```
Pour de grands détails, et en savoir plus sur cette approche, Le Projet de Documentation Linux, couvre beaucoup de terrain à http://tldp.org/LDP/abs/html/string-manipulation.html

InformationsquelleAutor mightypile
8

À l'aide de sed, si vous ne savez pas ce que le dernier caractère est en fait:
```
$ grep company_name file.txt | cut -d '=' -f2 | sed 's/.$//'
"Abc Inc"
```
- Je ne pense pas que vous avez besoin de la \{1\} depuis . signifie un caractère unique.
- c'est correct. Merci.
InformationsquelleAutor Det
5

Ne pas abuser de cats. Saviez-vous que grep peut lire les fichiers, trop?

L'approche canonique serait celui-ci:
```
grep "company_name" file.txt | cut -d '=' -f 2 | sed -e 's/;$//'
```
l'approche plus intelligente serait d'utiliser un seul perl ou awk instruction, qui peut ne filtre et les différentes transformations à la fois. Par exemple quelque chose comme ceci:
```
COMPANY_NAME=$( perl -ne '/company_name=(.*);/&& print $1' file.txt )
```
- Pourquoi le déloyale downvote?
InformationsquelleAutor Anony-Mousse
3

n'avez pas à chaîne donc de nombreux outils. Juste une commande awk fait le travail
```
 COMPANY_NAME=$(awk -F"=" '/company_name/{gsub(/;$/,"",$2) ;print $2}' file.txt)
```
InformationsquelleAutor kurumi

En Bash en utilisant seulement un utilitaire externe:

IFS='= ' read -r discard COMPANY_NAME <<< $(grep "company_name" file.txt)
COMPANY_NAME=${COMPANY_NAME/%?}

InformationsquelleAutor Dennis Williamson

1

En supposant que les guillemets sont en fait une partie de la sortie, ne pourriez-vous utiliser l'option-o pour retourner tout ce qui est entre les guillemets?
```
COMPANY_NAME="\"ABC Inc\";" | echo $COMPANY_NAME | grep -o "\"*.*\""
```
InformationsquelleAutor Jens Bodal
1

Certains ajustements à la réponse ci-dessus. Pour supprimer plus d'un char vous ajoutez plusieurs points d'interrogation. Par exemple, pour supprimer les deux derniers caractères de la variable $SRC_IP_MSG, vous pouvez utiliser:
```
SRC_IP_MSG=${SRC_IP_MSG%??}
```
InformationsquelleAutor yuliskov
0
```
cat file.txt | grep "company_name" | cut -d '=' -f 2 | cut -d ';' -f 1
```
- c'est une évidence!.désolé j'ai oublié que la chose la plus évidente.
- comme linus torvalds dit, une des choses les plus difficiles à trouver dans un programmeur est le "bon goût", ce qui est difficile à définir. mais puisque vous en bénéficieraient je vais le faire dans ce cas: en raison de la première cat chaque élément de la canalisation qui n'travail réel fonctionne sur son entrée standard et la sortie standard. l'avantage est que vous pouvez remplacer le cat avec quelques autres pipeline qui produit une sortie semblable à file.txt et vous n'avez pas à changer, même un seul caractère dans la partie fonctionnelle de la canalisation. cela permet à la baisse-dans le pipeline de la réutilisabilité.
- fyb ci-dessus (oublié de vous marquer, juste comme quelqu'un qui pourrait oublier d'enlever l'argument d'entrée lors de la composition de pipelines et de se demander pourquoi la sortie n'est pas comme prévu)
- alors que je ne vois vraiment pas ce que vous me donner un "morceau de votre esprit" (lol je l'avais dit en passant) c'est plutôt l'extrême réutilisabilité pour préserver l'utilisation du cat juste pour vous donner la possibilité de le remplacer par quelque chose d'autre plus tard. La seule chose que j'ai pu voir, elle vaut pour est la simplicité. Si un utilisateur tape grep pattern file, alors je suis sacrément sûr qu'il comprenne c'est que la première partie qui lit le fichier et l'endroit où il commence la tuyauterie d'elle.
- merci pour le prendre positivement. il est raisonnable de dire grep foo file | grep bar | wc et il est raisonnable de dire cat file | grep foo | grep bar | wc. ce n'est pas raisonnable est de donner inutile chat prix pour le second. il y a plusieurs points spécifiques à preseve dans ma thèse sur le sujet. peut-être que vous pourriez ne pas apprécier maintenant que je n'ai pas lorsque je n'étais pas connu. je suis embêté pas à vous, mais les gens qui devraient savoir mieux que de les initier et de soutenir la pratique. l'espoir qui fait sens.
- ma réponse est désormais la un; bien sûr, c'est seulement l'opinion d'une personne autre que moi. merci pour la motivation à écrire.
- eh bien, c'est beaucoup mieux que celui de l'OP à l'origine, accepté. La discussion y est également très utile et précise le point que j'essayais de faire tout à fait bien. J'ai fait monter votre réponse aussi. Aussi, ce n'est pas comme I est celui qui a eu la motivation d'aller écrire une réponse, nous pouvons tous être fiers. Donc dans l'ensemble: content que vous l'avez énervé. Même si ce n'est pas moi.
- pourquoi je vous remercie! 🙂 on dirait que vous êtes l'apprentissage de unix choses avec un œil sur la rigueur. c'est la bonne approche afin de vous souhaiter bonne chance! ps: je voudrais offrir mes excuses à l'avance au cas où je me trompe et que vous êtes un unix vétéran simplement à la recherche pour combler les quelques lacunes dans les connaissances. LOL!
- loin d'elle.
InformationsquelleAutor necromancer
0

Je ne parviens pas à trouver que sed 's/;$//' œuvres. Il ne veut pas couper quoi que ce soit, mais je me demande si c'est parce que le personnage que je suis en train de couper arrive à être un "$". Ce qui fonctionne pour moi est sed 's/.\{1\}$//'.

InformationsquelleAutor ktappe
0

vous pouvez enlever les débuts et les fins d'une chaîne de N caractères à l'aide de cette bash construire, comme quelqu'un l'a déjà dit
```
$ fred=abcdefg.rpm
$ echo ${fred:1:-4}
bcdefg
```
CEPENDANT, ce n'est pas pris en charge dans les anciennes versions de bash.. comme je l'ai découvert juste en train d'écrire un script pour un Red hat EL6 processus d'installation. C'est la seule raison pour poster ici.
Un hacky façon d'y parvenir est d'utiliser sed avec extension de la regex comme ceci:
```
$ fred=abcdefg.rpm
$ echo $fred | sed -re 's/^.(.*)....$//g'
bcdefg
```
InformationsquelleAutor Paul M

Vous devez vous connecter pour publier un commentaire.