logo

EbookBell.com

Most ebook files are in PDF format, so you can easily read them using various software such as Foxit Reader or directly on the Google Chrome browser.
Some ebook files are released by publishers in other formats such as .awz, .mobi, .epub, .fb2, etc. You may need to install specific software to read these formats on mobile/PC, such as Calibre.

Please read the tutorial at this link:  https://ebookbell.com/faq 


We offer FREE conversion to the popular formats you request; however, this may take some time. Therefore, right after payment, please email us, and we will try to provide the service as quickly as possible.


For some exceptional file formats or broken links (if any), please refrain from opening any disputes. Instead, email us first, and we will try to assist within a maximum of 6 hours.

EbookBell Team

The Ultimate Linux Shell 1st Edition by Donald A Tevault ISBN 1835463576 9781835463574

  • SKU: BELL-200672196
The Ultimate Linux Shell 1st Edition by Donald A Tevault ISBN 1835463576 9781835463574
$ 31.00 $ 45.00 (-31%)

5.0

108 reviews

The Ultimate Linux Shell 1st Edition by Donald A Tevault ISBN 1835463576 9781835463574 instant download after payment.

Publisher: Packt Publishing
File Extension: EPUB
File size: 12.49 MB
Author: Donald A. Tevault
Language: English
Year: 2024

Product desciption

The Ultimate Linux Shell 1st Edition by Donald A Tevault ISBN 1835463576 9781835463574 by Donald A. Tevault instant download after payment.

The Ultimate Linux Shell 1st Edition by Donald A Tevault - Ebook PDF Instant Download/Delivery: 1835463576, 9781835463574
Full download The Ultimate Linux Shell 1st Edition after payment

Product details:

ISBN 10: 1835463576 
ISBN 13: 9781835463574
Author: Donald A Tevault

Master Linux Shells – Your Complete Guide to Practical Success with Bash, Zsh, PowerShell

Key Features
Develop portable scripts using Bash, Zsh, and PowerShell that work seamlessly across Linux, macOS, and Unix systems
Progress seamlessly through chapters with clear concepts, practical examples, and hands-on labs for skill development
Build real-world Linux administration scripts, enhancing your troubleshooting and management skills
Book Description
Dive into the world of Linux shell scripting with this hands-on guide. If you’re comfortable using the command line on Unix or Linux but haven’t fully explored Bash, this book is for you. It’s designed for programmers familiar with languages like Python, JavaScript, or PHP who want to make the most of shell scripting. This isn’t just another theory-heavy book—you’ll learn by doing. Each chapter builds on the last, taking you from shell basics to writing practical scripts that solve real-world problems. With nearly a hundred interactive labs, you’ll gain hands-on experience in automation, system administration, and troubleshooting. While Bash is the primary focus, you'll also get a look at Z Shell and PowerShell, expanding your skills and adaptability. From mastering command redirection and pipelines to writing scripts that work across different Unix-like systems, this book equips you for real-world Linux challenges. By the end, you'll be equipped to write efficient shell scripts that streamline your workflow and improve system automation.
What you will learn
Grasp the concept of shells and explore their diverse types for varied system interactions
Master redirection, pipes, and compound commands for efficient shell operations
Leverage text stream filters within scripts for dynamic data manipulation
Harness functions and build libraries to create modular and reusable shell scripts
Explore the basic programming constructs that apply to all programming languages
Engineer portable shell scripts, ensuring compatibility across diverse platforms beyond Linux
Who this book is for
This book is for programmers who use the command line on Unix and Linux servers already, but don't write primarily in Bash. This book is ideal for programmers who've been using a scripting language such as Python, JavaScript or PHP, and would like to understand and use Bash more effectively. It’s also great for beginning programmers, who want to learn programming concepts.

