In your specific case you can use the following bash command (bash is the default shell on macOS):

for f in *.png; do echo mv "{f/_*_/_}"; done

^{Note: If there's a chance that your filenames start with -, place -- before them[1]:
mv -- "{f/_*_/_}"}

Note: echo is prepended to mv so as to perform a dry run. Remove it to perform actual renaming.

You can run it from the command line or use it in a script.

• "${f/_*_/_}" is an application of bash parameter expansion: the (first) substring matching pattern _*_ is replaced with literal _, effectively cutting the middle token from the name.
• Note that _*_ is a pattern (a wildcard expression, as also used for globbing), not a regular expression (to learn about patterns, run man bash and search for Pattern Matching).

If you find yourself batch-renaming files frequently, consider installing a specialized tool such as the Perl-based rename utility. On macOS you can install it using popular package manager Homebrew as follows:

brew install rename

Here's the equivalent of the command at the top using rename:

rename -n -e 's/_.*_/_/'  *.png

Again, this command performs a dry run; remove -n to perform actual renaming.

• Similar to the bash solution, s/.../.../ performs text substitution, but - unlike in bash - true regular expressions are used.

^{[1] The purpose of special argument --, which is supported by most utilities, is to signal that subsequent arguments should be treated as operands (values), even if they look like options due to starting with -, as Jacob C. notes.}

First, do a dry run (will not actually rename any files) with the following:

for file in *.mov
do
  echo mv "$file" "${file/MP4./}"
done

If it all looks fine, remove the echo from the third line to actually rename the files.

Try something like this:

 for file in Picture*.jpg
 do
    mv "$file" "vacation-$file"
 done  

(open terminal and add one line {press Enter} at a time.)

What that does is uses the variable file for each entry matching Picture*.jpg. Then it takes the file or folder and moves it to be prefixed with "vacation".

Hope that helps

In zsh, from within the directory that contains those files, you'd run:

autoload -Uz zmv
zmv -n '*_ \((<0-999>)\)(* )—( * )(<1-12>)_(<1-31>)_(<1900-2100>)(.mp3)' \
       '2-6-{(l[2][0])4}-0900$7'

Example:

$ autoload -Uz zmv
$ zmv -n '*_ \((<0-999>)\)(* )—( * )(<1-12>)_(<1-31>)_(<1900-2100>)(.mp3)' \
         '2-6-{(l[2][0])4}-0900$7'
mv -- 'Public Talks_ (189) Walking With God Brings Blessings Now and Forever — Chris Ruscher 10_28_2023.mp3' '189 - Walking With God Brings Blessings Now and Forever - Chris Ruscher - 2023-28-10-0900.mp3'
mv -- 'Public Talks_ (55) How Can You Make a Good Name With God? — Gregory Duhon 11_4_2023.mp3' '055 - How Can You Make a Good Name With God? - Gregory Duhon - 2023-4-11-0900.mp3'
mv -- 'Public Talks_ (9) Walking With God Brings Blessings Now and Forever — Chris Ruscher 10_28_2023.mp3' '009 - Walking With God Brings Blessings Now and Forever - Chris Ruscher - 2023-28-10-0900.mp3'

Remove the -n (dry-run) if happy.

If that has to be a shell script that takes the file names as arguments:

#! /bin/zsh -
set -o extendedglob
pattern='(#b)*_ \((<0-999>)\)(* )—( * )(<1-12>)_(<1-31>)_(<1900-2100>)(.mp3)'
ret=0
for file {
  if [[ $file = $~pattern ]] {
    argv=( "$match[@]" )
    mv -i -- $file "2-6-{(l[2][0])4}-0900$7" || ret=$?
  } else {
    print -ru2 "Skipping $file which doesn't match the pattern"
  }
}
exit $ret

But you'd be missing on the extra safeguards of zmv.

Note that we're looping over all the arguments of the script instead of just processing the first ($1).

You are encountering one of the reasons why it is recommended to (almost) always quote your shell variables.

In your case, since you assign to the shell variable fichier a file name that contains whitespace, the shell will perform word splitting when you use that variable "as is", i.e. just as $fichier. That means that a directory Job offers etc as argument to mv would be interpreted as trying to move the three files Job, offers and etc to the destination directory Job_offers_etc⁽¹⁾.

In order to avoid the problem, place double-quotes around the variable reference, as in "$fichier".

⁽¹⁾ This can actually be dangerous; in some settings, if the destination directory doesn't exist, the command may lead to three files being renamed to the same name, effectively overwriting the first two by the third one.

For command line script to rename, this stackoverflow question has good answers.

For Mac, In GUI, Finder comes with bulk rename capabilities. If source list of files has some pattern to find & replace, it comes very handy.

Select all the files that need to be replaced, right click and select rename

On rename, enter find and replace string

Other options in rename, to sequence the file names:

To prefix or suffix text:

While you could precede each space with a \ character, you would be better of enclosing the entire file name with a pair of double quotes"", as shown below. Here I assume path is a variable, which also may contain spaces.

mv "$path/this is my app.ipa" "$path/this_is_my_app.ipa"

Or, a suppose you could also use the following.

mv "$path"/this\ is\ my\ app.ipa "$path"/this_is_my_app.ipa

If path is executable with output, then you are correct to use $(path).

Separating the path_name from the file_name, something like.

#!/usr/bin/env bash

while read -r file; do
  path_name="${file%/*}"; printf 'Path is %s\n' "$path_name"
  file_name="${file#"$path_name"}"; printf 'Filename is %s\n' "$file_name"
  newpath="$path_name${file_name//foo/bar}"
  echo mv -v "$file" "$newpath"
done < <(find . -name "*foo*" -type f)

Have a look at basename and dirname as well.

The printf's is just there to show which is the path and the filename.

The script just replace foo to bar from the file_name, It can be done with the path_name as well, just use the same syntax.

newpath="${path_name//bar/more}${file_name//foo/bar}"

So renaming both path_name and file_name.

Or renaming the path_name and then the file_name like your idea is an option also.

path_name="${file%/*}"
file_name="${file#"$path_name"}"
new_pathname="${path_name//bar/more}"

mv -v "$path_name" "$new_pathname"

new_filename="${file_name//foo/bar}"

mv -v "${new_pathname%/*}$file_name" "$new_pathname$new_filename"

There are no additional external tool/utility used, except from the ones being used by your script.

Remove the echo If you're satisfied with the result/output.

With unix-like systems, it's easier to use find

find ./  

(try this first to make sure that your list of files looks like what you were expecting

find ./ -exec mv ${} ${}.jpg \; 

This will append .jpg to the end of every file found. The regex for changing the final extension, rather than just appending, is left as an exercise for the reader.