10-ish Unix CLI File Commands Every WordPress Developer Should Know
Two weeks ago, we published a conceptual primer on the command line for WordPress developers who’ve never used it and never thought of using it. That article didn’t really touch on any of the nitty-gritty of using the command line, though. And the heart of deftly using the command line is really down to having sufficient knowledge of a bunch of different commands that you can use.
As we mentioned in the original CLI article, the command line varies a lot from traditional Windows and the more-Unix-y command lines of Macs and Linux distributions. This means that while some of these commands may roughly work on a Microsoft operating system, they will work differently enough that this tutorial is probably not useful for someone working in an exclusively or primarily Windows environment.
Also as mentioned in the first article, there are alternative shells for working on the Unix command line. As BASH (the Bourne-Again Shell) is the most common, all commands in this article will be in that format.
With those provisos out of the way, I think there is a lot of mileage that comes form having basic familiarity with a large number of Unix commands and having a sense of when and how they’re useful. So let’s get started. At the end of this tutorial you should have a solid understanding of all the most essential file-and-folder-manipulations commands.
Commands for Filesystem Navigation and Creation
Our last Quick Guide was about the very basic commands that you need to understand to move around the filesystem on the command line. Folders or directories are one of the most foundational concepts of modern computing, and being able to confidently and fluently move around there is the first step to take to be good at using the command line for your WordPress (or any other) work.
pwd tells you where you are
The first command that I think you must know to understand the command line is
pwd. Because it tells you where you are already. Knowing where you are is always (in technology and in life ;p) the first step to getting to where you want to be.
pwd stands for “present working directory”, and that’s just what it tells you: where you are right now. Here’s the basics of it working:
MacBook-Pro:~ david$ pwd /Users/david
If you’re not used to seeing the Unix/BASH command line, there’s a lot of unimportant gibberish to the left of the “$” on the first line there. You can really ignore it. For the curious, it lists where we are, and who we are. Then to the right of the dollar sign is the area where we type out command. In this case, we’re typing
pwd and it’s responding with a location of
That directory is actually really special. If we look just to the left of the dollar sign (
$), we see that to the terminal we’re currently
david. And the
/Users/david directory is thus our “home” directory for our user. This directory, in various commands and references, is used a lot. Because of its frequent use, it has a nice little shortcut: the tilde (~). That is on the key to the left of your number 1 in the top row of your keyboard.
cd moves your command line location for you
Changing where you are is accomplished with the
cd command. What does it do? It “changes” your current “directory”. So if you’re in
/Random/Folder/on/your/computer and you want to get back to your “home”, you’d type
And if you wanted to go to an arbitrary relative path (starting from where you are), you’d type:
If you wanted to deterministically and with certainty know where you were going, you’d start your
cdcommand with a file path that has a forward slash (
/) at it’s start.
And if you wanted to deterministically and with certainty know where you were going, you’d start your
cd command with a file path that has a forward slash (
/) at it’s start.
/Users/david is an absolute path. I could go from there to the
/Users/david/Dropbox/WebDev directory by using any of the following commands:
cd Dropbox/WebDev #relative to where I am now cd ~/Dropbox/WebDev #relative to my user root cd /Users/david/Dropbox/WebDev #relative to the system root
Assuming I started in
/Users/david, all three of those commands take me to the identical location. Knowing that, and being able to see how all of those yield the same location is crucial.
The final common need when
cding is to go up a level. If I’m in
/Users/david/Dropbox/WebDev I can get back to my home directory in a couple ways:
cd ../.. # or cd .. cd .. # or cd ~
The primary piece of new knowledge here is that .. means “up a level” in the Unix command line. (Less necessary to know but still really useful—a single dot,
., is where you currently are.) So typing
cd .. twice is the same as typing
cd ../.., which will both move me to a location two folders above (in the hierarchical structure of Unix directories) than I currently am.
ls tells you what’s in your current directory
So we’ve learned how to tell where we are. And we’ve covered how to change where we are. The last crucial thing to know (and the last bit of knowledge that we covered in the Quick Guide about starting to move around the filesystem from the command line), is
ls “lists” what is in the current directory that our terminal is resting. As if we’re in
ls will show us all the folders and files that are sitting in that folder.
If we need a little more detail, we’ll want to add the
ls -l will tell us not just the files and folders, but a wealth of other information like the user who owns each file, its size, and more. (Again, for a little more detail on the
ls flag(s), look over the Quick Guide about the using the CLI to navigate the filesystem.)
mkdir makes a new directory
mkdir is the first command that changes something other than your current terminal. And as you may have been able to guess, the
mkdir command is how you “make” a “directory”. That is, if I want a new folder, I’d just simply type the command:
If that worked—no typos—then we’ll now have a folder wherever we are called “new-directory”.
touch creates a file
touchis one of the less-obviously-named commands
Finally, the last command that I think you should know about for basic navigation around the command line is
touch is one of the less-obviously-named commands, in my opinion. What
touch does is create a file for you. If I wanted a text file called “touched.txt” I could easily create an empty file with the command:
Once that file exists, I can add things to it using other commands. Or I can remove it. Or move it. And that’s the focus of our next section: the essential file-manipulation commands that are crucial for effective use of the CLI in a Unix-y system.
Manipulating Files on the Command Line
Once you’ve moved around and have created some files and folders, the next thing you’ll need to do is make changes to them. Maybe that’s taking away a file or folder, or moving it, or changing its contents. The possibilities are big, but only a few commands are really essential to getting comfortable with manipulating files and folders from the command line. The core ones are listed below:
cp, editing commands, and version control.
rm deletes files
rm has a pretty understandable name, it “removes” files. So lets assume we have the
touched.txt file we made with the
touch command, but we decide we no longer want it. What do we do?
And it’s gone. What about removing a folder though? There are a couple options. The first is that there does exist an
rmdir command which is made to remove directories. The hitch is that if the directory has anything in it, it won’t work.
So that’s why most people use
rm -rf to remove a directory and all the files inside of it. This is just the same
rm command we used to remove
touched.txt, but we’ve given it two flags. The
-r flag signifies that we want
rm to act “recursively”. “Recursively” means “keep doing the same thing all the way down”. So when we
rm recursively we’ll remove all files and folders inside the file and folder we’ve told the CLI to remove. The
-f flag stands for “force”, which is your way of telling the CLI that you really mean it and you don’t want it questioning you or double-checking with you or quitting part-way on you.
mv moves files and folders for you
The “move” command works about how you’d expect: it moves files or folders for you. It’s typed as
mv and you start with where it is, and then say where it’s going. So it basically looks a little like this on your command line:
mv touched.txt moved-touched.txt
You can use it the exact same way for folders. And you can also use
mv to put a file in a folder. That’s done with a command like:
mv touched.txt moved-folder/touched.txt
cp is the CLI way to copy a file
You use move when you want to change the place a file is. You use
cp when you want to replicate file or folder. Like
mv you first say where it (the file or folder you want to copy) is, and then where you want to new duplicate to go. So to duplicate
touched.txt you’d do something like:
cp touched.txt touched-copy.txt
It’s more idly interesting than useful, but judicious use of
rm can get around you ever typing the
mv command. Why you’d try to do that is a bit of stumper for me though…
emacs are text editors that work from the command line
My newbie-CLI-editor of choice is
mv can do for you most everything with your files as black boxes of data. But they don’t change what’s inside of them. You can see what’s inside of your files with commands like
tail (that’ll be my only mention of them, as I don’t think they’re crucial to know, just cool).
But to really see your files and be able to make changes to them, you need a text editor. If you’re already comfortable with Sublime Text or Atom or whatever, getting to know a command line text editor is not completely required when you’re on a local machine. But as soon as you start using the command line on a remote server, having at least some familiarity with a CLI text editor is essential.
emacs—about which whole books could and have been written—are heavy-duty and may replace your current GUI editor for you if you learn them really well.
My newbie-CLI-editor of choice is
nano. And you can get inside of
touched.txt and start to actually add some content to it with a simple:
What I really like about Nano—as opposed to VI(M) or Emacs—is that all your basic manipulations are shown on the screen. It tells you that you write/save the file with CTRL+o, and so on right on the screen. If you’ve never found yourself (as many newbies do) in VI not being able to quit. That seems pretty trivial, but if you’ve been there, you’ll understand why I think the using screen space for those explanations is great for beginners (or anyone who just occasionally finds a need for a CLI text editor).
svn, etc let you version control
Knowing that the
gitcommand exists is useful, even if you stick to the GUI app you prefer.
Finally, as with the text editors, the scope of these commands are too big to cover in depth. But version control is a core part of file manipulation for developers in WordPress and beyond. And
git is the most common version control application in use today.
You can do version control with a GUI app, or even in your text editor itself, but the real heart of Git is in the command line interface. And so knowing that the
git command exists is useful, even if you stick to the GUI app you prefer. A commit is done with the
git commit command, and a push is done via
git push. I could go on, but as I said knowing the Git CLI well is far beyond this article’s scope.
If you ever doing any work with WordPress.org, it’s also important to know that
svn, which is the command line interface for the Subversion version control system, is also available on most Unix computers. That’s what WordPress.org uses, so as a WordPress developer it’s good to have at least passing familiarity with.
What We’ve Learned About Commands for File Manipulation
We’ve only scratched the surface of the entirety of the command line. It is a vast and long-established kingdom. But I hope now you feel confident in all the basic functions that you might need to do as a developer trying to make your first go at the command line.
I think there are other non-file commands that are essential to really know how to use the command line to it’s full potential, but it’s impossible to really get those under control without having an ability to do all the basic file manipulation things. So hopefully how you use
ls are all kind of clear to you. And you know that
mkdir make new things for you. That
rm gets rid of them,
cp duplicates them, and
mv will change where they are.
Knowing that version control and text editing can be done from the command line is crucial too, though many WordPress developers never really have a need for either of those. But some prefer it for one or the other operation. Try out the Unix command line interface for one or both at least a few times and you’ll find it much easier to do in the future when you absolutely must. Happy hacking!