Unix/ls: Difference between revisions

</pre>

<br><br>

 

=={{header|8080 Assembly}}==

filenames in sorted order, so it has to do the sorting itself.

 

puts: equ 9h ; Write string to console

sfirst: equ 11h ; Find first matching file

fcb: db 0,'???????????' ; Accept any file

ds fcb+36-$ ; Pad the FCB out to 36 bytes

 

=={{header|8th}}==

"*" f:glob

' s:cmp a:sort

"\n" a:join .

 

=={{header|Ada}}==

 

procedure Directory_List is

Put_Line(Result.Element(I));

end loop;

 

=={{header|Aime}}==

file f;

text s;

}

 

 

=={{header|Arturo}}==

 

 

=={{header|AWK}}==

{{works with|gawk}} "BEGINFILE" is a gawk-extension

# syntax: GAWK -f UNIX_LS.AWK * | SORT

BEGINFILE {

exit(0)

}

 

Sample commands and output under Windows 8:

 

=={{header|BaCon}}==

cnt% = 0

files$ = ""

PRINT FLATTEN$(f$)

NEXT

 

=={{header|C}}==

C does not have any os-independent way of reading a directory. The following uses readdir and should work on any Unix system.

#include <stdio.h>

#include <stdlib.h>

return 0;

}

 

=={{header|C sharp|C#}}==

using System.Collections.Generic;

using System.IO;

}

}

 

=={{header|C++}}==

{{libheader|Boost}}

#include <iostream>

#include <set>

std::cout << entry << '\n';

}

 

=={{header|Clojure}}==

 

 

=={{header|Common Lisp}}==

The workhorse is `files-list`, which returns a list of filenames. The `ls` function sorts the resulting list and formats it for output.

 

