bad assignment bash

Fixing "zsh: bad assignment" error in Linux

The other day I was trying to create an alias in Linux for repetitive commands. An alias is a name that is translated as another name or command (or a set of commands).

So, I tried to create the alias in the following manner:

And it threw me the following error:

If you are a regular user of the Linux command line, you must have identified the error on the previous command. But I was preoccupied with my program in C++ and I did not notice the obvious error here.

In fact, I thought it to be an error with the way I used the combination of error for the alias. So, I fiddled for a couple of minutes and just to make sure what I was doing wrong, tried this command:

Now, I was certain that there was no error with the commands this time but I git the same result as above:

And that’s when I realized my mistake. You see, I have been working a lot with C++ and was following the standard of using spaces before and after the assignment operator (=). And that is what I used here as well. And shell does not like the wastage of “space”.

I removed the extra white spaces before and after the = and voilà! There it worked like a charm.

In fact, the same error can be encountered with the export command as well or any other variable assignments in the shell. There should not be spaces before and after equals sign.

This taught me a lesson to not waste white space while dealing with shell scripts and Linux commands. It’s not the same as writing programs in other languages.

I would add this tiny learning lesson to my list of things to know about the Linux terminal.

I hope you would not have to waste your time with this problem if you mind those spaces before and after the equals sign.

Abhishek Prakash

Created It's FOSS 11 years ago to share my Linux adventures. Have a Master's degree in Engineering and years of IT industry experience. Huge fan of Agatha Christie detective mysteries 🕵️‍♂️

How To Fix Ubuntu Update Error: Problem With MergeList

How to fix "repository is not valid yet" error in ubuntu linux, how to use nightlight feature in linux mint to save your eyes at night, fixing 'shell script opening in text editor' in ubuntu and other linux, enabling bluetooth on arch linux, become a better linux user.

With the FOSS Weekly Newsletter, you learn useful Linux tips, discover applications, explore new distros and stay updated with the latest from Linux world

Great! You’ve successfully signed up.

Welcome back! You've successfully signed in.

You've successfully subscribed to It's FOSS.

Your link has expired.

Success! Check your email for magic link to sign-in.

Success! Your billing info has been updated.

Your billing was not updated.

zsh报错: bad assignment！我搞定了你呢？

最近在 .zshrc 文件中 alias 命令遇到这个报错

预计阅读时间： 1min

作者 ： 变优秀的小白

Github ： 关注YX-XiaoBai

爱好 ： Americano More Ice !

QQ学习交流群(new) : 811792998

在 .zshrc 文件新增了 alias gs = 'git status'

使用了 alias 之后 zsh 用不了

改为： alias gs='git status'

原因： alias 中的 = 两侧是不可以有空格的~

结束语：不懂算我输，当然~如果遇到什么疑问或者建议的，可直接留言评论！作者看到会马上一一回复！

如果觉得小白此文章不错或对你有所帮助，期待你的一键三连💫！❤️ni！.

“相关推荐”对你有帮助么？

请填写红包祝福语或标题

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

Stack Exchange Network

Stack Exchange network consists of 183 Q&A communities including Stack Overflow , the largest, most trusted online community for developers to learn, share their knowledge, and build their careers.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Why does Zsh complain of my variable assignment as "command not found"?

When I try to write a Zsh script on macOS Big Sur, Version 11.5.1, I noticed that it keeps failing to recognize my variables as variables.

Instead, Zsh treats them as UNIX-like commands.

Screenshot of the problem on the Terminal Application - variable assignment problem for Zsh shell scripts

In the screenshot linked above, I did the following on the Terminal application.

• Showed the contents of the simple Zsh shell script.
• Used the "ls -l" UNIX-like command to indicate its file permissions, and show that it is an executable Zsh shell script.
• Executed the Zsh shell script, which shows that the Zsh script interpreter complains of how my variable name is a "command not found".

The source code for my Zsh shell script is provided as follows:

Can you please kindly let me know what am I missing, and what did I do wrong?

I just want to assign values to variables in my Zsh shell scripts.

Thank you so much, and have a great day! Ciao!

• macos-bigsur

The syntax to assign a value to a variable is foo=bar , not foo = bar . Whitespaces matter. The latter syntax is a command foo with arguments = and bar .

Few examples of how = is interpreted:

This is not specific to Zsh. The POSIX shell ( sh ) and POSIX-compliant shells behave this way. Zsh (while not being POSIX-compliant in general) also follows.

• My upvote can only be recorded but not cast, since my reputation score is low for the "Super User" site of Stack Exchange. That said, thank you so much! It makes a lot of sense now. –  Giovanni Aug 12, 2021 at 19:17

You must log in to answer this question.

Not the answer you're looking for browse other questions tagged macos shell zsh macos-bigsur ..

• The Overflow Blog
• What a year building AI has taught Stack Overflow
• Want to be a great software engineer? Don’t be a jerk.
• Featured on Meta
• New Focus Styles & Updated Styling for Button Groups
• Upcoming initiatives on Stack Overflow and across the Stack Exchange network
• Google Cloud will be Sponsoring Super User SE

Hot Network Questions

• Taxicab Geometry
• Are wider tires on a road bike a good idea?
• How to partially terraform Venus?
• Book about teen girl living in a town by herself (with her dog) as everyone died of radiation poisoning
• I need a word for the atmosphere between two people
• Average momentum of particle/anti-particle pairs
• Can anyone explain this sacrifice?
• What happens when an automatic transmission completely fails?
• Why does one airliner fly along the coast and the other doesn't?
• Do faster responding low-pass filters exist compared to a traditional RC filter?
• A small REPL in Python
• Co-Existing with a Highly Extroverted Leader and "Forced Fun"
• Colorbar to illustrate the change of a specific parameter
• Frozen World Atmosphere?
• NSF grant proposal not reviewed despite being received
• Should the banker hit?
• Can "sit" mean "receive no attention"?
• Can You Train A Neural Network By Simply Giving It Ratings Each Time It Runs?
• Is this formula already known?
• Treatment of expl3 variables - registers versus macros
• I think I downloaded spyware! I used a curl command in terminal given by a fake support user to download a .sh file
• Making shortcrust pastry ahead of time
• "Entrance exam" homework assignment for 3rd-year algorithms?
• Sight reader or busker?

Assignment Operators in Bash

