Welcome to Linux Knowledge Base and Tutorial
"The place where you learn linux"

 Create an AccountHome | Submit News | Your Account  

Tutorial Menu
Linux Tutorial Home
Table of Contents

· Introduction to Operating Systems
· Linux Basics
· Working with the System
· Shells and Utilities
· Editing Files
· Basic Administration
· The Operating System
· The X Windowing System
· The Computer Itself
· Networking
· System Monitoring
· Solving Problems
· Security
· Installing and Upgrading
· Linux and Windows

Man Pages
Linux Topics
Test Your Knowledge

Site Menu
Site Map
Copyright Info
Terms of Use
Privacy Info
Masthead / Impressum
Your Account

Private Messages

News Archive
Submit News
User Articles
Web Links


The Web

Who's Online
There are currently, 76 guest(s) and 0 member(s) that are online.

You are an Anonymous user. You can register for free by clicking here




       Long  ago,  in Unix V6, there was a program /etc/glob that
       would expand  wildcard  patterns.   Soon  afterwards  this
       became a shell built-in.

       These  days  there  is also a library routine glob(3) that
       will perform this function for a user program.

       The rules are as follows (POSIX 1003.2, 3.13).


       A string is a wildcard pattern if it contains one  of  the
       characters `?', `*' or `['. Globbing is the operation that
       expands a wildcard pattern  into  the  list  of  pathnames
       matching the pattern. Matching is defined by:

       A `?' (not between brackets) matches any single character.

       A `*' (not between brackets) matches any string, including
       the empty string.

   Character classes
       An  expression `[...]' where the first character after the
       leading `[' is not an  `!'  matches  a  single  character,
       namely  any  of  the  characters enclosed by the brackets.
       The string enclosed  by  the  brackets  cannot  be  empty;
       therefore  `]'  can  be allowed between the brackets, pro≠
       vided that it  is  the  first  character.  (Thus,  `[][!]'
       matches the three characters `[', `]' and `!'.)

       There  is one special convention: two characters separated
       by `-' denote a range.  (Thus, `[A-Fa-f0-9]' is equivalent
       to  `[ABCDEFabcdef0123456789]'.)   One  may include `-' in
       its literal meaning by making it the first or last charac≠
       ter  between the brackets.  (Thus, `[]-]' matches just the
       two characters `]' and `-', and `[--0]' matches the  three
       characters `-', `.', `0', since `/' cannot be matched.)

       An  expression `[!...]' matches a single character, namely
       any character  that  is  not  matched  by  the  expression
       obtained  by  removing  the  first  `!'  from  it.  (Thus,
       `[!]a-]' matches any single character except `]', `a'  and

       One  can remove the special meaning of `?', `*' and `[' by
       preceding them by a backslash, or, in case this is part of
       a  shell  command line, enclosing them in quotes.  Between
       file, and `tar c *' will not archive all your files;  `tar
       c .' is better.)


       The  nice  and simple rule given above: `expand a wildcard
       pattern into the list of matching pathnames' was the orig≠
       inal Unix definition. It allowed one to have patterns that
       expand into an empty list, as in
            xv -wait 0 *.gif *.jpg
       where perhaps no *.gif files are present (and this is  not
       an  error).   However, POSIX requires that a wildcard pat≠
       tern is left unchanged when it is syntactically incorrect,
       or the list of matching pathnames is empty.  With bash one
       can   force   the   classical   behaviour    by    setting

       (Similar problems occur elsewhere. E.g., where old scripts
            rm `find . -name "*~"`
       new scripts require
            rm -f nosuchfile `find . -name "*~"`
       to avoid error messages from rm called with an empty argu≠
       ment list.)


   Regular expressions
       Note  that  wildcard patterns are not regular expressions,
       although they are a bit similar. First of all, they  match
       filenames, rather than text, and secondly, the conventions
       are not the same: e.g., in a regular expression `*'  means
       zero or more copies of the preceding thing.

       Now  that  regular  expressions  have  bracket expressions
       where the negation  is  indicated  by  a  `^',  POSIX  has
       declared  the  effect of a wildcard pattern `[^...]' to be

   Character classes and Internationalization
       Of course ranges were originally meant to be ASCII ranges,
       so  that  `[ -%]' stands for `[ !"#$%]' and `[a-z]' stands
       for "any lowercase  letter".   Some  Unix  implementations
       generalized this so that a range X-Y stands for the set of
       characters with code between the codes for X  and  for  Y.
       However, this requires the user to know the character cod≠
       ing in use on the local system, and moreover, is not  con≠
       venient  if  the collating sequence for the local alphabet
       differs from the ordering of the character codes.   There≠
       fore,  POSIX  extended  the bracket notation greatly, both
       for wildcard patterns and for regular expressions.  In the
       so that one can say `[[:lower:]]' instead of `[a-z]',  and
       have  things  work  in Denmark, too, where there are three
       letters past `z' in the alphabet.  These character classes
       are  defined  by  the  LC_CTYPE  category  in  the current

       (v) Collating symbols,  like  `[.ch.]'  or  `[.a-acute.]',
       where the string between `[.' and `.]' is a collating ele≠
       ment defined for the current locale. Note that this may be
       a multi-character element.

       (vi)  Equivalence  class  expressions, like `[=a=]', where
       the string between `[=' and `=]' is any collating  element
       from  its  equivalence  class,  as defined for the current
       locale. For example,  `[[=a=]]'  might  be  equivalent  to
       `[aŠŗš‚]'  (warning:  Latin-1  here),  that is, to `[a[.a-


       sh(1), glob(3), fnmatch(3), locale(7), regex(7)

Unix                        2003-08-24                    GLOB(7)
Show your Support for the Linux Tutorial

Purchase one of the products from our new online shop. For each product you purchase, the Linux Tutorial gets a portion of the proceeds to help keep us going.



Security Code
Security Code
Type Security Code

Don't have an account yet? You can create one. As a registered user you have some advantages like theme manager, comments configuration and post comments with your name.

Help if you can!

Amazon Wish List

Did You Know?
You can choose larger fonts by selecting a different themes.


Tell a Friend About Us

Bookmark and Share

Web site powered by PHP-Nuke

Is this information useful? At the very least you can help by spreading the word to your favorite newsgroups, mailing lists and forums.
All logos and trademarks in this site are property of their respective owner. The comments are property of their posters. Articles are the property of their respective owners. Unless otherwise stated in the body of the article, article content (C) 1994-2013 by James Mohr. All rights reserved. The stylized page/paper, as well as the terms "The Linux Tutorial", "The Linux Server Tutorial", "The Linux Knowledge Base and Tutorial" and "The place where you learn Linux" are service marks of James Mohr. All rights reserved.
The Linux Knowledge Base and Tutorial may contain links to sites on the Internet, which are owned and operated by third parties. The Linux Tutorial is not responsible for the content of any such third-party site. By viewing/utilizing this web site, you have agreed to our disclaimer, terms of use and privacy policy. Use of automated download software ("harvesters") such as wget, httrack, etc. causes the site to quickly exceed its bandwidth limitation and are therefore expressly prohibited. For more details on this, take a look here

PHP-Nuke Copyright © 2004 by Francisco Burzi. This is free software, and you may redistribute it under the GPL. PHP-Nuke comes with absolutely no warranty, for details, see the license.
Page Generation: 0.06 Seconds