(let* ((dir (concatenate 'string path "/"))

(abs-path (car (directory dir)))

 

(defun ls (&optional (path "."))

 

=={{header|D}}==

import std.stdio, std.file, std.path, std.array, std.algorithm;

 

foreach (const string path; dirEntries(getcwd, SpanMode.shallow).array.sort)

path.baseName.writeln;

 

=={{header|EchoLisp}}==

No directory in EchoLisp, which is run in a browser window. Instead, "stores" (folders) and keys in stores (file names) are located in local storage.

;; ls of stores (kind of folders)

(for-each writeln (list-sort < (local-stores))) →

Glory

Jonah

 

=={{header|Elixir}}==

#Function<6.54118792/1 in :erl_eval.expr/5>

iex(2)> ls.("foo")

a

b

 

=={{header|Erlang}}==

1> Ls = fun(Dir) ->

1> {ok, DirContents} = file:list_dir(Dir),

b

[ok,ok,ok,ok]

 

=={{header|F_Sharp|F#}}==

<p>Works with .NET framework 4.</p>

<p>Prior to .NET4 you had to enumerate files and directories separately.</p>

<p>The call to <code>sort</code> is probably redundant, since "sorted by name" seems to be the default in Windows.</p>

=={{header|Forth}}==

This is much easier without the 'sorted output' requirement:

: each-filename { xt -- } \ xt-consuming variant

s" ." open-dir throw { d }

: ]each-filename ]] repeat drop r> close-dir throw [[ ; immediate compile-only

 

 

Given that requirement, we must first generate a sorted array of filenames:

{{libheader|Forth Foundation Library}}

dup 1+ allocate throw dup >r place r> ;

 

: ls ( -- )

[: count cr type ;] each-sorted-filename ;

 

=={{header|Fortran}}==

USE DFLIB !Mysterious library.

TYPE(FILE$INFO) INFO !With mysterious content.

END IF !So much for that entry.

IF (MARK.NE.FILE$LAST) GO TO 10 !Lastness is discovered after the last file is fingered.

INTEGER*4 FUNCTION GETFILEINFOQQ(FILES, BUFFER,dwHANDLE)

!DEC$ ATTRIBUTES DEFAULT :: GETFILEINFOQQ

INTEGER*4 dwHANDLE

END FUNCTION

Getting this to work was quite annoying. It turned out that the irritating "files" . and .. are deemed a directory (via the bit in INFO.PERMIT matching that of FILE$DIR = 16) and so can be skipped along with proper subdirectories, but the "PERMIT" value of -1 returned for the FILE$LAST state also matches, though its (non-existent) file name length is given as zero. Thus, if one skips directories filter-style by IF ... GO TO 10, in such a case the end will never be seen. Further, although Fortran syntax allows <code>INFO.PERMIT .AND. FILE$DIR</code> the bit values of logical variables are strange. Instead, what is needed is <code>IAND(INFO.PERMIT,FILE$DIR)</code>

 

 

As for the ordering of results, on this Windows XP system, the file names came out ordered so there is no need to mess about with a storage area to sort the names in.

 

=={{header|FunL}}==

 

for f <- sort( list(File( "." ).list()).filterNot(s -> s.startsWith(".")) )

 

{{out}}

The output is indeed sorted, but not all filetypes alltogether: the sorting algorythm is invoked for the different filetypes separately, because it is the way I like it!

 

###sysinclude dir.uh

###sysinclude stringextra.uh

{ „temp” }

{ „makestring” #s * dup 10 !+ swap free #g = }

 

{{out}}

for non-privilegized use: 13951995904 ( 11% )

All available free space: 20411224064 ( 16% )

 

</pre>

 

=={{header|Gambas}}==

Dim sDir As String[] = Dir(User.Home &/ "test").Sort()

 

Print sDir.Join(gb.NewLine)

 

Output:

<pre>

 

=={{header|Go}}==

 

import (

fmt.Println(n)

}

 

=={{header|Haskell}}==

{{Works with|GHC|7.8.3}}

 

import Data.List

import System.Directory

main = do

files <- getDirectoryContents "."

 

=={{header|J}}==

See the [http://www.jsoftware.com/wsvn/base8/trunk/main/main/dir.ijs dir.ijs script] for a full description of the interface for <code>dir</code>:

 

=={{header|Java}}==

{{Works with|Java|11}}

 

package rosetta;

 

}

}

 

The challenge does not state that the files must be sorted in case-insensitive order, and the majority of solutions in other languages do not bother with same.

The above can be expanded to sort case-insensitively by mapping Path to String and using the predefined String Comparator:

Files.list(Path.of("")).map(Path::toString).sorted(String.CASE_INSENSITIVE_ORDER).forEach(System.out::println);

 

=={{header|Javascript}}==

 

{{Works with|Node.js|4.3.2+}}

 

=={{header|Jsish}}==

To emulate ''ls'', sorted, one entry per line:

 

 

=={{header|Julia}}==

 

for e in readdir() # Current directory

# Same for...

readdir("~") # Read home directory

 

=={{header|Kotlin}}==

 

import java.io.File

fun main(args: Array<String>) {

ls(".") // list files in current directory, say

 

=={{header|LiveCode}}==

put the folders & the files

set the defaultFolder to "/foo/bar"

 

=={{header|Lua}}==

Using LuaFileSystem - available in LuaRocks, ULua, major Linux distro repos, etc, etc.

 

 

=={{header|Nanoquery}}==

import sort

 

for i in range(0, len(fnames) - 1)

println fnames[i]

{{out}}

<pre>.\nanoquery-2.3_1866

 

=={{header|Nim}}==

from os import walkPattern

from sequtils import toSeq

 

for path in toSeq(walkPattern("*")).sorted:

 

=={{header|Objeck}}==

class Test {

function : Main(args : String[]) ~ Nil {

}

}

 

=={{header|OCaml}}==

 

Array.iter print_endline (

 

{{Output}}

=={{header|PARI/GP}}==

GP doesn't have this capability so we can either use the shell or PARI. For the latter see [[#C|C]]; for the former:

in DOS/Windows or

in *nix.

 

 

When tested via Windows XP, the names came out in sorted order (ignoring case) however in earlier systems the files would be presented in entry order. That is, if files a, c, b were saved, they would be named in that order. Then, if file c were deleted and then a file named x were added, they would be named in the order a, x, b. In this case, a scheme for saving an unknown number of names (of unknown length) would be needed so that they could be sorted. Perhaps some linked-list with an insertionsort for each added name...

Program ls; {To list the names of all files/directories in the current directory.}

Uses DOS;

end;

END.

 

=={{header|Perl}}==

 

while (readdir $handle) {

print "$_\n";

}

 

Alternatively, using <tt>glob</tt>:

 

 

=={{header|Phix}}==

{{Out}}

<pre>

 

=== just names ===

{{Out}}

<pre>

 

===prettier output===

{{out}}

<pre>

animation.svg a 900 12:49pm Sat May 25th 2019

...etc

</pre>

 

This will output all the filenames in the current directory.

 

<?php

foreach(scandir('.') as $fileName){

echo $fileName."\n";

}

 

=={{header|PicoLisp}}==

 

=={{header|Pike}}==

 

=={{header|PowerShell}}==

Get-ChildItem | Sort-Object Name | Write-Output

 

# Prints only the name of each file in the directory

 

=={{header|Python}}==

>>> print('\n'.join(sorted(os.listdir('.'))))

DLLs

pythonw.exe

tcl

 

=={{header|R}}==

cat(paste(list.files(), collapse = "\n"), "\n")

cat(paste(list.files("bar"), collapse = "\n"), "\n")

{{out}}

<pre>

Ooh... warning... if you run the <code>test</code> module (either with DrRacket with the test module automatically running, or with <code>raco test ls.rkt</code>, then the example directory tree is built but not torn down.

 

 

;; Racket's `directory-list' produces a sorted list of files

(parameterize ([current-directory dir]) (with-output-to-string ls)))

(test (ls/str "foo") => "bar\n"

 

Both tests pass.

There is a <tt>dir</tt> builtin command which returns a list of IO::Path objects. We stringify them all with a hyperoperator before sorting the strings.

 

 

=={{header|REXX}}==

Notes on the options used for the &nbsp; (Microsoft Windows&reg;) &nbsp; '''DIR''' &nbsp; command:

::::* &nbsp; '''b''' &nbsp; is for <u>'''b'''</u>are format (no heading information or summary).

 

=={{header|Ruby}}==

Dir.foreach("./"){|n| puts n}

This will output all files including hidden ones e.g. '.' and '..'.

 

=={{header|Run BASIC}}==

print "rowcount: ";#f ROWCOUNT() ' how many rows in directory

#f DATEFORMAT("mm/dd/yy") 'set format of file date or not

print "time: ";#f TIME$() ' time

print "isdir: ";#f ISDIR() ' 1 = is a directory

This will output RunBasics Default Directory.. It can be any directory

<pre>rowcount: 30

 

=={{header|Rust}}==

use std::io::{self, Write};

use std::path::Path;

writeln!(&mut io::stderr(), "{}", msg).expect("Could not write to stderr");

process::exit(code)

 

{{out}}

 

=={{header|S-lang}}==

foreach p (array_sort(d))

 

=={{header|Scala}}==

 

=={{header|Seed7}}==

include "osfiles.s7i";

 

writeln(name);

end for;

 

=={{header|Sidef}}==

Explicit, by opening the current working directory:

Dir.cwd.open.each { |file|

file ~~ < . .. > && next;

content.sort.each { |file|

say file;

 

Implicit, by using the <i>String.glob</i> method:

say file;

 

=={{header|Smalltalk}}==

cheating solution:

{{works with|Smalltalk/X}}

real solution:

{{works with|Smalltalk/X}}

full 'ls -l' output:

{{works with|Smalltalk/X}}

dir directoryContentsAsFilenames sort do:[:fn |

|line|

].

line printCR

{{out}}

<pre>-rw-r--r-- xxxxx staff 18436 13 Okt 14:16 .DS_Store

 

=={{header|Standard ML}}==

Doing it all by yourself:

local (* make a sort function *)

val rec insert = fn s :string =>fn [] => [s]

 

sort result;

 

=={{header|Stata}}==

Stata has a builtin '''[http://www.stata.com/help.cgi?dir dir]''' command (or equivalently '''ls''').

 

6.3k 6/12/17 14:26 auto.dta

2.3k 8/10/17 7:34 titanium.dta

 

=={{header|Tcl}}==

 

=={{header|Ursa}}==

decl string<> fnames

set fnames (sort (f.listdir "."))

for (decl int i) (< i (size fnames)) (inc i)

out fnames<i> endl console

 

=={{header|Wren}}==

 

var path = "./" // or whatever

 

// Note that output is automatically sorted using this method.

 

=={{header|XPL0}}==

Works on Raspberry Pi.

char S;

[S:= "ls";

bl system

}

 

=={{header|zkl}}==

Lists all files and directories in the current directory. If you only want a list of files:

{{out}}

<pre>

 

The globular method recurses down through the directories. It can send results to objects, functions, methods, threads, etc, etc. To get a sorted list of all the directories under the "Src" directory:

{{out}}

<pre>