In the Bash shell, assignment operators are used to assign values to variables. They are essential tools in scripting and programming, providing a method to store and manipulate data. This article will take you through the fundamental assignment operators in Bash, along with examples of their usage.

Standard Assignment Operator

In Bash, the standard assignment operator is the `=` symbol. It is used to assign the value on the right-hand side to the variable on the left-hand side. There should not be any spaces around the `=` operator. Here is an example:

In this example, the variable `NAME` is assigned the value “John Doe” . If you use `echo $NAME` , the output will be “John Doe” .

Compound Assignment Operators

Compound assignment operators combine an operation and an assignment into a single operation.

Please note that Bash only supports integer arithmetic natively. If you need to perform operations with floating-point numbers, you will need to use external tools like bc.

Read-only Assignment Operator

The readonly operator is used to make a variable’s value constant, which means the value assigned to the variable cannot be changed later. If you try to change the value of a readonly variable, Bash will give an error.

In the above example, PI is declared as a readonly variable and assigned a value of 3.14 . When we try to reassign the value 3.1415 to PI , Bash will give an error message: bash: PI: readonly variable .

Local Assignment Operator

The local operator is used within functions to create a local variable – a variable that can only be accessed within the function where it was declared.

In the above example, MY_VAR is declared as a local variable in the my_func function. When we call the function, it prints “I am local” . However, when we try to echo MY_VAR outside of the function, it prints nothing because MY_VAR is not accessible outside my_func .

Bash assignment operators are a crucial part of shell scripting, enabling the storage and manipulation of data. By understanding and using these operators effectively, you can enhance the functionality and efficiency of your scripts. This article covered the basic assignment operator, compound assignment operators, and special assignment operators like readonly and local. Understanding how and when to use each operator is a key aspect of mastering Bash scripting.

Related Posts

What is the “/dev/null 2>&1” in bash: a comprehensive guide, using the ‘-ge’ operator in bash: a comprehensive guide.

Generate Random Numbers in Bash

Save my name, email, and website in this browser for the next time I comment.

Type above and press Enter to search. Press Esc to cancel.

How-To Geek

How to work with variables in bash.

Want to take your Linux command-line skills to the next level? Here's everything you need to know to start working with variables.

Hannah Stryker / How-To Geek

Quick Links

Variables 101, examples of bash variables, how to use bash variables in scripts, how to use command line parameters in scripts, working with special variables, environment variables, how to export variables, how to quote variables, echo is your friend, key takeaways.

• Variables are named symbols representing strings or numeric values. They are treated as their value when used in commands and expressions.
• Variable names should be descriptive and cannot start with a number or contain spaces. They can start with an underscore and can have alphanumeric characters.
• Variables can be used to store and reference values. The value of a variable can be changed, and it can be referenced by using the dollar sign $ before the variable name.

Variables are vital if you want to write scripts and understand what that code you're about to cut and paste from the web will do to your Linux computer. We'll get you started!

Variables are named symbols that represent either a string or numeric value. When you use them in commands and expressions, they are treated as if you had typed the value they hold instead of the name of the variable.

To create a variable, you just provide a name and value for it. Your variable names should be descriptive and remind you of the value they hold. A variable name cannot start with a number, nor can it contain spaces. It can, however, start with an underscore. Apart from that, you can use any mix of upper- and lowercase alphanumeric characters.

Here, we'll create five variables. The format is to type the name, the equals sign = , and the value. Note there isn't a space before or after the equals sign. Giving a variable a value is often referred to as assigning a value to the variable.

We'll create four string variables and one numeric variable,

my_name=Dave

my_boost=Linux

his_boost=Spinach

this_year=2019

To see the value held in a variable, use the echo command. You must precede the variable name with a dollar sign $ whenever you reference the value it contains, as shown below:

echo $my_name

echo $my_boost

echo $this_year

Let's use all of our variables at once:

echo "$my_boost is to $me as $his_boost is to $him (c) $this_year"

The values of the variables replace their names. You can also change the values of variables. To assign a new value to the variable, my_boost , you just repeat what you did when you assigned its first value, like so:

my_boost=Tequila

If you re-run the previous command, you now get a different result:

So, you can use the same command that references the same variables and get different results if you change the values held in the variables.

We'll talk about quoting variables later. For now, here are some things to remember:

• A variable in single quotes ' is treated as a literal string, and not as a variable.
• Variables in quotation marks " are treated as variables.
• To get the value held in a variable, you have to provide the dollar sign $ .
• A variable without the dollar sign $ only provides the name of the variable.

You can also create a variable that takes its value from an existing variable or number of variables. The following command defines a new variable called drink_of_the_Year, and assigns it the combined values of the my_boost and this_year variables:

drink_of-the_Year="$my_boost $this_year"

echo drink_of_the-Year

Scripts would be completely hamstrung without variables. Variables provide the flexibility that makes a script a general, rather than a specific, solution. To illustrate the difference, here's a script that counts the files in the /dev directory.

Type this into a text file, and then save it as fcnt.sh (for "file count"):

#!/bin/bashfolder_to_count=/devfile_count=$(ls $folder_to_count | wc -l)echo $file_count files in $folder_to_count

Before you can run the script, you have to make it executable, as shown below:

chmod +x fcnt.sh

Type the following to run the script:

This prints the number of files in the /dev directory. Here's how it works:

• A variable called folder_to_count is defined, and it's set to hold the string "/dev."
• Another variable, called file_count , is defined. This variable takes its value from a command substitution. This is the command phrase between the parentheses $( ) . Note there's a dollar sign $ before the first parenthesis. This construct $( ) evaluates the commands within the parentheses, and then returns their final value. In this example, that value is assigned to the file_count variable. As far as the file_count variable is concerned, it's passed a value to hold; it isn't concerned with how the value was obtained.
• The command evaluated in the command substitution performs an ls file listing on the directory in the folder_to_count variable, which has been set to "/dev." So, the script executes the command "ls /dev."
• The output from this command is piped into the wc command. The -l (line count) option causes wc to count the number of lines in the output from the ls command. As each file is listed on a separate line, this is the count of files and subdirectories in the "/dev" directory. This value is assigned to the file_count variable.
• The final line uses echo to output the result.

But this only works for the "/dev" directory. How can we make the script work with any directory? All it takes is one small change.

Many commands, such as ls and wc , take command line parameters. These provide information to the command, so it knows what you want it to do. If you want ls to work on your home directory and also to show hidden files , you can use the following command, where the tilde ~ and the -a (all) option are command line parameters:

