compsci-missing_semester_2020/_subsections/lesson-02.org

lesson 02 | course overview + the shell

• Links
  • timestamps
• Notes
  • bash
    • spaces are critical with bash
    • quotes
  • sequential execution
    • bash functions
    • source
  • error codes
    • commands to access codes or values
    • code values
  • using $@ and $*
    • key points about $@
    • example
    • differences between $*
  • logical operators
    • example using the OR conditional
    • example using the AND conditional
  • concatenate commands
  • common substitution
  • process substitution
    • description
    • Syntax
    • examples
  • test utility
  • curly braces
    • example
    • ranges
  • python scripts
    • making them bash executable
    • args can be found through sys.argv[1:]
  • checking for problems in bash scripts using 'shellcheck'
  • man command
  • find
    • grep
    • ripgrep
      • Key Features of rg (ripgrep):
      • basic command structure
    • other alternatives
  • fuzzy finder

Links

• TOC | Missing Semester
• Playlist: Missing Semester
• Curr: https://youtu.be/kgII-YWo3Zw?si=Wm8KLT1ggOGG8W-g&t=1692

timestamps

• 00:54 - control flow functions
• 03:47 - sequential execution
• 07:05 - standard input
• 07:24 - error code
• 08:37 - logical operators
• 10:03 - concatenate commands
• 10:45 - common substitution
• 11:15 - process substitution
• 15:35 - comparison operator
• 19:33 - curly braces
• 22:39 - python script
• 28:27 - man command
• 31:26 - finding files
• 36:30 - grep
• 42:53 - fuzzy finder current
• 44:09 - history substring search

Notes

bash

spaces are critical with bash

• this works:

foo=bar
echo $foo

• this doesn't:

foo = bar
echo $foo

• the output of that will be zsh: command not found: foo
• what happens in the above example is that we are effectively calling the "foo" program with the arguments: "=" and "bar"

quotes

• you can use double or single quotes to print a value

  echo "Hello"

  echo 'Hello'

• double quotes can interpolate variables

  echo "Value is $foo"

  will return: Value is bar

• single quotes can NOT interpoloate variables

  echo 'Value is $foo'

  will return: Value is $foo

sequential execution

bash functions

• mcd.sh

mcd() {
        mkdir -p "$1"
        cd "$1"
        }

• creates a function that can be executed after loading

  • $1 is a global variable referring to the first parameter

source

• using source mcd.sh source mcd.sh
• then carry out the function mcd testdir
• this will create a new directory and cd into it as per the definied functioned

error codes

commands to access codes or values

• $0 – name of the script we are currently in

  • if you run this in the shell it will display 'bash'
• $1->$9 – the first through ninth argument given to a script
• $? – the last error message
• $_ — last argument of the previous call

• !! – recreates the last call with it's arguments

  • use with sudo if you found your call needed a sudo and you don't feel like retyping it again

  ls -lah
  sudo !!

code values

• boolean

  • true returns an error code of 0
  • false returns an error code of 1

using $@ and $*

• represents all the arguments passed to a script or a function as separate, individual strings. It preserves each argument as a distinct item, even if the argument contains spaces.

key points about $@

1. All Arguments: It refers to all the command-line arguments passed to the script.
2. Preserves Spaces: If an argument contains spaces, it is treated as a single argument.
3. Usage: It is commonly used in a loop to iterate over each argument.

example

./myscript.sh file1.txt "file with spaces.txt" file3.txt

then $@ will be file1.txt "file with spaces.txt" file3.txt

differences between $*

• $@ treats each argument as a sepearte item
• $* treats all arguments as a single, combined string

logical operators

• you can use the error return value in conditionals

example using the OR conditional

false || echo "Oops fail"
"Oops fail"

example using the AND conditional

true && echo "this will print"
"this will print"

concatenate commands

• you caoncatinate commands using the semicolon: ;

  false; echo "this prints always"
  "this prints always"

common substitution

• take the output of a command and put it in a variable

  foo=$(pwd)
  echo $foo
  "/Users/ronny/..."

• this can also be done by placing that format in a string and it will expand the string

  echo "the pwd output is: $(pwd)"
  "the pwd output is: /Users/ronny/..."

process substitution

description

Bash process substitution is a feature that allows you to use the output of a command or a process as if it were a file. It enables you to redirect input or output between processes in a flexible way without needing intermediate temporary files.

Syntax

• creates a temporary file descriptor for the output of the command, which can be used as an input file in another command.

   <(command)

• creates a temporary file descriptor for writing to the command, which can be used as an output file in another command.

   >(command)

examples

• this will take b, a, d, c and sort it so the result is 'a, b, c, d'

  sort <(echo -e "b\na") <(echo -e "d\nc")

• this will list the files, send the list to tee which will split a portion off to the screen and the rest to grep, followed by text_files.txt

  ls | tee >(grep "txt" > text_files.txt)

echo "Starting program at $(date)" # Date will be substituted
echo "Running program $0 with $# arguments with pid $$"

for file in "$@"; do
    grep foobar "$file" > /dev/null 2> /dev/null

    # when pattern is not found, grep has exit status 1
    # we redirect STDOUT and STDERR to a null register since we do not care about them

    if [[ "$?" - ne 0 ]]; then
        echo "File $file does not have any foober adding one"
        echo "# foobar" >> "$file"
     fi
done

• $$ pid given for program
• $# number of arguments

• $@ expands to all the arguments

  • can be used in a for loop
• 2> refers to STDERR
• > refers to STDOUT

test utility

test is a bash utility that you can use to test the condition of a file. look at the man page for more info

curly braces

curly braces are used as a form of program command expansion.

the braces contain a number of arguments seperated by commans that will expand into arguments for the program

example

touch foo{,1,2,10}
touch foo foo1 foo2 foo10

cp foo{,.old}
cp foo foo.old

ranges

this takes the format {1..20}

touch directory{1..4}/foo{a..z}.txt

python scripts

making them bash executable

• reference the python compiler at the top of the file

  • do it directly:

     #!/usr/local/bin/python

  • use the env program to do so

      #!/usr/bin/env python

args can be found through sys.argv[1:]

import sys
for arg in reversed(sys.argv[1:]):
  print(arg)

checking for problems in bash scripts using 'shellcheck'

shellcheck some_bash_script.sh

• will tell you problems
• and warnings

man command

• works with both os, and installed tools
• 'tldr' is easier to read

find

grep

• grep TEXT-TO-FIND LOCATION

• this will recursively go through all files in a directory looking for "TEXT"

  grep -R  TEXT .

ripgrep

Key Features of rg (ripgrep):

• Faster than grep (built with Rust and optimized for performance).
• Ignores files listed in .gitignore by default.
• Supports recursive searches automatically.
• Better default output formatting.
• Supports regex matching like grep -E.
• Multithreaded searching for better performance on modern CPUs.

basic command structure

• search recursively through all files for text

  rg "text"

• case insensitive search

  rg -i "text"

• show line numbers

  rg -n "text"

• search files of the pattern shown

  rg "text" --glob "*.txt"

• search through files that are classified under the type given

  • pattern example

    rg "text" -t txt

  • for example type 'txt' would search for

    • txt
    • md
    • rst
  • if you want to see the type list use

  rg --type-list

• ask for a specified number of lines of context around search match

  rg "text" -C 3

• dont ignore hidden files

  rg "text" -u

• add stats to search

  rg "text" --stats

other alternatives

• ack
• ag

fuzzy finder