The Ultimate Linux Shell 1st Table of contents:

  1. Who this book is for
  2. What this book covers
  3. To get the most out of this book
  4. Get in touch
  5. Getting Started with the Shell
  6. Understanding Shells
  7. Finding Help with Shell Commands
  8. Understanding Manual Pages
  9. Understanding Info Pages
  10. Getting to Know the Linux Documentation Project
  11. Using Your Favorite Search Engine
  12. Using a Text Editor to Create Shell Scripts
  13. Text-mode Editors
  14. GUI Text Editors
  15. Understanding Compiled versus Interpreted Programming
  16. Understanding root and sudo Privileges
  17. Summary
  18. Questions
  19. Further Reading
  20. Answers
  21. Join our community on Discord!
  22. Interpreting Commands
  23. Understanding the Structure of a Command
  24. Using Command Options
  25. Hands-on Lab – Practice With Command Options
  26. Using Command Arguments
  27. Executing Multiple Commands at Once
  28. Running Commands Interactively
  29. Using Command Sequences
  30. Chaining Commands with a Semi-Colon
  31. Conditional Command Execution with Double Ampersands
  32. Conditional Command Execution with Double Pipes
  33. Using the find Utility
  34. Performing Multiple Actions with find
  35. Hands-on Lab – Using find to Perform Other Commands
  36. Running Commands Recursively
  37. Hands-on Lab – Using Commands with Recursion
  38. Understanding the Command History
  39. Escaping and Quoting
  40. Escaping Metacharacters
  41. Quoting
  42. Summary
  43. Questions
  44. Further Reading
  45. Answers
  46. Join our community on Discord!
  47. Understanding Variables and Pipelines
  48. Understanding Environmental Variables
  49. Understanding Programming Variables
  50. Understanding Pipelines
  51. Summary
  52. Questions
  53. Further Reading
  54. Answers
  55. Join our community on Discord!
  56. Understanding Input/Output Redirection
  57. Introduction to Input/Output Redirection
  58. Understanding stdout
  59. Preventing File Overwrites
  60. Using the File Descriptor
  61. Understanding stdin
  62. Understanding stderr
  63. Understanding tee
  64. Hands-on Lab – Pipes, Redirectors, and find
  65. Summary
  66. Questions
  67. Further Reading
  68. Answers
  69. Join our community on Discord!
  70. Customizing the Environment
  71. Technical Requirements
  72. Reviewing the Environmental Variables
  73. Understanding Shell Sessions
  74. Understanding the Configuration Files
  75. bash Global Configuration Files on Fedora
  76. Users’ Configuration Files on Fedora
  77. bash Global Configuration Files on Debian
  78. Users’ Configuration Files on Debian
  79. Setting the Default Editor on Debian
  80. Setting Shell Options from the Command-line
  81. Understanding Aliases
  82. Summary
  83. Questions
  84. Further Reading
  85. Answers
  86. Join our community on Discord!
  87. Text-Stream Filters – Part 1
  88. Technical Requirements
  89. Introduction to Text-Stream Filters
  90. Using cat
  91. Using tac
  92. Using cut
  93. Using paste
  94. Using join
  95. Using sort
  96. Summary
  97. Questions
  98. Further Reading
  99. Answers
  100. Join our community on Discord!
  101. Text Stream Filters – Part 2
  102. Technical Requirements
  103. Using expand
  104. Using unexpand
  105. Using nl
  106. Using head
  107. Using tail
  108. Using Head And Tail Together
  109. Using od
  110. Using uniq
  111. Using wc
  112. Using fmt
  113. Using split
  114. Using tr
  115. Using xargs
  116. Using pr
  117. Printing from the Command-line
  118. Summary
  119. Questions
  120. Further Reading
  121. Answers
  122. Join our community on Discord!
  123. Basic Shell Script Construction
  124. Technical Requirements
  125. Understanding Basic Shell Script Construction
  126. Hands-on Lab – Counting Logged-in Users
  127. Performing Tests
  128. Using the test Keyword
  129. Enclosing a test Condition Within Square Brackets
  130. Using an if. . .then Construct
  131. Using Other Types of Tests
  132. Understanding Subshells
  133. Hands-on Lab – Testing Conditions
  134. Understanding Scripting Variables
  135. Creating and Deleting Variables
  136. Understanding Variables and Shell Levels
  137. Understanding Case Sensitivity
  138. Understanding Read-Only Variables
  139. Understanding Array Variables
  140. Hands-on Lab – Using Arrays
  141. Understanding Variable Expansion
  142. Substituting a Value for an Unset Variable
  143. Substituting a Value for a Set Variable
  144. Assigning a Value to a Variable
  145. Displaying an Error Message
  146. Using Variable Offsets
  147. Matching Patterns
  148. Understanding Command Substitution
  149. Understanding Decisions and Loops
  150. The if. .then Construct
  151. The do. . while construct
  152. The for..in Construct
  153. The for Construct
  154. Using break
  155. Using continue
  156. The until Construct
  157. The case Construct
  158. Using Positional Parameters
  159. Understanding Exit Codes
  160. Standard Shell Exit Codes
  161. User-defined Exit Codes
  162. More Information About echo
  163. Looking at Some Real-World Examples
  164. Hands-on Lab: Using if..then
  165. Hands-on Lab – Parsing an Apache Access Log
  166. Hands-on Lab – Beta Testing a Hard Drive
  167. Summary
  168. Questions
  169. Further Reading
  170. Answers
  171. Join our community on Discord!
  172. Filtering Text with grep, sed, and Regular Expressions
  173. Technical Requirements
  174. Understanding Regular Expressions
  175. Literals and Metacharacters
  176. Understanding sed
  177. Understanding sed Portability Issues
  178. Installing gsed on FreeBSD
  179. Installing gsed on macOS
  180. Installing gsed on OpenIndiana
  181. Substitution with sed
  182. Example 1: Modifying an Office Memo
  183. Example 2: Modifying a List of Hollywood Actors
  184. Example 3: Modifying Lists of Cars
  185. Example 4: Performing a Whole-Word Substitution
  186. Deletion with sed
  187. Example 1: Deleting Items from a List
  188. Example 2: Deleting Blank Lines
  189. Appending and Inserting with sed
  190. Example 1: Appending Lines of Text
  191. Example 2: Performing Multiple Operations at Once
  192. Example 3: Inserting Lines of Text
  193. Changing with sed
  194. Example 1: Changing Edsel to Studebaker
  195. Example 2: Changing Entire Lines of Text
  196. Other Miscellaneous sed tricks
  197. Example 1: Using the q Command
  198. Example 2: Using the w Command
  199. Example 3: Using the r Command
  200. Using sed program files
  201. Example 1: Appending Lines in a Text File
  202. Example 2: Changing Lines in a Text File
  203. Example 3: Substituting Text
  204. Example 4: Copying Lines from One File to Another
  205. Compound Scripts in sed Program Files
  206. Using sed in Shell Scripts
  207. Understanding grep
  208. Basic Searches with grep
  209. More Advanced Searches with grep
  210. Example 1: Searching for Whole Words
  211. Even More Advanced Searches with grep
  212. Example 1: Auditing Source Code Files
  213. Example 2: Searching for Social Security Numbers
  214. Example 3: Using the ^ Metacharacter
  215. Using Extended Regular Expressions with grep
  216. Example 1: Basic Search with Extended Syntax
  217. Example 2: Searching for Consecutive Duplicate Words
  218. Example 3: Searching for Words that Begin with a Certain Letter
  219. Example 4: Searching for Words with Digits
  220. Using Fixed-strings Regular Expressions with grep
  221. Using RegEx Helper Programs
  222. RegexBuddy and RegexMagic
  223. Regex101
  224. Looking at Some Real-World Examples
  225. Modifying Multiple Files at Once
  226. Searching Through Apache Webserver Logs for Cross-site Scripting Attacks
  227. Automating Third-party Repository Installations
  228. Filling Empty Fields in a .csv File
  229. Summary
  230. Questions
  231. Further Reading
  232. Answers
  233. Join our community on Discord!
  234. Understanding Functions
  235. Technical Requirements
  236. Introduction to Functions
  237. Defining a Function
  238. Using Functions in Shell Scripts
  239. Creating and Calling Functions
  240. Passing Positional Parameters to Functions
  241. Passing Values from a Function
  242. Creating Function Libraries
  243. Looking at Some Real-World Examples
  244. Checking Network Connectivity
  245. Using the CoinGecko API
  246. Hands-on Lab – Creating the coingecko.sh Script
  247. Summary
  248. Questions
  249. Further Reading
  250. Answers
  251. Join our community on Discord!
  252. Performing Mathematical Operations
  253. Technical Requirements
  254. Performing Integer Math with Expressions
  255. Using the expr Command
  256. Using echo with Math Expressions
  257. Performing Integer Math with Integer Variables
  258. Performing Floating Point Math with bc
  259. Using bc in Interactive Mode
  260. Using bc Program Files
  261. Using bc in Shell Scripts
  262. Summary
  263. Questions
  264. Further Reading
  265. Answers
  266. Join our community on Discord!
  267. Automating Scripts with here Documents and expect
  268. Technical Requirements
  269. Using here Documents
  270. Creating here Documents with Static Data
  271. Creating here documents with Dynamic Data
  272. Using Functions in here Documents
  273. Automating Responses with expect
  274. Security Implications with expect
  275. Summary
  276. Questions
  277. Further Reading
  278. Answers
  279. Join our community on Discord!
  280. Scripting with ImageMagick
  281. Technical Requirements
  282. Converting Non-standard Filename Extensions
  283. Installing ImageMagick
  284. Displaying Images
  285. Viewing Image Properties
  286. Resizing and Customizing Images
  287. Batch-processing Image Files
  288. Using Fred’s ImageMagick Scripts
  289. Summary
  290. Questions
  291. Further Reading
  292. Answers
  293. Join our community on Discord!
  294. Using awk – Part 1
  295. Introducing awk
  296. Understanding Patterns and Actions
  297. Obtaining Input from Text Files
  298. Looking for Human Users
  299. Parsing Webserver Access Logs
  300. Using Regular Expressions
  301. Obtaining Input from Commands
  302. Summary
  303. Questions
  304. Further Reading
  305. Answers
  306. Join our community on Discord!
  307. Using awk – Part 2
  308. Technical Requirements
  309. Basic awk Script Construction
  310. Using Conditional Statements
  311. Using a while Construct and Setting Variables
  312. Summing Numbers in a Line
  313. Finding the CPU Generation
  314. Using for loops and Arrays
  315. Using Floating Point Math and printf
  316. Working with Multi-Line Records
  317. Summary
  318. Questions
  319. Further Reading
  320. Answers
  321. Join our community on Discord!
  322. Creating User Interfaces with yad, dialog, and xdialog
  323. Technical Requirements
  324. Creating a Graphical User Interface with yad
  325. The yad Basics
  326. Creating Data Entry Forms
  327. Creating a Drop-down List
  328. Using the yad File Manager
  329. Creating a File Checksum Utility
  330. Creating a GUI Front-end for ImageMagick
  331. Programming Form Buttons
  332. Some Final Thoughts about yad
  333. Creating User Interfaces with dialog and xdialog
  334. The dialog Basics
  335. The xdialog Basics
  336. Automatically Choosing Either dialog or xdialog
  337. Adding Widgets
  338. Creating an SSH Login Interface
  339. Summary
  340. Questions
  341. Further Reading
  342. Answers
  343. Join our community on Discord!
  344. Using Shell Script Options with getops
  345. Technical Requirements
  346. Understanding the Need for getopts
  347. Understanding getopt versus getopts
  348. Using getopts
  349. Looking at Real-world Examples
  350. The Modified Coingecko Script
  351. The Tecmint Monitor Script
  352. Summary
  353. Questions
  354. Further Reading
  355. Answers
  356. Join our community on Discord!
  357. Shell Scripting for Security Professionals
  358. Technical Requirements
  359. Simple Scripts for Auditing
  360. Identifying an Operating System
  361. A Simple Port-scanning Script
  362. Auditing the root User Account
  363. Creating the root Account Auditing Script for Linux and OpenIndiana
  364. Modifying the root Account Auditing Script for Use on FreeBSD
  365. Creating a User Activity Monitoring Script
  366. Creating Simple Firewall Scripts
  367. Creating an IP Address Blocking Script for Red Hat Distros
  368. Hands-on Lab: Create the Script with an Array and a for loop
  369. Hands-on Lab: Creating the Script with xargs
  370. Searching for Existing Security-related Scripts
  371. Summary
  372. Questions
  373. Further Reading
  374. Answers
  375. Join our community on Discord!
  376. Shell Script Portability
  377. Technical Requirements
  378. Running bash on Non-Linux Systems
  379. Using env to Set the bash Environment
  380. Creating a Symbolic Link to bash
  381. Understanding POSIX compliance
  382. Understanding the Differences Between Shells
  383. Understanding Bashisms
  384. Using Portable Tests
  385. Making Portable Arrays
  386. Understanding Portability Problems with echo
  387. Testing Scripts for POSIX Compliance
  388. Creating Scripts on a POSIX-compliant Shell
  389. Using checkbashisms
  390. Using shellcheck
  391. Specifying a Shell with the -s Option
  392. Hands-on Lab – Using -s to Scan Function Libraries
  393. Using shall
  394. Summary
  395. Questions
  396. Further Reading
  397. Answers
  398. Join our community on Discord!
  399. Shell Script Security
  400. Technical Requirements
  401. Controlling Access to Your Scripts
  402. Assigning sudo Privileges
  403. Hands-on Lab ­– Configuring sudo
  404. Using an Access Control List
  405. Hands-on Lab – Setting an ACL for Horatio on Linux
  406. Hands-on Lab – Setting an ACL for Horatio on FreeBSD 14
  407. Hands-on Lab – Setting an ACL for Horatio on OpenIndiana
  408. Obfuscating Plain-Text Scripts
  409. Installing shc
  410. Hands-on Lab – Using shc
  411. Hands-on Lab – Creating Untraceable Executables
  412. Decrypting shc Binaries
  413. Understanding SUID and SGID Considerations
  414. Avoiding Sensitive Data Leakage
  415. Securing Temporary Files
  416. Understanding the /tmp/ Directory
  417. The Wrong Way to Create Temporary Files
  418. The Right Way to Create Temporary Files
  419. Using Passwords in Shell Scripts
  420. Hands-on Lab – Encrypting Passwords
  421. Understanding Command Injection with eval
  422. Using eval on the Command-line
  423. Using eval Safely
  424. Using eval Dangerously
  425. Using Alternatives to eval
  426. Using Command Substitution
  427. Evaluating if eval is Necessary
  428. Understanding Path Security
  429. Attack Scenario 1: Compromising the User’s Account
  430. Attack Scenario 2: Social Engineering
  431. Summary
  432. Questions
  433. Further Reading
  434. Answers
  435. Join our community on Discord!
  436. Debugging Shell Scripts
  437. Technical Requirements
  438. Understanding Common Scripting Errors
  439. Not Enough Quoting
  440. Filenames with Blank Spaces
  441. Problems with Unset Variables
  442. Creating a Wild Loop
  443. Using Shell Script Debugging Tools and Techniques
  444. Using echo Statements
  445. Using xtrace for Debugging
  446. Checking for Undefined Variables
  447. Checking for Errors with the -e Option
  448. Understanding the Problems with set -e and -e
  449. Using bash Debugger
  450. Installing bashdb on Linux
  451. Installing bashdb on FreeBSD
  452. Installing on macOS
  453. Debugging a Script with bashdb
  454. Getting Help with bashdb
  455. Summary
  456. Questions
  457. Further Reading
  458. Answers
  459. Join our community on Discord!
  460. Introduction to Z Shell Scripting
  461. Technical Requirements
  462. Introducing zsh
  463. Installing zsh
  464. Understanding the Unique Features of zsh Scripting
  465. Differences in Variable Expansion
  466. Substituting Values
  467. Substituting Substrings
  468. Translating Between Upper and Lower Case
  469. Extended File Globbing
  470. Understanding zsh Arrays
  471. Enhanced Math Capabilities
  472. Using zsh Modules
  473. Using the mathfunc Module
  474. The datetime Module
  475. Summary
  476. Questions
  477. Further Reading
  478. Answers
  479. Join our community on Discord!
  480. Using PowerShell on Linux
  481. Technical Requirements
  482. Installing PowerShell on Linux and macOS
  483. Installing PowerShell on Linux via a snap Package
  484. Installing PowerShell on Fedora
  485. Installing PowerShell on macOS
  486. Invoking PowerShell
  487. Reasons for Linux and Mac Admins to Learn PowerShell
  488. Working with Mixed Operating System Environments
  489. PowerShell Commands Can Be Simpler
  490. Enhanced Builtin Math Capabilities
  491. Differences Between PowerShell Scripting and Traditional Linux/Unix Scripting
  492. Using Filename Extensions and the Executable Permission
  493. PowerShell is Object-oriented
  494. PowerShell Uses Cmdlets
  495. Using Aliases on PowerShell
  496. Viewing the Available PowerShell Commands
  497. Getting Help with PowerShell Commands
  498. Real-World Cross-Platform PowerShell Scripts
  499. The write-marquee.ps1 Script

People also search for The Ultimate Linux Shell 1st:

the ultimate linux shell scripting guide packt
    
the ultimate linux shell scripting guide pdf free download
    
the ultimate linux shell scripting guide download
    
the ultimate linux shell scripting guide by donald a tevault
    
the ultimate linux newbie guide

 

 

Tags: Donald A Tevaultt, Linux, Shell

Related Products