This is what I have:

    glob(os.path.join(&#39;src&#39;,&#39;*.c&#39;))

but I want to search the subfolders of src. Something like this would work:

    glob(os.path.join(&#39;src&#39;,&#39;*.c&#39;))
    glob(os.path.join(&#39;src&#39;,&#39;*&#39;,&#39;*.c&#39;))
    glob(os.path.join(&#39;src&#39;,&#39;*&#39;,&#39;*&#39;,&#39;*.c&#39;))
    glob(os.path.join(&#39;src&#39;,&#39;*&#39;,&#39;*&#39;,&#39;*&#39;,&#39;*.c&#39;))

But this is obviously limited and clunky.

How to use glob() to find files recursively?

I need to write a script that starts my program with different arguments, but I&#39;m new to Bash. I start my program with:

`./MyProgram.exe Data/data1.txt [Logs/data1_Log.txt]`.

Here is the pseudocode for what I want to do:

    for each filename in /Data do
      for int i = 0, i = 3, i++
        ./MyProgram.exe Data/filename.txt Logs/filename_Log{i}.txt
      end for
    end for

So I&#39;m really puzzled how to create second argument from the first one, so it looks like dataABCD_Log1.txt and start my program. 

How to loop over files in directory and change path and add suffix to filename

I am trying to get a list of files in a directory using Python, but I do not want a list of ALL the files.

What I essentially want is the ability to do something like the following but using Python and not executing ls.

    ls 145592*.jpg

If there is no built-in method for this, I am currently thinking of writing a for loop to iterate through the results of an `os.listdir()` and to append all the matching files to a new list.

However, there are a lot of files in that directory and therefore I am hoping there is a more efficient method (or a built-in method).

Get a filtered list of files in a directory

Say I want to copy the contents of a directory excluding files and folders whose names contain the word &#39;Music&#39;.

    cp [exclude-matches] *Music* /target_directory

What should go in place of [exclude-matches] to accomplish this?

How can I use inverse or negative wildcards when pattern matching in a unix/linux shell?

For example I had a folder called `Temp&#39; and I wanted to delete or flush all files from this folder using PHP. Could I do this?


Deleting all files from a folder using PHP?

I need to count the number of files in a directory using Python.

I guess the easiest way is `len(glob.glob(&#39;*&#39;))`, but that also counts the directory itself as a file.

Is there any way to count only the _files_ in a directory?

How to count the number of files in a directory using Python

If I want to check for the existence of a single file, I can test for it using `test -e filename` or `[ -e filename ]`.

Supposing I have a glob and I want to know whether any files exist whose names match the glob. The glob can match 0 files (in which case I need to do nothing), or it can match 1 or more files (in which case I need to do something). How can I test whether a glob has any matches? (I don&#39;t care how many matches there are, and it would be best if I could do this with one `if` statement and no loops (simply because I find that most readable).

(`test -e glob*` fails if the glob matches more than one file.)


Test whether a glob has any matches in Bash

I have written the following Python code:

    #!/usr/bin/python
    # -*- coding: utf-8 -*-

    import os, glob

    path = &#39;/home/my/path&#39;
    for infile in glob.glob( os.path.join(path, &#39;*.png&#39;) ):
        print infile

Now I get this:


    /home/my/path/output0352.png
    /home/my/path/output0005.png
    /home/my/path/output0137.png
    /home/my/path/output0202.png
    /home/my/path/output0023.png
    /home/my/path/output0048.png
    /home/my/path/output0069.png
    /home/my/path/output0246.png
    /home/my/path/output0071.png
    /home/my/path/output0402.png
    /home/my/path/output0230.png
    /home/my/path/output0182.png
    /home/my/path/output0121.png
    /home/my/path/output0104.png
    /home/my/path/output0219.png
    /home/my/path/output0226.png
    /home/my/path/output0215.png
    /home/my/path/output0266.png
    /home/my/path/output0347.png
    /home/my/path/output0295.png
    /home/my/path/output0131.png
    /home/my/path/output0208.png
    /home/my/path/output0194.png


In which way is it ordered?

To clarify: I am not interested in ordering - I know `sorted`. I want to know in which order it comes by default.

It might help you to get my ls -l output:


    -rw-r--r-- 1 moose moose 627669 2011-07-17 17:26 output0005.png
    -rw-r--r-- 1 moose moose 596417 2011-07-17 17:26 output0023.png
    -rw-r--r-- 1 moose moose 543639 2011-07-17 17:26 output0048.png
    -rw-r--r-- 1 moose moose 535384 2011-07-17 17:27 output0069.png
    -rw-r--r-- 1 moose moose 543216 2011-07-17 17:27 output0071.png
    -rw-r--r-- 1 moose moose 561776 2011-07-17 17:27 output0104.png
    -rw-r--r-- 1 moose moose 501865 2011-07-17 17:27 output0121.png
    -rw-r--r-- 1 moose moose 547144 2011-07-17 17:27 output0131.png
    -rw-r--r-- 1 moose moose 530596 2011-07-17 17:27 output0137.png
    -rw-r--r-- 1 moose moose 532567 2011-07-17 17:27 output0182.png
    -rw-r--r-- 1 moose moose 553562 2011-07-17 17:27 output0194.png
    -rw-r--r-- 1 moose moose 574065 2011-07-17 17:27 output0202.png
    -rw-r--r-- 1 moose moose 552197 2011-07-17 17:27 output0208.png
    -rw-r--r-- 1 moose moose 559809 2011-07-17 17:27 output0215.png
    -rw-r--r-- 1 moose moose 549046 2011-07-17 17:27 output0219.png
    -rw-r--r-- 1 moose moose 566661 2011-07-17 17:27 output0226.png
    -rw-r--r-- 1 moose moose 561678 2011-07-17 17:27 output0246.png
    -rw-r--r-- 1 moose moose 525550 2011-07-17 17:27 output0266.png
    -rw-r--r-- 1 moose moose 565715 2011-07-17 17:27 output0295.png
    -rw-r--r-- 1 moose moose 568381 2011-07-17 17:28 output0347.png
    -rw-r--r-- 1 moose moose 532768 2011-07-17 17:28 output0352.png
    -rw-r--r-- 1 moose moose 535818 2011-07-17 17:28 output0402.png

It is not ordered by filename or size.

Other links: [`glob`][1], [`ls`][2]


  [1]: http://docs.python.org/library/glob.html
  [2]: http://en.wikipedia.org/wiki/Ls

How are glob.glob()&#39;s return values ordered?

Is there a better way to use glob.glob in python to get a list of multiple file types such as .txt, .mdown, and .markdown?  Right now I have something like this:

    projectFiles1 = glob.glob( os.path.join(projectDir, &#39;*.txt&#39;) )
    projectFiles2 = glob.glob( os.path.join(projectDir, &#39;*.mdown&#39;) )
    projectFiles3 = glob.glob( os.path.join(projectDir, &#39;*.markdown&#39;) )



Python glob multiple filetypes

How do I recursively add files by a pattern (or glob) located in different directories?

For example, I&#39;d like to add `A/B/C/foo.java` and `D/E/F/bar.java` (and several other java files) with one command:

    git add &#39;*.java&#39;

Unfortunately, that doesn&#39;t work as expected.

Recursively add files by pattern

How can I move all files except one? I am looking for something like: 

    &#39;mv ~/Linux/Old/!Tux.png ~/Linux/New/&#39;

where I move old stuff to new stuff -folder except `Tux.png`. !-sign represents a negation. Is there some tool for the job?

Move all files except one

My issue is that I have a bunch of WordPress websites in my git repo, of which I want to selectively commit only the content of my `themes` folders, while ignoring the rest of the redundant files found in WordPress.  

I&#39;ve used .gitignore files to ignore file types before, but can it be used the other way around- that is to ignore everything BUT a certain folder path?

&gt; root (git repo)&lt;br&gt;
&gt; - / wordpress&lt;br&gt; 
&gt; - - / (WordPress Site 1)/wp-content/themes&lt;br&gt; 
&gt; - - / (WordPress Site 2)/wp-content/themes&lt;br&gt; 
&gt; - - / (WordPress Site 3)/wp-content/themes&lt;br&gt;

Thanks-

**UPDATE:** 

Based on the answers I did the following, but it&#39;s not working.  Any ideas?

    # Ignore everything:
    *
    # Except for wordpress themes:
    !*/wp-content/themes/*


I&#39;ve also tried the following variations:

    !*/wp-content/themes*
    !*wp-content/themes/*
    !wp-content/themes/*
    !/wordpress/*/wp-content/themes*
    !wordpress/*/wp-content/themes*


None of these read my `themes` folders.



Using .gitignore to ignore everything but specific directories

I have a directory with a bunch of files inside: `eee2314`, `asd3442` ... and `eph`.

I want to exclude all files that start with `eph` with the `glob` function.

How can I do it?

glob exclude pattern

    for i in $(ls);do
        if [ $i = &#39;*.java&#39; ];then
            echo &quot;I do something with the file $i&quot;
        fi
    done

I want to loop through each file in the current folder and check if it matches a specific extension. The code above doesn&#39;t work, do you know why? 

Loop through all the files with a specific extension

I want to open a series of subfolders in a folder and find some text files and print some lines of the text files. I am using this:

    configfiles = glob.glob(&#39;C:/Users/sam/Desktop/file1/*.txt&#39;)

But this cannot access the subfolders as well. Does anyone know how I can use the same command to access subfolders as well?

How can I search sub-folders using glob.glob module?

I&#39;ve tried the following command but I am having trouble interpreting the results:

```bash
ls **
```

I&#39;m not sure exactly what it is outputting and why.

What do double-asterisk (**) wildcards mean?

Is there a way I can use glob on a directory, to get files with a specific extension, but only the filename itself, not the whole path?

Python Glob without the whole path - only the filename

This is a pretty dumb question, but I haven&#39;t really been able to find a satisfactory answer: How do I use gulp globbing to select *all* files in *all* subdirectories below a certain directory?

I&#39;ve tried:

`&#39;./src/less&#39;`
`&#39;./src/less/&#39;`
`&#39;./src/less/*&#39;`

None of them seem to work.

gulp globbing- how to watch everything below directory

I know `**/*.ext` expands to all files in all subdirectories matching `*.ext`, but what is a similar expansion that includes all such files in the *current* directory as well?

What expands to all files in current directory recursively?

I&#39;m currently using gulp to call a bash script that cleans my `dist/` directory and moves the appropriate files to the clean directory. I would like this to be done with gulp because I am not sure the script would work on a non *nix file system.  
So far, I&#39;m using the gulp-clean module to clean the `dist/` directory but when I try to move the required directories and their files to the dist folder, the directories are empty.

    var gulp = require(&#39;gulp&#39;),
        clean = require(&#39;gulp-clean&#39;);

    gulp.task(&#39;clean&#39;, function(){
      return gulp.src([&#39;dist/*&#39;], {read:false})
      .pipe(clean());
    });

    gulp.task(&#39;move&#39;,[&#39;clean&#39;], function(){
      gulp.src([&#39;_locales&#39;, &#39;icons&#39;, &#39;src/page_action&#39;, &#39;manifest.json&#39;])
      .pipe(gulp.dest(&#39;dist&#39;));
    });

    gulp.task(&#39;dist&#39;, [&#39;move&#39;]);

calling `gulp dist` results in the the `dist/` directory being populated with the correct directories but they are all empty

    $ ls dist/*
    dist/manifest.json

    dist/_locales:

    dist/icons:

    dist/page_action:
How do I copy the directories and their contents to the `dist/` folder?

Use gulp to select and move directories and their files

I have this path in my react gulpfile:

&lt;!-- language: lang-javascript --&gt;

    var path = {
      HTML: &#39;src/index.html&#39;,
      ALL: [&#39;src/js/*.js&#39;, &#39;src/js/**/*.js&#39;, &#39;src/index.html&#39;],
      JS: [&#39;src/js/*.js&#39;, &#39;src/js/**/*.js&#39;],
      MINIFIED_OUT: &#39;build.min.js&#39;,
      DEST_SRC: &#39;dist/src&#39;,
      DEST_BUILD: &#39;dist/build&#39;,
      DEST: &#39;dist&#39;
    };

What is the double glob character?

I know what the single glob is... but what is the double?
[single glob](https://en.wikipedia.org/wiki/Glob_(programming))

What is the ** glob character?

Is there a standard (preferably Apache Commons or similarly non-viral) library for doing &quot;glob&quot; type matches in Java?  When I had to do similar in Perl once, I just changed all the &quot;`.`&quot; to &quot;`\.`&quot;, the &quot;`*`&quot; to &quot;`.*`&quot; and the &quot;`?`&quot; to &quot;`.`&quot; and that sort of thing, but I&#39;m wondering if somebody has done the work for me.

Similar question: https://stackoverflow.com/questions/445910/create-regex-from-glob-expression

Is there an equivalent of java.util.regex for &quot;glob&quot; type patterns?

I&#39;m attempting to pass gulp.src an array of files that I want it to deal with. This is the array as it stands.

    [&#39;bower_components/jquery/jquery.js&#39;,
     &#39;bower_components/superscrollorama/js/greensock/TweenMax.min.js&#39;,
     &#39;bower_components/superscrollorama/jquery.superscrollorama.js&#39; ]

I&#39;m finding though that gulp.src doesn&#39;t seem to like that and the third element doesn&#39;t make it through into the end destination.

I&#39;ve found that everything works fine when I introduce some wildcard characters like this:

    [&#39;bower_components/**/jquery.js&#39;,
     &#39;bower_components/**/js/greensock/TweenMax.min.js&#39;,
     &#39;bower_components/**/jquery.superscrollorama.js&#39; ]

But why? Something to do with the way globbing works? I&#39;ve googled but can&#39;t find out.

Maybe this isn&#39;t the intended purpose of globbing but it doesn&#39;t make sense to me that it should work this way. Can anyone shed some light?

Why does gulp.src not like being passed an array of complete paths to files?

I have a situation where I&#39;m trying to use grunt to lint a codebase, excluding specific folders.

grunt uses minimatch (similar to bsdglob) under the hood to match files, but I can&#39;t seem to figure out how to do a .gitignore style exclude of a folder.

I&#39;d like to ingest this:

`ignoreme`

and match these:

    /folder/path/here/to/something/ok.js
    /another/folder/path.js
    /test.js

but not match these:

    /folder/ignoreme/something.js
    /folder/path/here/to/ignoreme/metoo/file.js

This will match everything, including ignoreme:

    /**/*.js

So I figured I could do something like:

    /**/!(ignoreme)/**/*.js

but that matches files in the ignoreme folder.

I&#39;m used to regexes, but can&#39;t seem to figure out how to repeat a pattern or something here - I also tried stuff like:

    /(!(ignoreme)|*)*/*.js

hoping the container would repeat, but that doesn&#39;t work, it just fails to match everything.

Any way to either pass a regex to grunt file paths, or make this work for me?

Update:
===

Here&#39;s how I&#39;m currently dealing with this issue:

    var pattern = /\/ignoreme\//
    var files = grunt.file.expandFiles(arrayOfFilesPassedToMinimatch).filter(function(f){
      return !pattern.test(f)
    })

I&#39;d still be interested if folder excludes are possible in minimatch.

grunt (minimatch/glob) folder exclusion

Here&#39;s how one might list all files matching a pattern in bash:

    ls *.jar

How to list the complement of a pattern? i.e. all files not matching *.jar?

List files not matching a pattern?

I am learning python (python 3) and I can copy 1 file to a new directory
by doing this

    import shutil 
    shutil.copyfile(&#39;C:/test/test.txt&#39;, &#39;C:/lol/test.txt&#39;)

What I am now trying to do is to copy all *.txt files from C:/ to C:/test

*.txt is a wildcard to search for all the text files on my hard drive

python copy files by wildcards

I&#39;m a new user to gulp.js.  I&#39;d like to move all of my non-javascript files to a build directory.  What I&#39;ve got right now is this:

    //Test copy
    gulp.task(&#39;test-copy&#39;, function() {
    	gulp.src([&#39;myProject/src/**/*.!(js|map|src)&#39;])
    		.pipe(gulp.dest(&#39;myProject/build&#39;));
    });


    //Results for various files
    myProject/css/style.css //Copied - GOOD
    myProject/html/index.html //Copied - GOOD
    myProject/js/foo.js //Not Copied - GOOD
    myProject/js/bar.min.js //Copied - BAD!
    myProject/js/jquery-2.0.3.min.js //Copied - BAD!
    myProject/js/jquery-2.0.3.min.map //Copied - BAD!

As you can see, it only matches after the first dot in the file path string, not the last one, as I&#39;d like.  How can I modify the glob search string to behave as I&#39;d like?

Glob matching, exclude all JS files

Directly from [this][1] Java Oracle tutorial:

&gt; Two asterisks, **, works like * but crosses directory boundaries. This
&gt; syntax is generally used for matching complete paths.

Could anybody do a real example out of it?
What do they mean with &quot;crosses directory boundary&quot;?
Crossing the directory boundary, I imagine something like checking the file from root to `getNameCount()-1`.
Again a real example explaining the difference between * and ** in *practice* would be great.

  [1]: http://docs.oracle.com/javase/tutorial/essential/io/fileOps.html#glob


When to use ** (double star) in glob syntax within JAVA

This question is a spin-off from [this one][1]. Some history: when I first learned Perl, I pretty much always used `glob` rather than `opendir` + `readdir` because I found it easier. Then later various posts and readings suggested that `glob` was bad, and so now I pretty much always use `readdir`.

After thinking over [this recent question][2] I realized that my reasons for one or the other choice may be bunk. So, I&#39;m going to lay out some pros and cons, and I&#39;m hoping that more experienced Perl folks can chime in and clarify. The question in a nutshell is are there compelling reasons to prefer `glob` to `readdir` or `readdir` to `glob` (in some or all cases)?

### `glob` pros:

 1. No dotfiles (unless you ask for them)
 2. Order of items is guaranteed
 3. No need to prepend the directory name onto items manually
 4. Better name (c&#39;mon - `glob` versus `readdir` is no contest if we&#39;re judging by names alone)
 5. (From [ysth&#39;s answer](#1507507); cf. `glob` cons 4 below) Can return non-existent filenames:

        @deck = glob &quot;{A,K,Q,J,10,9,8,7,6,5,4,3,2}{\x{2660},\x{2665},\x{2666},\x{2663}}&quot;;


### `glob` cons:

 1. Older versions are just plain broken (but &#39;older&#39; means pre 5.6, I think, and frankly if you&#39;re using pre 5.6 Perl, you have bigger problems)
 2. Calls `stat` each time (i.e., useless use of `stat` in most cases).
 3. Problems with spaces in directory names (is this still true?)
 4. (From [brian&#39;s answer](#1506886)) Can return filenames that don&#39;t exist:

        $ perl -le &#39;print glob &quot;{ab}{cd}&quot;&#39;

### `readdir` pros:

 1. (From [brian&#39;s answer](#1506886)) `opendir` returns a filehandle which you can pass around in your program (and reuse), but `glob` simply returns a list
 2. (From [brian&#39;s answer](#1506886)) `readdir` is a proper iterator and provides functions to `rewinddir`, `seekdir`, `telldir`
 3. Faster? (Pure guess based on some of `glob`&#39;s features from above. I&#39;m not really worried about this level of optimization anyhow, but it&#39;s a theoretical pro.)
 4. Less prone to edge-case bugs than `glob`?
 5. Reads everything (dotfiles too) by default (this is also a con)
 6. May convince you not to name a file `0` (a con also - see [Brad&#39;s answer](#2365358))
 7. Anyone? Bueller? Bueller?

### `readdir` cons:

 1. If you don&#39;t remember to prepend the directory name, you **will** get bit when you try to do filetests or copy items or edit items or...
 2. If you don&#39;t remember to `grep` out the `.` and `..` items, you **will** get bit when you count items, or try to walk recursively down the file tree or...
 3. Did I mention prepending the directory name? (A sidenote, but my very first post to the Perl Beginners mail list was the classic, &quot;Why does this code involving filetests not work some of the time?&quot; problem related to this gotcha. Apparently, I&#39;m still bitter.)
 4. Items are returned in no particular order. This means you will often have to remember to sort them in some manner. (This could be a pro if it means more speed, and if it means that you actually *think* about how and if you need to sort items.) **Edit**: Horrifically small sample, but on a Mac `readdir` returns items in alphabetical order, case insensitive. On a Debian box and an OpenBSD server, the order is utterly random. I tested the Mac with Apple&#39;s built-in Perl (5.8.8) and my own compiled 5.10.1. The Debian box is 5.10.0, as is the OpenBSD machine. I wonder if this is a filesystem issue, rather than Perl? 
 5. Reads everything (dotfiles too) by default (this is also a pro)
 6. Doesn&#39;t necessarily deal well with a file named `0` (see pros also - see [Brad&#39;s answer](#2365358))

 


  [1]: https://stackoverflow.com/questions/1499672/how-do-i-open-an-array-of-files-in-perl
  [2]: https://stackoverflow.com/questions/1499672/how-do-i-open-an-array-of-files-in-perl

What reasons are there to prefer glob over readdir (or vice-versa) in Perl?

I want to be able to match a pattern in [`glob`](https://docs.python.org/2/library/glob.html) format to a list of strings, rather than to actual files in the filesystem. Is there any way to do this, or convert a `glob` pattern easily to a regex?



Python glob but against a list of strings rather than the filesystem

I have several .screen files inside `/xxx/documentation` and its subdirectories that are already tracked by Git.

After modifying many of these screen files, I run `git add documentation/\\*.screen`—as indicated by the first example in `git-add`&#39;s documentation—to stage these files, but the command fails:

&lt;pre&gt;fatal: pathspec &#39;documentation/\*.screen&#39; did not match any files&lt;/pre&gt;

Is my command bad, or does git have a bug?

git: How do I recursively add all files in a directory subtree that match a glob pattern?

    import glob
    
    list = glob.glob(r&#39;*abc*.txt&#39;) + glob.glob(r&#39;*123*.txt&#39;) + glob.glob(r&#39;*a1b*.txt&#39;)
    
    for i in list:
      print i

This code works to list files in the current folder which have `&#39;abc&#39;`, `&#39;123&#39;` or `&#39;a1b&#39;` in their names.

How would I use one `glob` to perform this function?


Regular expression usage in glob.glob?

One rule in my Makefile zips an entire directory (`res/`) into a ZIP file. Obviously, this rule needs to execute when *any* file under the `res/` directory changes. Thus, I want the rule to have as a prerequisite all files underneath that directory. How can I implement this rule?

In Bash [with the `globstar` option enabled](https://unix.stackexchange.com/questions/49913/recursive-glob/49917#49917), you can obtain a list of all the files in that directory using the wildcard pattern `res/**/*`. However, it doesn&#39;t seem to work if you specify it as a prerequisite in the Makefile:

    filename.jar: res/**/*

Even after `touch`ing a file in `res/`, Make still reports

    make: `filename.jar&#39; is up to date.

so clearly it is not recognizing the pattern.

If I declare the directory itself as a prerequisite:

    filename.jar: res

then Make will not re-execute when a file is modified (I think `make` only looks at the modified date of the directory itself, which only changes when immediate children are added, removed, or renamed).

Makefile rule that depends on all files under a directory (including within subdirectories)

I am looking for a better glob pattern for usemin, i want to to find all `.js` files but exclude the `.spec.js` files. I have the following solution so far.

```&lt;script src=&quot;components/**/*(.js|!(*.spec.js|*.scss))&quot;&gt;&lt;/script&gt;
```

The solution i have at the moment requires me to keep adding file extensions to exclude them, else they get picked up, for example `.html` files.

I tried to make it only look for `.js` files and exclude the `.spec.js` from them but it does not seem to work.

Also adding a `!components/**/*.spec.js` as another script below does not seem to work.

Node glob pattern for every .js file except .spec.js

I&#39;ve encountered situations where only glob-style patterns are supported and full regular expression support is not there, for instance redis keys. I&#39;d like to know the distinction between the two. Also it makes me wonder, is implementing regex matching algorithm way harder compared to glob-style pattern that some softwares doesn&#39;t support regex at all?

What are the differences between glob-style pattern and regular expression?

Is there a built-in mechanism in .NET to match patterns other than Regular Expressions?  I&#39;d like to match using UNIX style (glob) wildcards (* = any number of any character).  

I&#39;d like to use this for a end-user facing control.  I fear that permitting all RegEx capabilities will be very confusing.

glob pattern matching in .NET

I am using following script, which uses case statement to find the server. 

        #!/bin/bash
    SERVER=$1;
    echo $SERVER | egrep &quot;ws-[0-9]+\.host\.com&quot;;
    case $SERVER in
    ws-[0-9]+\.host\.com) echo &quot;Web Server&quot;
    ;;
    db-[0-9]+\.host\.com) echo &quot;DB server&quot;
    ;;
    bk-[0-9]+\.host\.com) echo &quot;Backup server&quot;
    ;;
    *)echo &quot;Unknown server&quot;
    ;;
    esac

But it is not working. Regex is working with egrep but not with case. sample O/P


    ./test-back.sh ws-23.host.com
    ws-23.host.com
    Unknown server

Any Idea ?


Regular expressions in a Bash case statement

When the following two lines of code are executed in a bash script, &quot;ls&quot; complains that the files don&#39;t exist:

    dirs=/content/{dev01,dev02}
    ls -l $dirs

When I run the script with the -x option, it appears to be passing the variable within single quotes (which would prevent globbing):

    + dirs=/content/{dev01,dev01}
    + ls -l &#39;/content/{dev01,dev01}&#39;
    ls: /content/{dev01,dev01}: No such file or directory

If I execute the &quot;ls&quot; command from my interactive shell (sans quotes), it returns the two directories.

I&#39;ve been reading through the Bash Reference Manual (v 3.2) and can&#39;t see any reason for filename globbing to not take place (I&#39;m not passing -f to the shell), or anything that I can set to ensure that globbing happens.


How to assign a glob expression to a variable in a Bash script?

I&#39;m using the npm module [node-glob][1].

This snippet returns recursively all files in the current working directory.

    var glob = require(&#39;glob&#39;);
    glob(&#39;**/*&#39;, function(err, files) {
        console.log(files);
    });

sample output:

    [ &#39;index.html&#39;, &#39;js&#39;, &#39;js/app.js&#39;, &#39;js/lib.js&#39; ]

I want to exclude **index.html** and **js/lib.js**.
I tried to exclude these files with negative pattern **&#39;!&#39;** but without luck.
Is there a way to achieve this only by using a pattern?


  [1]: https://github.com/isaacs/node-glob

All Glob Solutions on Gang of Coders

Total of 39 Glob Solutions