Our scripts can accept command line parameters. They're referenced as $1 for the first parameter, $2 as the second, and so on, up to $9 for the ninth parameter. (Actually, there's a $0 , as well, but that's reserved to always hold the script.)

You can reference command line parameters in a script just as you would regular variables. Let's modify our script, as shown below, and save it with the new name fcnt2.sh :

#!/bin/bashfolder_to_count=$1file_count=$(ls $folder_to_count | wc -l)echo $file_count files in $folder_to_count

This time, the folder_to_count variable is assigned the value of the first command line parameter, $1 .

The rest of the script works exactly as it did before. Rather than a specific solution, your script is now a general one. You can use it on any directory because it's not hardcoded to work only with "/dev."

Here's how you make the script executable:

chmod +x fcnt2.sh

Now, try it with a few directories. You can do "/dev" first to make sure you get the same result as before. Type the following:

./fnct2.sh /dev

./fnct2.sh /etc

./fnct2.sh /bin

You get the same result (207 files) as before for the "/dev" directory. This is encouraging, and you get directory-specific results for each of the other command line parameters.

To shorten the script, you could dispense with the variable, folder_to_count , altogether, and just reference $1 throughout, as follows:

#!/bin/bash file_count=$(ls $1 wc -l) echo $file_count files in $1

We mentioned $0 , which is always set to the filename of the script. This allows you to use the script to do things like print its name out correctly, even if it's renamed. This is useful in logging situations, in which you want to know the name of the process that added an entry.

The following are the other special preset variables:

• $# : How many command line parameters were passed to the script.
• $@ : All the command line parameters passed to the script.
• $? : The exit status of the last process to run.
• $$ : The Process ID (PID) of the current script.
• $USER : The username of the user executing the script.
• $HOSTNAME : The hostname of the computer running the script.
• $SECONDS : The number of seconds the script has been running for.
• $RANDOM : Returns a random number.
• $LINENO : Returns the current line number of the script.

You want to see all of them in one script, don't you? You can! Save the following as a text file called, special.sh :

#!/bin/bashecho "There were $# command line parameters"echo "They are: $@"echo "Parameter 1 is: $1"echo "The script is called: $0"# any old process so that we can report on the exit statuspwdecho "pwd returned $?"echo "This script has Process ID $$"echo "The script was started by $USER"echo "It is running on $HOSTNAME"sleep 3echo "It has been running for $SECONDS seconds"echo "Random number: $RANDOM"echo "This is line number $LINENO of the script"

Type the following to make it executable:

chmod +x special.sh

Now, you can run it with a bunch of different command line parameters, as shown below.

Bash uses environment variables to define and record the properties of the environment it creates when it launches. These hold information Bash can readily access, such as your username, locale, the number of commands your history file can hold, your default editor, and lots more.

To see the active environment variables in your Bash session, use this command:

If you scroll through the list, you might find some that would be useful to reference in your scripts.

When a script runs, it's in its own process, and the variables it uses cannot be seen outside of that process. If you want to share a variable with another script that your script launches, you have to export that variable. We'll show you how to this with two scripts.

First, save the following with the filename script_one.sh :

#!/bin/bashfirst_var=alphasecond_var=bravo# check their valuesecho "$0: first_var=$first_var, second_var=$second_var"export first_varexport second_var./script_two.sh# check their values againecho "$0: first_var=$first_var, second_var=$second_var"

This creates two variables, first_var and second_var , and it assigns some values. It prints these to the terminal window, exports the variables, and calls script_two.sh . When script_two.sh terminates, and process flow returns to this script, it again prints the variables to the terminal window. Then, you can see if they changed.

The second script we'll use is script_two.sh . This is the script that script_one.sh calls. Type the following:

#!/bin/bash# check their valuesecho "$0: first_var=$first_var, second_var=$second_var"# set new valuesfirst_var=charliesecond_var=delta# check their values againecho "$0: first_var=$first_var, second_var=$second_var"

This second script prints the values of the two variables, assigns new values to them, and then prints them again.

To run these scripts, you have to type the following to make them executable:

chmod +x script_one.shchmod +x script_two.sh

And now, type the following to launch script_one.sh :

./script_one.sh

This is what the output tells us:

• script_one.sh prints the values of the variables, which are alpha and bravo.
• script_two.sh prints the values of the variables (alpha and bravo) as it received them.
• script_two.sh changes them to charlie and delta.
• script_one.sh prints the values of the variables, which are still alpha and bravo.

What happens in the second script, stays in the second script. It's like copies of the variables are sent to the second script, but they're discarded when that script exits. The original variables in the first script aren't altered by anything that happens to the copies of them in the second.

You might have noticed that when scripts reference variables, they're in quotation marks " . This allows variables to be referenced correctly, so their values are used when the line is executed in the script.

If the value you assign to a variable includes spaces, they must be in quotation marks when you assign them to the variable. This is because, by default, Bash uses a space as a delimiter.

Here's an example:

site_name=How-To Geek

Bash sees the space before "Geek" as an indication that a new command is starting. It reports that there is no such command, and abandons the line. echo shows us that the site_name variable holds nothing — not even the "How-To" text.

Try that again with quotation marks around the value, as shown below:

site_name="How-To Geek"

This time, it's recognized as a single value and assigned correctly to the site_name variable.

It can take some time to get used to command substitution, quoting variables, and remembering when to include the dollar sign.

Before you hit Enter and execute a line of Bash commands, try it with echo in front of it. This way, you can make sure what's going to happen is what you want. You can also catch any mistakes you might have made in the syntax.

• bash / FAQ / Shell Scripting

Bash variable assignment examples

by Ramakanta · Published January 19, 2013 · Updated February 11, 2015

This section we will describe the following: 1. Variable assignment 2. Variable substitution 3. Built-in shell variables 4. Other shell variables 5. Variable Assignment

Variable names consist of any number of letters, digits, or underscores. Upper- and lowercase letters are distinct, and names may not start with a digit.

Variables are assigned values using the = operator. There may not be any whitespace between the variable name and the value. You can make multiple assignments on the same line by separating each one with whitespace:

By convention, names for variables used or set by the shell have all uppercase letters; however, you can use uppercase names in your scripts if you use a name that isn’t special to the shell. By default, the shell treats variable values as strings, even if the value of the string is all digits. However, when a value is assigned to an integer variable (created via declare -i), Bash evaluates the righthand side of the assignment as an expression.

