Showing preview only (707K chars total). Download the full file or copy to clipboard to get everything.
Repository: jlevy/the-art-of-command-line
Branch: master
Commit: 6b50745d2e78
Files: 21
Total size: 687.2 KB
Directory structure:
gitextract_b6brm25b/
├── AUTHORS.md
├── CONTRIBUTING.md
├── README-cs.md
├── README-de.md
├── README-el.md
├── README-es.md
├── README-fr.md
├── README-id.md
├── README-it.md
├── README-ja.md
├── README-ko.md
├── README-pl.md
├── README-pt.md
├── README-ro.md
├── README-ru.md
├── README-sl.md
├── README-uk.md
├── README-zh-Hant.md
├── README-zh.md
├── README.md
└── admin/
└── authors-info.yml
================================================
FILE CONTENTS
================================================
================================================
FILE: AUTHORS.md
================================================
# Authors
This work is the result of the effort of many people around the world.
Contributors are listed in alphabetical order by GitHub login.
Some contributors are also assigned roles as maintainers.
They have kindly agreed to review and help update future contributions for the translation or section they own.
*Maintainers*
* [Ahmad Zafrullah (23Pstars)](https://github.com/23Pstars) — [3+](https://github.com/jlevy/the-art-of-command-line/commits?author=23Pstars)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3A23Pstars) — _translation maintainer (id)_
* [Anna Damtsa (anna-d)](https://github.com/anna-d) — [24+](https://github.com/jlevy/the-art-of-command-line/commits?author=anna-d)/[7+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aanna-d) — _translation maintainer (el)_
* [Carlos Mantilla (ceoaliongroo)](https://github.com/ceoaliongroo) — [29+](https://github.com/jlevy/the-art-of-command-line/commits?author=ceoaliongroo)/[16+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aceoaliongroo) — _translation maintainer (es)_
* [Dmytro Kovalov (uk: Дмитро Ковальов) (dmytro)](https://github.com/dmytro) — [6+](https://github.com/jlevy/the-art-of-command-line/commits?author=dmytro)/[4+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Admytro) — _translation maintainer (uk)_
* [Hayato Matsuura (doublemarket)](https://github.com/doublemarket) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=doublemarket)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Adoublemarket) — _translation maintainer (ja)_
* [Diomidis Spinellis (dspinellis)](https://github.com/dspinellis) — [15+](https://github.com/jlevy/the-art-of-command-line/commits?author=dspinellis)/[11+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Adspinellis) — _section maintainer (Windows)_
* [Éric Guirbal (ericguirbal)](https://github.com/ericguirbal) — [31+](https://github.com/jlevy/the-art-of-command-line/commits?author=ericguirbal)/[14+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aericguirbal) — _translation maintainer (fr)_
* [Francesco Malatesta (francescomalatesta)](https://github.com/francescomalatesta) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=francescomalatesta)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Afrancescomalatesta) — _translation maintainer (it)_
* [Joshua Levy (jlevy)](https://github.com/jlevy) — [162+](https://github.com/jlevy/the-art-of-command-line/commits?author=jlevy)/[59+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ajlevy) — _original author and project maintainer_
* [kevingo (kevingo)](https://github.com/kevingo) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=kevingo)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Akevingo) — _translation maintainer (zh-Hant)_
* [lsrom](https://github.com/lsrom) — [14+](https://github.com/jlevy/the-art-of-command-line/commits?author=lsrom)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Alsrom) — _translation maintainer (cs)_
* [Mihai Maruseac (mihaimaruseac)](https://github.com/mihaimaruseac) — [10+](https://github.com/jlevy/the-art-of-command-line/commits?author=mihaimaruseac)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amihaimaruseac) — _translation maintainer (ro)_
* [Nilton Vasques (niltonvasques)](https://github.com/niltonvasques) — [24+](https://github.com/jlevy/the-art-of-command-line/commits?author=niltonvasques)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aniltonvasques) — _translation maintainer (pt)_
* [Oleg Berman (olegberman)](https://github.com/olegberman) — [15+](https://github.com/jlevy/the-art-of-command-line/commits?author=olegberman)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aolegberman) — _translation maintainer (ru)_
* [Peter Kokot (petk)](https://github.com/petk) — [54+](https://github.com/jlevy/the-art-of-command-line/commits?author=petk)/[39+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Apetk) — _translation maintainer (sl)_
* [Chujie Zeng (Psycho7)](https://github.com/Psycho7) — [25+](https://github.com/jlevy/the-art-of-command-line/commits?author=Psycho7)/[9+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3APsycho7) — _translation maintainer (zh)_
* [Martin Folkers (S1SYPHOS)](https://github.com/S1SYPHOS) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=S1SYPHOS)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3AS1SYPHOS) — _translation maintainer (de)_
* [Stepan Babala (stepan0904)](https://github.com/stepan0904) — [37+](https://github.com/jlevy/the-art-of-command-line/commits?author=stepan0904)/[6+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Astepan0904) — _translation (uk)_
* [Ungsik Yun (Ungsik-Yun)](https://github.com/Ungsik-Yun) — [15+](https://github.com/jlevy/the-art-of-command-line/commits?author=Ungsik-Yun)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3AUngsik-Yun) — _translation maintainer (ko)_
*Translators*
* [Antonio Ossa (aaossa)](https://github.com/aaossa) — [5+](https://github.com/jlevy/the-art-of-command-line/commits?author=aaossa)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aaaossa) — _translator (es)_
* [Chong Guo (Armour)](https://github.com/Armour) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=Armour)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3AArmour) — _translator (zh)_
* [Bogdan Luput (bgdnlp)](https://github.com/bgdnlp) — _translator (ro)_
* [Alex Vergara Gil (BishopWolf)](https://github.com/BishopWolf) — [4+](https://github.com/jlevy/the-art-of-command-line/commits?author=BishopWolf)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3ABishopWolf) — _translator (es)_
* [Gernot Pointner (gernd)](https://github.com/gernd) — [6+](https://github.com/jlevy/the-art-of-command-line/commits?author=gernd)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Agernd) — _translator (de)_
* [githubashto](https://github.com/githubashto) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=githubashto)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Agithubashto) — _translator (ru)_
* [Grigory Rechistov (grigory-rechistov)](https://github.com/grigory-rechistov) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=grigory-rechistov)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Agrigory-rechistov) — _translator (ru)_
* [Sung Kim (hunkim)](https://github.com/hunkim) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=hunkim)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ahunkim) — _translator (ko)_
* [kstn (kastian)](https://github.com/kastian) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=kastian)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Akastian) — _translator (ru)_
* [Kohei Takada (koh7)](https://github.com/koh7) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=koh7)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Akoh7) — _translator (ja)_
* [osmero](https://github.com/osmero) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=osmero)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aosmero) — _translator (ru)_
* [Remi Verchere (rverchere)](https://github.com/rverchere) — _translator (fr)_
* [Snowcat8436 (Snowcat8436)](https://github.com/Snowcat8436) — [4+](https://github.com/jlevy/the-art-of-command-line/commits?author=Snowcat8436)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3ASnowcat8436) — _translator (ko)_
* [spmbt (spmbt)](https://github.com/spmbt) — [13+](https://github.com/jlevy/the-art-of-command-line/commits?author=spmbt)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aspmbt) — _translator (ru)_
* [Steven Liu (stevenlordiam)](https://github.com/stevenlordiam) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=stevenlordiam)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Astevenlordiam) — _translator (zh)_
* [Thomas Sungjin Kang (ujuc)](https://github.com/ujuc) — [6+](https://github.com/jlevy/the-art-of-command-line/commits?author=ujuc)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aujuc) — _translator (ko)_
* [Valeria de Paiva (vcvpaiva)](https://github.com/vcvpaiva) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=vcvpaiva)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Avcvpaiva) — _translator (pt)_
* [Xu Chunyang (xuchunyang)](https://github.com/xuchunyang) — [13+](https://github.com/jlevy/the-art-of-command-line/commits?author=xuchunyang)/[7+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Axuchunyang) — _translator (zh)_
*Contributors*
* [0xCD](https://github.com/0xCD) — [4+](https://github.com/jlevy/the-art-of-command-line/commits?author=0xCD)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3A0xCD)
* [0xmohit](https://github.com/0xmohit) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=0xmohit)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3A0xmohit)
* [Jiang Guoxi (374632897)](https://github.com/374632897) — [3+](https://github.com/jlevy/the-art-of-command-line/commits?author=374632897)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3A374632897)
* [Andrii (aaabramov)](https://github.com/aaabramov) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=aaabramov)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aaaabramov)
* [Ahmet Alp Balkan (ahmetb)](https://github.com/ahmetb) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=ahmetb)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aahmetb)
* [Alexander Bodin (AlexanderBodin)](https://github.com/AlexanderBodin) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=AlexanderBodin)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3AAlexanderBodin)
* [Semir Patel (analogue)](https://github.com/analogue) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=analogue)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aanalogue)
* [Andreas Hofmann (andreas-hofmann)](https://github.com/andreas-hofmann) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=andreas-hofmann)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aandreas-hofmann)
* [Desmond Stonie (aneasystone)](https://github.com/aneasystone) — [3+](https://github.com/jlevy/the-art-of-command-line/commits?author=aneasystone)/[8+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aaneasystone)
* [anna-4](https://github.com/anna-4) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=anna-4)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aanna-4)
* [Brad Beyenhof (augmentedfourth)](https://github.com/augmentedfourth) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=augmentedfourth)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aaugmentedfourth)
* [b-jazz (b-jazz)](https://github.com/b-jazz) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=b-jazz)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ab-jazz)
* [bafoed](https://github.com/bafoed) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=bafoed)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Abafoed)
* [Colas BROUX (brouxco)](https://github.com/brouxco) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=brouxco)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Abrouxco)
* [Alex Cabrera (cabreraalex)](https://github.com/cabreraalex) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=cabreraalex)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Acabreraalex)
* [Chris Kuehl (chriskuehl)](https://github.com/chriskuehl) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=chriskuehl)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Achriskuehl)
* [Christopher Biscardi (ChristopherBiscardi)](https://github.com/ChristopherBiscardi) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=ChristopherBiscardi)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3AChristopherBiscardi)
* [Sihan Li (ClumsyLee)](https://github.com/ClumsyLee) — [12+](https://github.com/jlevy/the-art-of-command-line/commits?author=ClumsyLee)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3AClumsyLee)
* [Corey Richardson (cmr)](https://github.com/cmr) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=cmr)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Acmr)
* [CodinCat (CodinCat)](https://github.com/CodinCat) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=CodinCat)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3ACodinCat)
* [Colin Wang (colinwjd)](https://github.com/colinwjd) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=colinwjd)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Acolinwjd)
* [Chris Rhodes (crr0004)](https://github.com/crr0004) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=crr0004)/[4+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Acrr0004)
* [Daniel t. (danasmera)](https://github.com/danasmera) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=danasmera)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Adanasmera)
* [Dmytro Danylevskyi (danylevskyi)](https://github.com/danylevskyi) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=danylevskyi)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Adanylevskyi)
* [Dave Loyall (daveloyall)](https://github.com/daveloyall) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=daveloyall)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Adaveloyall)
* [Kirill (DDyst)](https://github.com/DDyst) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=DDyst)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3ADDyst)
* [Deborah Gertrude Digges (Deborah-Digges)](https://github.com/Deborah-Digges) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=Deborah-Digges)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3ADeborah-Digges)
* [Jamie Luck (delucks)](https://github.com/delucks) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=delucks)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Adelucks)
* [Dillon Flamand (dflamand)](https://github.com/dflamand) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=dflamand)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Adflamand)
* [Michael Diamond (dimo414)](https://github.com/dimo414) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=dimo414)/[4+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Adimo414)
* [Vincent Wong (EaterOA)](https://github.com/EaterOA) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=EaterOA)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3AEaterOA)
* [Veck Hsiao (fbukevin)](https://github.com/fbukevin) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=fbukevin)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Afbukevin)
* [Fernando Almeida (fernandoalmeida)](https://github.com/fernandoalmeida) — [8+](https://github.com/jlevy/the-art-of-command-line/commits?author=fernandoalmeida)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Afernandoalmeida)
* [Sami (fnzv)](https://github.com/fnzv) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=fnzv)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Afnzv)
* [Gaga Pan (gaga5lala)](https://github.com/gaga5lala) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=gaga5lala)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Agaga5lala)
* [Massimiliano Arione (garak)](https://github.com/garak) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=garak)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Agarak)
* [XinYu Zheng (gayu-mike)](https://github.com/gayu-mike) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=gayu-mike)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Agayu-mike)
* [Konstantin Gribov (grossws)](https://github.com/grossws) — [3+](https://github.com/jlevy/the-art-of-command-line/commits?author=grossws)/[6+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Agrossws)
* [Ashhar Hasan (hashhar)](https://github.com/hashhar) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=hashhar)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ahashhar)
* [Beau Hastings (hastinbe)](https://github.com/hastinbe) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=hastinbe)/[4+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ahastinbe)
* [Iliana Panagopoulou (hpanago)](https://github.com/hpanago) — [3+](https://github.com/jlevy/the-art-of-command-line/commits?author=hpanago)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ahpanago)
* [Space exploration enthusiast (Hunter-Github)](https://github.com/Hunter-Github) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=Hunter-Github)/[5+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3AHunter-Github)
* [Hyojin Kwak (hyojin)](https://github.com/hyojin) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=hyojin)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ahyojin)
* [Ihor Dvoretskyi (idvoretskyi)](https://github.com/idvoretskyi) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=idvoretskyi)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aidvoretskyi)
* [Kevin Morales (iKenshu)](https://github.com/iKenshu) — [3+](https://github.com/jlevy/the-art-of-command-line/commits?author=iKenshu)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3AiKenshu)
* [Ilja Krauchanka (ikrauchanka)](https://github.com/ikrauchanka) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=ikrauchanka)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aikrauchanka)
* [Sergey Isaev (isvforall)](https://github.com/isvforall) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=isvforall)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aisvforall)
* [Igor Veksler (iveksl2)](https://github.com/iveksl2) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=iveksl2)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aiveksl2)
* [J Alan Brogan (jalanb)](https://github.com/jalanb) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=jalanb)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ajalanb)
* [James Kolce (jameskolce)](https://github.com/jameskolce) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=jameskolce)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ajameskolce)
* [Dotan J. Nahum (jondot)](https://github.com/jondot) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=jondot)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ajondot)
* [Jesse Sightler (jsight)](https://github.com/jsight) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=jsight)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ajsight)
* [Konstantin Mikhailov (jtraub)](https://github.com/jtraub) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=jtraub)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ajtraub)
* [Jakub Wilk (jwilk)](https://github.com/jwilk) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=jwilk)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ajwilk)
* [Wael Nasreddine (kalbasit)](https://github.com/kalbasit) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=kalbasit)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Akalbasit)
* [Colin Chan (kalgynirae)](https://github.com/kalgynirae) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=kalgynirae)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Akalgynirae)
* [Michalis Kargakis (kargakis)](https://github.com/kargakis) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=kargakis)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Akargakis)
* [Kesu J (kesu)](https://github.com/kesu) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=kesu)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Akesu)
* [Takuma Yamaguchi (kumon)](https://github.com/kumon) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=kumon)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Akumon)
* [Dmytro Prokhorenkov (l13t)](https://github.com/l13t) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=l13t)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Al13t)
* [Mikhail Letunovskiy (l3xx)](https://github.com/l3xx) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=l3xx)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Al3xx)
* [Lakshmipathi (Lakshmipathi)](https://github.com/Lakshmipathi) — [10+](https://github.com/jlevy/the-art-of-command-line/commits?author=Lakshmipathi)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3ALakshmipathi)
* [Pavel Zhukov (landgraf)](https://github.com/landgraf) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=landgraf)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Alandgraf)
* [lcmtwn](https://github.com/lcmtwn) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=lcmtwn)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Alcmtwn)
* [Lampros Mountrakis (lmount)](https://github.com/lmount) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=lmount)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Almount)
* [Luke Yeager (lukeyeager)](https://github.com/lukeyeager) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=lukeyeager)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Alukeyeager)
* [TAKAGI Masahiro (m-takagi)](https://github.com/m-takagi) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=m-takagi)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Am-takagi)
* [Who? Me?! (mark-i-m)](https://github.com/mark-i-m) — [5+](https://github.com/jlevy/the-art-of-command-line/commits?author=mark-i-m)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amark-i-m)
* [marocchino](https://github.com/marocchino) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=marocchino)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amarocchino)
* [Matjaž Lipuš (matjaz)](https://github.com/matjaz) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=matjaz)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amatjaz)
* [Mayra Cabrera (mayra-cabrera)](https://github.com/mayra-cabrera) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=mayra-cabrera)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amayra-cabrera)
* [Michael Barlow (michaelbarlow7)](https://github.com/michaelbarlow7) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=michaelbarlow7)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amichaelbarlow7)
* [Jinhui-Lin (mintisan)](https://github.com/mintisan) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=mintisan)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amintisan)
* [Crisoforo Gaspar Hernández (mitogh)](https://github.com/mitogh) — [3+](https://github.com/jlevy/the-art-of-command-line/commits?author=mitogh)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amitogh)
* [miuc (miuc)](https://github.com/miuc) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=miuc)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amiuc)
* [Michael Kwardakov (mkwardakov)](https://github.com/mkwardakov) — [7+](https://github.com/jlevy/the-art-of-command-line/commits?author=mkwardakov)/[14+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amkwardakov)
* [Harry Moreno (morenoh149)](https://github.com/morenoh149) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=morenoh149)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amorenoh149)
* [Dongliang Mu (mudongliang)](https://github.com/mudongliang) — [3+](https://github.com/jlevy/the-art-of-command-line/commits?author=mudongliang)/[10+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Amudongliang)
* [Lilian Besson (Naereen)](https://github.com/Naereen) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=Naereen)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3ANaereen)
* [Namgoo Lee (nglee)](https://github.com/nglee) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=nglee)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Anglee)
* [Serg Petrov (p12se)](https://github.com/p12se) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=p12se)/[0+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ap12se)
* [王霄池(wangxiaochi) (picasso250)](https://github.com/picasso250) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=picasso250)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Apicasso250)
* [pravdomil (pravdomil)](https://github.com/pravdomil) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=pravdomil)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Apravdomil)
* [Rahul Kavale (rahulkavale)](https://github.com/rahulkavale) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=rahulkavale)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Arahulkavale)
* [Rasmus Wriedt Larsen (RasmusWL)](https://github.com/RasmusWL) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=RasmusWL)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3ARasmusWL)
* [Riley Shaw (rileyjshaw)](https://github.com/rileyjshaw) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=rileyjshaw)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Arileyjshaw)
* [Ryan Delaney (rpdelaney)](https://github.com/rpdelaney) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=rpdelaney)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Arpdelaney)
* [Haoxuan Li (Sagir1)](https://github.com/Sagir1) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=Sagir1)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3ASagir1)
* [Saksham Sharma (sakshamsharma)](https://github.com/sakshamsharma) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=sakshamsharma)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Asakshamsharma)
* [Semen Martynov (SemenMartynov)](https://github.com/SemenMartynov) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=SemenMartynov)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3ASemenMartynov)
* [Kit Chan (shukitchan)](https://github.com/shukitchan) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=shukitchan)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ashukitchan)
* [Simarpreet Singh (simar7)](https://github.com/simar7) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=simar7)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Asimar7)
* [snowme34 (snowme34)](https://github.com/snowme34) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=snowme34)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Asnowme34)
* [Soham Chakraborty (SohamChakraborty)](https://github.com/SohamChakraborty) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=SohamChakraborty)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3ASohamChakraborty)
* [Fabien Dubosson (StreakyCobra)](https://github.com/StreakyCobra) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=StreakyCobra)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3AStreakyCobra)
* [Chengcheng Tang (tangchengcheng)](https://github.com/tangchengcheng) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=tangchengcheng)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Atangchengcheng)
* [taxusyew](https://github.com/taxusyew) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=taxusyew)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ataxusyew)
* [Timur (tim-teufel)](https://github.com/tim-teufel) — [4+](https://github.com/jlevy/the-art-of-command-line/commits?author=tim-teufel)/[3+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Atim-teufel)
* [Timotei Dolean (timotei)](https://github.com/timotei) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=timotei)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Atimotei)
* [Haoyu Qiu (timothyqiu)](https://github.com/timothyqiu) — [4+](https://github.com/jlevy/the-art-of-command-line/commits?author=timothyqiu)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Atimothyqiu)
* [René Ribaud (uggla)](https://github.com/uggla) — [5+](https://github.com/jlevy/the-art-of-command-line/commits?author=uggla)/[10+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Auggla)
* [Joe Block (unixorn)](https://github.com/unixorn) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=unixorn)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aunixorn)
* [vitzli](https://github.com/vitzli) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=vitzli)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Avitzli)
* [Eduardo Rolim (vndmtrx)](https://github.com/vndmtrx) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=vndmtrx)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Avndmtrx)
* [senhtry (w169q169)](https://github.com/w169q169) — [3+](https://github.com/jlevy/the-art-of-command-line/commits?author=w169q169)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Aw169q169)
* [Evan Wong (wyf88)](https://github.com/wyf88) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=wyf88)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Awyf88)
* [Okunev Yu Dmitry (xaionaro)](https://github.com/xaionaro) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=xaionaro)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Axaionaro)
* [yasuhiroki (yasuhiroki)](https://github.com/yasuhiroki) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=yasuhiroki)/[2+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ayasuhiroki)
* [Alex F. (youmee)](https://github.com/youmee) — [1+](https://github.com/jlevy/the-art-of-command-line/commits?author=youmee)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ayoumee)
* [Youngwoo Kim (youngwookim)](https://github.com/youngwookim) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=youngwookim)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ayoungwookim)
* [yssmcl](https://github.com/yssmcl) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=yssmcl)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Ayssmcl)
* [Zack Piper (zackp30)](https://github.com/zackp30) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=zackp30)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Azackp30)
* [Aleksandr Zhuravlev (zelark)](https://github.com/zelark) — [2+](https://github.com/jlevy/the-art-of-command-line/commits?author=zelark)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Azelark)
* [Xudong Zhang (zxdvd)](https://github.com/zxdvd) — [0+](https://github.com/jlevy/the-art-of-command-line/commits?author=zxdvd)/[1+](https://github.com/jlevy/the-art-of-command-line/issues?q=author%3Azxdvd)
Numbers link to commits/issues.
For simplicity, this file is maintained only in English.
If your name does not appear as you would like it above, verify your name on your GitHub profile.
Also confirm that your commits are using the correct e-mail to it is linked to your profile.
If you see inaccuracies or omissions, please file an issue, or edit the authors-info.yml file, regenerate, and file a PR.
(This file was auto-generated by [ghizmo assemble-authors](https://github.com/jlevy/ghizmo).)
================================================
FILE: CONTRIBUTING.md
================================================
## Contributing to The Art of Command Line
This guide is a [collaborative effort](AUTHORS.md), based on the generous work of many contributors.
## Questions
[](https://airtable.com/shrzMhx00YiIVAWJg)
The simplest thing you can do to help is [**submit any questions you might have**](https://airtable.com/shrzMhx00YiIVAWJg).
The more the better. Questions help identify where the guide needs to be improved.
## Contributions
Contributions of all kinds, including corrections, additions, improvements, and translations, are welcome!
We hope you'll join and help, in small ways or large.
Here are few notes before you jump in.
### Style
- Stay close to the existing style of the document when possible.
- Remember to focus on **brevity**, **specificity**, and **utility**.
- Avoid long explanations and instead prefer links to resources.
### Using issues and PRs
- Please **create and comment on issues freely** to discuss. A lot of the difficulty in accepting PRs is around style and format, and whether changes should be made at all, so rationale or explanations for the change are useful.
- Please **review open issues and pull requests** before submitting a new one, to help reduce duplication.
- To the extent possible, **break up changes into multiple PRs** so they can be approved separately. Large contributions are also welcome, but are harder and slower to approve, as they tend to require discussion or rewriting.
## Translations
The guide is now available in many languages. Here is the process for maintaining translations:
- This original version and content of the guide is maintained in English.
- *Translations follow the content of the original.* Note this means contributors to a translation must be able to read some English, so that translations do not diverge (unless it is only fixing a typo).
- Each translation has a maintainer to update the translation as the original evolves and to review others' changes. This doesn't require a lot of time, but review by the maintainer is important to maintain quality.
- See the [AUTHORS.md](AUTHORS.md) file for current maintainers. (This file is generated from the [authors-info.yml](admin/authors-info.yml) file.)
### Changes to translations
- Changes to content should be made to the English version first, and then translated to each other language.
- Changes that improve translations should be made directly on the file for that language. PRs should only modify one language at a time.
- Submit a PR with changes to the file in that language. Each language has a maintainer, who reviews changes in that language. Then the primary maintainer @jlevy merges it in.
- Prefix PRs and issues with language codes if they are for that translation only, e.g. "es: Improve grammar", so maintainers can find them easily.
### Adding a translation to a new language
Translations to new languages are always welcome! Keep in mind a transation must be maintained, so it's needed to have one person maintain each translation.
- Check existing issues to see if a translation is in progress or stalled. If so, offer to help.
- Do you have time to be a maintainer for the new language? Please say so so we know we can count on you in the future.
- If it is not in progress, file an issue for your language so people know you are working on it and we can arrange. Confirm you are native level in the language and are willing to maintain the translation, so it's not orphaned.
- To get it started, fork the repo, then submit a PR with the single file README-xx.md added, where xx is the language code. Use standard [IETF language tags](https://www.w3.org/International/articles/language-tags/), i.e. the same as is used by Wikipedia, *not* the code for a single country. These are usually just the two-letter lowercase code, for example, `fr` for French and `uk` for Ukrainian (not `ua`, which is for the country). For languages that have variations, use the shortest tag, such as `zh-Hant`.
- *Invite friends to review* if possible. Tranlsations are difficult and usually have erros others need to find. If desired, feel free to invite them to help your original translation by letting them fork your repo, then merging their PRs.
- Add links to your translation at the top of every README*.md file. (For consistency, the link should be added in alphabetical order by ISO code, and the anchor text should be in the native language.)
- When done, indicate on the PR that it's ready to be merged into the main repo.
### Further questions
Unsure of the process?
Or do you have skills and inclination to help in a more substantial way?
File an issue or e-mail the original author [@jlevy](https://github.com/jlevy).
================================================
FILE: README-cs.md
================================================
🌍
*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Indonesia](README-id.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [polski](README-pl.md) ∙ [Português](README-pt.md) ∙ [Română](README-ro.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)*
# Umění příkazové řádky
[](https://gitter.im/jlevy/the-art-of-command-line?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
- [Meta](#meta)
- [Základy](#zaklady)
- [Každodenní použití](#kazdodenni-pouziti)
- [Zpracování souborů a dat](#zpracovani-souboru-a-dat)
- [Ladění systému](#ladeni-systemu)
- [Jednořádkové příkazy](#jednoradkove-prikazy)
- [Neobvyklé ale užitečné](#neobvykle-ale-uzitecne)
- [Pouze pro OS X](#pouze-pro-os-x)
- [Další zdroje](#dalsi-zdroje)
- [Zřeknutí se odpovědnosti](#zreknuti-se-odpovednosti)
Plynulost práce na příkazové řádce je umění často opomíjené nebo považované za překonané, ale zlepšuje vaši flexibilitu a produktivitu jako inženýr jak očividně tak nenápadně. Toto je výběr poznámek a tipů pro použití příkazové řádky které shledáváme užitečnými při práci na Linuxu. Některé tipy jsou základní a některé jsou velmi specifické, komplikované či nejasné. Tato stránka není dlouhá, ale pokud dokážete použít a vybavit si všechny věci zde zmíněné, máte dostatečně rozsáhlé vědomosti.
Tato práce je výsledkem [mnoha autorů a překladatelů](AUTHORS.md).
Mnoho se
[původně](http://www.quora.com/What-are-some-lesser-known-but-useful-Unix-commands)
[objevilo](http://www.quora.com/What-are-the-most-useful-Swiss-army-knife-one-liners-on-Unix)
na webu [Quora](http://www.quora.com/What-are-some-time-saving-tips-that-every-Linux-user-should-know),
ale s ohledem na zájem, který tam panoval, se zdálo vhodné použít GitHub, kde lidé více talentovaní než původní autor mohli okamžitě navrhovat zlepšení. Pokud najdete chybu či něco, co by mohlo být vylepšeno, prosím vytvořte issue nebo pull request! (Samozřejmě nejdříve zkontrolujte meta sekci a existující pull requesty a issues.)
## Meta
Rozsah:
- Tento průvodce je pro začátečníky i pro pokročilé. Cílem je *široký záběr* (vše důležité), *specifičnost* (poskytnout konkrétní příklady nejčastějšího použití) a *stručnost* (vyhnout se věcem, které nejsou nezbytné nebo podobným tématům, které lze vyhledat jinde). Každý tip je v některých případech nenahraditelný nebo značně šetří čas oproti alternativám.
- Tento dokument je napsán pro Linux s vyjímkou sekcí označených jako "[Pouze pro OS X](#os-x-only)". Mnoho ostatních položek lze použít nebo je lze nainstalovat na jiných Unixových systémech nebo MacOS (dokonce i na Cygwin).
- Zaměření dokumentu je na inteaktivní Bash ačkoli mnoho tipů lze aplikovat na jiné shelly a obecné bashové scriptování.
. Jsou zahrnuty jak "standardní" Unixové příkazy tak příkazy vyžadující instalaci extra balíčků -- pokud jsou dost důležité aby zasloužily zmínku.
Poznámky:
- Pro udržení délky textu na jednu stranu, obsah je implicitně obsažen v odkazech. Jste dostatečně inteligentní aby jste si vyhledali více detailů z jiných zdrojů jakmile znáte příkaz či myšlenku na Googlu. Použijte `apt-get`, `yum`, `dnf`, `pacman`, `pip` nebo `brew` podle distribuce k instalaci nových progamů.
- Použijte [Explainshell](http://explainshell.com/) pro užitečné vysvětlení co příkazy, možnosti, roury a jiné dělají.
## Základy
- Naučte se základy Bashe. Vlastně, napište `man bash` a alespoň si to proleťte; je to celkem jednoduché a ne tak dlouhé. Jiné shelly mohou být dobré, ale Bash je mocný a vždy dostupný (znalost *pouze* zsh, fish a jiných ačkoli lákavá na vlastním notebooku omezuje v mnoha situacích, jako například při použití existujících serverů).
- Poznejte alespoň jeden textový editor dobře. Nejlépe Vim (`vi`) jelikož opravdu nemá pro občasné úpravy v terminálu nemá konkurenci (ani pokud většinu času používáte Emacs, velké IDE nebo moderní okenní editor).
- Naučte se číst dokumentaci pomocí `man` (pro zvědavce, `man man` vypíše čísla sekcí, například 1 jsou "obvyklé" příkazy, 5 jsou soubory/konvence a 8 je administrace). Hledejte manuálové stránky pomocí `apropos`. Vězte, že některé příkazy nejsou spustitelné programy, ale funkce zabudované v Bashi a nápovědu k nim můžete zobrazit příkazem `help` a `help-d`.
- Naučte se přesměrování výstupu a vstupu pomocí `>` a `<` a roury pomocí `|`. Pamatujte, že `>` přepíše obsah výstupního souboru a `>>` přidá na jeho konec. Nezapomeňte na stdout (stndardní výstup) a stderr (standardní chybový výstup).
- Poznejte souborovou hromadnou expanzi za pomoci `*` (případně `?` a `[`...`]`) a úvozovkách a rozdílu mezi dvojitými uvozovkami `"` a jednoduchými `'`. (Více na expanzi proměných níže.)
- Seznamte se se správou činností v Bashi: `&`, **ctrl-z**, ctrl-c**, `jobs`, `fg`, `bg`, `kill`, atd.
- Seznamte se s `ssh` a základy bezheslové autentizace pomocí `ssh-agent`, `ssh-add`, atd.
- Základní správa souborů: `ls` a `ls -l` (zejména co který sloupec v `ls -l` znamená), `less`, `head`, `tail` a `tail -f` (nebo ještě lépe `less +F`), `ln` a `ln -s` (pochopte rozdíly a výhody pevného odkazu a symoblického odkazu), `chown`, `chmod`, `du` (pro krátký souhrn využití disku: `du -hs *`). Pro správu souborového systému, `df`, `mount`, `fdisk`, `mkfs`, `lsblk`. Pochopte co je inode (`ls -i` nebo `df -i`).
- základní správa síťí: `ip` nebo `ifconfig`, `dig`.
- Dobře se naučte regulárních výrazů a rozličné příznaky pro `grep`/`egrep`. Přepínače `-i`, `-o`, `-v`, `-A`, `-B` a `-C` je také vhodné znát.
- Naučte se používat `apt-get`, `yum`, `dnf` nebo `pacman` (podle vaší distribuce) k hledání a instalaci balíků. A ujistěte se, že máte `pip` k instalace Pythonových terminálových nástrojů (některé je nejjednodušší nainstalovat pomocí `pip`).
## Každodenní použití
- V Bashi používejte **Tab** k dokončení argumentů nebo vylistování všech dostupných příkazů a **ctrl-r** k vyhledávání v historii příkazů (po stisknutí pište pro hledání a poté mačkejte opakovaně **ctrl-r** k procházení více shod, **Enter** k provedení nalezeného příkazu nebo šipku vpravo pro vložení výsledku hledání do terminálu a následnou editaci).
- V Bashi používejte **ctrl-w** pro smazní posledního slova a **ctrl-u** pro smazání všeho od současné pozice kurzoru až po začátek řádku. Používejte **alt-b** a **alt-f** k procházení řádku po slovech, **ctrl-a** pro skok na začátek řádku, **ctrl-e** pro skok kurzoru na konec řádku, **ctrl-k** pro smazání všeho od současné pozice až ke konci řádku, **ctrl-l** pro vyčištění obrazovky. Prohlédněte si `man readline` pro všechny defaultní klávesové zkratky v Bashi. Je jich hodně. Například **alt-.** projíždí předchozí argumenty a **alt-*** rozšíří řetězec.
- Pokud milujete klávesové zkratky ve stylu *vi*, použijte `set -o vi` (a `set -o emacs` pro návrat ke standardnímu rozložení).
- Pro úpravu dlouhých příkazů, po nastavení vašeho editoru (například `export EDITOR=vim`), **ctrl-x** **ctrl-e** v něm otevře stávající příkaz pro víceřádkovou úpravu. Nebo ve *vi* stylu, **escape-v**.
- Zobrazení nedávných příkazů se provádí pomocí `history`. Existuje spousta zkratek jako `!$` (poslední argument) a `!!` (poslední příkaz), ale tyto jsou jednoduše nahraditelné pomocí **ctrl-r** a **alt-.**.
- Pro přechod do předchozího pracovního adresáře: `cd -`.
- Pokud máte zpola napsaný příkaz, ale rozmyslíte si to, stiskněte **alt-#** pro přidání `#` na začátek řádku a vložte ho jako komentář (nebo použijte **ctrl-a**, **#**, **enter**). Takto se k němu můžete později vrátit v historii příkazů.
- Používejte `xargs` (nebo `parallel`). Jde o mocný příkaz. Nezapomeňte, že můžete ovládat kolik položek se má vykonat na řádku (`-L`) stejně jako paralelismus (`-P`). Pokud si nejste jisti zda to udělá co má, zkuste nejdříve `xargs echo`. Hodí se také `-I{}`.
Příklady:
```bash
find . -name '*.py' | xargs grep nejaka_funkce
cat hosts | xargs -I{} ssh root@{} hostname
```
- `pstree -p` je užitečné zobrazení stromu procesů.
- Používejte `pgrep` a `pkill` k hledání nebo posílání signálů procesům podle jména. (`-f` je také užitečné).
- Pamatujte si rozličné signály, které lze posílat procesům. Například, k pozastavení procesu, použijte `kill -STOP [pid]`. Celý seznam signálů v `man 7 signal`.
- Používejte `nohup` nebo `disown` pokud chcete, aby proces na pozadí běžel navždy.
- Kontrolujte, které procesy naslouchají pomocí `netstat -lntp` nebo `ss -plat` (pro TCP; přidejte `-u` pro UDP).
- Podívejte se také na `lsof` pro otevřené sockety a soubory.
- Jak dlouho systém běží poznáte díky `uptime` nebo `w`.
- Pomocí `alias` si nastavte zkratky pro často používané příkazy. Například `alias ll='ls -latr'` vytvoří novou zkratku `ll`.
- V Bashových scriptech používejte `set -x` (nebo jeho variantu `set -v`, která zaznamenává nezpracovaný vstup včetně nečekaných proměnných a komentářů) pro ladící výstup. Používejte striktní módy pokud nemáte dobrý důvod proč to tak nedělat: Příkazem `set -e` nastavíte přerušení při chybě (nenulový návratový kód). Použijte `set -u` pro zjištění použití neinicializovaných proměnných. Zvažte také `set -o pipefail` pro chyby v rourách (přečtěte si na tohle téma více pokud tuto možnost využijete, jelikož jde o citlivé téma). Pro více zapojených scriptů použijte `trap` na EXIT nebo ERR. Dobrým zvykem bývá začínat scripty takto, což zachytí a ukončí běh na běžných chybách a vypíše zprávu:
```bash
set -euo pipefail
trap "echo 'error: Script selhal: neuspesny prikaz vyse'" ERR
```
- V Bash scriptech jsou subshelly (psané s kulatými závorkami) vhodným způsobem shlukování příkazů. Běžným příkladem budiž dočasný přesun do jiného pracovního adresáře, například:
```bash
# udelej neco v soucasnem pracovnim adresari
(cd /nejaky/jiny/adresar && jiny-prikaz)
# pokracuj v puvodnim adresari
```
- Nezapomeňte, že v Bashi je mnoho druhů expanze proměnných. KOntrola, že proměnná existuje `${jmeno:?chybova hlaska}`. například, pokud script vyžaduje jediný argument, napište `vstupni_soubor=${1:?pouziti: $0 vstupni_soubor}`. Aritmetická expanze: `i=$(( (i + 1) % 5 ))`. Sekvence: `{1..10}`. Ořezání (trimming) řetězců: `${var%suffix}` a `${var#prefix}`. Pokud například `var=foo.pdf`, pak `echo ${var%.pdf}.txt` zobrazí `foo.txt`.
- Expanze složených závorek použitím `{`...`}` může snížit potřebu přepisovat podobné texty a zautomatizovat kombinaci položek. Toto může být užitečné například v `mv foo.{txt,pdf} nejaky-adresar` (což přesune oba soubory), `cp nejakysoubor{,.bak}` (což se rozšíří do `cp nejakysoubor nejakysoubor.bak`) nebo `mkdir -p test-{a,b,c}/subtest-{1,2,3}` (což se rozšíří do všech možných kombinací a vytvoří příslušný adresářový strom).
- S výstupem některých příkazů lze zacházet jako se souborem pomocí `<(nejaky prikaz)`. Například porovnání lokálního `/etc/hosts` se vzdáleným:
```sh
diff /etc/hosts <(ssh nejakyhost cat /etc/hosts)
```
- Poznejte "zdejší dokumenty" v Bashi, míněno `cat <<EOF ...`.
- -Přesměrujte jak standardní výstup tak standardní chybový výstup v Bashi pomocí: `nejaky-prikaz > logsoubor 2>&1` nebo `nejaky-prikaz &>logsoubor`. Častokrát, k zajištění, že příkaz nezanechá otevřený souborový držák (handle), navázání ho na terminál ve kterém jste, je dobrá praktika také přidat `</dev/null`.
- Používejte `man ascii` pro dobrou ASCII tabulku se šestnáctkovými i dekadickými hodnotami. Pro obecné kódovací informace jsou užitečné `man unicode`, `man utf-8` a `man latin1`.
- Používejte `screen` nebo [`tmux`](https://tmux.github.io/) k rozšíření obrazovky, což je užitečné zejména na vzdálených ssh připojeních a k odpojení a znovu-připojení k sezení. `byobu` dokáže vylepšit obrazovku nebo tmux a poskytovat více informací a jednodušší správu. Více minimalistická varianta pouze pro přetrvání sezení je `dtach`.
- v ssh je důležité vědět, jak tunelovat porty s pomocí `-L` nebo `-D` (a příležitostně `-R`) například k přístupu na webovou stránku ze vzdáleného serveru.
- Může být užitečné udělat trochu optimalizačních úprav vašeho ssh připojení; například v `~/.ssh/config` je nastavení pro vyhýbání se odhozeným spojením v jistých sítích, používá kompresi (což je užitečné se scp přeš síť s malou šířkou pásma připojení) a multiplexové kanály ke stejnému serveru v lokálním souboru.
```
TCPKeepAlive=yes
ServerAliveInterval=15
ServerAliveCountMax=6
Compression=yes
ControlMaster auto
ControlPath /tmp/%r@%h:%p
ControlPersist yes
```
- Některé další možnosti vstahující se k ssh jsou bezpečnostně citlivé a měli by být povoleny s opatrností, například pro jednotlivé podsítě nebo hosty v důvěryhodných sítích: `StrictHostKeyChecking=no`, `ForwardAgent=yes`
- Zvažte [`mosh`](https://mosh.org/) jako alternativu k ssh, která používá UDP, vyhýbá se padlým spojením a přidává pohodlí na cestách (vyžaduje nastavení na serveru).
- K získání oprávnění k souboru v osmičkové formě, což je užitečné pro systémovou konfiguraci, ale nedostupné v `ls` a lehko zpackatelné, použijte něco jako
```sh
stat -c '%A %a %n' /etc/timezone
```
- Pro interaktivní výběr hodnot ze vstupu jiného příkazu použijte [`percol`](https://github.com/mooz/percol) nebo [`fzf`](https://github.com/junegunn/fzf).
- Pro interakci se soubory v závislosti na vstupu jiného příkazu (třeba `git`), použijte `fpp` ([PathPicker](https://github.com/facebook/PathPicker)).
- Po zpřístupnění jednoduchého webového serveru pro všechny soubory v současném adresáři (a podadresářích), přístupného každému na vaší síti použijte:
`python -m SimpleHTTPServer 7777` (pro port 7777 a Python 2) a `python -m http.server 7777` (pro port 7777 a Python 3).
- Pro spuštění příkazu s právy použijte `sudo` (pro roota) nebo `sudo -u` (pro jiného uživatele). Používejte `su` nebo `sudo bash` pokud chcete aby shell běžel skutečně pod daným uživatelem. Použitím `su -` simulujte čerstvé přihlášení jako root nebo jiný uživatel.
## Zpracovaní souboru a dat
- K nalezení souboru podle jména v pracovním adresáři: `find . -iname '*something*'` (nebo podobně). K nalezení souboru podle jména kdekoliv na disku, použijte `locate jmeno` (pamatujte, že `updatedb` nemuselo nutně zaindexovat nedávno vytvořené soubory).
- Pro obecné prohledávání zdrojů nebo datových souborů (více sofistikované než `grep -r`), použijte [`ag`](https://github.com/ggreer/the_silver_searcher).
- Převeďte HTML na text pomocí `lynx -dump -stdin`.
- Vyzkoušejte [`pandoc`](http://pandoc.org/) pro Markdown, HTML a všechny druhy převodu dokumentů.
- Pokud musíte pracovat s XML `xmlstarlet` je starý, ale dobrý.
- Pro JSON použijte [`jq`](http://stedolan.github.io/jq/).
- Pro YAML, použijte [`shyaml`](https://github.com/0k/shyaml).
- Pro Excel nebo CSV suobory, [csvkit](https://github.com/onyxfish/csvkit) poskytuje `in2csv`, `csvcut`, `csvjoin`, `csvgrep`, atd.
- Pro Amazon S3, [`s3cmd`](https://github.com/s3tools/s3cmd) je pohodlnější a [`s4cmd`](https://github.com/bloomreach/s4cmd) je rychlejší. [`aws`](https://github.com/aws/aws-cli) od Amazonu a vylepšený [`saws`](https://github.com/donnemartin/saws) jsou nezbytné pro ostatní AWS úkoly.
- Mějte přehled o `sort` a `uniq`, včetně přepínače `-u` pro `uniq` a `-d` -- shlédněte jednořádkové příklady níže. A také `comm`.
- Mějte přehled také o `cut`, `paste` a `join` pro manipulaci s textovými soubory. Mnoho lidí používá `cut`, ale zapomínají na `join`.
- Udržujte přehled také o `wc` na počítání nových řádků (`-l`), znaků (`-m`), slov (`-w`) a bytů (`-c`).
- A přehled je dobré mít také o `tee` pro kopírování ze stdin do souboru a na stdout, podobně jako za použití `ls -la | tee soubor.txt`.
- Mějte na paměti, že nastavení lokalizace ovlivňuje mnoho příkazů v shellu mnoha způsoby včetně pořadí při třídění a výkonu. Většina Linuxových instalací nastaví `LANG` nebo jinou lokalizační proměnnou na lokální nastavení jako americká angličtina. Nezapomínejte však, že vaše třídění se změní změníte-li lokalizaci. A myslete na to, že i18n rutiny mohou způsobit, že třídění nebo jiné příkazy mohou běžet **mnohokrát** pomaleji. V některých situacích (při nastavování nebo testu unikátnost jako níže) lze bezpečně ignorovat pomalé i18n rutiny úplně a použít tradiční bytový pořádek pří třídění s `export LC_ALL=C`.
- Měli byste znát základní `awk` a `sed` pro jednoduché operace s daty. Například sčítání všech čísel ve třetím sloupci textového souboru: `awk '{ x += $3 } END { print x }'`. Tento příkaz je pravděpodobně 3x rychlejší a obsahuje 3x méně kódu než jeho ekvivalent v Pythonu.
- K nahrazení všech výskytů řetězce v jedno místě nebo ve více souborech:
```sh
perl -pi.bak -e 's/stary-retezec/novy-retezec/g' moje-soubory-*.txt
```
- K přejmenování více souborů a/nebo vyhledávání a nahrazení uvnitř těchto souborů zkuste [`repren`](https://github.com/jlevy/repren). (V některých případech příkazech `rename` také dovoluje vícenásobné přejmenování, ale buďte opatrní neboť není stejný na všech Linuxových distribucích).
```sh
# Plne jméno souboru, adresaru a obsahu foo -> bar:
repren --full --preserve-case --from foo --to bar .
# Obnov zalozni soubory cokoliv.bak -> cokoli:
repren --renames --from '(.*)\.bak' --to '\1' *.bak
# Stejne jako vyse za pouziti jmena pokud mozne:
rename 's/\.bak$//' *.bak
```
- Jak říká manuálová stránka, `rsync` je skutečně rychlý a neobyčejně univerzální nástroj na kopírování souborů. Je znám pro synchronizaci mezi stroji, ale je stejně užitečný lokálně. Jde také o jednu z [nejrychlejších cest](https://web.archive.org/web/20130929001850/http://linuxnote.net/jianingy/en/linux/a-fast-way-to-remove-huge-number-of-files.html) k odstranění velkého množství souborů:
```sh
mkdir prazdny && rsync -r --delete prazdny/ nejaky-adr && rmdir nejaky-adr
```
- Použijte `shuf` k zamíchání nebo vybrání náhodných řádek ze souboru.
- Mějte přehled v `sort` možnostech. Pro čísla, použijte `-n` nebo `-h` pro práci s lidsky čitelnými čísly (například z `du -h`). Pochopte jak fungují klíče (`-t` a `-k`). Zejména mějte na paměti, že musíte psát `-k,1` pro třídění za použití pouze prvního pole; `-k1` znamená třídění podle celého řádku. Stabilní třídění (`sort -s`) může být užitečné. Například k setřídění primárně podle druhého pole a sekundárně podle druhého pole můžete použít `sort -k1,1 | sort -s -k2,2`.
- Pokud někdy potřebujete zapsat znak tabulátor do příkazové řádky v Bashi (například pro -t argument pro třídění), stiskněte press **ctrl-v** **[Tab]** nebo napište $'\t'` (druhá možnost je lepší, protože výsledek můžete zkopírovat/vložit).
- Standardní nástroje pro porovnávání zdrojového kódu jsou `diff` a `patch`. Za zmínku stojí také `diffstat` zobrazující statistiky z diffu a `sdiff` pro rozdíly bok po boku. Nezapomeňte, že `diff -r` funguje pro celé adresáře. Použijte `diff -r strom1 strom2 | diffstat` pro shrnutí změn. A `vimdiff` pro porovnání a úpravu souborů.
- Pro binární soubory použijte `hd`, `hexdump` nebo `xxd` pro jednoduché hex dumpy a `bvi` nebo `biew` pro editaci binárek.
- Pro binární soubory můžete také použít `strings` (například spolu s `grep`, atd), což je nástroj pro hledání částí textu.
- Pro binární rozdíly (delta komprese) použijte `xdelta3`.
- Pro konverzi testových kódování zkuste `iconv`. Nebo `uconv` pro pokročilejší použití; podporuje některé pokročilé Unicode věci. Například tento příkaz mění text na malé znaky a odstraňuje akcenty (jejich rozvinutím a zahozením):
```sh
uconv -f utf-8 -t utf-8 -x '::Any-Lower; ::Any-NFD; [:Nonspacing Mark:] >; ::Any-NFC; ' < input.txt > output.txt
```
- Na rozdělení souborů do částí zkuste `split` (na rozdělení podle velikosti) a `csplit` (na rozdělení podle řetězce).
- K manipulaci s datem a časem použijte `dateadd`, `datediff`, `strptime` atd. z [`dateutils`](http://www.fresse.org/dateutils/).
- Použijte `zless`, `zmore`, `zcat`, a `zgrep` k operacím s komprimovanými soubory.
## Ladění systému
- Pro webové ladění jsou vhodné `curl` a `curl /I` nebo jejich `wget` ekvivalenty nebo více moderní [`httpie`](https://github.com/jkbrzt/httpie).
- Pro zjištění současného procesorového/diskového stavu, klasické nástroje jako `top` (nebo lépe `htop`). Použijte `iostat -mxz 15` pro základní CPU a detailní diskové stavy pro každý diskový oddíl a výkonostní statistiky.
- Pro detaily ohledně síťové konektivity použijte `netstat` a `ss`.
- Rychlý přehled co se děje v systému získáte pomocí užitečného `dstat`. Pro širší přehled s detaily použijte [`glances`](https://github.com/nicolargo/glances).
- Na zjištění stavu paměti spusťte `free` a `vmstat` a pokuste se porozumět jejich výstupům. Zejména dbejte na "cached" hodnotu což je paměť držená Linuxovým kernelem jako souborová cache, tudíž se počítá do "volné" paměťi.
- Ladění Javy je odlišný šálek čaje, ale jednoduchý trik na Javu od Oraclu a některé jiné JVM je, že stále můžete použít `kill -3 <pid>` a výpis zásobníku a haldy (včetně obecnějších detailů z **garbage collectoru**, které mohou být nesmírně informativní) bude zapsán do stderr/logs. Nástroje JDK jako `jps`, `jstat`, `jstack` a `jmap` jsou také užitečné, avšak [SJK tools](https://github.com/aragozin/jvm-tools) jsou více pokročilé.
- Použijte [`mtr`](http://www.bitwizard.nl/mtr/) jako lepší `traceroute` pro identifikování potíží se sítí.
- Při zjištování proč je disk plný, [`ncdu`](https://dev.yorhel.nl/ncdu) šetří čas oproti obvyklým příkazům jako `du /sh *`.
- Ke zjištění, který socket nebo proces zahlcuje pásmo, zkuste [`iftop`](http://www.ex-parrot.com/~pdw/iftop/) nebo [`nethogs`](https://github.com/raboof/nethogs).
- Nástroj `ab` (přibalený k Apachi) je užitečný pro rychlé a hrubé zkontrolování výkonosti webového serveru. Komplexnější měření umožňuje `siege`.
- Pro důslednější síťové ladění, [`wireshark`](https://wireshark.org/), [`tshark`](https://www.wireshark.org/docs/wsug_html_chunked/AppToolstshark.html) nebo [`ngrep`](http://ngrep.sourceforge.net/) jsou to pravé.
- Nezapomínejte na `strace` a `ltrace`. Mohou být nápomocné zejména pokud některý program selhává, zasekává se nebo padá a nevíte proč nebo pokud chcete mít obecnou představu o výkonu. Myslete na přepínač profilingu (`-c`) a schopnost připnout se k běžícímu procesu (`-p`).
- Dynamické knihovny vám umožní zkontrolovat `ldd`.
- Je důležité umět se připojit k běžícímu procesu za pomoci `gdb` a získat výpis jeho chodu.
- Používejte `/proc`. Je úžasně nápomocný v okamžicích, kdy ladíte živé problémy. Příklady: /proc/cpuinfo`, `/proc/meminfo`, `/proc/cmdline`, `/proc/xxx/cwd`, `/proc/xxx/exe`, `/proc/xxx/fd/`, `/proc/xxx/smaps` (kde `xxx` je id nebo pid procesu.).
- Když zjišťujete proč se něco v minulosti pokazilo, [`sar`](http://sebastien.godard.pagesperso-orange.fr/) může být nedocenitelný. Ukazuje historické statistiky CPU, paměti, sítě, atd.
- Pro hlubší systémovou a výkonostní analýzu se podívejte na `stap`([SystemTap](https://sourceware.org/systemtap/wiki)), [`perf`](https://en.wikipedia.org/wiki/Perf_(Linux)), a [`sysdig`](https://github.com/draios/sysdig).
- Zkontrolujte na jakém jste OS za pomoci `uname` nebo `uname -a` (obecné Unix/kernel informace) nebo `lsb_release -a` (v Linuxových distribucích).
- Použijte `dmesg` kdykoli se něco chová neočekávaně (může jít o hardwarový nebo driverový problém).
## Jednořádkové příkazy
Pár příkladů na spojování příkazů:
- Někdy je pozoruhodně užitečné dělat průnik, sjednocení a rozdíl textových souborů pomocí `sort`/`uniq`. Předpokládejte, že `a` a `b` jsou unikátní textové soubory. Toto je rychlé a funguje na souborech libovolné velikosti až do mnoha gigabytů. (Třídění pomocí `sort` není omezené pamětí, ale je možné, že budete muset použít `-T` přepínač, pokud se `/tmp` nachází na malém diskovém oddílu). Podívejte se také na poznámku o LC_ALL výše a přepínač `sortu` `-u` (vynechaný pro přehlednost).
```sh
cat a b | sort | uniq > c # c je sjednocení b
cat a b | sort | uniq -d > c # c je průnik b
cat a b b | sort | uniq -u > c # c je rozdíl a - b
```
- Použijte `grep .*` pro rychlé prošetření obsahu všech souborů v adresáři (každý soubor je spojen s názvem souboru) nebo `head -100 *` (aby každý soubor měl záhlaví). Může být užitečné pro adresáře s konfiguračními soubory jako jsou například `/sys`, `/proc` a `/etc`.
- Součet všech čísel ve třetím sloupci textového souboru (pravděpodobně 3x rychlejší a 3x méně kódu než ekvivalentní funkce v Pythonu):
```sh
awk '{ x += $3 } END { print x }' mujsoubor
```
- Pokud chcete zobrazit velikosti/datumy na souborovém stromu, následující příkaz je jako rekurzivní `ls -l`, ale jedodušší na čtení než `ls -lR`:
```sh
find . -type f -ls
```
- Řekněme, že máte textový soubor, jako log webového serveru, a jisté hodnoty, které se objevují na některých řádcích, jako například `acct_id` parametr, který se vyskytuje v URL. Pokud chcete záznam kolik požadavků pro každý `acct_id`:
```sh
cat access.log | egrep -o 'acct_id=[0-9]+' | cut -d= -f2 | sort | uniq -c | sort -rn
```
- K průběžnému monitorování změn použijte `watch`, například změn souborů v adresáři pomocí `watch -d -n 2 'ls -rth | tail'` nebo síťových nastavení při řešení potíží nastavení wifi: `watch -d -n 2 ifconfig`.
- Spusťte tuto funkci k získání náhodného tipu z tohoto dokumentu (parsuje Markdown a vyextrahuje jednu položku):
```sh
function taocl() {
curl -s https://raw.githubusercontent.com/jlevy/the-art-of-command-line/master/README.md |
pandoc -f markdown -t html |
xmlstarlet fo --html --dropdtd |
xmlstarlet sel -t -v "(html/body/ul/li[count(p)>0])[$RANDOM mod last()+1]" |
xmlstarlet unesc | fmt -80
}
```
## Neobvyklé ale užitečné
- `expr`: provede aritmetické nebo logické operace nebo vyhodnotí regulární výrazy
- `m4`: jednoduchý procesor maker
- `yes`: tiskne řetězec vícekrát
- `cal`: hezký kalendář
- `env`: provede příkaz (užitečné ve scriptech)
- `printenv`: vypíše proměnné prostředí (užitečné při ladění a ve scriptech)
- `look`: najde anglická slova (nebo řádky v souboru) začínající řetězcem
- `cut`, `paste` a `join`: manipulace s daty
- `fmt`: formátuje text do odstavců
- `pr`: formátuje text do stránek/sloupců
- `fold`: zalamuje řádky textu
- `column`: formátuje textová pole do zarovnaných sloupců nebo tabulek s danou šířkou
- `expand` a `unexpand`: převádí tabulátory a mezery
- `nl`: přidá čísla řádků
- `seq`: tiskne čísla
- `bc`: kalkulačka
- `factor`: provádí faktorizaci celých čísel (15 = 5 a 3)
- [`gpg`](https://gnupg.org/): šifruje a podepisuje soubory
- `toe`: tabulka informací o dostupných terminálech
- `nc`: síťové ladění a přenos dat
- `socat`: socketové relé a tcp port přesměrování (podobné `netcat`)
- [`slurm`](https://github.com/mattthias/slurm): visualizace síťového provozu
- `dd`: přesun dat mezi soubory nebo zařízeními
- `file`: identifikuje typ souboru
- `tree`: zobrazí adresáře a podadresáře jako vnořený strom; podobně jako `ls` ale rekurzivně
- `stat`: informace o souboru
- `time`: provede a načasuje příkaz
- `timeout`: provádí příkaz po specifikovanou dobu a zastaví proces když daná doba uplyne
- `lockfile`: vytvoří semaforový soubor, který lze odstranit pouze pomocí `rm -f`
- `logrotate`: rotuje, komprimuje a posílá logy emailem
- `watch`: spouští opakovaně příkaz a zobrazuje výsledky a/nebo zvýrazňuje změny
- `tac`: tiskne soubory pozpátku (po řádcích)
- `shuf`: náhodně vybere řádky ze souboru
- `comm`: porovná seřazení soubory řádek po řádku
- `pv`: monitoruje postup dat skrz rouru
- `hd`, `hexdump`, `xxd`, `biew` a `bvi`: vypíše nebo edituje binární soubory
- `strings`: vypreparuje textové řetězce z binárních souborů
- `tr`: překládá znaky nebo s nimi manipuluje
- `iconv` nebo `uconv`: převod pro kódování textu
- `split` a `csplit`: dělí soubory
- `sponge`: čte všechen vstup před tím než ho zapíše, užitečné pro čtení a následný zápis do téhož souboru, např. `grep -v neco nejaky-soubor | sponge nejaky-soubor`
- `units`: převody jednotek a výpočty; převádí jednotky mezi sebou, (viz. `/usr/share/units/definitions.units`)
- `apg`: generuje náhodná hesla
- `7z`: vysoko-poměrová datová komprese
- `ldd`: informace o dynamických knihovnách
- `nm`: vypíše symboly z objektových souborů
- `ab`: zátěžové testy webserverů
- `strace`: ladění systému
- [`mtr`](http://www.bitwizard.nl/mtr/): vylepšení traceroute pro síťové ladění
- `cssh`: vizuální souběžný shell
- `rsync`: synchronizuje soubory a adresáře přes SSH nebo v lokálním systému souborů
- [`wireshark`](https://wireshark.org/) a [`tshark`](https://www.wireshark.org/docs/wsug_html_chunked/AppToolstshark.html): zachytávání packetů a síťové ladění
- [`ngrep`](http://ngrep.sourceforge.net/): grep pro síťovou vrstvu
- `host` a `dig`: DNS vyhledávání
- `lsof`: zpracovává souborové popisovače (descriptory) a informace o socketech
- `dstat`: užitečné systémové informace
- [`glances`](https://github.com/nicolargo/glances): vysoko úrovňový, multi-systémový přehled
- `iostat`: statistiky využití disku
- `mpstat`: statistiky využití CPU
- `vmstat`: statistiky využití paměti
- `htop`: vylepšená verze top (správa procesů)
- `last`: historie přihlášení
- `w`: kdo je přihlášen
- `id`: informace o identitě uživatele/skupiny
- [`sar`](http://sebastien.godard.pagesperso-orange.fr/): historické systémové statistiky
- [`iftop`](http://www.ex-parrot.com/~pdw/iftop/) nebo [`nethogs`](https://github.com/raboof/nethogs): využití sítě pro proces nebo socket
- `ss`: statistika socketů
- `dmesg`: bootovací a systémové chybové zprávy
- `sysctl`: zobrazení a konfigurace parametrů Linuxového kernelu za běhu
- `hdparm`: SATA/ATA disková manipulace/výkon
- `lsblk`: seznam blokových zařízení: stromové zobrazení disků a diskových oddílů
- `lshw`, `lscpu`, `lspci`, `lsusb`, `dmidecode`: informace o hardwaru zahrnující CPU, BIOS, RAID, grafiku, zařízení, atd.
- `lsmod` a `modinfo`: seznam a detaily kernelových modulů
- `fortune`, `ddate`, a `sl`: hm, no, záleží jestli považujete parní lokomotivy a Zippyho citáty za "užitečné"
## Pouze pro OS X
Tyto věci jsou relevantní pouze pro macOS.
- Balíčky spravované pomocí `brew` (Homebrew) a/nebo `port` (MacPorts). Mohou být použity k instalaci mnoha předešlých příkazů na macOS.
- Kopírujte výstup jakéhokoli příkazu do desktopové aplikace pomocí `pbcopy` a vložte vstup z nějaké pomocí `pbpaste`.
- K povolení klávesy Option v Terminálu Mac OS jako klávesu Alt (pro použití v příkazech jako **alt-b**, **alt-f**, atd.), otevřete Předvolby -> Profily -> Klávesnice a zvolte "Použít Option jako Meta klávesu".
- K otevření souboru za pomoci desktopové aplikace použijte `open` nebo `open -a /Aplikace/Cokoli.app`.
- Spotlight: Prohledávejte soubory s `mdfind` a vypište metadata (například EXIF informace fotografie) pomocí `mdls`.
- Nezapomínejte, že macOS je založen na BSD Unixu a mnoho příkazů (například `ps`, `ls`, `tail`, `awk`, `sed`) mají spoustu jemných odlišností od Linuxu, což je z velké části ovlivněno System V (System Five) stylem Unixu a GNU nástroji. Mnohokrát mmůžete rozdíl poznat podle manuálové stránky mající v nadpise "BSD General Commands Manual". V některých případech mohou být GNU verze instalovány také (třeba `gawk` a `gsed` pro GNU awk a sed). Pokud píšete multi-platformní Bashové scripty, vyhýbejte se takovým příkazům (například, zvažte Python či `perl`) nebo pečlivě testujte.
- K získání informací o verzi vydání macOS použijte `sw_vers`.
## Další zdroje
- [awesome-shell](https://github.com/alebcay/awesome-shell): Organizovaný seznam shellových nástrojů a zdrojů.
- [awesome-osx-command-line](https://github.com/herrbischoff/awesome-osx-command-line): Průvodce Mac OS příkazovou řádkou více do hloubky.
- [Striktní mód](http://redsymbol.net/articles/unofficial-bash-strict-mode/) pro psaní lepších shellových scriptů.
- [shellcheck](https://github.com/koalaman/shellcheck): Nástroj pro statickou analýzu shellových scriptů. V podstatě lint pro bash/sh/zsh.
- [Souborové názvy a cesty v shellu](http://www.dwheeler.com/essays/filenames-in-shell.html): Bohužel velmi komplexní drobnosti o korektní práci se souborovými jmény v shellových scriptech.
## Zřeknutí se odpovědnosti
S vyjímkou velmi malých úkolů je kód psán tak, aby ho ostatní mohli přečíst. S mocí přichází zodpovědnost. Skutečnost, že něco *můžete* v Bashi udělat nemusí nutně znamenat, že byste měli! ;)
## License
[](http://creativecommons.org/licenses/by-sa/4.0/)
Tato práce je licencována pod [Creative Commons Attribution-ShareAlike 4.0 International License](http://creativecommons.org/licenses/by-sa/4.0/).
================================================
FILE: README-de.md
================================================
🌍
*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Indonesia](README-id.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [polski](README-pl.md) ∙ [Português](README-pt.md) ∙ [Română](README-ro.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)*
# The Art of Command Line
[](https://airtable.com/shrzMhx00YiIVAWJg)
[](https://gitter.im/jlevy/the-art-of-command-line?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
- [Kurzbeschreibung](#kurzbeschreibung)
- [Grundlagen](#grundlagen)
- [Täglicher Gebrauch](#täglicher-gebrauch)
- [Umgang mit Dateien und Daten](#umgang-mit-dateien-und-daten)
- [Fehlerbehebung auf Systemebene](#fehlerbehebung-auf-systemebene)
- [Einzeiler](#einzeiler)
- [Eigenartig aber hilfreich](#eigenartig-aber-hilfreich)
- [Nur MacOS X](#nur-macos-x)
- [Nur Windows](#nur-windows)
- [Weitere Quellen](#weitere-quellen)
- [Haftungsausschluss](#haftungsausschluss)
Der flüssige Umgang mit der Befehlszeile (auch Kommandozeile, engl. "command line") ist eine oft vernachlässigte oder als undurchsichtig empfundene Fähigkeit, steigert jedoch Flexibilität und Produktivität eines Informatikers auf offensichtliche als auch subtile Weise. Was folgt, ist eine Auswahl an Notizen und Tipps im Umgang mit der Befehlszeile, welche ich beim Arbeiten mit Linux zu schätzen gelernt habe. Manche dieser Hinweise beinhalten Grundwissen, andere sind sehr spezifisch, fortgeschritten oder auch eigenartig. Die Seite ist nicht lang, aber wenn du alle Punkte verstanden hast und anwenden kannst, weißt du eine ganze Menge.
Vieles davon
[erschien](http://www.quora.com/What-are-the-most-useful-Swiss-army-knife-one-liners-on-Unix)
[ursprünglich](http://www.quora.com/What-are-some-lesser-known-but-useful-Unix-commands)
auf [Quora](http://www.quora.com/What-are-some-time-saving-tips-that-every-Linux-user-should-know),
aber angesichts des Interesses scheint es vielversprechend, Github zu nutzen, wo talentiertere Menschen als ich es bin kontinuierlich Verbesserungen vorschlagen können. Wenn du einen Fehler entdeckst oder etwas, das man besser machen könnte, erstelle ein Issue oder einen PR! (Lies aber bitte zuerst die Kurzbeschreibung und überprüfe bereits vorhandene Issues/PRs.)
## Kurzbeschreibung
Umfang:
- Diese Anleitung richtet sich an Anfänger und Fortgeschrittene. Die Ziele sind *Breite* (alles ist wichtig), *Genauigkeit* (konkrete Beispiele für die gebräuchlichsten Anwendungsfälle) und *Knappheit* (Dinge, die nicht wesentlich sind oder leicht anderswo nachgeschlagen werden können, sollen vermieden werden). Jeder Tipp ist in einer bestimmten Situation wesentlich oder deutlich zeitsparend gegenüber bestehenden Alternativen.
- Sie ist für Linux geschrieben, mit der Ausnahme der Abschnitte "[Nur MacOS X](#nur-macos-x)" und "[Nur Windows](#nur-windows)". Viele der anderen Punkte lassen sich nutzen oder sind installierbar auf anderen Unices oder MacOS (oder sogar Cygwin).
- Der Fokus liegt auf interaktiver Bash, allerdings gelten viele Tipps auch auf anderen Shells sowie für allgemeines Bash-Skripting.
- Sie beinhaltet sowohl "normale" Unix-Befehle als auch solche, die bestimmte installierte Pakete voaussetzen -- sofern sie wichtig genug sind, dass sie die Aufnahme in diese Anleitung verdienen.
Hinweise:
- Um eine Seite nicht zu sprengen, ist ihr Inhalt durchgängig anhand von Verweisen aufgelistet. du bist schlau genug, anderswo zusätzliche Informationen nachzuschlagen, sobald du die Idee bzw. den Befehl dahinter kennst. Verwende `apt-get`, `yum`, `dnf`, `pacman`, `pip` oder `brew`, um ggf. neue Programme zu installieren.
- Verwende [Explainshell](http://explainshell.com/), um einen hilfreichen Einblick zu erhalten, was es mit Befehlen, Optionen, Pipes etc. auf sich hat.
## Grundlagen
- Lerne Bash-Grundlagen. Tatsächlich, gib `man bash` ein und überfliege das Ganze zumindest; es ist leicht zu verstehen und nicht allzu lang. Alternative Shells sind nett, aber Bash ist mächtig und immer verfügbar (*nur* zsh, fish, etc. zu lernen ist auf dem eigenen Laptop vielleicht reizvoll, beschränkt jedoch deine Möglichkeiten in vielerlei Hinsicht, etwa beim Arbeiten mit bestehenden Servern).
- Lerne mindestens einen Text-basierten Editor zu benutzen. Idealerweise Vim (`vi`), da es letztlich keinen vergleichbaren Mitbewerber für gelegentliche Einsätze in einem Terminal gibt (selbst dann, wenn man eine große Entwicklungsumgebung wie Emacs oder die meiste Zeit einen modernen Hipster-Editor benutzt).
- Wisse, wie man Dokumentationen mit `man` liest (für Neugierige, `man man` listet Abschnittsnummern, bspw. stehen unter 1 "reguläre" Befehle, 5 beinhaltet Dateien/Konventionen und unter 8 solche zur Rechnerverwaltung). Finde `man`-Seiten ("man pages") mit `apropos`. Wisse, dass manche Befehle keine ausführbaren Dateien, sondern Bash-Builtins sind, und dass du Hilfe zu diesen mit `help` und `help -d` erhälst.
- Lerne etwas über die Umleitung von Ein- und Ausgaben per `>` und `<` sowie `|` für Pipes. Wisse, dass `>` die Ausgabedatei überschreibt und `>>` etwas anhängt. Lerne etwas über stdout und stderr.
- Lerne etwas über die Dateinamenerweiterung mittels `*` (und eventuell `?` und `[`...`]`) sowie Anführungszeichen, etwa den Unterschied zwischen doppelten `"` und einfachen `'`. (Mehr zur Variablenerweiterung findest du unten.)
- Mach dich vertraut mit Bash-Jobmanagement: `&`, **ctrl-z**, **ctrl-c**, `jobs`, `fg`, `bg`, `kill`, etc.
- Kenne `ssh` und die Grundlagen passwortloser Authentifizierung mittels `ssh-agent`, `ssh-add`, etc.
- Grundlegende Dateiverwaltung: `ls` and `ls -l` (und spezieller, lerne die Funktion jeder einzelnen Spalte von `ls -l` kennen), `less`, `head`, `tail` und `tail -f` (oder noch besser, `less +F`), `ln` und `ln -s` (lerne die Unterschiede und Vorteile von Hard- und Softlinks), `chown`, `chmod`, `du` (für eine Kurzzusammenfassung der Festplattenbelegung: `du -hs *`). Für Dateisystemmanagement `df`, `mount`, `fdisk`, `mkfs`, `lsblk`. Lerne, was ein Inode (engl. index node) ist (`ls -i` oder `df -i`).
- Grundlagen der Netzwerkverwaltung: `ip` oder `ifconfig`, `dig`.
- Lerne etwas über Versionskontrolle und benutze ein entsprechendes System, wie etwa `git`.
- Kenne reguläre Ausdrücke gut, und die verschiedenen Statusindikatoren zu `grep`/`egrep`. Die Optionen `-i`, `-o`, `-v`, `-A`, `-B`, und `-C` sind gut zu wissen.
- Lerne den Umgang mit `apt-get`, `yum`, `dnf` oder `pacman` (je nach Linux-Distribution), um Pakete zu finden bzw. zu installieren. Und stell sicher, dass du `pip` hast, um Python-basierte Befehlszeilen-Werkzeuge nutzen zu können (einige der untenstehenden werden am einfachsten über `pip` installiert).
## Täglicher Gebrauch
- In Bash kannst du mit **Tab** Parameter vervollständigen sowie alle verfügbaren Befehle anzeigen lassen und mit **ctrl-r** bereits benutzte Befehle durchsuchen (drück die Kombination, gib dann deinen Suchtext ein und springe anschließend durch wiederholtes Drücken von **ctrl-r** durch die Suchergebnisse, mit **Enter** kannst du den gefundenen Befehl ausführen sowie mit der rechten Pfeiltaste in die aktuelle Zeile einfügen, um ihn zu bearbeiten).
- In Bash kannst du mit **ctrl-w** das letzte Wort löschen und mit **ctrl-u** alles bis zum Anfang einer Zeile. Verwende **alt-b** und **alt-f**, um dich Wort für Wort fortzubewegen, springe mit **ctrl-a** zum Beginn einer Zeile, mit **ctrl-e** zum Ende einer Zeile, lösche mit **ctrl-k** alles bis zum Ende einer Zeile und bereinige mit **ctrl-l** den Bildschirm. Siehe `man readline` für alle voreingestellten Tastenbelegungen in Bash. Davon gibt's viele. Zum Beispiel **alt-.** wechselt durch vorherige Parameter und **alt-*** erweitert ein Suchmuster.
- Alternativ, falls du vi-artige Tastenbelegungen magst, verwende `set -o vi` (und `set -o emacs`, um es wiederzuholen).
- Um kürzlich genutzte Befehle zu sehen, `history`. Es gibt außerdem viele Abkürzungen wie etwa `!$` (letzter Parameter) und `!!` (letzter Befehl), wenngleich diese oft einfach ersetzt werden durch **ctrl-r** und **alt-.**.
- Um lange Befehle zu bearbeiten, kannst du sie (nachdem du deinen Editor angegeben hast, etwa mit `export EDITOR=vim`) mit **ctrl-x** **ctrl-e** im Editor öffnen, um mehrere Zeilen bearbeiten zu können. Oder vi-Style, **escape-v**.
- Um kürzlich verwendete Befehle anzuzeigen, benutze `history`. Anschließend `!n` (wobei `n` die Nummer des Befehls ist), um es erneut auszuführen. Es gibt zudem zahlreiche Abkürzungen, die man verwenden kann, die nützlichste ist wahrscheinlich `!$` für den letzten Parameter und `!!` für den letzten Befehl (siehe "HISTORY EXPANSION" in der `man`-Seite). Diese werden allerdings oft einfach ersetzt durch **ctrl-r** und **alt-.**.
- In dein Benutzerverzeichnis gelangst du mit `cd`. Auf Dateien relativ zu diesem kannst du mit dem Präfix `~` zugreifen (etwa so `~/.bashrc`). In `sh`-Skripts heißt das Benutzerverzeichnis `$HOME`.
- Um ins vorangegangene Arbeitsverzeichnis zu gelangen: `cd -`
- Wenn du einen Befehl eingibst und es dir auf halbem Wege anders überlegst, drücke **alt-#**, um am Zeilenanfang ein `#` einzufügen und ihn damit als Kommentar auszuweisen (oder benutze **ctrl-a**, **#**, **enter**). du kannst später über die Befehlsgeschichte zurückgelangen.
- Verwende `xargs` (oder `parallel`). Es ist sehr mächtig. Beachte, wie du viele Dinge pro Zeile (`-L`) als auch parallel (`-P`) ausführen kannst. Wenn du dir nicht sicher bist, ob das Richtige dabei herauskommt, verwende zunächst `xargs echo`. Außerdem ist`-I{}` nützlich. Beispiele:
```bash
find . -name '*.py' | xargs grep irgendeine_funktion
cat hosts | xargs -I{} ssh root@{} hostname
```
- `pstree -p` liefert eine hilfreiche Anzeige des Prozessbaums.
- Verwende `pgrep` und `pkill`, um Prozesse anhand eines Namens zu finden oder festzustellen (`-f` ist hilfreich).
- Kenne die verschiedenen Signale, welche du Prozessen senden kannst. Um einen Prozess etwa zu unterbrechen, verwende `kill -STOP [pid]`. Für die vollständige Liste, siehe `man 7 signal`
- Verwende `nohup` oder `disown`, wenn du einen Hintergrundprozess für immer laufen lassen willst.
- Überprüfe mithörende Prozesse mit `netstat -lntp` oder `ss -plat` (für TCP; füge `-u` für UDP hinzu).
- Siehe zudem `lsof` für offene Sockets und Dateien.
- Siehe `uptime` oder `w`, um die laufende Betriebszeit des Systems zu erfahren,
- Verwende `alias`, um Verknüpfungen für gebräuchliche Befehle zu erstellen. So erstellt etwa `alias ll='ls -latr'` den neuen Alias `ll`.
- Speichere diese Alternativnamen ("aliases"), Shell-Einstellungen und häufig benutzte Funktionen in `~/.bashrc` und [stelle sie anderen Login-Shells zur Verfügung](http://superuser.com/a/183980/7106). So hast du auf dein Setup auch in allen anderen Shell-Sessions Zugriff.
- Platziere Einstellungen von Umgebungsvariablen sowie Befehle, welche nach einer Anmeldung ausgeführt werden sollen, in `~/.bash_profile`. Eine separate Konfiguration ist notwendig für Shells, welche du von einer grafischen Benutzeroberfläche startest sowie für `cron`-Jobs.
- Synchronisiere deine Konfigurationsdateien (etwa `.bashrc` und `.bash_profile`) zwischen mehreren Computern mit Git.
- Verstehe, dass Vorsicht geboten ist, wenn Variablen und Dateinamen Leerzeichen enthalten. Setze deine Bashvariablen daher mit Anführungszeichen: `"$FOO"`. Bevorzuge die Optionen `-0` oder `-print0`, um ungültige Schriftzeichen zu aktivieren und so Dateinamen zu begrenzen, bspw. `locate -0 pattern | xargs -0 ls -al` oder `find / -print0 -type d | xargs -0 ls -al`. Um in einem "for loop" Dateinamen durchzugehen, die Leerzeichen enthalten, sorge mit `IFS=$'\n'` dafür, dass dein IFS immer auf einer neuen Zeile steht.
- Benutze in Bash-Skripts `set -x` (oder die Abwandlung `set -v`, welche unverarbeiteten Input akzeptiert, einschließlich Kommentare und unexpandierte Variablen) zum Output der Fehlerbehebung. Benutze "strict modes", es sei denn, gute Gründe sprechen dagegen: Benutze `set -e`, um bei Fehlern abzubrechen ("nonzero exit code"). Benutze `set -u`, um die Verwendung nicht gesetzer Variablen aufzuspüren. Erwäge auch `set -o pipefail` für Fehler in Pipes (lies jedoch mehr zu diesem Thema, wenn du es vorhast, denn es ist ein wenig heikel). Benutze bei komplizierteren Skripts auch `trap` bei EXIT oder ERR. Es ist eine nützliche Angewohnheit, ein Skript folgendermaßen zu beginnen, um Fehler zu erkennen und sie ggf. mit einer entsprechenden Fehlermeldung abzubrechen:
```bash
set -euo pipefail
trap "echo 'error: Script failed: see failed command above'" ERR
```
- In Bash-Skripts stellen Subshells (geschrieben in runden Klammern) einen praktischen Weg dar, Befehle zusammenzufassen. Ein gebräuchliches Beispiel ist die vorübergehende Arbeit in einem anderen Arbeitsverzeichnis:
```bash
# erledige etwas im aktuellen Verzeichnis
(cd /irgendein/anderes/verzeichnis && anderer-befehl)
# fahre fort im aktuellen Verzeichnis
```
- Beachte, dass es in Bash viele Möglichkeiten gibt, Variablen zu erweitern. Überprüfen, ob eine Variable existiert: `${name:?error message}`.Wenn bspw. ein Bash-Skript nur einen einzelnen Parameter benötigt, schreibe einfach `input_file=${1:?usage: $0 input_file}`. Arithmetische Erweiterung: `i=$(( (i + 1) % 5 ))`. Sequenzen: `{1..10}`. Zeichenkette kürzen: `${var%suffix}` und `${var#prefix}`. Wenn bspw. `var=foo.pdf`, dann gibt `echo ${var%.pdf}.txt` die Ausgabe `foo.txt` aus.
- Klammererweiterung mittels `{`...`}` kann dafür sorgen, ähnlichen Text seltener wiederholen zu müssen und ermöglicht die Kombination von Objekten. Das ist etwa in Fällen nützlich wie `mv foo.{txt,pdf} zielverzeichnis` (verschiebt beide Dateien), `cp datei{,.bak}` (erweitert den Ausdruck um `cp datei datei.bak`) oder `mkdir -p test-{a,b,c}/subtest-{1,2,3}` (erweitert alle denkbaren Kombinationen und erstellt einen Verzeichnisbaum).
- Die Ausgabe eines Befehls kann wie eine Datei behandelt werden mit `<(befehl)`. Das Vergleichen der lokalen `/etc/hosts` mit einer entfernten:
```sh
diff /etc/hosts <(ssh andererhost cat /etc/hosts)
```
- Beim Schreiben von Skripts wirst du deinen Code womöglich in geschweifte Klammern setzen wollen. Falls die schließende Klammer fehlt, wird dein Skript aufgrund eines Syntaxfehlers nicht ausgeführt. Das ist etwa dann sinnvoll, wenn es im Internet verfügbar ist, da ein unvollständig heruntergeladenes Skript so an der Ausführung gehindert wird:
```bash
{
# Hier koennte dein Code stehen!
}
```
- Kenne "here documents" in Bash, wie etwa in `cat <<EOF ...`.
- In Bash, leite sowohl den standard output als auch den standard error um mit: `irgendein-befehl >logfile 2>&1`. Oftmals ist es gute Praxis, einen Befehl an das verwendete Terminal zu binden, um keinen offenen Dateizugriff im standard input zu erzeugen, also `</dev/null` hinzuzufügen.
- Verwende `man ascii` für eine gute ASCII-Tabelle, Mit Dezimal- und Hexadezimalwerten. Für allgemeine Informationen zu Kodierung sind `man unicode`, `man utf-8` und `man latin1` hilfreich.
- Verwende `screen` oder [`tmux`](https://tmux.github.io/), um einen Bildschirm zu multiplexen, besonders hilfreich ist dies für Fernzugriffe per `ssh` und zur Trennung und Neuverbindung mit einer Session. Eine minimalistische Alternative allein zur Aufrechterhaltung einer Session ist `dtach`.
- Bei SSH ist es hilfreich zu wissen, wie man einen Porttunnel mit `-L` oder `-D` (gelegentlich auch `-R`) einrichtet, etwa beim Zugriff auf Webseiten von einem Remote-Server.
- Es kann nützlich sein, ein paar Verbesserungen an den SSH-Einstellungen vorzunehmen; so enthält bspw. diese `~/.ssh/config` Einstellungen, um das Abreißen der Verbindung in bestimmten Netzwerkumgebungen zu vermeiden, verwendet Kompression (was hilfreich ist bei SCP über Verbindungen mit niedriger Bandbreite) und Multiplex-Kanäle zu demselben Server mithilfe einer lokalen Kontrolldatei:
```
TCPKeepAlive=yes
ServerAliveInterval=15
ServerAliveCountMax=6
Compression=yes
ControlMaster auto
ControlPath /tmp/%r@%h:%p
ControlPersist yes
```
- Einige andere Optionen im Zusammenhang mit SSH sind sicherheitsrelevant und sollten nur mit Bedacht aktiviert werden, etwa Zugriff per Subnet oder Host sowie in vertrauenswürdigen Netzwerken: `StrictHostKeyChecking=no`, `ForwardAgent=yes`.
- Erwäge [`mosh`](https://mosh.org/) als Alternative zu `ssh`, die UDP benutzt, um so abgebrochene Verbindungen zu vermeiden, was ja in gewisser Hinsicht auch komfortabel ist (benötigt Server-seitiges Setup).
- Um Zugriff auf eine Datei in Oktalform zu erhalten, was zur Systemkonfiguration zwar nützlich, jedoch über `ls` nicht verfügbar und leicht zu vermasseln ist, verwende etwas wie
```sh
stat -c '%A %a %n' /etc/timezone
```
- Verwende zur interaktiven Auswahl von Werten aus dem Output eines anderen Befehls [`percol`](https://github.com/mooz/percol) oder [`fzf`](https://github.com/junegunn/fzf).
- Verwende `fpp` ([PathPicker](https://github.com/facebook/PathPicker)) zur Interaktion mit Dateien als Output eines anderen Befehls (wie etwa `git`).
- Verwende für einen einfachen Webserver für alle Dateien im aktuellen Verzeichnis (sowie Unterverzeichnisse), der für alle in deinem Netzwerk abrufbar ist: `python -m SimpleHTTPServer 7777` (für Port 7777 und Python 2) sowie `python -m http.server 7777` (für Port 7777 und Python 3).
- Benutze `sudo`, um einen Befehl als ein anderer Benutzer auszuführen. Standardmäßig ist dies die Ausführung als root; benutze `-u` zur Angabe eines anderen benutzers sowie `-i`, um dich als dieser anzumelden (du wirst nach _deinem_ Passwort gefragt).
- Benutze `su benutzername` oder `su - benutzername`, um mit der Shell zu einem anderen Benutzer zu wechseln. Füge `-` hinzu, um eine Umgebung zu erhalten, als hättest du dich gerade mit diesem Benutzer angemeldet. Das Weglassen des Benutzernamens führt zur Anmeldung als root. du wirst gefragt nach dem Passwort _des Benutzers, als der du dich anmelden willst_.
- Kenne das [128K-Limit](https://wiki.debian.org/CommonErrorMessages/ArgumentListTooLong) der Befehlszeile. Der "Argument list too long"-Fehler erscheint häufig, wenn auf sehr viele Dateien über [Wildcards](https://de.wikipedia.org/wiki/Wildcard_(Informatik)) zugegriffen wird (wenn das passiert, können Alternativen wie `find` und `xargs` helfen).
- Benutze den `python`-Interpreter als einfachen Taschenrechner (und natürlich für den Zugriff auf Python im Allgemeinen). Beispiel:
```
>>> 2+3
5
```
## Umgang mit Dateien und Daten
- Um eine Datei im aktuellen Verzeichnis anhand des Namens zu finden, `find . -iname '*irgendwas*'`. Um eine Datei unabhängig vom Verzeichnis anhand des Namens zu finden, verwende `locate irgendwas` (bedenke jedoch, dass `updatedb` kürzlich erstellte Datein möglicherweise noch nicht indexiert hat).
- Für das allgemeine durchsuchen von (Quell-)Dateien (fortgeschrttener als `grep -r`), verwende [`ag`](https://github.com/ggreer/the_silver_searcher).
- Um HTML in Text zu konvertieren: `lynx -dump -stdin`
- Für Markdown, HTML und alle möglichen Arten von Dokumentkonvertierung, versuch's mit [`pandoc`](http://pandoc.org/).
- Wenn du mit XML arbeiten musst, `xmlstarlet` ist alt, aber gut.
- Für JSON, verwende [`jq`](http://stedolan.github.io/jq/).
- Für YAML gibt's [`shyaml`](https://github.com/0k/shyaml).
- Für Excel- bzw. CSV-Dateien hält [csvkit](https://github.com/onyxfish/csvkit) `in2csv`, `csvcut`, `csvjoin`, `csvgrep`, etc bereit.
- Für Amazon S3 ist [`s3cmd`](https://github.com/s3tools/s3cmd) praktisch und [`s4cmd`](https://github.com/bloomreach/s4cmd) schneller. Amazons [`aws`](https://github.com/aws/aws-cli) sowie das verbesserte [`saws`](https://github.com/donnemartin/saws) sind essentiell für andere AWS-bezogene Aufgaben.
- Kenne `sort` und `uniq`, letzteres einschließlich der Optionen `-u` und `-d` -- siehe die Einzeiler unten. Siehe auch `comm`.
- Kenne `cut`, `paste` und `join` zur Arbeit mit Textdateien. Viele Leute nutzen `cut`, vergessen aber `join`.
- Kenne `wc`, um neue Zeilen (`-l`), Zeichen (`-m`), Wörter (`-w`) und Bytes (`-c`) zu zählen.
- Kenne `tee`, um von stdin in eine Datei und sogar nach stdout zu kopieren, wie etwa mit `ls -al | tee datei.txt`.
- Bei komplexeren Berechnungen, einschließlich Gruppieren, Tauschen von Feldern und statistische Berechnungen, könnte [`datamash`](https://www.gnu.org/software/datamash/) passend sein.
- Sei dir bewusst, dass die regionale Spracheinstellung ("locale") viele Befehlszeilen-Werkzeuge auf subtile Art und Weise beeinflusst, inklusive der Sortierreihenfolge und ihrer Performance. Die meisten Linux Installation setzen `LANG` oder andere lokale Variablen auf eine lokale Einstellung wie z.B. "US English". Aber sei dir bewusst, dass sich das Sortierverhalten ändern wird, falls du die "locale" änderst. Und wisse, dass "i18n"-Routinen `sort` und andere Befehle *stark* verlangsamen können. In manchen Situationen (wie den Mengen oder Identitätsfunktionen unterhalb) kann man ruhigen Gewissens langsame "i18n"-Routinen ignorieren und traditionelle byte-basierte Sortierreihenfolge nutzen, indem man `export LC_ALL=C` setzt.
- Du kannst einem bestimmten Befehl eine Umgebung zuteilen, indem seinem Aufruf die Einstellung der Umgebungsvariable vorangestellt wird, wie hier: `TZ=Pacific/Fiji date`.
- Kenne Grundlagen von`awk` und `sed` für einfache Datenverarbeitung. Um z.B. alle Zahlen in der dritten Spalte einer Textdatei aufzusummieren: `awk '{ x += $3 } END { print x }'`. Das ist wahrscheinlich 3X schneller und 3X kürzer als das Python Äquivalent.
- Um mehrere Dateien umzubenennen sowie innerhalb von Dateien zu suchen/ersetzen, probier [`repren`](https://github.com/jlevy/repren) aus (gelegentlich kann man auch mit `rename` mehrere Dateien umbenennen, aber sei vorsichtig, da dessen Funktionsweise je nach Linux-Distribution abweicht).
```sh
# Vollständige Umbenennung von Dateinamen, Ordnern und Inhalten - foo -> bar:
repren --full --preserve-case --from foo --to bar .
# Backupdateien wiederherstellen - whatever.bak -> whatever:
repren --renames --from '(.*)\.bak' --to '\1' *.bak
# Wie oben, aber mit rename, sofern verfügbar:
rename 's/\.bak$//' *.bak
```
- Wie die `man`-Seite richtig sagt, ist `rsync` ein schnelles und vielseitiges Werkzeug zum Kopieren von Dateien. Es ist bekannt für das Synchronisieren zwischen Rechnern, ist lokal aber ebenso nützlich. Wenn es die Sicherheitsbestimmungen zulassen, erlaubt `rsync` im Gegensatz zu `scp` die Wiederaufnahme einer Übertragung, ohne nochmal von vorn beginnen zu müssen. Es ist zudem einer der [schnellsten Wege](https://web.archive.org/web/20130929001850/http://linuxnote.net/jianingy/en/linux/a-fast-way-to-remove-huge-number-of-files.html), um große Mengen an Dateien zu löschen:
```sh
mkdir leeres-verzeichnis && rsync -r --delete leeres-verzeichnis/ verzeichnis && rmdir verzeichnis
```
- Benutze `shuf` zum Mischen oder um zufällige Zeilen aus einer Datei auszuwählen.
- Kenne die Optionen von `sort`. Benutze `-n` für Zahlen, oder `-h` um mit menschenlesbaren Zahlen umzugehen (wie z.B. von `du -h`). Sei dir bewusst, wie Schlüssel funktionieren (`-t` und `-k`). Sei dir insbesondere bewusst, dass du `-k1,1` verwenden musst, um bezüglich des ersten Felds zu sortieren;`-k1` bedeutet, sortiere anhand der ganzen Zeile. Stabiles Suchen (`sort -s`) kann ebenfalls nützlich sein. Um bspw. primär nach Feld 2 und sekundär nach Feld 1 zu sortieren, kannst du `sort -k1,1 | sort -s -k2,2` benutzen.
- Falls du jemals ein Tabulator Literal in eine Befehlszeile in Bash schreiben musst (etwa den Parameter `-t` für `sort`), drücke **ctrl-v** **[Tab]** oder schreibe `$'\t'` (letzteres ist besser, da man es Kopieren/Einfügen kann).
- Die Standardwerkzeuge für das Patchen von Quellcode sind `diff` und `patch`. Siehe auch `diffstat`, um zusammenfassende Statistiken eines diffs zu erhalten. Beachte, dass `diff -r` für komplette Verzeichnisse funktioniert. Nutze `diff -r tree1 tree2 | diffstat`, um eine Übersicht aller Änderungen zu bekommen. Benutze `vimdiff`, um Dateien zu vergleichen und zu bearbeiten.
- Benutze für Binärdateien `hd`, `hexdump` or `xxd` zur Erstellung einfacher [Hexdumps](https://de.wikipedia.org/wiki/Dump#Hexdump) und `bvi` oder `biew` zur binären Bearbeitung.
- Ebenfalls für Binärdateien kann `strings` (und `grep`, etc.) benutzt werden, um Textpassagen zu finden.
- Um Diffs für Binärdateien zu erstellen (Delta Kompression), nutze `xdelta3`.
- Um zwischen Textkodierungen zu konvertieren, solltest du `iconv` probieren, oder aber `uconv` für fortgeschrittene Anwendungsfälle; es unterstüzt einige fortgeschrittene Unicode-Dinge. Dieser Befehl bspw. wandelt alle Buchstaben in Kleinbuchstaben um und entfernt alle Akzente (indem sie erweitert und verworfen werden):
```sh
uconv -f utf-8 -t utf-8 -x '::Any-Lower; ::Any-NFD; [:Nonspacing Mark:] >; ::Any-NFC; ' < input.txt > output.txt
```
- Um Dateien aufzuteilen, siehe `split` (Teilung anhand einer bestimmten Größe) und `csplit` (Teilung anhand eines bestimmten Musters).
- Benutze `zless`, `zmore`, `zcat`, und `zgrep` um mit komprimierten Dateien zu arbeiten.
- Dateieigenschaften können mit `chattr` gesetzt werden und stellen eine niederschwelligere Alternative zu Dateiberechtungen dar. So kann man etwa, um das versehentliche Löschen einer Datei zu verhindern, eine entsprechende Flag ("immutable flag") setzen: `sudo chattr +i /wichtiges/verzeichnis/oder/datei`
- Benutze `getfacl` und `setfacl`, um Dateiberechtigungen zu speichern und wiederherzustellen. Beispiel:
```sh
getfacl -R /irgendein/pfad > berechtigungen.txt
setfacl --restore=berechtigungen.txt
```
## Fehlerbehebung auf Systemebene
- Zur Fehlersuche bei Webanwendungen sind `curl` und `curl -I` hilfreich, ebenso wie ihre `wget` Äquivalente oder das modernere [`httpie`](https://github.com/jakubroztocil/httpie).
- Um den aktuellen CPU-/Festplattenstatus zu erfahren, sind die Klassiker `top` (oder das bessere `htop`), `iostat` und `iotop`. Benutze `iostat -mxz 15` for basic CPU and detailed per-partition disk stats and performance insight.
- Benutze für Informationen zu Netzwerkverbindungen `netstat` und `ss`.
- Für eine schnelle Übersicht, was sich auf einem System abspielt, ist `dstat` sehr nützlich. Für einen guten Gesamtüberblick bietet sich zudem [`glances`](https://github.com/nicolargo/glances) an.
- Um den Zustand des Speichers zu erfahren, führst du am besten `free` und `vmstat` aus und verstehst deren Ausgabe. Sei dir insbesondere bewusst, dass der "cached"-Wert jener Wert ist, der vom Linux-Kernel als Dateicache genutzt wird, da dieser effektiv als zum "free"-Wert addiert werden kann.
- Fehlerbehebung ("debugging") auf Java-Systemen ist ein anderes Paar Schuhe, aber ein simpler Trick für die Oracle JVM (der teilweise auch für andere JVMs funktioniert) ist `kill -3 <pid>`, sodass ein vollständiger Strack trace und Heap Informationen (inklusive Garbage Collection Details, die sehr informativ sein können) nach stderr/logs ausgegeben werden. Die JDK-Befehle `jps`, `jstat`, `jstack`, `jmap` sind ebenfalls nützlich. [SJK-Werkzeuge](https://github.com/aragozin/jvm-tools) sind noch weiter fortgeschritten.
- Benutze [`mtr`](http://www.bitwizard.nl/mtr/) als ein besseres traceroute, um Netzwerkprobleme zu identifizieren.
- Willst du wissen, warum eine Festplatte voll ist, dann spart [`ncdu`](https://dev.yorhel.nl/ncdu) Zeit gegenüber den üblichen Befehlen wie `du -sh *`.
- Um herauszufunden, welcher Socket oder Prozess Bandbreite verbraucht, kannst du [`iftop`](http://www.ex-parrot.com/~pdw/iftop/) oder [`nethogs`](https://github.com/raboof/nethogs) verwenden.
- Das `ab`-Werkzeug (ein Teil vom Apache) ist hilfreich, um schnell und pragmatisch die Performance eines Webservers zu messen. Für komplexere Messungen kannst du `siege` ausprobieren.
- Für eine tiefergehende Netzwerk Problemsuche, [`wireshark`](https://wireshark.org/), [`tshark`](https://www.wireshark.org/docs/wsug_html_chunked/AppToolstshark.html), oder [`ngrep`](http://ngrep.sourceforge.net/).
- Kenne `strace` und `ltrace`. Diese können hilfreich sein, falls ein Programm fehlschlägt, hängt oder abstürzt und du weißt nicht warum, oder um einen generellen Eindruck von der Performance zu bekommen. Beachte die Profiling-Option (`-c`) und die Fähigkeit, sich mit laufenden Prozessen zu verbinden (`-p`).
- Kenne `ldd`, um "shared libraries" zu überprüfen.
- Sei in der Lage, dich mittels `gdb` mit einem laufenden Prozess zu verbinden und dessen "stack traces" zu holen.
- Benutze `/proc`. Es ist manchmal unglaublich hilfreich, um Probleme in Echtzeit zu debuggen. Beispiele: `/proc/cpuinfo`, `/proc/meminfo`, `/proc/cmdline`, `/proc/xxx/cwd`, `/proc/xxx/exe`, `/proc/xxx/fd/`, `/proc/xxx/smaps` (wobei `xxx` die Prozess-ID / pid ist).
- Bei der Frage, warum in der Vergangenheit etwas schief gelaufen ist, kann [`sar`](http://sebastien.godard.pagesperso-orange.fr/) sehr hilfreich sein. Es zeigt historische Statistiken über CPU, Speicher, Netzwerk, etc.
- Für eine genauere System und Performanceanalyse, solltest du dir `stap` ([SystemTap](https://sourceware.org/systemtap/wiki)), [`perf`](http://en.wikipedia.org/wiki/Perf_(Linux)), und [`sysdig`](https://github.com/draios/sysdig) ansehen.
- Finde heraus, welches Betriebssystem du nutzt mittels `uname` oder `uname -a` (allgemeine Unix-/Kernelinformationen) oder `lsb_release -a` (Informationen zur verwendeten Linux-Distribution)
- Benutze `dmesg` wenn sich etwas merkdwürdig verhält (es könnte ein Hardware oder Treiber Problem sein)
- Wenn du eine Datei löschst, jedoch laut `du` nicht der erwartete Festplattenspeicher frei wird, dann überprüfe, ob die Datei von einem Prozess verwendet wird: `lsof | grep deleted | grep "dateiname"`
## Einzeiler
Ein paar Beispiele, wie man Befehle zusammen benutzen kann:
- Manchmal ist es unglaublich hilfreich, dass man die Schnittmenge, Vereinigung und den Unterschied zwischen Textdateien via `sort`/`uniq` bilden kann. Angenommen, a und b sind Textdateien, die bereits "unique" sind. Diese Herangehensweise ist schnell und funktioniert mit Dateien beliebiger Größe, bis zu mehreren Gigabytes (`sort` ist nicht durch Speicher beschränkt, obwohl man eventuell die `-T`-Option nutzen muss, falls `/tmp` auf einer kleinen Root-Partition liegt). Siehe auch die Bemerkung über `LC_ALL` weiter oben und die `-u`-Option von `sort` (wurde oben aus Gründen der Übersichtlichkeit ausgelassen).
```sh
cat a b | sort | uniq > c # c ist a vereint mit b
cat a b | sort | uniq -d > c # c ist a geschnitten b
cat a b b | sort | uniq -u > c # c ist die Menge mit unterschiedlichen Elementen a - b
```
- Eine schnelle Überprüfung der Inhalte aller Dateien in einem Verzeichnis erreichst du mit `grep . *` (damit enthält jede Zeile den Dateinamen) oder `head -100 *` (damit erhält jede Datei eine Überschrift). Dies kann nützlich sein für Verzeichnisse, die Konfigurationsdateien enthalten wie jene in `/sys`, `/proc` und `/etc`.
- Alle Zahlen in der dritten Spalte einer Textdatei aufsummieren (dieser Ansatz ist wahrscheinlich dreimal schneller und enthält dreimal weniger Code als dessen Entsprechung in Python):
```sh
awk '{ x += $3 } END { print x }' meinedatei
```
- Falls man die Größen/Datumsangaben von einem Dateibaum wissen möchte, funktioniert das Folgende wie ein rekursives `ls -l`, aber ist leichter zu lesen als `ls -lR`:
```sh
find . -type f -ls
```
- Um Größen/Datumsangaben in einem Verzeichnisbaum zu sehen, wirkt dies wie ein umgedrehtes `ls -l`, ist aber einfacher zu lesen als `ls -lR`:
```sh
find . -type f -ls
```
- Angenommen innerhalb einer Textdatei, so wie ein server web log, tauch ein gewisser Wert in manchen Zeilen auf, wie z.B. ein `acct_id` Parameter in der URL. Falls eine Aufzählung gewünscht ist, wie viele Anfragen es jeweils für eine `acct_id` gibt:
```sh
cat access.log | egrep -o 'acct_id=[0-9]+' | cut -d= -f2 | sort | uniq -c | sort -rn
```
- Um durchgehend Änderungen zu überwachen, solltest du "watch" benutzen; z.B. Dateiänderungen in einem Verzeichnis können mittels `watch -d -n 2 'ls -rtlh | tail'` überwacht werden, während du Deine Wifi Einstellungen mittels `watch -d -n 2 ifconfig` auf Fehler überprüfen kannst.
- Führe diese Funktion aus, um einen zufälligen Tip aus diesem Dokument zu erhalten(parst das Markdown Dokument und extrahiert ein Element)
```sh
function taocl() {
curl -s https://raw.githubusercontent.com/jlevy/the-art-of-command-line/master/README-de.md |
pandoc -f markdown -t html |
xmlstarlet fo --html --dropdtd |
xmlstarlet sel -t -v "(html/body/ul/li[count(p)>0])[$RANDOM mod last()+1]" |
xmlstarlet unesc | fmt -80
}
```
## Eigenartig aber hilfreich
- `expr`: Führe arithmetische oder bool'sche Operationen aus oder werte reguläre Ausdrücke aus
- `m4`: Simpler Macro-Auswerter
- `yes`: Gib eine Zeichenkette sehr oft aus
- `cal`: Netter Kalender
- `env`: Führe einen Befehl aus (nützlich für Skripte)
- `printenv`: Gebe Umgebungsvariablen aus (nützlich zum Debuggen und für Skripte)
- `look`: Finde englische Worte (oder Zeilen in einer Datei), die mit einer bestimmten Zeichenkette anfangen
- `cut`, `paste` und `join`: Datenmanipulation
- `fmt`: Formatiere Textabsätze
- `pr`: Formatiere Text als Seiten/Spalten
- `fold`: Breche Textzeilen um
- `column`: Formatiere Textfelder als bündige Spalten oder Tabellen mit fester Größe
- `expand` und `unexpand`: Konvertiere zwischen Tabs und Spaces
- `nl`: Füge Zeilennummern hinzu
- `seq`: Gib Zahlen aus
- `bc`: Taschenrechner
- `factor`: Faktorisiere Ganzzahlen
- [`gpg`](https://gnupg.org/): Verschlüsseln und Signieren von Dateien
- `toe`: Tabelle von `terminfo`-Einträgen
- `nc`: Netzwerk-Debugging und Datentransfer
- `socat`: Socket- und TCP-Port-Weiterleitung (ähnlich wie `netcat`)
- [`slurm`](https://github.com/mattthias/slurm): Visulaisierung des Netzwerkverkehrs ("traffic")
- `dd`: Daten zwischen Dateien und Geräten bewegen
- `file`: Identifiziere den Typ einer Datei
- `tree`: Zeige Verzeichnisse und Unterverzeichnisse als verschachtelten Baum; wie `ls` aber rekursiv
- `stat`: Datei Infomationen
- `time`: Führe einen Befehl aus und messe die Zeit
- `timeout`: Führe einen Befehl für eine bestimmte Zeit aus und beende ihn anschließend wieder
- `lockfile`: Erstelle eine Semaphordatei, die nur gelöscht werden kann mit `rm -f`
- `logrotate`: Rotiert, komprimiert und mailt System-Log-Dateien
- `watch`: Führe einen Befehl wiederholt aus, wobei die Ergebnisse angezeigt und/oder Änderungen hervorgehoben werden
- `tac`: Gebe Dateien in umgekehrter Reihenfolge aus
- `shuf`: Zufällige Auswahl von Zeilen von einer Datei
- `comm`: Vergleiche sortierte Dateien Zeile für Zeile
- `pv`: Überwache den Fortschritt von Daten durch eine Pipe
- `hd`, `hexdump`, `xxd`, `biew` und `bvi`: Ausgabe und Editieren von Binärdateien
- `strings`: Text aus Binärdateien extrahieren
- `tr`: Buchstabenübersetzung und -manipulation
- `iconv` oder `uconv`: Konvertierung von Zeichensätzen
- `split` und `csplit`: Dateien aufteilen
- `sponge`: Liest die gesamte Eingabe, bevor sie wieder ausgegeben wird. Nützlich, um aus derselben Datei zu lesen und in diese zu schreiben, bspw. `grep -v irgendwas irgendeine-datei | sponge irgendeine-datei`
- `units`: Einheiten Konvertierungen und Berechnungen; konvertiert Furlong(Achtelmeile)/Fortnights(2 Wochen) zu twips/blink (siehe `/usr/share/units/definitions.units`)
- `apg`: Generiert zufällige Passwörter
- `xz`: Hochgradige Dateikompression
- `ldd`: Informationen zu dynamisch gelinkten Bibliotheken
- `nm`: Symbole aus Objektdateien anzeigen
- `ab`: Webserver benchmarken
- `strace`: Debugging von Syscalls
- [`mtr`](http://www.bitwizard.nl/mtr/): Ein besseres "traceroute" zum Netzwerk-Debugging
- `cssh`: Visuelle, nebenläufige Shell
- `rsync`: Synchronisiere Dateien und Ordner über SSH oder im lokalen Dateisystem
- [`wireshark`](https://wireshark.org/) and [`tshark`](https://www.wireshark.org/docs/wsug_html_chunked/AppToolstshark.html): Pakete aufzeichnen und Netzwerk-Debugging
- [`ngrep`](http://ngrep.sourceforge.net/): grep für die Netzwerkschicht
- `host` und `dig`: DNS-Auflösung
- `lsof`: Prozess Datei Deskriptor und Socket Informationen
- `dstat`: Nützliche Systemstatistiken
- [`glances`](https://github.com/nicolargo/glances): Grobe Übersicht über zahlreiche Subsysteme
- `iostat`: Fesplatten-Nutzungsstatistiken
- `mpstat`: CPU-Nutzungstatistiken
- `vmstat`: Speicher-Nutzungsstatistiken
- `htop`: Verbesserte Version von `top`
- `last`: Loginverlauf
- `who`: Wer gerade angemeldet ist
- `id`: Identitätsinformationen zu Benutzern/Gruppen
- [`sar`](http://sebastien.godard.pagesperso-orange.fr/): Historische Systemstatistiken
- [`iftop`](http://www.ex-parrot.com/~pdw/iftop/) or [`nethogs`](https://github.com/raboof/nethogs): Netzwerknutzung durch Sockets oder Prozesse
- `ss`: Socket-Statistiken
- `dmesg`: Bootvorgang und System-Fehlermeldungen
- `sysctl`: Anzeige und Konfiguration von Linux Kernel Parametern zur Laufzeit
- `hdparm`: SATA/ATA-Festplattenmanipulation/-performanceinformationen
- `lsblk`: Auflisten von block devices: eine Baumansicht deiner Festplatten und Partitionen
- `lshw`, `lscpu`, `lspci`, `lsusb`, `dmidecode`: Hardware-Informationen, inklusive CPU, BIOS, RAID, Grafikkarten, Geräte, etc.
- `lsmod` und `modinfo`: Auflisten und Details anzeigen von Kernelmodulen
- `fortune`, `ddate`, und `sl`: Ähm ja, kommt darauf an, ob man Dampflokomotiven und flotte Zitate "nützlich" findet
## Nur MacOS X
Diese Hinweise sind *nur* für MacOS relevant.
- Paketverwaltung mit `brew` (Homebrew) und/oder `port` (MacPorts). Mit diesen Werkzeugen kann man viele der obrigen Programme für MacOs installieren.
- Kopiere die Ausgabe eines beliebigen Befehls an eine Desktop App mit `pbcopy` und füge die Eingabe von einer solchen ein mit `pbpaste`.
- Um die Option Taste als alt-Taste in einer Mac OS Konsole zu nutzen (so wie in den obrigen Befehle wie **alt-b**, **alt-f**, etc.), öffne Einstellungen -> Profile -> Tastatur und aktiviere "Benutze Option Taste als Meta Taste"
- Um eine Datei mit einer Desktopanwendung zu öffnen, kann man `open` oder `open -a /Applications/Whatever.app` benutzen.
- Spotlight: Dateisuche mit `mdfind` und Ausgabe von Metadaten (wie z.B. photo EXIF info) mit `mdls`.
- Man sollte sich bewusst sein, dass MacOS auf BSD Unix basiert und sich viele Befehle (wie z.B. `ps`, `ls`, `tail`, `awk`, `sed`) bezüglich subtiler Kleinigkeiten von Linux, das stark von System V-style Unix und GNU tools beeinflusst ist, unterscheiden. Oft kann man den Unterschied daran erkennen, dass eine `man`-Seite die Überschrift "BSD General Commands Manual" trägt. In manchen Fällen kann auch die GNU-Version installiert werden (wie z.B. bei `gawk` und `gsed` für GNU awk und sed). Falls manplattformübergreifende Bash-Skripte schreiben möchte, sollte man solche Befehle vermeiden (und z.B. Python oder `perl` in Betracht ziehen) oder sorgfätig testen.
- Benutze `sw_vers` für OS X Systeminformationen.
## Nur Windows
Diese Hinweise sind *nur* für Windows relevant.
### Möglichkeiten, Unix-Tools unter Windows zu erhalten
- Zugriff auf die Macht der Unix-Shell erhälst du unter Microsoft Windows durch die Installation von [Cygwin](https://cygwin.com/). Die meisten hier beschriebenen Dinge funktionieren damit ohne weiteren Aufwand.
- Mit Windows 10 kannst du [Bash on Ubuntu on Windows](https://msdn.microsoft.com/commandline/wsl/about) benutzen, das eine vertraute Bash-Umgebung mit Unix-Befehlszeilen-Werkzeugen. Dies erlaubt einerseits die Nutzung von Linux-Programmen auf Windows, unterstützt andererseits jedoch nicht die Ausführung von Windows-Programmen von der Bash-Konsole.
- Eine weitere Option, GNU-Entwicklerwerkzeuge (etwa GCC) auf Windows zu nutzen, besteht darin, [MinGW](http://www.mingw.org/) und dessen Paket [MSYS](http://www.mingw.org/wiki/msys), das Hilfsprogramme wie bash, gawk, make and grep beinhaltet, zu installieren. MSYS bringt allerdings nicht so viele Features mit wie etwa Cygwin. MinGW ist besonders nützlich für die Erstellung nativer Windows-Ports von Unix-Werkzeugen.
- Eine andere Möglichkeit, ein wenig Unix auf dein Windows-System zu bringen, bietet [Cash](https://github.com/dthree/cash). Beachte allerdings, dass nur sehr wenige Unix-Befehle und Befehlszeilen-Optionen in dieser Umgebung zur Verfügung stehen.
### Nützliche Windows Befehlszeilen-Werkzeugen
- Du kannst die meisten Aufgaben der Windows-Systemverwaltung von der Befehlszeile ausführen und skripten, indem du den Umgang mit `wmic` lernst.
- Native Windows Befehlszeilen Netzwerk Werkzeugen, die du nützlich finden kannst, gehören `ping`,` ipconfig`, `traceroute` und `netstat`.
- Du kannst [viele nützliche Windows-Aufgaben] (http://www.thewindowsclub.com/rundll32-shortcut-commands-windows) durch Aufrufen des Befehls `Rundll32` ausführen.
### Cygwin Tipps und Tricks
- Installiere zusätzliche Unix-Programme mit Cygwins Paketmanager.
- Benutze `mintty` als dein Befehlszeilenfenster.
- Greife mit `/dev/clipboard` auf die Zwischenablage von Windows zu.
- Öffne beliebige Dateien über `cygstart` mit deren Standardprogramm.
- Greife mit `regtool` auf die Windows-Registry zu.
- Beachte, dass der Windows-Pfad `C:\` unter Cygwin zu `/cygdrive/c` wird und dass Cygwins `/` unter Windows als `C:\cygwin` verfügbar ist. Für die Umwandlung zwischen Cygwin- und Windows-Pfaden steht `cygpath` zur Verfügung. Dies ist inbesondere für Skripte nützlich, welche Windows-Programme ausführen.
## Weitere Quellen
- [awesome-shell](https://github.com/alebcay/awesome-shell): Eine hilfreiche Liste von Shell-Werkzeugen und Quellen.
- [awesome-osx-command-line](https://github.com/herrbischoff/awesome-osx-command-line): Eine ausführliche Anleitung für die Befehlszeile unter OS X.
- [Strict mode](http://redsymbol.net/articles/unofficial-bash-strict-mode/), um bessere Shell-Skripte zu schreiben.
- [shellcheck](https://github.com/koalaman/shellcheck): Ein statisches Analysetool für Shell-Skripte. Im Grunde lint für bash/sh/zsh.
- [Filenames and Pathnames in Shell](http://www.dwheeler.com/essays/filenames-in-shell.html): Entmutigend komplexe Einzelheiten darüber, wie Dateinamen in Shell-Skripts richtig eingesetzt werden.
- [Data Science at the Command Line](http://datascienceatthecommandline.com/#tools): Mehr Befehle und Werkzeuge, die für ["data science"](https://de.wikipedia.org/wiki/Data_Science) hilfreich sind, aus dem gleichnamigen Buch.
## Haftungsausschluss
Mit der Ausnahme einiger sehr kleiner Aufgaben ist der Code so geschrieben, dass andere ihn lesen können. Mit Macht kommt Verantwortung. Die Tatsache etwas in Bash tun zu *können*, heißt nicht zwangsläufig, dass du es tun solltest!
## Lizenz
[](http://creativecommons.org/licenses/by-sa/4.0/)
Dieses Werk ist lizensiert gemäß der [Creative Commons Attribution-ShareAlike 4.0 International License](http://creativecommons.org/licenses/by-sa/4.0/).
================================================
FILE: README-el.md
================================================
🌍
*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Indonesia](README-id.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [polski](README-pl.md) ∙ [Português](README-pt.md) ∙ [Română](README-ro.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)*
# Η Τέχνη της Γραμμής Εντολών
+[](https://airtable.com/shrzMhx00YiIVAWJg)
[](https://gitter.im/jlevy/the-art-of-command-line?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
- [Meta](#meta)
- [Τα βασικά](#basics)
- [Καθημερινή χρήση](#everyday-use)
- [Επεξεργασία αρχείων και δεδομένων](#processing-files-and-data)
- [Αποσφαλμάτωση συστήματος](#system-debugging)
- [Εντολές σε μία γραμμή](#one-liners)
- [Ασυνήθιστες αλλά χρήσιμες](#ασυνήθιστες-αλλά-χρήσιμες)
- [Μόνο για OS X](#os-x-only)
- [Μόνο για Windows](#windows-only)
- [Περισσότερες πηγές](#more-resources)
- [Αποποίηση ευθύνης](#disclaimer)
Η ευχέρεια στη χρήση της γραμμής εντολών είναι μία δεξιότητα συχνά παραμελημένη ή που θεωρείται ότι είναι για τους λίγους.
Όμως η ευχέρια αυτή βελτιώνει την ευελιξία και την παραγωγικότητά σας ως μηχανικός τόσο με προφανείς όσο και με λιγότερο ευδιάκριτους τρόπους. Αυτή είναι μία συλλογή από σημειώσεις και συμβουλές που αφορούν τη χρήση της γραμμής εντολών και τις οποίες βρήκαμε χρήσιμες, ενώ εργαζόμασταν σε Linux. Κάποιες συμβουλές είναι εισαγωγικές και μερικές πιο συγκρεκριμένες, εξειδικευμένες ή εις βάθος. Αυτή η σελίδα δεν είναι μεγάλη, αλλά αν μπορείτε να τα θυμάστε όλα, τότε γνωρίζετε πολλά.
Αυτή η εργασία είναι αποτέλεσμα [πολλών συγγραφέων και μεταφραστών](AUTHORS.md).
Μέρος της
[αρχικά](http://www.quora.com/What-are-some-lesser-known-but-useful-Unix-commands)
[δημοσιεύτηκε](http://www.quora.com/What-are-the-most-useful-Swiss-army-knife-one-liners-on-Unix)
στο [Quora](http://www.quora.com/What-are-some-time-saving-tips-that-every-Linux-user-should-know),
αλλά έπειτα μετακινήθηκε στο GitHub, όπου άνθρωποι πιο ταλαντούχοι από τον αρχικό συγγραφέα έχουν κάνει πολυάριθμες βελτιώσεις.
[**Παρακαλώ υποβάλετε μία ερώτηση**](https://airtable.com/shrzMhx00YiIVAWJg), αν έχετε μία ερώτηση σχετική με τη γραμμή εντολών. [**Παρακαλώ συνεισφέρετε**](/CONTRIBUTING.md), αν δείτε ένα λάθος ή κάτι που μπορεί να βελτιωθεί!
## Meta
Αντικείμενο:
- Αυτός ο οδηγός απευθύνεται τόσο σε αρχάριους όσο και σε έμπειρους. Οι στόχοι είναι το *εύρος* (ό,τι είναι σημαντικό), η *ακρίβεια* (να δοθούν συγκεκριμένα παραδείγματα για τις συνηθέστερες περιπτώσεις)και η *συντομία* (να αποφευχθούν πράγματα που δεν είναι αναγκαία ή παρεκβάσεις που μπορεί κανείς εύκολα να αναζητήσει αλλού). Κάθε συμβουλή είναι απαραίτητη σε κάποια περίπτωση ή εξοικονομεί χρόνο σε σημαντικό βαθμό σε σύγκριση με εναλλακτικές.
- Το παρόν είναι γραμμένο για Linux, με εξαίρεση των τμημάτων «[Μόνο για OS X](#os-x-only)» και «[Μόνο για Windows](#windows-only)». Πολλά από τα υπόλοιπα κομμάτια ισχύουν ή μπορούν να εγκατασταθούν σε άλλα Unices ή OS X (ή ακόμη και Cygwin).
- Εστιάζεται στον διαδραστικό φλοιό Bash, αν και πολλές συμβουλές ισχύουν και για άλλους φλοιούς και γενικότερα στη συγγραφή σεναρίων (scripts) για Bash.
- Περιλαμβάνει τόσο τις «τυπικές» εντολές Unix καθώς και άλλες που απαιτούν την εγκατάσταση ειδικών πακέτων λογισμικού -- αρκεί να είναι αρκετά σημαντικές ώστε να αξίζει να περιληφθούν.
Σημειώσεις:
- Για να κρατηθεί το παρόν σε μία σελίδα, υπάρχει περιεχόμενο που περιλαμβάνεται έμμεσα κάνοντας αναφορά σε αυτό. Είστε αρκετά έξυπνοι ώστε να αναζητήσετε περαιτέρω λεπτομέρειες αλλού, μόλις καταλάβετε την ιδέα ή την εντολή που χρειάζεται να αναζητήσετε στο Google. Χρησιμοποιήστε `apt-get`, `yum`, `dnf`, `pacman`, `pip` ή `brew` (ανάλογα με την περίπτωση) για να εγκαταστήσετε νέα προγράμματα.
- Χρησιμοποιήστε [Explainshell](http://explainshell.com/) για να έχετε μια χρήσιμη ανάλυση του τι κάνουν κάνουν εντολές, επιλογές, σωληνώσεις κλπ.
## Τα βασικά
- Μάθετε τα βασικά του φλοιού Bash. Πράγματι, πληκτρολογήστε `man bash` και τουλάχιστον ρίξτε μια ματιά σε αυτό που εμφανίζεται· είναι αρκετά εύκολο να το ακολουθήσετε κι όχι και τόσο μεγάλο. Άλλοι φλοιοί μπορεί να είναι μια χαρά, αλλά ο φλοιός Bash έχει πολλές δυνατότητες και είναι πάντα διαθέσιμος (το να μάθετε *μόνο* zsh, fish κλπ., αν και δελεαστικό όσο δουλεύετε στο δικό σας laptop, σας περιορίζει σε πολλές περιπτώσεις, όπως στην περίπτωση servers που ήδη υπάρχουν).
- Μάθετε τουλάχιστον έναν text-based επεξεργαστή κειμένου καλά. Ο επεξεργαστής κειμένου `nano` είναι από τους από τους απλούστερους για βασική επεξεργασία (άνοιγμα, επεξεργασία, αποθήκευση, αναζήτηση). Όμως, για τον έμπειρο χρήστη σε ένα τερματικό κειμένου, δεν υπάρχει υποκατάστατο για τον Vim (`vi`), τον δύσκολο να τον μάθει κάνεις αλλά αξιόλογο, γρήγορο και ολοκληρωμένο επεξεργαστή κειμένου. Πολλοί χρησιμοποιούν ακόμη τον κλασικό Emacs, ιδιαίτερα για μεγαλύτερες εργασίες που αφορούν επεξεργασία κειμένου. (Βέβαια, κάθε σύγχρονος προγραμματιστής που εργάζεται σε ένα μεγάλο έργο είναι απίθανο να χρησιμοποιεί μόνο έναν απλό text-based επεξεργαστή κειμένου και θα πρέπει να είναι επίσης εξοικειωμένος με σύγχρονα και με γραφικό περιβάλλον IDEs και εργαλεία.)
- Να γνωρίζετε πώς να διαβάζετε τεκμηρίωση με την εντολή `man` (για τον περίεργο, η εντολή `man man` εμφανίζει σε λίστα τους αριθμούς των ενοτήτων, π.χ. η 1 περιέχει τις εντολές του φλοιού, η 5 αρχεία/συμβάσεις και η 8 είναι για διαχείριση). Αναζητήστε σελίδες man με την εντολή `apropos`. Να γνωρίζετε ότι μερικές εντολές δεν είναι εκτελέσιμα προγράμματα αλλά ενσωματωμένες στον φλοιό και μπορείτε να ζητήσετε βοήθεια σχετικά με αυτές με `help` και `help -d`. Μπορείτε να βρείτε αν μια εντολή είναι εκτελέσιμο πρόγραμμα, ή ενσωματωμένη στον φλοιό ή ένα ακόμη όνομα (συντόμευση) που έχει αντιστοιχηθεί στην εντολή αυτή χρησιμοποιώντας την εντολή `type command`.
- Μάθετε για την ανακατεύθυνση της εξόδου και της εισόδου με χρήση των τελεστών `>` και `<` και για τις σωληνώσεις εντολών με χρήση του `|`. Να γνωρίζετε ότι ο τελεστής `>` αντικαθιστά το αρχείο εξόδου και ο `>>` προσθέτει στο τέλος του αρχείου. Μάθετε για τα stdout και stderr.
- Μάθετε για την επέκταση αρχείων μπαλαντέρ (glob) με `*` (και ίσως του `?` και `[`...`]`) και τη χρήση εισαγωγικών και τη διαφορά ανάμεσα στα διπλά `"` και τα μονά `'` εισαγωγικά. (Δείτε περισσότερα για την επέκταση μεταβλητών παρακάτω.)
- Εξοικειωθείτε με τη διαχείριση εργασιών στον Bash: `&`, **ctrl-z**, **ctrl-c**, `jobs`, `fg`, `bg`, `kill` κλπ.
- Να γνωρίζετε την εντολή `ssh` και τα βασικά της αυθεντικοποίησης χωρίς κωδικό με χρήση των `ssh-agent`, `ssh-add` κλπ.
- Βασική διαχείριση αρχείων: `ls` και `ls -l` (συγκεκριμένα, μάθετε τι σημαίνει κάθε στήλη που εμφανίζει η `ls -l`), `less`, `head`, `tail` και `tail -f` (ή ακόμη καλύτερα, `less +F`), `ln` και `ln -s` (μάθετε τις διαφορές και τα πλεονεκτήματα των κανονικών συνδέσμων σε σύγκριση με τους συμβολικούς), `chown`, `chmod`, `du` (για μία γρήγορη περίληψη της χρήσης του δίσκου: `du -hs *`). Για διαχείριση του συστήματος αρχείων, `df`, `mount`, `fdisk`, `mkfs`, `lsblk`. Μάθετε τι είναι inode (`ls -i` ή `df -i`).
- Βασική διαχείριση δικτύου: `ip` ή `ifconfig`, `dig`, `traceroute`, `route`.
- Μάθετε και χρησιμοποιήστε ένα σύστημα διαχείρισης και ελέγχου εκδόσεων, όπως το `git`.
- Να γνωρίζετε καλά κανονικές εκφράσεις και τις διάφορες επιλογές (flags) για τις `grep`/`egrep`. Τις επιλογές `-i`, `-o`, `-v`, `-A`, `-B`και `-C` αξίζει να τις γνωρίζετε.
- Μάθετε να χρησιμοποιείτε τις εντολές `apt-get`, `yum`, `dnf` ή `pacman` (ανάλογα με τη διανομή του λειτουργικού σας συστήματος) για να βρίσκετε και να εγκαθιστάτε πακέτα λογισμικού. Και βεβαιωθείτε ότι έχετε την `pip` για να εγκαθιστάτε εργαλεία της γραμμής εντολών που βασίζονται σε Python (μερικά από τα παρακάτω είναι πιο εύκολο να εγκατασταθούν με `pip`).
## Καθημερινή χρήση
- Στον Bash, χρησιμοποιήστε **Tab** για να ολοκληρώσετε ορίσματα ή να εμφανίσετε σε λίστα όλες τις διαθέσιμες εντολές, **ctrl-r** για να αναζητήσετε στο ιστορικό των εντολών (αφού πατήσετε, πληκτρολογήστε για να αναζητήσετε, πατήστε **ctrl-r** επαναλαμβανόμενα για να περιηγηθείτε σε περισσότερα αποτελέσματα αναζήτησης, πατήστε **Enter** για να εκτελέσετε την εντολή που βρήκατε ή πατήστε το δεξί βέλος για να μεταφέρετε το αποτέλεσμα στην τρέχουσα γραμμή ώστε να μπορείτε να το επεξεργαστείτε).
- Στον Bash, χρησιμοποιήστε **ctrl-w** για να διαγράψετε την τελευταία λέξη και **ctrl-u** για να διαγράψετε το περιεχόμενο από την τρέχουσα θέση του δρομέα μέχρι την αρχή της γραμμής. Χρησιμοποιήστε **alt-b** και **alt-f** για να μετακινηθείτε κατά μια λέξη, **ctrl-a** για να μετακινήσετε τον δρομέα στην αρχή της γραμμής, **ctrl-e** για να μετακινήσετε τον δρομέα στο τέλος της γραμμής, **ctrl-k** για να διαγράψετε ως το τέλος της γραμμής, **ctrl-l** για να καθαρίσετε την οθόνη. Δείτε τη `man readline` για όλες τις συντομεύσεις πληκτρολογίου στον Bash. Υπάρχουν πολλές. Για παράδειγμα, η **alt-.** επαναλαμβάνει κυκλικά τα προηγούμενα ορίσματα και η **alt-** αναπτύσσει ένα μπαλαντέρ (glob).
- Εναλλακτικά, αν σας αρέσουν οι συντομεύσεις τύπου vi, χρησιμοποιήστε `set -o vi` (και `set -o emacs` για να επαναφέρετε).
- Για την επεξεργασία μεγάλων εντολών, αφού ορίσετε τις ρυθμίσεις του επεξεργαστή κειμένου σας (για παράδειγμα `export EDITOR=vim`), με **ctrl-x** **ctrl-e** θα ανοίξει η τρέχουσα εντολή σε έναν επεξεργαστή κειμένου για επεξεργασία πολλών γραμμών. Ή αν έχετε ορίσει συντομεύσεις τύπου vi, **escape-v**.
- Για να δείτε πρόσφατες εντολές χρησιμοποιήστε την εντολή `history`. Ακολουθήστε την με την εντολή `!n` (όπου `n` είναι ο αριθμός της εντολής) για να την εκτελέσετε ξανά. Υπάρχουν πάρα πολλές συντομεύσεις που μπορείτε να χρησιμοποιήσετε. Από αυτές οι πιο χρήσιμες μάλλον είναι η `!$` για την τελευταία παράμετρο και η `!!` για την τελευταία εντολή (δείτε το "HISTORY EXPANSION" στην τεκμηρίωση του φλοιού). Όμως, αυτές συχνά εύκολα αντικαθίστανται από **ctrl-r** και **alt-.**.
- Πηγαίνετε στον προσωπικό σας κατάλογο (home) με `cd`. Αποκτήστε πρόσβαση σε αρχεία που βρίσκονται σε σχετική θέση με τον προσωπικό κατάλογό σας με το πρόθεμα `~` (π.χ. `~/.bashrc`). Σε σενάριο `sh` μπορείτε να αναφέρεστε στον προσωπικό σας κατάλογο ως `$HOME`.
- Για να πάτε στον προηγούμενο κατάλογο όπου εργαζόσαστε: `cd -`.
- Αν έχετε γράψει μέχρι τη μέση μία εντολή, αλλά αλλάξατε γνώμη, πατήστε **alt-#** για να προσθέσετε ένα`#` στην αρχή και να την προσθέσετε ως ένα σχόλιο (ή χρησιμοποιήστε **ctrl-a**, **#**, **enter**). Μπορείτε να επιστρέψετε σε αυτή αργότερα με το ιστορικό εντολών.
- Χρησιμοποιήστε `xargs` (ή `parallel`). Έχει πολλές δυνατότητες. Σημειώστε ότι μπορείτε να ελέγξετε πόσα στοιχεία θα εκτελέσετε ανά γραμμή (`-L`) καθώς και παράλληλη εκτέλεση εντολών (`-P`). Αν δεν είστε σίγουρος ότι θα κάνει το σωστό, χρησιμοποιήστε πρώτα `xargs echo`. Επίσης, η επιλογή `-I{}` είναι χρήσιμη. Παραδείγματα:
```bash
find . -name '*.py' | xargs grep some_function
cat hosts | xargs -I{} ssh root@{} hostname
```
- `pstree -p` είναι μία χρήσιμη εμφάνιση του δέντρου διεργασιών.
- Χρησιμοποιήστε `pgrep` και `pkill` για να αναζητήσετε ή να στείλετε σήμα σε διεργασίες με βάση το όνομά τους (η επιλογή `-f` είναι χρήσιμη).
- Να γνωρίζετε τα διάφορα σήματα που μπορείτε να στείλετε σε διεργασίες. Για παράδειγμα, για να αναστείλετε μία διεργασία χρησιμοποιήστε `kill -STOP [pid]`. Για ολόκληρη τη λίστα, δείτε `man 7 signal`
- Χρησιμοποιήστε `nohup` ή `disown`, αν θέλετε μία διεργασία παρασκηνίου να συνεχίσει να εκτελείται για πάντα.
- Ελέγξτε ποιες διεργασίες είναι σε αναμονή για κλήση listen με `netstat -lntp` ή `ss -plat` (για TCP· προσθέστε `-u` για UDP) ή `lsof -iTCP -sTCP:LISTEN -P -n` (που δουλεύει επίσης σε OS X).
- Δείτε επίσης `lsof` και `fuser` για ανοιχτές συνδέσεις δικτύου (sockets) και αρχεία.
- Δείτε `uptime` ή `w` για να δείτε για πόσο το σύστημα βρίσκεται σε λειτουργία.
- Χρησιμοποιήστε `alias` για να δημιουργήσετε συντομεύσεις για συχνά χρησιμοποιούμενες εντολές. Για παράδειγμα, η `alias ll='ls -latr'` δημιουργεί μία νέα συντόμευση `ll`.
- Αποθηκεύστε συντομεύσεις, ρυθμίσεις φλοιού και μεθόδους που χρησιμοποιείτε συχνά στο `~/.bashrc`και [προβλέψτε ώστε οι login φλοιοί να τα διαβάζουν](http://superuser.com/a/183980/7106). Αυτό θα κάνει τις ρυθμίσεις σας διαθέσιμες κάθε φορά που χρησιμοποιείτε τον φλοιό.
- Βάλτε τις ρυθμίσεις των μεταβλητών περιβάλλοντος καθώς και τις εντολές που χρειάζεται να εκτελεστούν με την είσοδό σας στο `~/.bash_profile`. Ξεχωριστές ρυθμίσεις θα χρειαστούν για τους φλοιούς που εκτελούνται από είσοδο από γραφικό περιβάλλον και εργασίες `cron`.
- Συγχρονίστε τα αρχεία με τις ρυθμίσεις σας (π.χ. `.bashrc` και `.bash_profile`) μεταξύ διαφορετικών υπολογιστών χρησιμοποιώντας Git.
- Κατανοήστε ότι χρειάζεται προσοχή, όταν μεταβλητές και ονόματα αρχείων περιέχουν κενούς (whitespace) χαρακτήρες. Περικλείετε τις μεταβλητές του Bash σε εισαγωγικά, π.χ. `"$FOO"`. Προτιμήστε τις επιλογές `-0` ή `-print0` για να επιτρέψετε σε κενούς χαρακτήρες να διαχωρίζουν ονόματα αρχείων, π.χ. `locate -0 pattern | xargs -0 ls -al` ή `find / -print0 -type d | xargs -0 ls -al`. Για να περάσετε ένα προς ένα από όλα τα αρχεία που περιέχουν κενούς χαρακτήρες σε έναν βρόχο επανάληψης `for`, ορίστε τη μεταβλητή IFS να είναι ο χαρακτήρας νέας γραμμής χρησιμοποιώντας `IFS=$'\n'`.
- Σε σενάρια για Bash, χρησιμοποιήστε `set -x` (ή την παραλλαγή `set -v`, που γράφει τα πρωτογενή στοιχεία, όπως σχόλια και μεταβλητές πριν αντικατασταθούν) για να τα αποσφαλματώσετε. Χρησιμοποιείτε αυστηρές λειτουργίες (strict modes) εκτός κι αν έχετε σημαντικό λόγο να μην το κάνετε: Χρησιμοποιήστε `set -e` για να εγκαταλείψετε την εκτέλεση σε περίπτωση σφάλματος (μη μηδενικός κωδικός εξόδου). Χρησιμοποιήστε `set -u` για να ανιχνεύσετε τη χρήση μεταβλητών χωρίς τιμή. Έχετε υπόψη σας και την εντολή `set -o pipefail`, για να εμφανίσετε τα σφάλματα που προκύπτουν στο ενδιάμεσο σωληνώσεων εντολών (αλλά διαβάστε περισσότερο για αυτή, αν τη χρησιμοποιήσετε καθώς αυτό το θέμα είναι ιδιαίτερα λεπτό). Για πιο πολύπλοκα σενάρια, χρησιμοποιήστε επίσης την εντολή `trap` για κωδικούς εξόδου EXIT ή ERR. Μια χρήσιμη συνήθεια είναι να ξεκινάτε ένα σενάριο έτσι, κάνοντάς το να ανιχνεύει και να τερματίζει σε συνήθη σφάλματα και να τυπώνει ένα μήνυμα:
```bash
set -euo pipefail
trap "echo 'error: Script failed: see failed command above'" ERR
```
- Σε σενάρια για Bash, οι υποφλοιοί (γραμμένοι μέσα σε παρενθέσεις) είναι βολικοί τρόποι ομαδοποίησης εντολών. Ένα συνηθισμένο παράδειγμα είναι η προσωρινή μετακίνηση σε διαφορετικό τρέχοντα κατάλογο, π.χ.
```bash
# do something in current dir
(cd /some/other/dir && other-command)
# continue in original dir
```
- Στον Bash, σημειώστε ότι υπάρχουν πολλοί τρόποι επέκτασης μίας μεταβλητής. Έλεγχος του αν μία μεταβλητή υπάρχει: `${name:?error message}`. Για παράδειγμα, αν ένα σενάριο Bash παίρνει ένα μόνο όρισμα, απλά γράψτε `input_file=${1:?usage: $0 input_file}`. Χρήση μίας προεπιλεγμένης τιμής αν μία μεταβλητή είναι κενή: `${name:-default}`. Αν θέλετε να προσθέσετε μία επιπλέον (προαιρετική) παράμετρο στο προηγούμενο παράδειγμα, μπορείτε να χρησιμοποιήσετε κάτι όπως: `output_file=${2:-logfile}`. Αν η `$2` παραλείπεται και άρα είναι κενή, η τιμή της `output_file` θα είναι `logfile`. Αριθμητική επέκταση: `i=$(( (i + 1) % 5 ))`. Ακολουθίες: `{1..10}`. Περικοπή αλφαριθμητικών: `${var%suffix}` και `${var#prefix}`. Για παράδειγμα, αν `var=foo.pdf`, τότε η `echo ${var%.pdf}.txt` τυπώνει `foo.txt`.
- Η επέκταση με αγκύλες χρησιμοποιώντας `{`...`}` μπορεί να μειώσει τις φορές που χρειάζεται να πληκτρολογήσετε ξανά παρόμοιο κείμενο και να αυτοματοποιήσει συνδυασμούς στοιχείων. Αυτό είναι χρήσιμο σε παραδείγματα όπως `mv foo.{txt,pdf} some-dir` (που μετακινεί και τα δύο αρχεία), `cp somefile{,.bak}` (που επεκτείνεται σε `cp somefile somefile.bak`) ή `mkdir -p test-{a,b,c}/subtest-{1,2,3}` (που επεκτείνεται σε όλους τους πιθανούς συνδυασμούς και δημιουργεί ένα δέντρο καταλόγων). Η επέκταση με αγκύλες πραγματοποιείται πριν από οποιαδήποτε άλλη επέκταση.
- Η σειρά των επεκτάσεων είναι: επέκταση με αγκύλες· επέκταση περισπωμένης, επέκταση παραμέτρων και μεταβλητών, αριθμητική επέκταση και αντικατάσταση εντολής (γίνεται από τα αριστερά προς τα δεξιά)· χωρισμός λέξεων· και επέκταση ονομάτων αρχείων. Για παράδειγμα, ένα εύρος τιμών όπως `{1..20}` δεν μπορεί να εκφραστεί με μεταβλητές χρησιμοποιώντας `{$a..$b}`. Χρησιμοποιήστε αντί μεταβλητών την εντολή `seq` ή μία δομή επανάληψης `for`, π.χ. `seq $a $b` ή `for((i=a; i<=b; i++)); do ... ; done`.)
- Μπορείτε να χειριστείτε την έξοδο μίας εντολής ως αρχείο `<(some command)` (είναι γνωστό ως αντικατάσταση διεργασίας). Για παράδειγμα, συγκρίνετε το τοπικό `/etc/hosts` με ένα απομακρυσμένο:
```sh
diff /etc/hosts <(ssh somehost cat /etc/hosts)
```
- Όταν γράφετε σενάρια, ίσως θέλετε να βάλετε όλον σας τον κώδικα μέσα σε άγκριστρα. Αν το δεξί άγκιστρο λείπει, το σενάριό σας δε θα εκτελεστεί λόγω συντακτικού σφάλματος. Αυτό είναι σκόπιμο, όταν το σενάριό σας πρόκειται να μεταφορτωθεί από το διαδίκτυο, αφού έτσι εμποδίζεται η εκτέλεση σεναρίων που έχουν μερικώς ληφθεί:
```bash
{
# Your code here
}
```
- Να γνωρίζετε για το «here documents» στον Bash, όπως στην `cat <<EOF ...`.
- Στον Bash, ανακατευθύνετε τόσο την έξοδο όσο και την έξοδο σφαλμάτων ως εξής: `some-command >logfile 2>&1` ή `some-command &>logfile`. Συχνά για να βεβαιωθείτε ότι μία εντολή δεν αφήνει μια σύνδεση αρχείου ανοιχτή στην είσοδο, δεσμεύοντας τον στο τερματικό που βρίσκεστε, είναι μία καλή πρακτική να προσθέτετε `</dev/null`.
- Χρησιμοποιήστε `man ascii` για έναν καλό πίνακα ASCII, με δεξαεξαδικές και δεκαδικές τιμές. Για γενικές πληροφορίες που αφορούν την κωδικοποίηση, οι `man unicode`, `man utf-8` και `man latin1`είναι χρήσιμες.
- Χρησιμοποιήστε `screen` ή [`tmux`](https://tmux.github.io/) για να ενεργοποιήσετε την πολυπλεξία της οθόνης. Αυτό είναι ιδιαίτερα χρήσιμο σε απομακρυσμένες συνεδρίες ssh και για να διακόψετε ή να επαναφέρετε μια συνεδρία. H εντολή `byobu` ή `tmux` μπορεί να βελτιώσει την οθόνη παρέχοντας περισσότερες πληροφορίες και πιο εύκολη διαχείριση. Μία πιο απλή εναλλακτική μόνο για τη διατήρηση συνεδριών είναι η [`dtach`](https://github.com/bogner/dtach).
- Με ssh, το να γνωρίζετε πώς να προωθήσετε μία θύρα με τις επιλογές `-L` ή `-D` (και καμιά φορά με την `-R`) είναι χρήσιμο, π.χ. για να έχετε πρόσβαση σε ιστοσελίδες από έναν απομακρυσμένο server.
- Μπορεί να είναι χρήσιμο να κάνετε μερικές βελτιστοποιήσεις στις ssh ρυθμίσεις σας· για παράδειγμα, αυτό `~/.ssh/config` περιέχει ρυθμίσεις για να αποφεύγετε τις συνδέσεις που διακόπτονται σε ορισμένα περιβάλλοντα δικτύου, χρησιμοποιεί συμπίεση (που είναι χρήσιμη με scp σε συνδέσεις με περιορισμένο εύρος ζώνης) και πολύπλεξη καναλιών στον ίδιο server με τοπικό αρχείο έλέγχου:
```
TCPKeepAlive=yes
ServerAliveInterval=15
ServerAliveCountMax=6
Compression=yes
ControlMaster auto
ControlPath /tmp/%r@%h:%p
ControlPersist yes
```
- Μερικές άλλες επιλογές σχετικές με την ssh είναι ευαίσθητες όσον αφορά την ασφάλεια και θα πρέπει να ενεργοποιούνται με προσοχή, π.χ. ανά υποδίκτυο ή host ή σε έμπιστα δίκτυα: `StrictHostKeyChecking=no`, `ForwardAgent=yes`
- ´Εχετε υπόψη σας την εντολή [`mosh`](https://mosh.org/) ως μία εναλλακτική της ssh που χρησιμοποιεί UDP, αποφεύγοντας τις συνδέσεις που διακόπτονται και διευκολύνοντας τη διαδικασία (απαιτεί ρύθμιση στον server).
- Για να πάρετε τα δικαιώματα ενός αρχείου σε οκταδική μορφή, πράγμα που είναι χρήσιμο για την παραμετροποίηση του συστήματος, αλλά δεν είναι διαθέσιμο με την `ls` και είναι εύκολο να γίνει άτσαλα, χρησιμοποιήστε κάτι όπως
```sh
stat -c '%A %a %n' /etc/timezone
```
- Για διαδραστική επιλογή τιμών από την έξοδο μίας άλλης εντολής, χρησιμοποιήστε [`percol`](https://github.com/mooz/percol) ή [`fzf`](https://github.com/junegunn/fzf).
- Για επιλογή αρχείων με βάση την έξοδο μιας άλλη εντολής (όπως της `git`), χρησιμοποιήστε `fpp` ([PathPicker](https://github.com/facebook/PathPicker)).
- Για έναν απλό web server και για όλα τα αρχεία στον τρέχοντα κατάλογο (και υποκαταλόγους) διαθέσιμα σε οποιονδήποτε στο δίκτυο, χρησιμοποιήστε:
`python -m SimpleHTTPServer 7777` (για τη θύρα 7777 και Python 2) και `python -m http.server 7777` (για τη θύρα 7777 και Python 3).
- Για την εκτέλεση μίας εντολής ως άλλος χρήστης, χρησιμοποιήστε `sudo`. Από προεπιλογή εκτελείται ως `root`· χρησιμοποιήστε `-u` για να ορίσετε άλλον χρήστη. Χρησιμοποιήστε `-i` για να συνδεθείτε ως αυτός ο χρήστης. (Μπορεί να σας ζητηθεί το συνθηματικό σας.)
- Για να αλλάξετε τον φλοιό σε άλλον χρήστη, χρησιμοποιήστε `su username` ή `su - username`. Το τελευταίο με "-" φορτώνει το περιβάλλον με τον ίδιο τρόπο όπως αν μόλις συνδεόταν ένας άλλος χρήστης. Παραλείποντας το username χρησιμοποιείτε την προεπιλογή `root`. Αν δεν είστε `root`, θα σας ζητηθεί το συνθηματικό.
- Έχετε υπόψη σας τον [περιορισμό των 128K](https://wiki.debian.org/CommonErrorMessages/ArgumentListTooLong) για τις γραμμές εντολών. Το σφάλμα «Η λίστα των ορισμάτων είναι πολύ μεγάλη» είναι κοινό, όταν γίνεται ταίριασμα με χαρακτήρα wildcard ενάντι μεγάλου αριθμού αρχείων. (Όταν συμβαίνει αυτό, εναλλακτικές όπως οι `find` και `xargs` μπορεί να βοηθήσουν.)
- Για να κάνετε μια απλή πράξη αριθμητικής (και βέβαια γενικά για πρόσβαση σε Python), χρησιμοποιήστε τον διερμηνευτή `python`. Για παράδειγμα,
```python
>>> 2+3
5
```
## Επεξεργασία αρχείων και δεδομένων
- Για να εντοπίσετε ένα αρχείο με βάση το όνομά του στον τρέχοντα κατάλογο, `find . -iname '*something*'` (ή με παρόμοιο τρόπο). Για να βρείτε ένα αρχείο με το όνομά του οπουδήποτε, χρησιμοποιήστε `locate something` (αλλά να έχετε στον νου σας ότι η `updatedb` μπορεί να μην έχει δημιουργήσει ευρετήριο για αρχεία που δημιουργήθηκαν πρόσφατα).
- Για γενική αναζήτηση σε αρχεία πηγαίου κώδικα ή αρχεία δεδομένων, υπάρχουν αρκετές επιλογές πιο προχωρημένες ή γρήγορες από την `grep -r`, συμπεριλαμβανομένων (και κατά προσέγγιση ταξινομημένων από την πιο παλιά στη νεότερη) των [`ack`](https://github.com/beyondgrep/ack2), [`ag`](https://github.com/ggreer/the_silver_searcher) ("the silver searcher"), και [`rg`](https://github.com/BurntSushi/ripgrep) (ripgrep).
- Για να μετατρέψετε HTML σε κείμενο: `lynx -dump -stdin`
- Για Markdown, HTML και άλλου είδους μετατροπές κειμένου, δοκιμάστε [`pandoc`](http://pandoc.org/).
- Αν χρειάζεται να χειριστείτε XML, η `xmlstarlet` είναι παλιά αλλά καλή.
- Για JSON, χρησιμοποιήστε [`jq`](http://stedolan.github.io/jq/). Για διαδραστική χρήση, δείτε επίσης [`jid`](https://github.com/simeji/jid) και [`jiq`](https://github.com/fiatjaf/jiq).
- Για YAML, χρησιμοποιήστε [`shyaml`](https://github.com/0k/shyaml).
- Για αρχεία Excel ή CSV, το πακέτο [csvkit](https://github.com/onyxfish/csvkit) παρέχει τις `in2csv`, `csvcut`, `csvjoin`, `csvgrep` κλπ.
- Για Amazon S3, η [`s3cmd`](https://github.com/s3tools/s3cmd) είναι βολική και η [`s4cmd`](https://github.com/bloomreach/s4cmd) είναι γρηγορότερη. Η [`aws`](https://github.com/aws/aws-cli) της Amazon και η βελτιωμένη [`saws`](https://github.com/donnemartin/saws) είναι απαραίτητες για εργασίες που σχετίζονται με AWS.
- Να γνωρίζετε για τις `sort` και `uniq`, συμπεριλαμβανομένων των επιλογών `-u` και `-d` της uniq -- παρακάτω δείτε το κομμάτι που αφορά τις εντολές σε μία γραμμή. Δείτε επίσης την `comm`.
- Να γνωρίζετε για τις `cut`, `paste` και `join` για να χειρίζεστε αρχεία κειμένου. Πολλοί χρησιμοποιούν την `cut`, αλλά ξεχνούν την `join`.
- Να γνωρίζετε για τη `wc` για να μετράτε νέες γραμμές (`-l`), χαρακτήρες (`-m`), λέξεις (`-w`) και bytes (`-c`).
- Να γνωρίζετε για την `tee` για να αντιγράφετε από το stdin σε ένα αρχείο κι επίσης στο stdout, όπως στην `ls -al | tee file.txt`.
- Για πιο πολύπλοκους υπολογισμούς, όπως ομαδοποίηση, αναστροφή πεδίων και στατιστικούς υπολογισμούς, έχετε υπόψη σας την εντολή [`datamash`](https://www.gnu.org/software/datamash/).
- Να γνωρίζετε ότι η τοπική διαμόρφωση του συστήματος (locale, π.χ. ελληνικό) επηρεάζει πολλά εργαλεία γραμμής εντολών με λιγότερο προφανείς τρόπους, συμπεριλαμβανομένων της σειράς ταξινόμησης (collation) και της απόδοσης. Οι περισσότερες εγκαταστάσεις Linux θα έχουν αναθέσει στη μεταβλητή `LANG` ή σε άλλες σχετικές με locale μεταβλητές τιμή μιας τοπική ρύθμισης όπως η Αγγλική ΗΠΑ. Αλλά να έχετε υπόψη ότι η ταξινόμηση μπορεί να αλλάξει, αν θέσετε άλλο locale. Και να γνωρίζετε ότι οι διεθνοποιημένες ρουτίνες μπορούν να κάνουν την ταξινόμηση ή άλλες εντολές να εκτελούνται *πολλές φορές* πιο αργά. Σε μερικές περιπτώσεις (όπως στον ορισμό διεργασιών ή της μοναδικότητας διεργασιών παρακάτω) μπορείτε με ασφάλεια να αγνοήσετε εντελώς αργές διεθνοποιημένες ρουτίνες και να χρησιμοποιήσετε παραδοσιακή ταξινόμηση με βάση bytes, χρησιμοποιώντας `export LC_ALL=C`.
- Μπορείτε να ορίσετε ένα συγκεκριμένο περιβάλλον για μία εντολή προσθέτοντάς της ως πρόθεμα τις ρυθμίσεις της μεταβλητής περιβάλλοντος, όπως στην `TZ=Pacific/Fiji date`.
- Να γνωρίζετε τα βασικά για τις `awk` και `sed` για απλή επεξεργασία δεδομένων. Δείτε [Εντολές σε μία γραμμή](#one-liners) για παραδείγματα.
- Για να αντικαταστήσετε επί τόπου όλες τις εμφανίσεις ενός αλφαριθμητικού σε ένα ή περισσότερα αρχεία:
```sh
perl -pi.bak -e 's/old-string/new-string/g' my-files-*.txt
```
- Για να μετονομάσετε πολλά και/ή να αναζητήσετε και να αντικαταστήσετε σε αρχεία, δοκιμάστε την [`repren`](https://github.com/jlevy/repren). (Σε ορισμένες περιπτώσεις η εντολή `rename` επιτρέπει επίσης πολλαπλές μετονομασίες, αλλά να είστε προσεχτικοί καθώς δε συμπεριφέρεται με τον ίδιο τρόπο σε όλες τις διανομές Linux.)
```sh
# Full rename of filenames, directories, and contents foo -> bar:
repren --full --preserve-case --from foo --to bar .
# Recover backup files whatever.bak -> whatever:
repren --renames --from '(.*)\.bak' --to '\1' *.bak
# Same as above, using rename, if available:
rename 's/\.bak$//' *.bak
```
- Όπως λέει η σελίδα man, η `rsync` είναι πράγματι ένα γρήγορο και εξαιρετικά ευέλικτο εργαλείο αντιγραφής αρχείων. Είναι γνωστή για τον συγχρονισμό μεταξύ υπολογιστών, αλλά είναι εξίσου χρήσιμη και τοπικά. Όταν οι περιορισμοί ασφάλειας το επιτρέπουν, η χρήση της `rsync` αντί της `scp` επιτρέπει τη συνέχιση μιας μεταφοράς χωρίς να ξεκινήσει από την αρχή. Επίσης, είναι ανάμεσα στους [πιο γρήγορους τρόπους](https://web.archive.org/web/20130929001850/http://linuxnote.net/jianingy/en/linux/a-fast-way-to-remove-huge-number-of-files.html) να διαγράψει κανείς μεγάλο αριθμό αρχείων:
```sh
mkdir empty && rsync -r --delete empty/ some-dir && rmdir some-dir
```
- Για να παρακολουθείτε την πρόοδο όταν αντιγράφετε αρχεία, χρησιμοποιήστε τις `pv`, [`pycp`](https://github.com/dmerejkowsky/pycp), [`progress`](https://github.com/Xfennec/progress), `rsync --progress`, ή για αντιγραφή σε επίπεδο μπλοκ την `dd status=progress`.
- Χρησιμοποιήστε την `shuf` για να ανακατέψετε ή να επιλέξετε τυχαίες γραμμές από ένα αρχείο.
- Να γνωρίζετε τις επιλογές της `sort`. Για αριθμούς χρησιμοποιήστε τις `-n`, ή `-h` για χειρισμό αριθμών που είναι εύκολο να διαβαστούν από άνθρωπο (π.χ. από `du -h`). Να γνωρίζετε πώς λειτουργούν τα ορίσματα (`-t` και `-k`). Συγκεκριμένα, προσέξτε ότι χρειάζεται να γράψετε `-k1,1` για να ταξινομήσετε με βάση μόνο το πρώτο πεδίο· `-k1` σημαίνει ταξινόμηση με βάση όλη τη γραμμή. Η σταθερή ταξινόμηση (`sort -s`) μπορεί να είναι χρήσιμη. Για παράδειγμα, για να ταξινομήσετε πρώτα με βάση το πεδίο 2 και δευτερευόντως με βάση το πεδίο 1, μπορείτε να χρησιμοποιήσετε `sort -k1,1 | sort -s -k2,2`.
- Αν πότε χρειαστεί να γράψετε έναν χαρακτήρα στηλοθέτη (tab) στη γραμμή εντολών στον Bash (π.χ. για να ταξινομήσετε με βάση το όρισμα της επιλογής -t), πιέστε **ctrl-v** **[Tab]** ή γράψτε `$'\t'` (το τελευταίο είναι καλύτερο, γιατί μπορείτε να το αντιγράψετε/επικολλήσετε).
- Τα συνήθη εργαλεία αυτοματοποιημένης επεξεργασίας αλλαγών (patch) πηγαίου κώδικα είναι οι εντολές `diff` (εμφάνιση διαφορών) και `patch` (εφαρμογή διαφορών σε άλλο αρχείο). Επίσης, δείτε την `diffstat` για περίληψη στατιστικών στοιχείων της εντολής diff και `sdiff` για εμφάνιση διαφορών πλάι-πλάι. Σημειώστε ότι η `diff -r` λειτουργεί για ολόκληρους καταλόγους. Χρησιμοποιήστε την `diff -r tree1 tree2 | diffstat` για μια περίληψη αλλαγών. Χρησιμοποιήστε την `vimdiff` για να συγκρίνετε και να επεξεργαστείτε αρχεία μέσω της διεπαφής του vim.
- Για δυαδικά αρχεία, χρησιμοποιήστε τις `hd`, `hexdump` ή την `xxd` για απλά δεκαεξαδικά dumps και τις `bvi`, `hexedit` ή `biew` για επεξεργασία σε δυαδική μορφή.
- Επίσης, για δυαδικά αρχεία η `strings` (και η `grep` κλπ.) σας δίνει τη δυνατότητα να βρείτε κομματάκια κειμένου που κρύβονται σ' αυτά.
- Για δυαδικές διαφορές (συμπίεση δέλτα), χρησιμοποιήστε `xdelta3`.
- Για να μετατρέψετε κωδικοποίηση κειμένου, δοκιμάστε την `iconv`. Ή `uconv` για πιο προχωρημένη χρήση· υποστηρίζει πιο προχωρημένα στοιχεία του προτύπου Unicode. Για παράδειγμα:
:
```sh
# Εμφανίζει τους δεκαεξαδικούς κωδικούς ή πραγματικά ονόματα χαρακτήρων (χρήσιμο για αποσφαλμάτωση):
uconv -f utf-8 -t utf-8 -x '::Any-Hex;' < input.txt
uconv -f utf-8 -t utf-8 -x '::Any-Name;' < input.txt
# Mετατρέπει σε πεζούς χαρακτήρες και απαλείφει τους τόνους (επεκτείνοντας και απορρίπτοντάς τους):
uconv -f utf-8 -t utf-8 -x '::Any-Lower; ::Any-NFD; [:Nonspacing Mark:] >; ::Any-NFC; ' < input.txt > output.txt
```
- Για να σπάσετε αρχεία σε κομμάτια, δείτε τη `split` (για να σπάσετε με βάση το μέγεθος) και τη `csplit` (για να σπάσετε με βάση πρότυπο).
- Ημερομηνία και ώρα: Για να πάρετε την τρέχουσα ημερομηνία και ώρα στη χρήσιμη μορφή [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601), χρησιμοποιήστε `date -u +"%Y-%m-%dT%H:%M:%SZ"` (άλλες επιλογές [είναι](https://stackoverflow.com/questions/7216358/date-command-on-os-x-doesnt-have-iso-8601-i-option) [προβληματικές](https://unix.stackexchange.com/questions/164826/date-command-iso-8601-option)). Για να χειριστείτε εκφράσεις ημερομηνίας και χρόνου, χρησιμοποιήστε τις εντολές `dateadd`, `datediff`, `strptime` κλπ. από το πακέτο [`dateutils`](http://www.fresse.org/dateutils/).
- Χρησιμοποιήστε `zless`, `zmore`, `zcat`και `zgrep` για να χειριστείτε συμπιεσμένα αρχεία.
- Ιδιότητες αρχείων μπορούν να οριστούν με την `chattr` και προσφέρει μία εναλλακτική για τα δικαιώματα των αρχείων σε χαμηλό επίπεδο. Για παράδειγμα, για να προστατευτείτε από κατά λάθος διαγραφή αρχείου χρησιμοποιήστε την επιλογή immutable: `sudo chattr +i /critical/directory/or/file`
- Χρησιμοποιήστε τις `getfacl` και `setfacl` για να αποθηκεύσετε και να επαναφέρετε δικαιώματα αρχείων. Για παράδειγμα:
```sh
getfacl -R /some/path > permissions.txt
setfacl --restore=permissions.txt
```
- Για να δημιουργήσετε άδεια αρχεία γρήγορα, χρηρσιμοποιήστε την `truncate` (δημιουργεί [αραιό αρχείο](https://en.wikipedia.org/wiki/Sparse_file)), τη `fallocate` (ext4, xfs, btrfs και ocfs2 συστήματα αρχείων), την `xfs_mkfile` (σχεδόν για κάθε σύστημα αρχείων, περιλαμβάνεται στο πακέτο xfsprogs), τη `mkfile` (για συστήματα τύπου Unix όπως Solaris, Mac OS).
## Αποσφαλμάτωση συστήματος
- Για web αποσφαλμάτωση, οι εντολές `curl` και `curl -I` είναι χρήσιμες, ή οι ισοδύναμες `wget`, ή η πιο καινούρια [`httpie`](https://github.com/jkbrzt/httpie).
- Για να γνωρίζετε την τρέχουσα κατάσταση του επεξεργαστή και των δίσκων, τα κλασικά εργαλεία είναι η `top` (ή η καλύτερη `htop`), η `iostat`και η `iotop`. Χρησιμοποιήστε την `iostat -mxz 15` για βασικά στατιστικά που αφορούν τον επεξεργαστή ή για λεπτομερή στατιστικά των δίσκων ανά διαμέρισμα και για να έχετε μια εικόνα της απόδοσης.
- Για λεπτομέρειες που αφορούν τη σύνδεση δικτύου, χρησιμοποιήστε τη `netstat` και την `ss`.
- Για μια γρήγορη επισκόπηση του τι συμβαίνει σε ένα σύστημα, η `dstat` είναι ιδιαίτερα χρήσιμη. Για καλύτερη επισκόπηση με λεπτομέρειες, χρησιμοποιήστε [`glances`](https://github.com/nicolargo/glances).
- Για να γνωρίζετε την κατάσταση της μνήμης, εκτελέστε και κατανοήστε την έξοδο των `free` και `vmstat`. Συγκεκριμένα, να έχετε υπόψη ότι η «cached» τιμή είναι μνήμη που δεσμεύει ο πυρήνας του Linux ως προσωρινά αποθηκευμένο αρχείο, ώστε στην ουσία προσμετράται ως «free» τιμή.
- Η αποσφαλμάτωση συστημάτων Java είναι άλλη ιστορία, αλλά ένα απλό κόλπο για το JVM της Oracle και άλλων είναι να τρέξετε την εντολή `kill -3 <pid>` και ένα πλήρες ίχνος στοίβας και περίληψη σωρού (συμπεριλαμβανομένων και λεπτομερειών που αφορούν τη συλλογή απορριμάτων σε γενιές, που μπορεί να είναι πολύ κατατοπιστικές) θα εμφανιστούν στο stderr/logs. Οι εντολές του JDK `jps`, `jstat`, `jstack`, `jmap` είναι χρήσιμες. [Τα εργαλεία SJK](https://github.com/aragozin/jvm-tools) είναι για πιο προχωρημένους.
- Χρησιμοποιήστε την [`mtr`](http://www.bitwizard.nl/mtr/) ως μια βελτίωση της traceroute για να ανιχνεύετε ζητήματα του δικτύου.
- Για να δείτε γιατί ένας δίσκος είναι γεμάτος, η [`ncdu`](https://dev.yorhel.nl/ncdu) εξοικονομεί χρόνο σε σύγκριση με τις συνήθεις εντολές όπως `du -sh *`.
- Για να βρείτε ποια δικτυακή σύνδεση ή διεργασία χρησιμοποιεί εύρος ζώνης, δοκιμάστε [`iftop`](http://www.ex-parrot.com/~pdw/iftop/) ή [`nethogs`](https://github.com/raboof/nethogs).
- Το εργαλείο `ab` (έρχεται μαζί με Apache) βοηθά στον πρόχειρο έλεγχο της απόδοσης web server. Για πιο σύνθετο έλεγχο φόρτου, δοκιμάστε `siege`.
- Για πιο σοβαρή αποσφαλμάτωση δικτύου, [`wireshark`](https://wireshark.org/), [`tshark`](https://www.wireshark.org/docs/wsug_html_chunked/AppToolstshark.html), ή [`ngrep`](http://ngrep.sourceforge.net/).
- Να γνωρίζετε για τις `strace` και `ltrace`. Αυτές μπορεί να φανούν χρήσιμες, όταν ένα πρόγραμμα αποτυγχάνει, παγώνει ή καταρρέει και δε γνωρίζετε γιατί ή αν θέλετε να έχετε μία γενική ιδέα της απόδοσης. Σημειώστε την επιλογή μέτρησης (`-c`) και τη δυνατότητα να συνδέσετε σε μία διεργασία που εκτελείται (`-p`). Χρησιμοποιήστε την επιλογή για να παρακολουθείτε τις διεργασίες παιδιά (`-f`) για να μη χάνετε σημαντικές κλήσεις.
- Να γνωρίζετε για την `ldd` ώστε να ελέγχετε διαμοιραζόμενες βιβλιοθήκες κλπ. — αλλά [ποτέ να μην την εκτελείτε σε αρχεία που δεν εμπιστεύεστε](http://www.catonmat.net/blog/ldd-arbitrary-code-execution/).
- Να γνωρίζετε πώς να συνδέεστε σε μία διεργασία που εκτελείται με `gdb` και να παίρνετε τα ίχνη της στοίβας της.
- Χρησιμοποιήστε τον κατάλογο `/proc`. Είναι εκπληκτικά χρήσιμος ορισμένες φορές, όταν αποσφαλματώνετε ζωντανά προβλήματα. Παραδείγματα: `/proc/cpuinfo`, `/proc/meminfo`, `/proc/cmdline`, `/proc/xxx/cwd`, `/proc/xxx/exe`, `/proc/xxx/fd/`, `/proc/xxx/smaps` (όπου `xxx` είναι το id της διεργασίας ή pid).
- Όταν αποσφαλματώνετε κάτι που ήταν λάθος στο παρελθόν, η [`sar`](http://sebastien.godard.pagesperso-orange.fr/) μπορεί να είναι πολύ χρήσιμη. Δείχνει ιστορικά στατιστικά για επεξεργαστή, μνήμη, δίκτυο κλπ.
- Για πιο εις βάθος ανάλυση συστήματος και απόδοσης, δείτε τις `stap` ([SystemTap](https://sourceware.org/systemtap/wiki)), [`perf`](https://en.wikipedia.org/wiki/Perf_%28Linux%29) και [`sysdig`](https://github.com/draios/sysdig).
- Ελέγξτε ποιο είναι το λειτουργικό σύστημά σας με `uname` ή `uname -a` (γενικές πληροφορίες Unix/πυρήνα) ή `lsb_release -a` (πληροφορίες διανομής Linux).
- Χρησιμοποιήστε την `dmesg`, όποτε κάτι συμπεριφέρεται πραγματικά παράξενα (μπορεί να έχει να κάνει με υλικό ή με οδηγούς).
- Αν διαγράψετε ένα αρχείο και δεν απελευθερωθεί ο σύμφωνα με την `du` αναμενομένος χώρος στον δίσκο, ελέξτε αν το αρχείο χρησιμοποιείται από κάποια διεργασία:
`lsof | grep deleted | grep "filename-of-my-big-file"`
## Εντολές σε μία γραμμή
Μερικά παραδείγματα σωλήνωσης εντολών:
- Είναι εξαιρετικά βοηθητικό ορισμένες φορές το γεγονός ότι μπορείτε να εφαρμόσετε τις πράξεις της τομής, της ένωσης και της διαφοράς σε αρχεία κειμένου με τις εντολές `sort`/`comm`. Έστω ότι `a` και `b` είναι ταξινομημένα αρχεία κειμένου. Αυτό είναι γρήγορο και δουλεύει σε αρχεία οποιουδήποτε μεγέθους έως πολλά gigabytes. (H εντολή `sort` δεν περιορίζεται από τη μνήμη, αν και ίσως χρειαστεί να χρησιμοποιήσετε την επιλογή `-T`, αν ο `/tmp` βρίσκεται σε μικρή κατάτμηση (partition). Επίσης, δείτε την παρατήρηση παραπάνω για τη μεταβλητή `LC_ALL` και την επιλογή `-u` της εντολής `sort` (παραλείπεται παρακάτω ώστε να είναι πιο ξεκάθαρο το παράδειγμα).
```sh
sort -mu a b > c # το c είναι a ένωση b
comm -12 a b > c # c είναι a τομή b
comm -23 a b > c # το c είναι η διαφορά του a από το b
```
- Χρησιμοποιήστε `grep . *` για να εξετάσετε γρήγορα το περιεχόμενο όλων των αρχείων ενός καταλόγου (έτσι κάθε γραμμή αρχείου εμφανίζεται σε ζεύγος με το όνομα του αρχείου), ή `head -100 *` (έτσι κάθε αρχείο έχει μια κεφαλίδα). Αυτό μπορεί να είναι χρήσιμο για καταλόγους γεμάτους με αρχεία ρυθμίσεων όπως αυτά στους καταλόγους `/sys`, `/proc`, `/etc`.
- Η άθροιση όλων των αριθμών στην τρίτη στήλη ενός αρχείου κειμένου (αυτό είναι μάλλον 3X γρηγορότερο και απαιτεί 3X λιγότερο κώδικα από την αντίστοιχη υλοποίηση σε Python):
```sh
awk '{ x += $3 } END { print x }' myfile
```
- Για να δείτε μεγέθη/ημερομηνίες σε ένα δέντρο αρχείων, η παρακάτω είναι σα μια αναδρομική `ls -l`, αλλά είναι πιο ευανάγνωστη από `ls -lR`:
```sh
find . -type f -ls
```
- Έστω ότι έχετε ένα αρχείο κειμένου, όπως το αρχείο καταγραφής (log)/υπ ενός web server και μία συγκεκριμένη τιμή που εμφανίζεται σε μερικές γραμμές, όπως μία παράμετρος `acct_id` που εμφανίζεται στο URL. Αν θέλετε μια καταμέτρηση του πόσα αιτήματα έγιναν για κάθε `acct_id`:
```sh
egrep -o 'acct_id=[0-9]+' access.log | cut -d= -f2 | sort | uniq -c | sort -rn
```
- Για να παρακολουθείτε συνεχώς αλλαγές, χρησιμοποιήστε `watch`, π.χ. ελέγξτε αλλαγές σε αρχεία ενός καταλόγου με `watch -d -n 2 'ls -rtlh | tail'` ή σε ρυθμίσεις δικτύου ενώ επιδιορθώνετε τις ρυθμίσεις wifi με `watch -d -n 2 ifconfig`.
- Εκτελέστε αυτή τη μέθοδο για να πάρετε μια τυχαία συμβουλή από αυτό το έγγραφο (αναλύει Markdown και εξάγει ένα στοιχείο):
```sh
function taocl() {
curl -s https://raw.githubusercontent.com/jlevy/the-art-of-command-line/master/README.md |
sed '/cowsay[.]png/d' |
pandoc -f markdown -t html |
xmlstarlet fo --html --dropdtd |
xmlstarlet sel -t -v "(html/body/ul/li[count(p)>0])[$RANDOM mod last()+1]" |
xmlstarlet unesc | fmt -80 | iconv -t US
}
```
## Ασυνήθιστες αλλά χρήσιμες
- `expr`: εκτελέστε αριθμητικές και λογικές πράξεις ή εφαρμόζετε κανονικές εκφράσεις
- `m4`: απλός μακροεπεξεργαστής
- `yes`: τυπώστε ένα αλφαριθμητικό πολλές φορές
- `cal`: όμορφο ημερολόγιο
- `env`: εκτελέστε μία εντολή (χρήσιμο σε σενάρια)
- `printenv`: τυπώστε μεταβλητές περιβάλλοντος (χρήσιμο στην αποσφαλμάτωση και σε σενάρια)
- `look`: βρείτε αγγλικές λέξεις (ή γραμμές σε ένα αρχείο) αρχίζοντας με ένα αλφαριθμητικό
- `cut`, `paste` και `join`: επεξεργασία δεδομένων
- `fmt`: μορφοποίηση παραγράφων
- `pr`: μορφοποίηση κειμένου σε σελίδες/στήλες
- `fold`: τύλιγμα γραμμών κειμένου
- `column`: μορφοποίηση πεδίων κειμένου σε στοιχισμένες, σταθερού πλάτους στήλες ή πίνακες
- `tree`: εμφανίστε καταλόγους και υποκαταλόγους σε φωλιασμένο δένδρο, όπως η `ls` αλλά αναδρομική
- `stat`: πληροφορίες αρχείου
- `time`: εκτελέστε και χρονομετρήστε μία εντολή
- `timeout`: εκτελέστε μια εντολή για συγκεκριμένο χρονικό διάστημα και σταμάτησε τη διεργασία, όταν ολοκληρωθεί το χρονικό διάστημα αυτό
- `lockfile`: δημιουργήστε αρχεία σημαφόρους που μπορούν να διαγραφούν μόνο με `rm -f`
- `logrotate`: περιστρέψτε, συμπιέστε και στείλτε με ηλ-ταχ αρχεία καταγραφής (logs).
- `watch`: εκτελέστε μία εντολή επαναλαμβανόμενα εμφανίζοντας αποτελέσματα ή/και επισημαίνοντας αλλαγές
- [`when-changed`](https://github.com/joh/when-changed): εκτελεί όποια εντολή ορίσετε, όποτε βλέπει ότι ένα αρχείο άλλαξε. Δείτε ακόμη τις `inotifywait` και `entr`.
- `tac`: τυπώστε αρχεία ανεστραμμένα
- `comm`: συγκρίνετε ταξινομημένα αρχεία γραμμή προς γραμμή
- `strings`: εξάγετε κείμενο από δυαδικά αρχεία
- `tr`: μετάφραση χαρακτήρων ή επεξεργασία
- `iconv` ή `uconv`: μετατροπή κωδικοποίησης κειμένου
- `split` και `csplit`: χώρισμα αρχείων
- `sponge`: διαβάστε όλη την είσοδο πριν γράψετε σε αυτή, χρήσιμο όταν πρόκειται να διαβάσετε από ένα αρχείο και μετά να γράψετε σε αυτό, π.χ., `grep -v something some-file | sponge some-file`
- `units`: μετατροπές μονάδων και υπολογισμοί· κάνει ό,τι μετατροπές μπορείτε να σκεφτείτε (δείτε επίσης `/usr/share/units/definitions.units`)
- `apg`: δημιουργεί τυχαίους κωδικούς
- `xz`: υψηλής αναλογίας συμπίεση αρχείων
- `ldd`: πληροφορίες για δυναμικές βιβλιοθήκες
- `nm`: σύμβολα από αντικειμενικά αρχεία
- `ab` ή [`wrk`](https://github.com/wg/wrk): συγκριτική αξιολόγηση web servers
- `strace`: αποσφαλμάτωση κλήσης συστήματος
- [`mtr`](http://www.bitwizard.nl/mtr/): καλύτερο εργαλείο traceroute για αποσφαλμάτωση δικτύου
- `cssh`: visual concurrent shell
- `rsync`: συγχρονισμός αρχείων και καταλόγων μέσω SSH ή σε τοπικό σύστημα αρχείων
- [`wireshark`](https://wireshark.org/) και [`tshark`](https://www.wireshark.org/docs/wsug_html_chunked/AppToolstshark.html): συλλογή πακέτων και αποσφαλμάτωση δικτύου
- [`ngrep`](http://ngrep.sourceforge.net/): grep για το επίπεδο δικτύου
- `host` και `dig`: αναζητήσεις DNS
- `lsof`: εμφανίστε περιγραφείς αρχείου και πληροφορίες δικτυακών συνδέσεων
- `dstat`: χρήσιμα στατιστικά συστήματος
- [`glances`](https://github.com/nicolargo/glances): υψηλού επιπέδου επισκόπηση πολλαπλών υποσυστημάτων
- `iostat`: στατιστικά χρήσης δίσκου
- `mpstat`: στατιστικά χρήσης επεξεργαστή
- `vmstat`: στατιστικά χρήσης μνήμης
- `htop`: βελτιωμένη έκδοση της top
- `last`: ιστορικό σύνδεσης (login)
- `w`: ποιος συνδέθηκε
- `id`: πληροφορίες ταυτότητας χρήστη/ομάδας
- [`sar`](http://sebastien.godard.pagesperso-orange.fr/): ιστορικά στατιστικά συστήματος
- [`iftop`](http://www.ex-parrot.com/~pdw/iftop/) ή [`nethogs`](https://github.com/raboof/nethogs): χρήση δικτύου ανά δικτυακή σύνδεση ή διεργασία
- `ss`: στατιστικά ανά δικτυακή σύνδεση
- `dmesg`: μηνύματα για σφάλματα κατά την εκκίνηση ή σφάλματα συστήματος
- `sysctl`: δείτε και ρυθμίστε τις παραμέτρους του πυρήνα Linux, ενώ εκτελείται
- `hdparm`: διαχείριση/απόδοση δίσκου SATA/ATA
- `lsblk`: εμφανίστε σε λίστα συσκευές αποθήκευσης: μία προβολή σε δέντρο των δίσκων σας και των διαμερισμάτων τους
- `lshw`, `lscpu`, `lspci`, `lsusb`, `dmidecode`: πληροφορίες υλικού, συμπεριλαμβανομένων επεξεργαστή, BIOS, RAID, γραφικών, συσκευών κλπ.
- `lsmod` και `modinfo`: εμφανίστε σε λίστα και προβάλλετε λεπτομέρειες για λειτουργικές μονάδες του πυρήνα
- `fortune`, `ddate`και `sl`: ε, λοιπόν, εξαρτάται από το αν θεωρείτε τα τρένα με ατμομηχανή και τις ρήσεις του Zippy «χρήσιμα»
## Μόνο για OS X
Τα παρακάτω σημεία σχετίζονται *μόνο* με OS X.
- Διαχείριση πακέτων λογισμικού με `brew` (Homebrew) και/ή `port` (MacPorts). Μπορούν να χρησιμοποιηθούν για εγκατάσταση σε OS X πολλών από τις παραπάνω εντολές.
- Αντιγράψτε την έξοδο οποιασδήποτε εντολής σε μια desktop εφαρμογή με `pbcopy` και επικολλήστε στην είσοδο με `pbpaste`.
- Για να ενεργοποιήσετε το πλήκτρο Option σε τερματικό OS X ως πλήκτρο alt (όπως χρησιμοποιείται στις παραπάνω εντολές όπως **alt-b**, **alt-f** κλπ.), ανοίξτε Προτιμήσεις -> Προφίλ -> Πληκτρολόγιο και επιλέξτε «Χρήση Option ως μετα-πλήκτρου».
- Για να ανοίξετε ένα αρχείο με μια desktop εφαρμογή χρησιμοποιήστε `open` ή `open -a /Applications/Whatever.app`.
- Spotlight: Αναζητήστε αρχεία με `mdfind` και εμφανίστε σε λίστα μεταδεδομένα (όπως τις πληροφορίες EXIF μιας φωτογραφίας) με `mdls`.
- Έχετε υπόψη σας ότι το OS X βασίζεται σε BSD Unix και πολλές εντολές (για παράδειγμα `ps`, `ls`, `tail`, `awk`, `sed`) έχουν μικρές διαφορές από το Linux, που έχει ευρέως επηρεαστεί από το System V-style Unix και τα εργαλεία GNU. Συνήθως μπορείτε να βρίσκετε τη διαφορά επισημαίνοντας ότι μια man σελίδα έχει την επικεφαλίδα «Εγχειρίδιο γενικών εντολών BSD». Σε ορισμένες περιπτώσεις μπορούν επίσης να εγκατασταθούν εκδόσεις GNU, (όπως οι `gawk` και `gsed` για τις GNU awk και sed). Αν γράφετε σενάρια Bash που στοχεύετε να εκτελούνται σε διάφορες πλατφόρμες, αποφύγετε τέτοιες εντολές (για παράδειγμα, έχετε υπόψη σας την Python ή `perl`) ή ελέγξτε προσεχτικά.
- Για να πάρετε πληροφορίες για την έκδοση OS X χρησιμοποιήστε `sw_vers`.
## Μόνο για Windows
Τα παρακάτω σημεία σχετίζονται *μόνο* με Windows.
### Πρόσβαση στα εργαλεία του Unix από Windows
- Αποκτήστε πρόσβαση στη δύναμη του φλοιού του Unix σε περιβάλλον Microsoft Windows εγκαθιστώντας το [Cygwin](https://cygwin.com/). Τα περισσότερα από αυτά που περιγράφονται σε αυτό το έγγραφο θα λειτουργήσουν μεμιάς.
- Σε Windows 10, μπορείτε να χρησιμοποιήσετε το [Bash σε Ubuntu για Windows](https://msdn.microsoft.com/commandline/wsl/about), το οποίο παρέχει ένα περιβάλλον παρόμοιο με του Bash με εργαλεία γραμμής εντολών Unix. Έχει το πλεονέκτημα ότι επιτρέπει σε προγράμματα Linux να εκτελεστούν σε Windows. Από την άλλη πλευρά, σε αντίθεση με το περιβάλλον Cygwin, δεν επιτρέπει την εκτέλεση προγραμμάτων Windows από τη γραμμή εντολών του Bash.
- Αν σας ενδιαφέρει κυρίως η χρήση των εργαλείων ανάπτυξης GNU (όπως ο μεταγλωττιστής GCC) σε Windows, σκεφτείτε τη χρήση των [MinGW](http://www.mingw.org/) και [MSYS](http://www.mingw.org/wiki/msys), τα οποία παρέχουν εργαλεία όπως bash, gawk, make και grep. Το MSYS δεν υποστηρίζει όμως όλες τις δυνατότητες του Cygwin. Το MinGW είναι κυρίως χρήσιμο για να δημιουργήσετε εγγενείς εκδόσεις Windows εργαλείων του Unix.
- Μια άλλη επιλογή για να έχετε εντολές Unix κάτω από Windows είναι το σύστημα [Cash](https://github.com/dthree/cash). Αυτό όμως υποστηρίζει πολύ λίγες εντολές και επιλογές του Unix.
### Χρήσιμα εργαλεία της γραμμής εντολών Windows
- Μπορείτε να εκτελέσετε και να γράψετε scripts για τις περισσότερες εργασίες διαχείρισης συστήματος των Windows από τη γραμμή εντολών μαθαίνοντας και χρησιμοποιώντας την `wmic`.
- Χρήσιμα εγγενή εργαλεία της γραμμής εντολών των Windows για διαχείριση και αποσφαλμάτωση του δικτύου είναι τα `ping`,` ipconfig`, `traceroute` και `netstat`.
- Πολλές [χρήσιμες λειτουργίες των Windows] (http://www.thewindowsclub.com/rundll32-shortcut-commands-windows) μπορούν να εκτελεστούν μέσω της εντολής `Rundll32`.
### Συμβουλές για αποδοτική χρήση του Cygwin
- Εγκαταστήστε πρόσθετα προγράμματα Unix με τον διαχειριστή πακέτων του Cygwin.
- Χρησιμοποιήστε το `mintty` ως το παράθυρο γραμμής εντολών σας.
- Αποκτήστε πρόσβαση στο πρόχειρο (clipboard) των Windows μέσω του `/dev/clipboard`.
- Εκτελέστε τη `cygstart` για να ανοίξετε ένα οποιοδήποτε αρχείο με την εφαρμογή που είναι ορισμένη να χρησιμοποιείται για το άνοιγμά του.
- Αποκτήστε πρόσβαση στο μητρώο των Windows με `regtool`.
- Σημειώστε ότι η διαδρομή `C:\` των Windows γίνεται `/cygdrive/c` στο Cygwin και ότι το `/` του Cygwin εμφανίζεται ως `C:\cygwin` στα Windows. Μετατρέψετε διαδρομές αρχείων από τη μορφή που χρησιμοποιεί το Cygwin σε αυτή που χρησιμοποιούν τα Windows και αντίστροφα με `cygpath`. Αυτό είναι πολύ χρήσιμο σε σενάρια που καλούν προγράμματα Windows.
- Μπορείτε να εκτελέσετε και να γράψετε σενάρια για τις περισσότερες εργασίες διαχείρισης συστήματος των Windows από τη γραμμή εντολών μαθαίνοντας και χρησιμοποιώντας την `wmic`.
- Μία άλλη επιλογή για να έχετε την εμφάνιση και την εμπειρία χρήσης Unix σε Windows είναι το [Cash](https://github.com/dthree/cash). Σημειώστε ότι μόνο πολύ λίγες εντολές Unix και επιλογές γραμμής εντολών είναι διαθέσιμες σε αυτό το περιβάλλον.
## Περισσότερες πηγές
- [awesome-shell](https://github.com/alebcay/awesome-shell): Μία προσεγμένη λίστα με εργαλεία και πηγές σχετικές με τον φλοιό .
- [awesome-osx-command-line](https://github.com/herrbischoff/awesome-osx-command-line): Ένας περισσότερο εις βάθος οδηγός της γραμμής εντολών του OS X.
- [Strict mode](http://redsymbol.net/articles/unofficial-bash-strict-mode/) για να γράφετε καλύτερα σενάρια φλοιού.
- [shellcheck](https://github.com/koalaman/shellcheck): Ένα εργαλείο στατικής ανάλυσης για σενάρια για φλοιό. Στην ουσία, lint για bash/sh/zsh.
- [Filenames and Pathnames in Shell](http://www.dwheeler.com/essays/filenames-in-shell.html): Οι δυστυχώς περίπλοκες μικρολεπτομέρειες του πώς να διαχειριστεί κανείς σωστά ονόματα αρχείων σε σενάρια για φλοιό.
- [Data Science at the Command Line](http://datascienceatthecommandline.com/#tools): Περισσότερες εντολές και εργαλεία χρήσιμα για την άσκηση της επιστήμης δεδομένων, από το βιβλίο με το ίδιο όνομα.
## Αποποίηση ευθύνης
Με την εξαίρεση πολύ μικρών εργασιών, ο κώδικας πρέπει να γράφεται ώστε να μπορούν οι άλλοι να τον διαβάζουν. Η δύναμη συνεπάγεται ευθύνη. Το γεγονός ότι *μπορείτε* να κάνετε κάτι με Bash δε σημαίνει απαραίτητα ότι θα έπρεπε! ;)
## Άδεια χρήσης
[](http://creativecommons.org/licenses/by-sa/4.0/)
Η εργασία αυτή έχει αδειοδοτηθεί με [Creative Commons Attribution-ShareAlike 4.0 International License](http://creativecommons.org/licenses/by-sa/4.0/).
================================================
FILE: README-es.md
================================================
🌍
*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](README-es.md) ∙ [Français](README-fr.md) ∙ [Indonesia](README-id.md) ∙ [Italiano](README-it.md) ∙ [日本語](README-ja.md) ∙ [한국어](README-ko.md) ∙ [polski](README-pl.md) ∙ [Português](README-pt.md) ∙ [Română](README-ro.md) ∙ [Русский](README-ru.md) ∙ [Slovenščina](README-sl.md) ∙ [Українська](README-uk.md) ∙ [简体中文](README-zh.md) ∙ [繁體中文](README-zh-Hant.md)*
# El Arte del Terminal
[](https://gitter.im/jlevy/the-art-of-command-line?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
- [Meta](#meta)
- [Fundamentos](#fundamentos)
- [Uso diario](#de-uso-diario)
- [Procesamiento archivos y datos](#procesamiento-de-archivos-y-datos)
- [Depuración del sistema](#depuración-del-sistema)
- [One-liners](#one-liners)
- [Obscuro pero útil](#osbcuro-pero-útil)
- [Solo para OS X](#solo-para-os-x)
- [Solo para Windows](#solo-windows)
- [Más recursos](#más-recursos)
- [Advertencia](#advertencia)
La fluidez en el terminal es una destreza a menudo abandonada y considerada arcaica, pero ésta mejora tu flexibilidad y productividad como ingeniero de formas obvias y sutiles. Esta es una selección de notas y consejos para usar el terminal que encontramos útiles al trabajar en Linux. Algunos consejos son elementales y algunos bastante específicos, sofisticados u oscuros. Esta página no es larga, pero si puedes usar y recordar todos los puntos aquí mostrados, sabrás un montón.
Este trabajo es el resultado de [muchos autores y traductores](AUTHORS.md).
Parte de esta:
[originalmente](http://www.quora.com/What-are-some-lesser-known-but-useful-Unix-commands)
[apareció](http://www.quora.com/What-are-the-most-useful-Swiss-army-knife-one-liners-on-Unix)
en [Quora](http://www.quora.com/What-are-some-time-saving-tips-that-every-Linux-user-should-know),
pero se ha movido desde entonces a Github, donde personas más talentosas que el autor han hecho numerosas mejoras.
[**Por favor contribuye**](/CONTRIBUTING.md) Si ves un error o algo que podría ser mejor!
## Meta
Alcance:
- Esta guía es tanto para principiantes como para experimentados. Los objetivos son *diversidad* (todo importa), *especificidad* (dar ejemplos concretos del caso más común), y *concisión* (evitar cosas que no son esenciales o insignificantes que puedas buscar fácilmente en otro lugar). Cada consejo es esencial en alguna situación o significativamente puede ahorrar tiempo comparado con otras alternativas.
- Está escrita para Linux, con excepción de la secciones "[Solo para OS X](#os-x-only)" y "[Solo para Windows](#solo-windows)". Muchos de los otros puntos aplican o pueden ser instalados en otros Unices o OS X (o incluso Cygwin).
- Se centra en Bash interactivo, aunque muchos de los consejos aplican para otros shells y al Bash scripting por lo general.
- Incluye tanto comandos "estándar" Unix así como los que requieren instalaciones de paquetes especiales -- siempre que sean lo suficientemente importantes para merecer su inclusión.
Notas:
- Para mantener esto en una página, el contenido está incluido implícitamente por referencia. Eres lo suficientemente inteligente para consultar más detalles en otros lugares buscando en Google una vez conoces la idea o el comando. Usa `apt-get`, `yum`, `dnf`, `pacman`, `pip` o `brew` (según proceda) para instalar los nuevos programas.
- Usa [Explainshell](http://explainshell.com/) para obtener detalles de ayuda sobre que hacen los comandos, las opciones, las pipes, etc.
## Fundamentos
- Aprende conocimientos básicos de Bash, de hecho, escribe `man bash` y al menos échale un vistazo a todo el asunto. Es bastante fácil de seguir y no es tan largo. Alternar entre shells puede ser agradable, pero Bash es poderoso y siempre está disponible (conocer *solo* zsh, fish, etc., aunque resulte tentador en tu propia laptop, Te restringe en muchas situaciones, tales como el uso de servidores existentes).
- Aprende bien al menos un editor de texto, idealmente Vim (`vi`), como no hay realmente una competencia para la edición aleatoria en un terminal (incluso si usa Emacs, un gran IDE, o un editor alternativo (hipster) moderno la mayor parte del tiempo).
- Conoce como leer la documentación con `man` (Para curiosos, `man man` lista las secciones enumeradas, ej. 1 es comandos "regulares", 5 son archivos/convenciones, y 8 para administración). Encuentra las páginas de man `apropos`. Sepa que alguno de los comandos no son ejecutables, pero son Bash builtins, y que puedes obtener ayuda sobre ellos con `help` y `help -d`.
- Aprende sobre redirección de salida `>`, entrada `<` y pipes utilizando `|`. Conozca que `>` sobrescribe el archivo de salida y `>>` añade. Aprende sobre stdout y stderr.
- Aprende sobre expansión de archivos glob con `*` (y tal vez `?` y `[`...`]`) y quoting y la diferencia entre comillas dobles `"` y simples `'`. (Ver más en expansión de variables más abajo.)
- Familiarízate con la administración de trabajo en Bash: `&`, **ctrl-z**, **ctrl-c**, `jobs`, `fg`, `bg`, `kill`, etc.
- Conoce `ssh` y lo básico de autenticación sin contraseña, vía `ssh-agent`, `ssh-add`, etc.
- Administración de archivos básica: `ls` y `ls -l` (en particular, aprende el significado de cada columna en `ls -l`), `less`, `head`, `tail` y `tail -f` (o incluso mejor, `less +F`), `ln` y `ln -s` (aprende las diferencias y ventajas entre enlaces hard y soft), `chown`, `chmod`, `du` (para un resumen rápido del uso del disco: `du -hs *`). Para administración de archivos de sistema, `df`, `mount`, `fdisk`, `mkfs`, `lsblk`. Aprenda que un inode es `ls -i` or `df -i`).
- Administración básica de redes: `ip` o `ifconfig`, `dig`.
- Aprende y usa un sistema de control de versiones, por ejemplo `git`.
- Conoce bien las expresiones regulares y varias opciones (flags) para `grep`/`egrep`. Las opciones `-i`, `-o`, `-v`, `-A`, `-B` y `-C` son dignas de ser recordadas.
- Aprende el uso de `apt-get`, `yum`, `dnf` o `pacman` (dependiendo de la distribución "distro") para buscar e instalar paquetes. Y asegúrate que tienes `pip` para instalar la herramienta de línea de comando basada en Python (un poco más abajo esta explicado como instalar vía `pip`).
## De uso diario
- En Bash, se usa **Tab** para completar los argumentos o lista todos los comandos disponibles y **ctrl-r** para buscar a través del historial de comandos (despues de presionar, escribe la búsqueda, presiona **ctrl-r** repetidamente para hacer un ciclo a través de más coincidencias, presiona **Enter** para ejecurar el comando encontrado, o presiona la flecha derecha para poner el resultado en la línea actual y editar).
- En Bash, se usa **ctrl-w** para borrar la última palabra, y **ctrl-u** para borrar todo hacia atrás hasta el inicio de la línea. Se usa **alt-b** y **alt-f** para moverse entre palabras, **ctrl-a** para mover el cursor al principio de la línea, **ctrl-e** para mover el cursor al final de la línea, **ctrl-k** para eliminar hasta el final de la línea, **ctrl-l** para limpiar la pantalla. Ver `man readline` para todos los atajos de teclado por defecto en Bash. Son una gran cantidad. Por ejemplo **alt-.** realiza un ciclo a través de los comandos previos, y **alt-*** expande un glob.
- Alternativamente, si amas los atajos de teclado vi-style, usa `set -o vi`. (y `set -o emacs` para regresar a la anterior).
- Para editar largos comandos, después de configurar to editor (por ejemplo `export EDITOR=vim`), **ctrl-x** **ctrl-e** se abrirá el comando actual en un editor para editar multiples líneas. O en estilo vi, **escape-v**.
- Para ver los últimos comandos, `history`. También existen abreviaciones, tales como, `!$` (último argumento) y `!!` último comando, aunque son fácilmente remplazados con **ctrl-r** y **alt-.**.
- Para volver al directorio principal con `cd`. Accede a los archivos relativos a tu directorio principal con el prefijo `~` (ej. `~/.bashrc`). En scripts `h`refierete al directorio principal con `$HOME`.
- Para volver al directorio de trabajo previo: `cd -`.
- Si estás a medio camino al escribir un comando pero cambias de opinión, presiona **alt-#** para agregar un `#` al principio y lo agrega como comentario (o usa **ctrl-a**, **#**, **enter**). Luego puedes regresar a este vía comando `history`.
- Usa `xargs` (o `parallel`). Es muy poderoso. Ten en cuenta que puedes controlar cuántos elementos son ejecutados por línea (`-L`), así como el paralelismo (`-P`). Si no estas seguro de que este haga la cosa correcta, usa `xargs echo` primero. También, `-I{}` es útil. Ejemplos:
```bash
find . -name '*.py' | xargs grep some_function
cat hosts | xargs -I{} ssh root@{} hostname
```
- `pstree -p` es útil para mostrar el árbol de procesos.
- Usa `pgrep` y `pkill` para encontrar o señalar procesos por su nombre (`-f` es de mucha ayuda).
- Conoce las señales que puedes enviar a los procesos. Por ejemplo, para suspender un proceso usa `kill -STOP [pid]`. Con `man 7 signal` puedes ver la lista completa
- Usa `nohup` o `disown` si quieres que un proceso de fondo se mantenga corriendo para siempre.
- Verifica que procesos están escuchando vía `netstat -lntp` o `ss -plat` (para TCP; agrega `-u` para UDP).
- Consulta también `lsof` para abrir sockets y archivos.
- Consulta `uptime` o `w` para conocer cuánto tiempo el sistema ha estado corriendo.
- Usa `alias` para crear atajos para comandos comúnmente usados. Por ejemplo, `alias ll="las -latr"` crea el alias `ll`
- En Bash scripts, usa `set -x` (o su variantes `set -v`, que registra las entradas sin procesar, incluyendo variables sin expander y comantarios) para depurar la salida. Usa el modo estricto al menos que tengas una buena razón para no hacerlo: Usa `set -e` para abortar en caso de errores (códigos de salida distintos a cero). Usa `set -u` para detectar uso de variables no definidas. Considera `set -o pipefail` también, para los errores con pipes, también (estudiar mas sobre este como un tema delicado). Para scripts más complejos, usa también `trap`. en EXIT o ERR. Un hábito útil es para comenzar un script como este, el cual detectará y abortará con errores comunes e imprimirá un mensaje:
```bash
set -euo pipefail
trap "echo 'error: Falló del Script: ver arriba comando que falló'" ERR
```
- En Bash scripts, subshells (escritos con paréntesis) son maneras convenientes para agrupar los comandos. Un ejemplo común es temporalmente moverse hacia un directorio de trabajo diferente, Ej.
```bash
# do something in current dir
(cd /some/other/dir && other-command)
# continue in original dir
```
- En Bash, considera que hay muchas formas de expansión de variables. Verificar la existencia de una variable: `${name:?error message}`. Por ejemplo, si un script Bash requiere un único argumento, solo escribe `input_file=${1:?usage: $0 input_file}`. Expansión aritmética: `i=$(( (i + 1) % 5 ))`. Secuencias: `{1..10}`. Reducción de cadenas de texto: `${var%suffix}` y `${var#prefix}`. Por ejemplo si `var=foo.pdf`, entonces `echo ${var%.pdf}.txt` imprime `foo.txt`.
- Utilizando la expansión de corchetes `{`...`}` puede reducir el tener que retipear un texto similar y automatizar conbinaciones de elementos. Esto es útil en ejemplos como `mv foo.{txt,pdf} some-dir` (el cual mueve ambos archivos), `cp somefile{,.bak}` (el cual se expandirá a `cp somefile somefile.bak`) o `mkdir -p test-{a,b,c}/subtest-{1,2,3}` (el cual se expandirá en todas las posibles conbinaciones y creará un árbol de directorios).
- La salida de un comando puede ser tratado como un archivo por medio de `<(some command)`. Por ejemplo, comparar el `/etc/hosts` local con uno remoto:
```sh
diff /etc/hosts <(ssh somehost cat /etc/hosts)
```
- Conocer acerca de "here documents" en Bash, como también de `cat <<EOF ...`.
- En Bash, redirecciona ambas la salida estándar y el error estándar, mediante: `some-command >logfile 2>&1` o `some-command &>logfile`. Frecuentemente, para garantizar que un comando no haya dejado abierto un archivo para controlar la entrada estándar vinculada al terminal en el que te encuentras y también como buena práctica puedes agregar `</dev/null`.
- Usa `man ascii` para una buena tabla ASCII con valores hexadecimal y decimales. Para información de codificación general, `man unicode`, `man utf-8`, y `man latin1` son de utilidad.
- Usa `screen` o [`tmux`](https://tmux.github.io/) para multiplexar la pantalla, especialmente útil en sesiones ssh remotas y para desconectar y reconectar a una sesión. `byobu` puede mejorar la pantalla o tmux proporcionando mayor información y gestión ás sencilla. Una alternativa más minimalista para persistencia de la sesión solo sería `dtach`.
- En ssh, saber cómo hacer un port tunnel con `-L` o `-D` (y de vez en cuando `-R`) es útil, Ej. para acceder a sitios web desde un servidor remoto.
- Puede ser útil hacer algunas optimizaciones a su configuración ssh; por ejemplo, `~/.ssh/config`, contiene la configuración para evitar desconexiones en ciertos entornos de red, utiliza compresión (cual es útil con scp sobre conexiones con un bajo ancho de banda), y la multiplexión de canales para el mismo servidor con un archivo de control local:
```
TCPKeepAlive=yes
ServerAliveInterval=15
ServerAliveCountMax=6
Compression=yes
ControlMaster auto
ControlPath /tmp/%r@%h:%p
ControlPersist yes
```
- Algunas otras opciones relevantes a ssh son sensibles en cuanto a seguridad y deben ser usadas con cuidado, Ej. por subnet, host o en redes confiables: `StrictHostKeyChecking=no`, `ForwardAgent=yes`.
- Considera [`mosh`](https://mosh.org/) una alternativa para ssh que utiliza UDP, evitando conexiones caidas y agregando conveniencia en el camino. (require configuración del lado del servidor).
- Para obtener permiso sobre un archivo en forma octal, el cual es útil para la configuración del sistema pero no está disponible con `ls` y fácil de estropear, usa algo como
```sh
stat -c '%A %a %n' /etc/timezone
```
- Para selección interactiva de valores desde la salida de otro comando, use [`percol`](https://github.com/mooz/percol) o [`fzf`](https://github.com/junegunn/fzf).
- Para la interacción con archivos basados en la salida de otro comando (como `git`), use `fpp` ([PathPicker](https://github.com/facebook/PathPicker)).
- Para un servidor web sencillo para todos los archivos en el directorio actual (y subdirectorios), disponible para cualquiera en tu red, usa:
`python -m SimpleHTTPServer 7777` (para el puerto 7777 y Python 2) y `python -m http.server 7777` (para 7777 y Python 3).
- Para ejecutar un comando con privilegios, usando `sudo` (para root) o `sudo -u` (para otro usuario). Usa `su` o `sudo bash` para realmente ejecutar un shell como este usuario. Usa `su -` para simular un login fresco como root u otro usuario.
## Procesamiento de archivos y datos
- Para localizar un archivo por nombre en el directorio actual, `find . -iname '*algo*'` (o similar). Para encontrar un archivo en cualquier lado por nombre, usa `locate something` (pero tenga en mente que `updatedb` quizás no haya indexado recientemente los archivos creados).
- Para búsqueda general a través de archivos fuente o de datos (más avanzado que `grep -r`), usa [`ag`](https://github.com/ggreer/the_silver_searcher).
- Para convertir HTML a texto: `lynx -dump -stdin`
- Para Markdown, HTML, y todos los tipos de conversión de documentos, prueba [`pandoc`](http://pandoc.org/).
- Si debe manipular XML, `xmlstarlet` es viejo pero bueno.
- Para JSON usa [`jq`](http://stedolan.github.io/jq/).
- Para YAML, usa [`shyaml`](https://github.com/0k/shyaml).
- Para archivos Excel o CSV, [csvkit](https://github.com/onyxfish/csvkit) proporciona `in2csv`, `csvcut`, `csvjoin`, `csvgrep`, etc.
- Para Amazon S3, [`s3cmd`](https://github.com/s3tools/s3cmd) es conveniente y [`s4cmd`](https://github.com/bloomreach/s4cmd) es el mas rápido. [`aws`](https://github.com/aws/aws-cli) de Amazon y el mejorado [`saws`](https://github.com/donnemartin/saws) son esenciales para otras tareas relacionadas al AWS.
- Conoce acerca de `sort` y `uniq`, incluyendo las opciones de uniq `-u` y `-d` -- ver [one-liners](https://github.com/jlevy/the-art-of-command-line/blob/master/README-es.md#one-liners) más abajo. Ver también `comm`
- Conoce acerca de `cut`, `paste` y `join` para manipular archivos de texto. Muchas personas usan `cut` pero se olvidan acerca de `join`.
- Conoce acerca de `wc` para contar saltos de línea (`-l`), caracteres (`-m`), palabras (`-w`) y bytes (`-c`).
- Conoce acerca de `tee` para copiar desde el stdin hacia un archivo y también hacia el stdout, al igual que en `ls -al | tee file.txt`.
- Conoce que la localización afecta muchas herramientas de línea de comando en forma delicada, incluyendo el ordenamiento (compaginación) y rendimiento. La mayoría de las instalaciones de Linux configuran `LANG` u otras variables de localización para la configuración local como US English. Pero ten en mente que el ordenamiento puede cambiar si cambia la localización. Y también las rutinas i18n pueden hacer que `sort` u otros comandos se ejecuten más lentamente. En algunas situaciones (tales como la realización de operaciones u operaciones singulares descritas más abajo) puedes ignorar las rutinas i18n por completo y utilizar el sort tradicional basado en bytes, usando `export LC_ALL=C`.
- Conoce los aspectos básicos de `awk` y `sed` para manejo de datos. Por ejemplo, sumar todos lo números en la tercera columna de un archivo de texto: `awk '{ x += $3 } END { print x }'`. Esto es probablemente 3 veces más rápido y 3 veces más corto que su equivalente en Python.
- Para reemplazar todas las ocurrencias de un string en su lugar, en uno o más archivos:
```sh
perl -pi.bak -e 's/old-string/new-string/g' my-files-*.txt
```
- Para renombrar multiples y/o buscar y remplazar dentro de archivos, intenta [`repren`](https://github.com/jlevy/repren). (En algunos casos el comando `rename` también permite multiples renombramientos, pero sea cuidadoso ya que esta funcionalidad no es igual en todas las distribuciones de Linux.)
```sh
# Renombramiento completo de archivos, carpetas y contenidos foo -> bar:
repren --full --preserve-case --from foo --to bar .
# Recuperar archivos de respaldo cualquier.bak -> cualquier:
repren --renames --from '.*)\.bak' --to '\1' *.bak
# Igual que arriba, utilizando rename, si esta disponible:
rename 's/\.bak$//' *.bak
```
- Como dice la página de man, `rsync` es una muy rápida y extraordinariamente versatil herramienta de copiado. Esta se conoce por la sincronización entre máquinas pero es igualmente útil localmente. Esta también se encuentra entre las [formas más rápidas](https://web.archive.org/web/20130929001850/http://linuxnote.net/jianingy/en/linux/a-fast-way-to-remove-huge-number-of-files.html) para borrar un gran número de archivos:
```sh
mkdir empty && rsync -r --delete empty/ some-dir && rmdir some-dir
```
- Usa `shuf` para mezclar o seleccionar líneas aleatorias de un archivo.
- Conoce las opciones de `sort`. Para números, usa `-n`, o `-h` para manipulación de números humanamente leíbles (Ej. desde `du -h`). Conoce el trabajo principal de (`-t` y `-k`). En particular, esta atento que lo necesitas escribir`-k1,1` para ordenar por solo el primer campo; `-k1` significa ordenar de acuerdo a toda la línea. Orden estable (`sort -s`) puede ser útil. Por ejemplo, para organizar el primer por el campo 2, entonces secundariamente hacerlo por el campo 1, Puedes usar `sort -k1,1 | sort -s -k2,2`.
- Si alguna vez necesitas escribir un tab literal en una línea de comandos en Bash (Ej. para el argumento -t de ordenar), presiona **ctrl-v** **[Tab]** o escribe `$'\t'` (El último es mejor porque puedes copiarlo/pegarlo).
- Las herramientas estándar para reparar el código fuente son `diff` y `patch`. Consulta también `diffstat` para resumen estadístico de una diff y `sdiff` para un diff puesto lado a lado. Considera `diff -r` trabaja con directorios por completo. Usa `diff -r tree1 tree2 | diffstat` para el resumen de cambios. Urilizá `vimdiff` para comparar y editar archivos.
- Para archivos binarios, usa `hd`, `hexdeump` or `xxd` para volcados hexdecimales simples y `bvi` o `biew` para edición de binario.
- También para archivos binarios, `strings` (además de `grep`, etc.) permite encontrar fragmentos de texto.
- Para diffs binaria (compresión delta), usa `xdelta3`.
- Para convertir la codificación del texto, probar `iconv`. O `uconv` para uso más avanzado; este soporta algunos elementos Unicode avanzados. Por ejemplo, este comando coloca en minúsculas y remueve todas los acentos (por su expansión y colocándolos):
```sh
uconv -f utf-8 -t utf-8 -x '::Any-Lower; ::Any-NFD; [:Nonspacing Mark:] >; ::Any-NFC; ' < input.txt > output.txt
```
- Para dividir archivos en múltiples partes, consulta `split` (para dividir por tamaño) y `csplit` (para dividir por un patrón).
- Para manipular expresiones de fecha y tiempo, usa `dateadd`, `datediff`, `strptime` etc. de [`dateutils`](http://www.fresse.org/dateutils/).
- Usa `zless`, `zmore`, `zcat`, y `zgrep` para operar sobre archivos comprimidos.
## Depuración del sistema
- Para depuración web, `curl` y `curl -I` son prácticos, o como sus equivalentes `wget`, o el más moderno [`httpie`](https://github.com/jkbrzt/httpie).
- Para conocer el estado del cpu/disco, las clásicas herramientas son `top` (o mejor `htop`), `iostat`, y `iotop`. Usa `iostat -mxz 15` para CPU básicas y estadísticas detalladas y visión de rendimiento por partición del disco.
- Para detalles de la conexión de red, usa `netstat` y `ss`.
- Para una rápida visión general de que esta pasando en un sistema, `dstat` es especialmente útil. Para una visión general más amplia con detalles usa [`glances`](https://github.com/nicolargo/glances).
- Para conocer el estado de la memoria, ejecuta y entiende la salida de `free` y `vmstat`. En particular, ten en cuenta que el valor "cached" es mantenido en memoria por el kernel de Linux como un archivo de cache, por lo que efectivamente cuenta como valor para "free".
- El sistema de depuración de Java es harina de otro costal, pero un truco simple en las JSM de Oracle y otros consta en que puedes ejecutar `kill -3 <pid>` y una traza completa y un resumen del montículo "heap summary" (incluyendo del detalle de la colección de basura generacional, la cual puede ser altamente informativa) serán descargados al stderr/logs. Las herramientas `jps`, `jstat`, `jstack`, `jmap` del JDK son útiles. [SJK tools](https://github.com/aragozin/jvm-tools) son más avanzadas.
- Usa [`mtr`](http://www.bitwizard.nl/mtr/) como un mejor traceroute para identificar los problemas en la red.
- Para examinar por qué el disco está lleno, [`ncdu`](https://dev.yorhel.nl/ncdu) ahorra tiempo en comparación con los comandos usuales como `du -sh *`.
- Para encontrar cual socket o proceso está utilizando el ancho de banda, prueba [`iftop`](http://www.ex-parrot.com/~pdw/iftop/) o [`nethogs`](https://github.com/raboof/nethogs).
- La herramienta `ab` (viene con Apache) es útil para una verificación rápida del rendimiento de un servidor web. Para pruebas de carga más complejas prueba `siege`.
- Para una depuración mas seria de redes, [`wireshark`](https://wireshark.org/), [`tshark`](https://www.wireshark.org/docs/wsug_html_chunked/AppToolstshark.html), o [`ngrep`](http://ngrep.sourceforge.net/).
- Conoce acerca de `strace` y `ltrace`. Estas puede ser de utilidad si un programa está fallando, suspendido, o colgado, y no sabe por qué, o si quieres tener una idea general del rendimiento. Considera la opción de elaboración de perfiles (`-c`), y la habilidad de adjuntar a un proceso en ejecución (`-p`).
- Conoce acerca `ldd` para verificar librerías compartidas etc.
- Conoce como conectarse a un proceso en ejecución con `gdb` y obtener su traza de pilas.
- Usa `/proc`. Es extraordinariamente útil algunas veces cuando se depuran problemas en vivo. Ejemplos: `/proc/cpuinfo`, `/proc/xxx/cwd`, `/proc/meminfo`, `/proc/cmdline`, `/proc/xxx/exe`, `/proc/xxx/fd/`, `/proc/xxx/smaps` (donde `xxx` es el id o pid del proceso).
- Cuando se depura porque algo salió mal en el pasado, [`sar`](http://sebastien.godard.pagesperso-orange.fr/) puede ser muy útil. Este muestra la estadística histórica en CPU, memoria, red, etc.
- Para sistemas y análisis de rendimiento de mayor profundidad, examina `stap` ([SystemTap](https://sourceware.org/systemtap/wiki)), [`perf`](https://en.wikipedia.org/wiki/Perf_(Linux)), y [`sysdig`](https://github.com/draios/sysdig).
- Comprueba en que OS se encuentra con `uname` o `uname -a` (información general en Unix/kernel) o `lsb_release -a` (información en Linux distro).
- Usa `dmesg` siempre que algo actúe raro (esto podría ser problemas con el hardware o driver).
## One-liners
Algunos ejemplos de comandos reunidos:
- Es notablemente útil en ocasiones que pueda realizar intersección, unión, y diferencia de conjuntos de archivos de texto vía `sort`/`uniq`. Suponga que `a` y `b` como archivos de texto que son únicos. Esto es rápido, y trabaja con archivos de tamaño arbitrario, hasta varios gigabytes. (Sort no está limitado por la memoria, aunque quizás necesite utilizar la opción `-T` si `/tmp` está en una pequeña partición de raíz.) Consulta también la nota acerca de `LC_ALL` y las opciones de `sort`, `-u` (dejado de lado para clarificar más abajo).
```sh
cat a b | sort | uniq > c # c es a unido con b
cat a b | sort | uniq -d > c # c es a intersectado con b
cat a b b | sort | uniq -u > c # c es el conjunto diferencia a - b
```
- Usa `grep . *` para rápidamente examinar el contenido de todos los archivos de un directorio (para que cada línea este emparejada con con el nombre de archivo), o `head -100 *` (para que cada archivo tenga un encabezado). Esto puede se útil para directorios llenos con ajustes de configuración como aquellos en `/sys`, `/proc`, `/etc`.
- Sumar todos los números en la tercera columna de un archivo de texto (esto es probablemente 3 veces más rápido y 3 veces menos código que el equivalente en Python):
```sh
awk '{ x += $3 } END { print x }' miarchivo
```
- Consultar tamaños/fechas en un árbol de archivos, esto es como un `ls -l` recursivo pero es más fácil de leer que `ls -lR`:
```sh
find . -type f -ls
```
- Digamos que tiene un archivo de texto, como un log de un servidor web, y un cierto valor comienza a aparecer en algunas líneas, tales como un parámetro `acct_id` que está presente en la URL. Si quieres un recuento de cuantas peticiones por cada `acct_id`:
```sh
cat access.log | egrep -o 'acct_id=[0-9]+' | cut -d= -f2 | sort | uniq -c | sort -rn
```
- Para monitorear continuamente los cambios, usa `watch`, Ej. verificar los cambios de archivos en un directorio con `watch -d -n 2 'ls -rt1h | tail'` o para configuraciones de red mientras solucionas problemas con la configuración wifi `watch -d -n 2 ifconfig`.
- Ejecuta esta función para obtener un consejo aleatorio desde este documento (analiza el Markdown y extrae un elemento):
```sh
function taocl() {
curl -s https://raw.githubusercontent.com/jlevy/the-art-of-command-line/master/README.md |
pandoc -f markdown -t html |
xmlstarlet fo --html --dropdtd |
xmlstarlet sel -t -v "(html/body/ul/li[count(p)>0])[$RANDOM mod last()+1]" |
xmlstarlet unesc | fmt -80
}
```
## Obscuro, pero útil
- `expr`: ejecuta operaciones aritméticas o booleanas o evalúa expresiones regulares
- `m4`: procesador de macro sencillo
- `yes`: imprime un string sin fin
- `cal`: lindo calendario
- `env`: ejecuta un comando (útil en scripts)
- `printenv`: imprime las variables del entorno (útil en depuración y scripts)
- `look`: buscar palabras en inglés (o líneas en un archivo) comenzando con un string
- `cut`, `paste` y `join`: manipulación de datos
- `fmt`: formatea los párrafos de texto
- `pr`: formatea el texto en páginas/columnas
- `fold`: ajusta de líneas de texto
- `column`: formatea campos de texto alineados, en columnas de ancho fijo o tablas
- `expand` y `unexpand`: conversión entre tabuladores y espacios
- `nl`: agrega números de línea
- `seq`: imprime números
- `bc`: calculadora
- `factor`: factorización de enteros
- [`gpg`](https://gnupg.org/): encripta y firma archivos
- `toe`: tabla de información de términos
- `nc`: depuración de la red y transferencia de datos
- `socat`: socket relay y redireccionador de puerto tcp (similar a `netcat`)
- [`slurm`](https://github.com/mattthias/slurm): visualización del tráfico de red
- `dd`: moviliza datos entre archivos o dispositivos
- `file`: identifica el tipo de archivo
- `tree`: muestra directorios y subdirectorios como un árbol anidado; parecido a `ls` pero recursivo
- `stat`: información del archivo
- `time`: ejecuta y calcula el tiempo de ejecución de un comando
- `timeout`: ejecuta un comando especificando una cantidad de tiempo y deteniendo el proceso cuando la cantidad de tiempo especificado se completa.
- `lockfile`: crea un archivo semáforo que puedes solo ser removido con `rm -f`
- `logrotate`: rota, comprime y registra correos electrónicos.
- `watch`: ejecuta un comando repetidamente, mostrando resultados y/o resaltando cambios
- `tac`: imprime archivos en forma inversa
- `shuf`: selección aleatoria de líneas de un archivo
- `comm`: compara archivos ordenados línea por línea
- `pv`: monitorea el progreso de datos a través de un tubo
- `hd`, `hexdump`, `xxd`, `bview` y `bvi`: descarga o edita archivos binarios
- `strings`: extrae texto desde archivos binarios
- `tr`: traducción o manipulación de caracteres
- `iconv` o `uconv`: conversión de codificaciones de texto
- `split` y `csplit`: división de archivos
- `sponge`: lee todas las entradas antes de escribirlo, útil para vista previa y posterior escritura sobre el mismo archivo, Ej., `grep -v something some-file | sponge some-file`
- `units`: unidades de conversión y cálculos; convierte furlongs por fortnight a twips por blink (ver también `/usr/share/units/definitions.units`)
- `apg`: genera contraseñas aleatorias.
- `7z`: compresión de archivos de alto nivel
- `ldd`: información de librería dinámica
- `nm`: símbolos de archvios objeto
- `ab`: benchmarking de servidores web
- `strace`: depuración de llamadas del sistema
- [`mtr`](http://www.bitwizard.nl/mtr/): mejor traceroute para la depuración de la red
- `cssh`: shell concurrente visual
- `rsync`: sincronización de archivos y carpetas sobre SSH o en sistema de archivos locales
- [`wireshark`](https://wireshark.org/) y [`tshark`](https://www.wireshark.org/docs/wsug_html_chunked/AppToolstshark.html): captura de paquetes y depuración de la red
- [`ngrep`](http://ngrep.sourceforge.net/): grep para la capa de la red
- `host` y `dig`: consultas DNS
- `lsof`: descriptor de archivo de procesos e información de socket
- `dstat`: sistema de estadísticas útil
- [`glances`](https://github.com/nicolargo/glances): visión general de multi-subsistemas, de alto nivel
- `iostat`: estadísticas del uso del disco duro
- `mpstat`: estadísticas del uso del CPU
- `vmstat`: estadísticas del uso de la memoria
- `htop`: versión mejorada de top
- `last`: historial de login
- `w`: quién está autenticado
- `id`: información de identidad de usuario/grupo
- [`sar`](http://sebastien.godard.pagesperso-orange.fr/): estadísticas históricas del sistema
- [`iftop`](http://www.ex-parrot.com/~pdw/iftop/) o [`nethogs`](https://github.com/raboof/nethogs): utilización de la red por un socket o proceso
- `ss`: estadísticas de socket
- `dmesg`: mensajes de error del arranque y del sistema
- `sysctl`: examina y configura los parámetros de kernel de Linux en tiempo de ejecución
- `hdparm`: manipulación/rendimiento de discos SATA/ATA
- `lsblk`: lista de dispositivos de bloque: una vista tipo arbol de sus discos y particiones de disco
- `lshw`, `lscpu`, `lspci`, `lsusb`, `dmidecode`: información de hardware, incluyendo CPU, BIOS, RAID, gráficos, dispositivos, etc
- `lsmod` y `modinfo`: lista y muestra detalles de los módulos del kernel
- `fortune`, `ddate`, y `sl`: um, bien, depende de si considera las locomotoras de vapor y citas Zippy "útiles"
## Solo para OS X
Estos son puntos relevantes *únicamente* para OS X.
- Administración de paquetes con `brew` (Homebrew) y/o `port` (MacPorts). Estos pueden ser utilizados para instalar en OS X muchos de los comandos de arriba.
- Copie la salida de cualquier comando en una aplicación de escritorio con `pbcopy` y pegue una entrada con `pbpaste`.
- Para activar la tecla
gitextract_b6brm25b/
├── AUTHORS.md
├── CONTRIBUTING.md
├── README-cs.md
├── README-de.md
├── README-el.md
├── README-es.md
├── README-fr.md
├── README-id.md
├── README-it.md
├── README-ja.md
├── README-ko.md
├── README-pl.md
├── README-pt.md
├── README-ro.md
├── README-ru.md
├── README-sl.md
├── README-uk.md
├── README-zh-Hant.md
├── README-zh.md
├── README.md
└── admin/
└── authors-info.yml
Condensed preview — 21 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (716K chars).
[
{
"path": "AUTHORS.md",
"chars": 34969,
"preview": "# Authors\n\nThis work is the result of the effort of many people around the world.\nContributors are listed in alphabetica"
},
{
"path": "CONTRIBUTING.md",
"chars": 4764,
"preview": "## Contributing to The Art of Command Line\n\nThis guide is a [collaborative effort](AUTHORS.md), based on the generous wo"
},
{
"path": "README-cs.md",
"chars": 33194,
"preview": "🌍\n*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](READM"
},
{
"path": "README-de.md",
"chars": 43792,
"preview": "🌍\n*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](READM"
},
{
"path": "README-el.md",
"chars": 49490,
"preview": "🌍\n*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](READM"
},
{
"path": "README-es.md",
"chars": 37505,
"preview": "🌍\n*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](READM"
},
{
"path": "README-fr.md",
"chars": 49639,
"preview": "🌍\n*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](READM"
},
{
"path": "README-id.md",
"chars": 42127,
"preview": "🌍\n*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](READM"
},
{
"path": "README-it.md",
"chars": 34853,
"preview": "🌍\n*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](READM"
},
{
"path": "README-ja.md",
"chars": 25494,
"preview": "🌍\n*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](READM"
},
{
"path": "README-ko.md",
"chars": 28694,
"preview": "🌍\n*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](READM"
},
{
"path": "README-pl.md",
"chars": 48517,
"preview": "🌍\n*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](READM"
},
{
"path": "README-pt.md",
"chars": 27895,
"preview": "🌍\n*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](READM"
},
{
"path": "README-ro.md",
"chars": 40355,
"preview": "🌍\n*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](READM"
},
{
"path": "README-ru.md",
"chars": 39142,
"preview": "🌍\n*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](READM"
},
{
"path": "README-sl.md",
"chars": 42596,
"preview": "🌍\n*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](READM"
},
{
"path": "README-uk.md",
"chars": 35389,
"preview": "🌍\n*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](READM"
},
{
"path": "README-zh-Hant.md",
"chars": 18523,
"preview": "🌍\n*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](READM"
},
{
"path": "README-zh.md",
"chars": 23106,
"preview": "🌍\n*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](READM"
},
{
"path": "README.md",
"chars": 40803,
"preview": "🌍\n*[Čeština](README-cs.md) ∙ [Deutsch](README-de.md) ∙ [Ελληνικά](README-el.md) ∙ [English](README.md) ∙ [Español](READM"
},
{
"path": "admin/authors-info.yml",
"chars": 2882,
"preview": "# This file is used to configure the \"ghizmo assemble-authors\" command.\n\nheader: |\n This work is the result of the effo"
}
]
About this extraction
This page contains the full source code of the jlevy/the-art-of-command-line GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 21 files (687.2 KB), approximately 229.8k tokens. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.