string truncate

[spiralofhope]

This leverages string iteration in #17 to truncate a given string to a specified length.

string_truncate() {
  string_length_maximum="$1"
  shift
  string="$*"
  string_length=${#string}
  #
  if [ "$string_length" -le "$string_length_maximum" ]; then
    _debug  "  (not truncating)"
    \echo  "$string"
  else
    __="$string"
    #
    while [ -n "$__" ]; do
      rest="${__#?}"
      first_character="${__%"$rest"}"
      result="$result$first_character"
      __="$rest"
      #
      if [ ${#result} -eq "$string_length_maximum" ]; then
        \echo  "$result"
        break
      fi
    done
  fi
}



string_truncate  3  'string'
# =>
# str

[cmplstofB]

Would you let me know your opinion about this method?

string_truncate() {
    expr "$2" : '\(.\{'"$1"'\}\).*'
}

string_truncate  3  'string'
# =>
# str

[spiralofhope]

I personally wouldn't do things that way, because it's using expr.

[cmplstofB]

I'm sorry for asking so many times.
Are you reluctant to use expr because it's an external command?

[posguy99]

"The goal of this book is to document commonly-known and lesser-known methods of doing various tasks using only built-in POSIX sh features."

[notevenaperson]

I came up with an alternative solution that is, simply stacking the match-one-character wildcard ? as many times as the number of characters we want to delete. It's dumb but works.

   s='string'
echo ${s%???}
# =>
# str
      a='abcdefg'
echo ${a#?????}
# => fg

trunc() {
	local desired_len="$1" ; shift ; local string="$*" 
	local len="${#string}" ques ques_len

	[ "$desired_len" -ge "$len" -o "$((- desired_len))" -ge "$len" -o "$desired_len" = 0 ] \
		&& { echo "$string" ; return 1 ; } #Error: Function has no work to do if desired length is larger or = string length

	if [ "$desired_len" -gt 0 ]; then #test if desired_len is a negative number
		local left_len="$desired_len"
		local right_len="$((len - left_len))" 
	else #inverse our desired lengths
		local right_len="$((- desired_len))" 
		local left_len="$((len - right_len))"
	fi

	while true; do
		ques="$ques"'?'
		ques_len="${#ques}"
		if [ "$ques_len" = "$right_len" ]; then #delete end to get the truncated string
			truncated="${string%$ques}" #fun fact: this doesn't work in zsh
			break
		fi
		if [ "$ques_len" = "$left_len" ]; then #
			local rest="${string#$ques}" #fun fact: this doesn't work in zsh
			truncated="${string%%$rest}"
			break
		fi
	done
	echo "$truncated"
}

This solution iterates on adding more ???? until it matches the closest desired length, then trims the string at once. It may be faster than @spiralofhope's solution, which reads $string at least once on every iteration, slowly biting off characters just to be able to delete them.

Demo

trunc 19 'The brown fox jumps over the lazy dog'
# => The brown fox jumps
trunc -1 'The brown fox jumps over the lazy dog' # also added support for truncating counting from the end
# => The brown fox jumps over the lazy do
trunc -17 'The brown fox jumps over the lazy dog'
# => The brown fox jumps 

[notevenaperson]

I made a faster and powerful version a week later, but forgot to post it. Down to the syntax, it emulates Bash's substring expansion.

#Usage: substr offset:length "string"

rpt() { 
	#repeat string N times
	#$ rpt 50 "foobar"

	#algorithm snatched from: https://stackoverflow.com/questions/202605/repeat-string-javascript/4152613#4152613
	#See also: https://en.wikipedia.org/wiki/Ancient_Egyptian_multiplication
	#basically, it doubles $str at the same rate $count halves, spiraling down synchronously to the asked length.
	#i had the intuition that an algorithm must be faster than just doing 50 iterations to get 50 length.
	#multiplication could save some iterations, but i had to be careful to not overshoot. it wasn't this elegant.


	count="$1" ; shift ; s="$*"

	while [ $count -gt 1 ];do 
		[ $((count & 1)) -eq 1 ] && result="$result""$s"
		count=$((count >> 1)) 
		s="$s""$s"
	done

	#junk below isn't necessary as a standalone function
	repeated="$result""$s"
	unset count s result
}

substr() {
	#Parse
	if [ -z "${1##*:*}" ]; then #result is only empty if there isn't a ':'
		offset="${1%%:*}"
		desired_len="${1##*:}"
	else
		offset="$1"
	fi
	shift; str="$*" 

	len="${#str}"


	[ "$offset" -ge "$len" ] || [ "$((-offset))" -ge "$len" ] && return 1 #bad input

	[ "$offset" = 0 ] || {
		#"If offset evaluates to a number less than zero, the value is used as an offset in characters from the end of the value" 
		[ "$offset" -lt 0 ] && offset=$((len - -offset))
		rpt "$offset" '?'
		str="${str#$repeated}"
	}


	# Below only gets executed if user specified a length
	[ "$desired_len" ] || { echo "$str" ; return 0 ; }
	

	[ "$desired_len" -ge "$len" ] || [ "$((- desired_len))" -ge "$len" ] || [ "$desired_len" = 0 ] \
		&& { echo "$str" ; return 1 ; } #Error: Function has no work to do if desired length is > or = str length

	if [ "$desired_len" -gt 0 ]; then #test if desired_len is a negative number
		left_len="$desired_len"
		right_len="$((len - left_len))" 
	else #inverse our desired lengths
		right_len="$((- desired_len))" 
		left_len="$((len - right_len))"
	fi

	#decide which trimming direction is faster
	if [ "$right_len" -lt "$left_len" ]; then 
		rpt "$right_len" '?'
		truncated="${str%$repeated}" #fun fact: this doesn't work in zsh
	elif [ "$left_len" -lt "$right_len" ]; then
		rpt "$left_len" '?'
		rest="${str#$ques}"
		truncated="${str%%$repeated}"
	else #not necessary, but readability, bro.
		rpt "$right_len" '?'
		truncated="${str%$repeated}"
	fi

	echo "$truncated"
}