For example:

The += operator allows you to add or append the righthand side of the assignment to an existing value. Integer variables treat the righthand side as an expression, which is evaluated and added to the value. Arrays add the new elements to the array.

Variable Substitution

No spaces should be used in the following expressions. The colon (:) is optional; if it’s included, var must be nonnull as well as set.

var=value … Set each variable var to a value.

${var} Use value of var; braces are optional if var is separated from the following text. They are required for array variables.

${var:-value} Use var if set; otherwise, use value.

${var:=value} Use var if set; otherwise, use value and assign value to var.

${var:?value} Use var if set; otherwise, print value and exit (if not interactive). If value isn’t supplied, print the phrase parameter null or not set.

${var:+value} Use value if var is set; otherwise, use nothing.

${#var} Use the length of var.

${#*} Use the number of positional parameters.

${#@} Same as previous.

${var#pattern} Use value of var after removing text matching pattern from the left. Remove the shortest matching piece.

${var##pattern} Same as #pattern, but remove the longest matching piece.

${var%pattern} Use value of var after removing text matching pattern from the right. Remove the shortest matching piece.

${var%%pattern} Same as %pattern, but remove the longest matching piece.

${var^pattern} Convert the case of var to uppercase. The pattern is evaluated as for filename matching. If the first letter of var matches the pattern, it is converted to uppercase. var can be * or @, in which case the positional parameters are modified. var can also be an array subscripted by * or @, in which case the substitution is applied to all the elements of the array.

${var^^pattern} Same as ^pattern, but apply the match to every letter in the string.

${var,pattern} Same as ^pattern, but convert matching characters to lower case. Applies only to the first character in the string.

${var,,pattern} Same as ,pattern, but apply the match to every letter in the string.

${!prefix*},${!prefix@} List of variables whose names begin with prefix.

${var:pos},${var:pos:len} Starting at position pos (0-based) in variable var, extract len characters, or extract rest of string if no len. pos and len may be arithmetic expressions.When var is * or @, the expansion is performed upon the positional parameters. If pos is zero, then $0 is included in the resulting list. Similarly, var can be an array indexed by * or @.

${var/pat/repl} Use value of var, with first match of pat replaced with repl.

${var/pat} Use value of var, with first match of pat deleted.

${var//pat/repl} Use value of var, with every match of pat replaced with repl.

${var/#pat/repl} Use value of var, with match of pat replaced with repl. Match must occur at beginning of the value.

${var/%pat/repl} Use value of var, with match of pat replaced with repl. Match must occur at end of the value.

${!var} Use value of var as name of variable whose value should be used (indirect reference).

Bash provides a special syntax that lets one variable indirectly reference another:

$ greet=”hello, world” Create initial variable

$ friendly_message=greet Aliasing variable

$ echo ${!friendly_message} Use the alias

hello, world Example:

Built-in Shell Variables

Built-in variables are automatically set by the shell and are typically used inside shell scripts. Built-in variables can make use of the variable substitution patterns shown previously. Note that the $ is not actually part of the variable name, although the variable is always referenced this way. The following are

available in any Bourne-compatible shell:

$# Number of command-line arguments.

$- Options currently in effect (supplied on command line or to set). The shell sets some options automatically.

$? Exit value of last executed command.

$$ Process number of the shell.

$! Process number of last background command.

$0 First word; that is, the command name. This will have the full pathname if it was found via a PATH search.

$n Individual arguments on command line (positional parameters).

The Bourne shell allows only nine parameters to be referenced directly (n = 1–9); Bash allows n to be greater than 9 if specified as ${n}.

$*, $@ All arguments on command line ($1 $2 …).

“$*” All arguments on command line as one string (“$1 $2…”). The values are separated by the first character in $IFS.

“$@” All arguments on command line, individually quoted (“$1” “$2” …). Bash automatically sets the following additional variables: $_ Temporary variable; initialized to pathname of script or program being executed. Later, stores the last argument of previous command. Also stores name of matching MAIL file during mail checks.

BASH The full pathname used to invoke this instance of Bash.

BASHOPTS A read-only, colon-separated list of shell options that are currently enabled. Each item in the list is a valid option for shopt -s. If this variable exists in the environment when Bash starts up, it sets the indicated options before executing any startup files.

BASHPID The process ID of the current Bash process. In some cases, this can differ from $$.

BASH_ALIASES Associative array variable. Each element holds an alias defined with the alias command. Adding an element to this array creates a new alias; removing an element removes the corresponding alias.

BASH_ARGC Array variable. Each element holds the number of arguments for the corresponding function or dot-script invocation. Set only in extended debug mode, with shopt –s extdebug. Cannot be unset.

BASH_ARGV An array variable similar to BASH_ARGC. Each element is one of the arguments passed to a function or dot-script. It functions as a stack, with values being pushed on at each call. Thus, the last element is the last argument to the most recent function or script invocation. Set only in extended debug

mode, with shopt -s extdebug. Cannot be unset.

BASH_CMDS Associative array variable. Each element refers to a command in the internal hash table maintained by the hash command. The index is the command name and the value is the full path to the command. Adding an element to this array adds a command to the hash table; removing an element removes the corresponding entry.

BASH_COMMAND The command currently executing or about to be executed. Inside a trap handler, it is the command running when the trap was invoked.

BASH_EXECUTION_STRING The string argument passed to the –c option.

BASH_LINENO Array variable, corresponding to BASH_SOURCE and FUNCNAME. For any given function number i (starting at zero), ${FUNCNAME[i]} was invoked in file ${BASH_SOURCE[i]} on line ${BASH_LINENO[i]}. The information is stored with the most recent function invocation first. Cannot be unset.

BASH_REMATCH Array variable, assigned by the =~ operator of the [[ ]] construct. Index zero is the text that matched the entire pattern. The other

indices are the text matched by parenthesized subexpressions. This variable is read-only.

BASH_SOURCE Array variable, containing source filenames. Each element corresponds to those in FUNCNAME and BASH_LINENO. Cannot be unset.

BASH_SUBSHELL This variable is incremented by one each time a subshell or subshell environment is created.

BASH_VERSINFO[0] The major version number, or release, of Bash.

BASH_VERSINFO[1] The minor version number, or version, of Bash.

BASH_VERSINFO[2] The patch level.

BASH_VERSINFO[3] The build version.

BASH_VERSINFO[4] The release status.

BASH_VERSINFO[5] The machine type; same value as in $MACHTYPE.

BASH_VERSION A string describing the version of Bash.

COMP_CWORD For programmable completion. Index into COMP_WORDS, indicating the current cursor position.

COMP_KEY For programmable completion. The key, or final key in a sequence, that caused the invocation of the current completion function.

COMP_LINE For programmable completion. The current command line.

COMP_POINT For programmable completion. The position of the cursor as a character index in $COMP_LINE.

COMP_TYPE For programmable completion. A character describing the type of programmable completion. The character is one of Tab for normal completion, ? for a completions list after two Tabs, ! for the list of alternatives on partial word completion, @ for completions if the word is modified, or % for menu completion.

COMP_WORDBREAKS For programmable completion. The characters that the readline library treats as word separators when doing word completion.

COMP_WORDS For programmable completion. Array variable containing the individual words on the command line.

COPROC Array variable that holds the file descriptors used for communicating with an unnamed coprocess.

DIRSTACK Array variable, containing the contents of the directory stack as displayed by dirs. Changing existing elements modifies the stack, but only pushd and popd can add or remove elements from the stack.

EUID Read-only variable with the numeric effective UID of the current user.

FUNCNAME Array variable, containing function names. Each element corresponds to those in BASH_SOURCE and BASH_LINENO.

GROUPS Array variable, containing the list of numeric group IDs in which the current user is a member.

HISTCMD The history number of the current command.

HOSTNAME The name of the current host.

HOSTTYPE A string that describes the host system.

LINENO Current line number within the script or function.

MACHTYPE A string that describes the host system in the GNU cpu-company-system format.

MAPFILE Default array for the mapfile and readarray commands.

OLDPWD Previous working directory (set by cd).

OPTARG Value of argument to last option processed by getopts.

OPTIND Numerical index of OPTARG.

OSTYPE A string that describes the operating system.

PIPESTATUS Array variable, containing the exit statuses of the commands in the most recent foreground pipeline.

PPID Process number of this shell’s parent.

PWD Current working directory (set by cd).

RANDOM[=n] Generate a new random number with each reference; start with integer n, if given.

READLINE_LINE For use with bind -x. The contents of the editing buffer are available in this variable.

READLINE_POINT For use with bind -x. The index in $READLINE_LINE of the insertion point.

REPLY Default reply; used by select and read.

SECONDS[=n] Number of seconds since the shell was started, or, if n is given, number of seconds since the assignment + n.

SHELLOPTS A read-only, colon-separated list of shell options (for set -o). If set in the environment at startup, Bash enables each option present in the list before reading any startup files.

SHLVL Incremented by one every time a new Bash starts up.

UID Read-only variable with the numeric real UID of the current user.

Other Shell Variables

The following variables are not automatically set by the shell, although many of them can influence the shell’s behavior. You typically use them in your .bash_profile or .profile file, where you can define them to suit your needs. Variables can be assigned values by issuing commands of the form:

This list includes the type of value expected when defining these variables:

BASH_ENV If set at startup, names a file to be processed for initialization commands. The value undergoes parameter expansion, command substitution, and arithmetic expansion before being interpreted as a filename.

BASH_XTRACEFD=n File descriptor to which Bash writes trace output (from set -x).

CDPATH=dirs Directories searched by cd; allows shortcuts in changing directories; unset by default.

COLUMNS=n Screen’s column width; used in line edit modes and select lists.

COMPREPLY=(words …) Array variable from which Bash reads the possible completions generated by a completion function.

EMACS If the value starts with t, Bash assumes it’s running in an Emacs buffer and disables line editing.

ENV=file Name of script that is executed at startup in POSIX mode or when Bash is invoked as /bin/sh; useful for storing alias and function definitions. For example, ENV=$HOME/.shellrc.

FCEDIT=file Editor used by fc command. The default is /bin/ed when Bash is in POSIX mode. Otherwise, the default is $EDITOR if set, vi if unset.

FIGNORE=patlist Colon-separated list of patterns describing the set of filenames to ignore when doing filename completion.

GLOBIGNORE=patlist Colon-separated list of patterns describing the set of filenames to ignore during pattern matching.

HISTCONTROL=list Colon-separated list of values controlling how commands are saved in the history file. Recognized values are ignoredups, ignorespace, ignoreboth, and erasedups.

HISTFILE=file File in which to store command history.

HISTFILESIZE=n Number of lines to be kept in the history file. This may be different from the number of commands.

HISTIGNORE=list A colon-separated list of patterns that must match the entire command line. Matching lines are not saved in the history file. An unescaped & in a pattern matches the previous history line.

HISTSIZE=n Number of history commands to be kept in the history file.

HISTTIMEFORMAT=string A format string for strftime(3) to use for printing timestamps along with commands from the history command. If set (even if null), Bash saves timestamps in the history file along with the commands.

HOME=dir Home directory; set by login (from /etc/passwd file).

HOSTFILE=file Name of a file in the same format as /etc/hosts that Bash should use to find hostnames for hostname completion.

IFS=’chars’ Input field separators; default is space, Tab, and newline.

IGNOREEOF=n Numeric value indicating how many successive EOF characters must be typed before Bash exits. If null or nonnumeric value, default is 10.

INPUTRC=file Initialization file for the readline library. This overrides the default value of ~/.inputrc.

LANG=locale Default value for locale; used if no LC_* variables are set.

LC_ALL=locale Current locale; overrides LANG and the other LC_* variables.

LC_COLLATE=locale Locale to use for character collation (sorting order).

LC_CTYPE=locale Locale to use for character class functions.

LC_MESSAGES=locale Locale to use for translating $”…” strings.

LC_NUMERIC=locale Locale to use for the decimal-point character.

LC_TIME=locale Locale to use for date and time formats.

LINES=n Screen’s height; used for select lists.

MAIL=file Default file to check for incoming mail; set by login.

MAILCHECK=n Number of seconds between mail checks; default is 600 (10 minutes).

MAILPATH=files One or more files, delimited by a colon, to check for incoming mail. Along with each file, you may supply an optional message that the shell prints when the file increases in size. Messages are separated from the filename by a ? character, and the default message is You have mail in $_. $_ is replaced with the name of the file. For example, you might have MAIL PATH=”$MAIL?Candygram!:/etc/motd?New Login Message” OPTERR=n When set to 1 (the default value), Bash prints error messages from the built-in getopts command.

PATH=dirlist One or more pathnames, delimited by colons, in which to search for commands to execute. The default for many systems is /bin:/usr/bin. On Solaris, the default is /usr/bin:. However, the standard startup scripts change it to /usr/bin:/usr/ucb:/etc:.

POSIXLY_CORRECT=string When set at startup or while running, Bash enters POSIX mode, disabling behavior and modifying features that conflict with the POSIX standard.

PROMPT_COMMAND=command If set, Bash executes this command each time before printing the primary prompt.

PROMPT_DIRTRIM=n Indicates how many trailing directory components to retain for the \w or \W special prompt strings. Elided components are replaced with an ellipsis.

PS1=string Primary prompt string; default is $.

PS2=string Secondary prompt (used in multiline commands); default is >.

PS3=string Prompt string in select loops; default is #?.

PS4=string Prompt string for execution trace (bash –x or set -x); default is +.

SHELL=file Name of user’s default shell (e.g., /bin/sh). Bash sets this if it’s not in the environment at startup.

TERM=string Terminal type.

TIMEFORMAT=string A format string for the output from the time keyword.

TMOUT=n If no command is typed after n seconds, exit the shell. Also affects the read command and the select loop.

TMPDIR=directory Place temporary files created and used by the shell in directory.

auto_resume=list Enables the use of simple strings for resuming stopped jobs. With a value of exact, the string must match a command name exactly. With a value of substring, it can match a substring of the command name.

histchars=chars Two or three characters that control Bash’s csh-style history expansion. The first character signals a history event, the second is the “quick substitution” character, and the third indicates the start of a comment. The default value is !^#.

In case of any ©Copyright or missing credits issue please check CopyRights page for faster resolutions.

Like the article... Share it.

• Click to print (Opens in new window)
• Click to email a link to a friend (Opens in new window)
• Click to share on Reddit (Opens in new window)
• Click to share on Pinterest (Opens in new window)
• Click to share on LinkedIn (Opens in new window)
• Click to share on WhatsApp (Opens in new window)
• Click to share on Twitter (Opens in new window)
• Click to share on Facebook (Opens in new window)
• Click to share on Tumblr (Opens in new window)
• Click to share on Pocket (Opens in new window)
• Click to share on Telegram (Opens in new window)

CURRENTLY TRENDING...

Tags: bash variable

• Next story  Grep Command Tutorial For Unix
• Previous story  Bash redirect to file and screen

Leave a Reply Cancel reply

This site uses Akismet to reduce spam. Learn how your comment data is processed .

Sign Up For Our Free Email Newsletter    

Search code, repositories, users, issues, pull requests...

Provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Notifications

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement . We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Full list of checks #641

mat813 commented Apr 4, 2016

brother commented Apr 5, 2016

Sorry, something went wrong.

mat813 commented Apr 5, 2016

koalaman commented Apr 5, 2016

rasa commented Feb 2, 2021 • edited

• 👍 3 reactions

felipecrs commented Aug 26, 2023

• 👍 1 reaction

No branches or pull requests

Home > Bash Scripting Tutorial > Bash Variables > Variable Declaration and Assignment > Bash Variable Naming Conventions in Shell Script [6 Rules]

Bash Variable Naming Conventions in Shell Script [6 Rules]

When writing shell scripts in Bash , choosing appropriate names for variables is essential for code readability and maintainability . By adhering to consistent naming conventions , you can enhance the clarity and understandability of your scripts, making them easier to debug and modify . This article will state some rules for Bash Variable naming conventions in the shell script .

Key Takeaways

• Learning of Bash Variable Naming Conventions.
• Creating your own variable name using the provided materials.
• An assignment to test your understanding of the Variable Naming Convention.

Free Downloads

6 different bash variable naming conventions in shell script.

To build a comprehensive and easily understandable code, naming the variables with a proper guideline is crucial. This also allows one to avoid any unexpected errors occurring during Debugging time.

While Bash doesn’t enforce any strict naming conventions, developers often follow certain conventions to enhance code clarity and consistency. Down below, I have discussed six different rules that should be followed while choosing your variable name.

Rule 01: Naming a Variable Using Alphabets and Numbers

While alphabets are commonly used in variable names, incorporating numbers can add a level of specificity and clarity to your code. However, bash script is a case-sensitive language which means you can store different data in the same variable having different case combinations.

Steps to Follow >

❶ At first, launch an Ubuntu Terminal .

❷ Write the following command to open a file in Nano :

• nano : Opens a file in the Nano text editor.
• var_alphabet.sh : Name of the file.

❸ Copy the script mentioned below:

The first line #!/bin/bash specifies the interpreter to use ( /bin/bash ) for executing the script. Then, there are three variables var , VAR , and var123 created to store some data in it. Later, the echo command was used to print their stored value to prove that all those variables’ naming are correct and in compliance with the bash script naming convention.

❹ Press CTRL+O and ENTER to save the file; CTRL + X exit.

❺ Use the following command to make the file executable:

• chmod : is used to change the permissions of files and directories.
• u+x : Here, u refers to the “ user ” or the owner of the file and +x specifies the permission being added, in this case, the “ execute ” permission. When u+x is added to the file permissions, it grants the user ( owner ) of the file permission to execute ( run ) the file.
• var_alphabet.sh : is the name of the file to which the permissions are being applied.

❻ Run the script by the following command:

Rule 02: Avoid Using Number at the Beginning of the Variable Name

When it comes to naming variables in Bash shell scripts, one important convention to follow is to avoid using a numeric digit as the first character of a variable name. Here is a sample example demonstrated below where I created several variables placing the number digit at the beginning and end of the variable name. The variable with the number digit at the beginning does not return its corresponding value in the execution time.

You can follow the steps of rule 01 , to save & make the script executable.

Script (var_number.sh) >

Here, #! /bin/bash : ‘ #! ’, is called shebang or hashbang . It indicates the interpreter to be used for executing the script, in this case, it’s bash . Next, a random variable 123var has been created by placing the number digit first. Another variable var123 is also named to show the correct way of naming. Later, the echo command displays the corresponding value contained in the variable.

Rule 03: Using Underscore to Avoid Whitespace

If a variable name consists of multiple words , it is advisable to separate them using underscores (_). For instance, user_name is advisable instead of using username

Script (var_underscore.sh) >

The #!/bin/bash is called a shebang , and it specifies the interpreter (in this case, /bin/bash ) that should be used to execute the script. Next, the var_name variable is created and tried to display using the echo command . Similarly, another var_name variable is created to store a string inside it and displayed later.

Rule 04: No Whitespace on Either Side of the Assignment Operator(=)

When using this operator, it is recommended to have no whitespace (spaces or tabs) immediately before or after the operator. The interpreter takes it as a command instead of assigning value to the variable otherwise. Here is a relevant example stated below.

Script (var_whitespace.sh) >

Here, #! /bin/bash : ‘ #! ’, is called shebang or hashbang . It indicates the interpreter to be used for executing the script, in this case, it’s bash . Then a variable var1 is created and a whitespace is there followed by the var1 . In the case of the second variable, var2 , there is another whitespace followed by the equal sign . Both cases are wrong and thus will occur an error in execution time. Later another variable var3 has been created in the correct way and then displayed with the echo command .

Rule 05: Avoiding Special Characters (Except Underscore)

In general, it is best to stick to alphanumeric characters ( letters and numbers ) and underscores when naming variables. Avoid using special characters , whitespace , or punctuation marks, as they can cause syntax errors or introduce unexpected behaviour. For instance, using any special character such as @, $, or # anywhere while declaring a variable is not legal.

Script (var_special_character.sh) >

Here, #! /bin/bash : ‘ #! ’, is called shebang or hashbang . It indicates the interpreter to be used for executing the script, in this case, it’s bash . Next, three different variables are created using special characters such as @, #, $. Next, all three variables are called using the echo command to display their individual data. Later, another variable var is also created and displayed using the echo command .

Rule 06: Avoid Reserved Keywords or Built-in Command Names as Variable Names

Bash has a set of reserved keywords that have special meanings and functionalities within the shell. Although you will get the variable data, to prevent conflicts and unexpected behaviour, it is crucial to avoid using these reserved keywords as variable names. Examples of reserved keywords include if , else , case , do , while, etc.

Script (var_Reserved_keyword.sh) >

Here, #! /bin/bash : ‘ #! ’, is called shebang or hashbang . It indicates the interpreter to be used for executing the script, in this case, it’s bash . Some reserved words such as while , if , elif , etc store data in this code. Then it displays the value using the echo command .

Comparison of Correct and Incorrect Variable Naming Conventions

Lastly, I draw a summary of the discussion in a table to describe the permissible and non-permissible ways to name the variable. Check this out to get the overall view.

Assignment on Bash Variable Naming Convention

Here I have also made a list of assignments to practice by yourself. Don’t forget to share your answer in the comment section.

• Using uppercase letters in variable names is acceptable. (True/False)
• We can use hyphens (-) in variable names in Bash . (True/False)
• Bash is case-sensitive, so myVar and myvar are considered different variables. (True/False)
• We can use Whitespace in variable names in Bash. (True/False)
• Variable names can contain special characters like !, @, and # in Bash. (True/False)
• Provide a valid variable name in Bash that includes both uppercase and lowercase letters, as well as an underscore .
• Determine whether the following variable names are correct or not :
• My variable

In conclusion, adhering to proper variable naming conventions is essential when working with Bash variables in shell scripts. In this article, I have tried to give you some must known rules to follow while choosing your variable name. Things are easy if you remember however if you have any query related to this article. Feel free to comment below. Thank you.

People Also Ask

Related Articles

• How to Declare Variable in Bash Scripts? [5 Practical Cases]
• How to Assign Variables in Bash Script? [8 Practical Cases]
• How to Check Variable Value Using Bash Scripts? [5 Cases]
• How to Use Default Value in Bash Scripts? [2 Methods]
• How to Use Set – $Variable in Bash Scripts? [2 Examples]
• How to Read Environment Variables in Bash Script? [2 Methods]
• How to Export Environment Variables with Bash? [4 Examples]

<< Go Back to Variable Declaration and Assignment  | Bash Variables | Bash Scripting Tutorial

Mohammad Shah Miran

Hey, I'm Mohammad Shah Miran, previously worked as a VBA and Excel Content Developer at SOFTEKO, and for now working as a Linux Content Developer Executive in LinuxSimply Project. I completed my graduation from Bangladesh University of Engineering and Technology (BUET). As a part of my job, i communicate with Linux operating system, without letting the GUI to intervene and try to pass it to our audience.

Leave a Comment Cancel reply

Save my name, email, and website in this browser for the next time I comment.

• Mobile Site
• Staff Directory
• Advertise with Ars

Filter by topic

• Biz & IT
• Gaming & Culture

Front page layout

NIGHTMARE SUPPLY CHAIN ATTACK SCENARIO —

What we know about the xz utils backdoor that almost infected the world, malicious updates made to a ubiquitous tool were a few weeks away from going mainstream..

Dan Goodin - Apr 1, 2024 6:55 am UTC

On Friday, a lone Microsoft developer rocked the world when he revealed a backdoor had been intentionally planted in xz Utils, an open source data compression utility available on almost all installations of Linux and other Unix-like operating systems. The person or people behind this project likely spent years on it. They were likely very close to seeing the backdoor update merged into Debian and Red Hat, the two biggest distributions of Linux, when an eagle-eyed software developer spotted something fishy.

Further Reading

Researchers have spent the weekend gathering clues. Here's what we know so far.

What is xz Utils?

xz Utils is nearly ubiquitous in Linux. It provides lossless data compression on virtually all Unix-like operating systems, including Linux. xz Utils provides critical functions for compressing and decompressing data during all kinds of operations. xz Utils also supports the legacy .lzma format, making this component even more crucial.

What happened?

Andres Freund, a developer and engineer working on Microsoft’s PostgreSQL offerings, was recently troubleshooting performance problems a Debian system was experiencing with SSH, the most widely used protocol for remotely logging in to devices over the Internet. Specifically, SSH logins were consuming too many CPU cycles and were generating errors with valgrind , a utility for monitoring computer memory.

Through sheer luck and Freund’s careful eye, he eventually discovered the problems were the result of updates that had been made to xz Utils. On Friday, Freund took to the Open Source Security List to disclose the updates were the result of someone intentionally planting a backdoor in the compression software.

It's hard to overstate the complexity of the social engineering and the inner workings of the backdoor. Thomas Roccia, a researcher at Microsoft, published a graphic on Mastodon that helps visualize the sprawling extent of the nearly successful endeavor to spread a backdoor with a reach that would have dwarfed the SolarWinds event from 2020.

What does the backdoor do?

Malicious code added to xz Utils versions 5.6.0 and 5.6.1 modified the way the software functions. The backdoor manipulated sshd, the executable file used to make remote SSH connections. Anyone in possession of a predetermined encryption key could stash any code of their choice in an SSH login certificate, upload it, and execute it on the backdoored device. No one has actually seen code uploaded, so it's not known what code the attacker planned to run. In theory, the code could allow for just about anything, including stealing encryption keys or installing malware.

Wait, how can a compression utility manipulate a process as security sensitive as SSH?

Any library can tamper with the inner workings of any executable it is linked against. Often, the developer of the executable will establish a link to a library that's needed for it to work properly. OpenSSH, the most popular sshd implementation, doesn’t link the liblzma library, but Debian and many other Linux distributions add a patch to link sshd to systemd , a program that loads a variety of services during the system bootup. Systemd, in turn, links to liblzma, and this allows xz Utils to exert control over sshd.

How did this backdoor come to be?

It would appear that this backdoor was years in the making. In 2021, someone with the username JiaT75 made their first known commit to an open source project. In retrospect, the change to the libarchive project is suspicious, because it replaced the safe_fprint funcion with a variant that has long been recognized as less secure. No one noticed at the time.

The following year, JiaT75 submitted a patch over the xz Utils mailing list, and, almost immediately, a never-before-seen participant named Jigar Kumar joined the discussion and argued that Lasse Collin, the longtime maintainer of xz Utils, hadn’t been updating the software often or fast enough. Kumar, with the support of Dennis Ens and several other people who had never had a presence on the list, pressured Collin to bring on an additional developer to maintain the project.

In January 2023, JiaT75 made their first commit to xz Utils. In the months following, JiaT75, who used the name Jia Tan, became increasingly involved in xz Utils affairs. For instance, Tan replaced Collins' contact information with their own on oss-fuzz, a project that scans open source software for vulnerabilities that can be exploited. Tan also requested that oss-fuzz disable the ifunc function during testing, a change that prevented it from detecting the malicious changes Tan would soon make to xz Utils.

In February of this year, Tan issued commits for versions 5.6.0 and 5.6.1 of xz Utils. The updates implemented the backdoor. In the following weeks, Tan or others appealed to developers of Ubuntu, Red Hat, and Debian to merge the updates into their OSes. Eventually, one of the two updates made its way into the following releases, according to security firm Tenable:

There’s more about Tan and the timeline here .

reader comments

Promoted comments.

It should be noted that the attack only works because Debian and Redhat added functionality to sshd that is not present in it as distributed by its developers. The extra functionality adds systemd interaction, which requires libsystemd which requires liblzma, a component of the (compromised) xz package. One should be wary of distributions adding functionality. Often it increases the attack surface, not only because of the modifications/additions themselves, but also by adding dependencies.

So a prime reason this became potentially exploitable is libsystemd in OpenSSH. Need I say more.

The prime reason is a very well funded and capable attacker looked for a way in. if not xz or systemd then they would have attacked via the next candidate weak point.

"This developer persona has touched dozens of other pieces of open-source software in the past few years.". Well, I guess the Opensource community have some codes to review. Maybe the xz incident is only the tips of the iceberg.

Channel Ars Technica

• THE BAD BATCH
• THE ACOLYTE
• THE HIGH REPUBLIC
• QUIZZES + POLLS
• BOOKS + COMICS
• THIS WEEK! IN STAR WARS
• The Bad Batch
• The Acolyte
• The Mandalorian
• Star Wars Outlaws
• Games + Apps
• VR + Immersive
• ALL DATABANK
• THE DISNEY BUNDLE

ALL OF YOUR STAR WARS FAVORITES NOW STREAMING ON DISNEY+

• Behind the Scenes
• Books + Comics
• Characters + Histories
• Disney Parks
• Fans + Community
• Force For Change
• Forces of Destiny
• Galaxy of Adventures
• In Pop Culture
• LEGO Star Wars
• Merchandise
• Obi-Wan Kenobi
• Quizzes + Polls
• Star Wars Celebration
• Star Wars Day
• Star Wars Rebels
• Star Wars Resistance
• The Book of Boba Fett
• The Clone Wars
• The Force Awakens
• The High Republic
• The Last Jedi
• The Rise of Skywalker
• The Star Wars Show

{:title=>"The Bad Batch", :url=>"https://www.starwars.com/news/category/the-bad-batch"} {:title=>"Disney+", :url=>"https://www.starwars.com/news/category/disney+"}

Bad batch declassified: 5 highlights from “identity crisis”.

Follow Dr. Emerie Karr on a new assignment into the heart of Mount Tantiss.

The final season of Star Wars: The Bad Batch is here! In Bad Batch Declassified, we’ll explore our favorite moments from each episode, available only on Disney+ . Armor up and join us for the ride.

Spoiler warning: This article discusses details and plot points from the Star Wars: The Bad Batch episode, “Identity Crisis.”

They call it Project Necromancer, and it’s a high-priority, top-secret undertaking of personal interest to Emperor Palpatine . This week, our story turns away from the Bad Batch to investigate what’s really going on inside Mount Tantiss. Although we’ve only just begun to scratch the surface, Emerie Karr’s promotion to become Dr. Royce Hemlock’s right hand in charge of the vital lab experiments deep in the vault reveals some shocking new developments at play. Here are five highlights from “Identity Crisis.”

StarWars.com. All Star Wars, all the time.

Related Stories

Bad batch declassified: 5 highlights from “point of no return”.

April 4, 2024

Bad Batch Declassified: 5 Highlights from "The Harbinger"

March 28, 2024

Ventress Strikes Back

March 27, 2024

Star Wars Movies and Series Viewing Guide

Bad batch declassified: 5 highlights from “bad territory”.

March 21, 2024

The Acolyte Trailer Breaks Lucasfilm Records

The acolyte characters revealed - first look.

March 19, 2024

“Whatever You Think The Acolyte  Is, It’s Not”: Star Wars Series Creator Leslye Headland Revels in the First Teaser Trailer

TM & © Lucasfilm Ltd. All Rights Reserved