26 respuestas en este tema

[monchito_elroro]

Buenas amiguitos no se molesten si posteo otra vez plis  ....... les quiero mostrar un código que encontre para contar archivos
tomado de ecfisa le he modificado un poquitin:

delphi

Uses
Windows....;
 
var
myfiles : integer;
 
 
procedure TotalFilesFolders(Path:string);
var
  SR: TSearchRec;
begin
  ChDir(Path);
  if FindFirst ('*.*', faDirectory, SR )=0 then
  repeat
    if ((SR.Attr and fadirectory) = fadirectory) then
    begin
      if (SR.Name <> '.') and (SR.Name <> '..') then
      begin
        myfiles:=myfiles+1;
        //Inc(TotalFolders);
        TotalFilesFolders(Path + '\' + SR.Name );
      end
    end
    else
      myfiles:=myfiles+1;
      //Inc(TotalFiles);
  until FindNext(SR) <> 0;
  FindClose( SR );
end;

y lo llamo de la siguiente manera:

delphi

procedure TForm1.Button1Click(Sender: TObject);
begin
  myfiles:=0;
  TotalFilesFolders('E:\');
  ShowMessage(IntToStr(myfiles));
end;

Funciona bien pero que le tengo que agregar al código para que me cuente los archivos y carpetas
estando estos ocultos, pues estando visibles si los cuenta pero ocultos me manda 0...


Gracias.....


Edito: He modificado el mensaje para colocar el link al código del amigo ecfisa de ClubDelphi.

[escafandra]

Te propongo esta otra función. Cuenta todas las carpetas, subcarpetas y archivos:

delphi

function FileFolderCount(Dir:String): integer;
var
  sr: TSearchRec;
begin
    Result:= 0;
    if FindFirst(Dir + '\*.*', faAnyFile, sr) = 0 then
    repeat
      if (sr.Name <> '.') and (sr.Name <> '..') then
      begin
          if (sr.Attr and faDirectory)<>0 then
          begin
            inc(Result);
            // Para añadir subcarpetas
            Result:= Result + FileFolderCount(Dir + '\' + sr.Name);
          end else
            inc(Result);
      end;
    until FindNext(sr)<>0;
    FindClose(sr);
end;

Ejemplo de uso:

delphi

  Label.Caption:= IntToStr(FileFolderCount('C:\adaptec'));

Saludos.

[monchito_elroro]

Gracias amigo lo probarè......

[Delphius]

El problema de porqué no te cuenta las carpetas y archivos ocultos está en que tu solo evalúas con el atributo faDirectory. Si lees en la documentación para el parámetro Atrr son posibles los siguientes valores:

faReadOnly $00000001 Read-only files
faHidden $00000002 Hidden files
faSysFile $00000004 System files
faVolumeID $00000008 Volume ID files
faDirectory $00000010 Directory files
faArchive $00000020 Archive files
faAnyFile $0000003F Any file

Lee la ayuda sobre FindFirst. Te aclarará las dudas de cómo utilizar esta función.

Por cierto, los ejemplos mostrados contabilizan el total, si lo que buscas es contar archivos y carpetas dentro de cada subcarpeta deberás disponer de una estructura de datos llamada árbol diseñado para llevar dichos datos. Aunque claro, ahora será un poco más complicado el código.

Saludos,

[escafandra]

El problema de porqué no te cuenta las carpetas y archivos ocultos está en que tu solo evalúas con el atributo faDirectory...

Buena aclaración, por eso en mi ejemplo uso faAnyFile, incorporando a la cuenta todo tipo de archivos y carpetas.

...los ejemplos mostrados contabilizan el total, si lo que buscas es contar archivos y carpetas dentro de cada subcarpeta deberás disponer de una estructura de datos llamada árbol diseñado para llevar dichos datos. Aunque claro, ahora será un poco más complicado el código.

Mi ejemplo calcula los totales pero, como puedes ver, cuenta todas las carpetas y archivos incluidas las subcarpetas. Si queremos diferenciar lo que son carpatas y subcarpetas, por un lado, y archivos por otro (como lo hace el explorador al ver las propiedades de una carpeta) el código no se complica casi nada:

delphi

procedure FileFolderCount2(Dir:String; var FolderCount, FileCount: integer);
var
  sr: TSearchRec;
  nFolders, nFiles: integer;
begin
    FolderCount:= 0; FileCount:= 0;
    if FindFirst(Dir + '\*.*', faAnyFile, sr) = 0 then
    repeat
      if (sr.Name <> '.') and (sr.Name <> '..') then
      begin
          if (sr.Attr and faDirectory)<>0 then
          begin
            inc(FolderCount);
            // Para añadir subcarpetas
            FileFolderCount2(Dir + '\' + sr.Name, nFolders, nFiles);
            inc(FolderCount, nFolders);
            inc(FileCount, nFiles);
          end else
            inc(FileCount);
      end;
    until FindNext(sr)<>0;
    FindClose(sr);
end;

Forma de uso_

delphi

var
  nFolders, nFiles: integer;
begin
  FileFolderCount2('C:\Archivos de programa', nFolders, nFiles);
end;

Saludos.

[Wilson]

Gracias maestro escafandra, como de costumbre, código elegante y valioso.

Saludos

[Delphius]

Mi ejemplo calcula los totales pero, como puedes ver, cuenta todas las carpetas y archivos incluidas las subcarpetas. Si queremos diferenciar lo que son carpatas y subcarpetas, por un lado, y archivos por otro (como lo hace el explorador al ver las propiedades de una carpeta) el código no se complica casi nada:

A lo que yo apunto es que si se necesita llevar la cuenta tanto de los archivos y carpetas dentro de un directorio, de forma recursiva, y sin totalizar "hacia arriba" entonces SI se requiere de una estructura de datos árbol:

delphi

+----+----------+-------------+
-|Raiz|Archivos: |SubCarpetas: |
 +----+----------+-------------+
  |
  |  +-------------+----------+-------------+
  +--|SubCarpeta 1 |Archivos: |SubCarpetas: |
  |  +-------------+----------+-------------+
  |    |
  |    |
  |    +--- ...
  |
  ...
  |  +-------------+----------+-------------+
  +--|SubCarpeta N |Archivos: |SubCarpetas: |
     +-------------+----------+-------------+

Espero que se entienda a lo que apunto.

Saludos,

[escafandra]

A lo que yo apunto es que si se necesita llevar la cuenta tanto de los archivos y carpetas dentro de un directorio, de forma recursiva, y sin totalizar "hacia arriba" entonces SI se requiere de una estructura de datos árbol...

...Espero que se entienda a lo que apunto.

Si, ya entiendo lo que querías decir  . Bueno, ese caso si es un poco mas complejo, pero no creo que sea la duda que planteaba monchito_elroro.


Saludos.

[Delphius]

Bueno, ese caso si es un poco mas complejo, pero no creo que sea la duda que planteaba monchito_elroro.

Saludos.

Puede que no sea la duda de monchito_elroro pero yo nomás lo decía, por las dudas... Quien sabe, si al final también se podría o se requiera de eso (puede ser de interés para algunos; y quizá asi lo quieran).
Estuve pensando en como encararlo por ese lado pero tengo que reconocer que tengo oxidado la teoría de árboles-n. Por un momento me pensé en aprovechar alguno de las clases TTreeXXX pero no se me prende la lámpara.
La vía simple que podría pensar es directamente aprovechar un Tstrings y hacer el listado a como viene y se van apilando las llamadas. Algo como: DirectorioActual + CantArchivos + CantSubCarpetas.

Saludos,

[monchito_elroro]

Buenas con todos, ante todo gracias al amigo escafranda por el còdigo, me ha ayudado mucho..... y por otro lado me gustarìa tener como segunda mano otra forma de hacerlo es por eso que quize ver si arreglaba el primer còdigo que puse, lo he intentado asì:

delphi

procedure TotalFilesFolders(Path:string);
var
  SR: TSearchRec;
begin
  ChDir(Path);
  if FindFirst ('*.*', faanyfile, SR )=0 then    // le he puesto anyfile
  repeat
    if ((SR.Attr and faanyfile) = faanyfile) then      // le he puesto anyfile
    begin
      if (SR.Name <> '.') and (SR.Name <> '..') then
      begin
        myfiles:=myfiles+1;
        //Inc(TotalFolders);
        TotalFilesFolders(Path + '\' + SR.Name );  // Este debe ser la resursividad, pero no
                                                                          // pasa nada
      end
    end
    else
      myfiles:=myfiles+1;
      //Inc(TotalFiles);
  until FindNext(SR) <> 0;
  FindClose( SR );
end;

Pero que raro, si me funciona pero solo cuenta los archivos de la raìz (este oculto o no)

denme una manito.....

[Delphius]

Hola,

El error está justamente en cómo funciona la recursividad. Cada invocación a un procedimiento o función recursiva hace que se apile la llamada y se reserve un nuevo "pedazo" de memoria con el que va a trabajar. A medida que se van finalizando la pila va sacando elementos.
Si el procedimiento o función no regresa un valor que sea utilizado por la anterior llamada, entonces se pierde cualquier valor interno.
Fíjate que tu variable myFiles tiene ámbito solo dentro de cada llamada, y como ésta se va liberando a medida que sale de pila su valor se pierde, quedándote unicamente la cuenta realizada en el directorio raíz.

La solución es muy simple: debes hacer del procedimiento una función que regrese la cuenta y de ese modo poder recuperar y pasar el valor de una llamada a su "padre" o bien añadir un parámetro por valor al procedimiento.

Entonces con la 1ra alternativa:

delphi

function TotalFilesFolders(Path: string): integer;
...
result := result + TotalFilesFolders(Path + '\' + SR.Name);
...
end;

Fíjate cómo se va acumulando y se llama a si misma. En cuanto llegue al último elemento y se tenga en pila los valores parciales, TotalFilesFolders se vuelve sobre sus pasos de modo que el valor que éste regresa se pasa al de la llamada de su padre. El padre incrementa su valor, y así hasta llegar a la primera llamada y así es como se llega a la cuenta final.

Con la 2da alternativa:

delphi

procedure TotalFilesFolders(Path: string; var Count: integer);
var MiCount: integer;
...
  // incremento mi cuenta privada para esta llamada
  inc(MiCount);
  // ahora llamo recurvisamente...
  TotalFilesFolders(Path + '\' + SR.Name; Count);
  // ahora que volví a mis pasos en Count se la cantidad de la llamada de mi hijo
  // entonces ahora se cuanto debo contar yo: Count = Count + MiCount
  inc(Count,MiCount);
...
end;

Con todo respeto, te hace falta repasar un poco más el concepto de recursividad.

Saludos,

[escafandra]

En realidad el diseño recursivo no es muy bueno, pero la cuenta si la lleva pues usa una variable global: myfiles.

No funciona porque no terminaste de entender FindFirst y FindNext.
Fíjate como quedaría el código que quieres modificar:

delphi

procedure TotalFilesFolders(Path:string);
var
  SR: TSearchRec;
begin
  ChDir(Path);
  if FindFirst ('*.*', faanyfile, SR )=0 then     // le he puesto anyfile
  repeat
    if ((SR.Attr and fadirectory) = fadirectory) then
    begin
       if (SR.Name <> '.') and (SR.Name <> '..') then
       begin
         myfiles:=myfiles+1;
         //Inc(TotalFolders);
         TotalFilesFolders(Path + '\' + SR.Name );   
       end
    end
    else
      myfiles:=myfiles+1;
      //Inc(TotalFiles);
  until FindNext(SR) <> 0;
  FindClose( SR );
end;

De esta forma funciona, pero yo devolvería el valor en la función en lugar de usar una variable global.


Saludos.

[escafandra]

Puede que no sea la duda de monchito_elroro pero yo nomás lo decía, por las dudas... Quien sabe, si al final también se podría o se requiera de eso (puede ser de interés para algunos; y quizá asi lo quieran).
Estuve pensando en como encararlo por ese lado pero tengo que reconocer que tengo oxidado la teoría de árboles-n. Por un momento me pensé en aprovechar alguno de las clases TTreeXXX pero no se me prende la lámpara...

Bueno, por si las dudas, he desarrollado un pequeño ejemplo basado en el código FileFolderCount2 en el que incorporo una cuenta por parciales en un TTreView complicando muy poco el código. De esta forma puede que las necesidades queden cubiertas:

delphi

procedure FileFolderCount3(Dir:String; var FolderCount, FileCount: integer; var TreeView: TTreeView; Node: pointer = nil);
var
  sr: TSearchRec;
  nFolders, nFiles, lFolders, lFiles: integer;
begin
    FolderCount:= 0; FileCount:= 0;
    lFolders:= 0; lFiles:= 0;
    Node:= TreeView.Items.AddChild(Node, ExtractFileName(Dir));
    if FindFirst(Dir + '\*.*', faAnyFile, sr) = 0 then
    repeat
       if (sr.Name <> '.') and (sr.Name <> '..') then
       begin
          if (sr.Attr and faDirectory)<>0 then
          begin
             inc(FolderCount); inc(lFolders);
             // Para añadir subcarpetas
             FileFolderCount3(Dir + '\' + sr.Name, nFolders, nFiles, TreeView, Node);
             inc(FolderCount, nFolders);
             inc(FileCount, nFiles);
          end else
          begin
             inc(FileCount);  inc(lFiles);
          end;
       end;
    until FindNext(sr)<>0;
    FindClose(sr);
    TTreeNode(Node).Text:= TTreeNode(Node).Text+' ['+IntToStr(lFolders)+' Carpetas y '+IntToStr(lFiles)+' Archivos]';
end;

Forma de uso:

delphi

// El formulario debe contener un TreeView o crearse previamente.
procedure TForm1.Button1Click(Sender: TObject);
var
  Files, Folders: integer;  // Darán la cuenta total.
begin
  FileFolderCount3('D:\TC4', Folders, Files, TreeView1);
end;

Saludos.

[Delphius]

¡Me rindo ante tus pies escafandra!
No se me hubiera ocurrido de esa forma, estuve divagando en como hacer un buen árbol y hacer la cuenta hacia atrás. El bosque no me dejaba ver el árbol.

Vaya si que es simple el código. Y yo que me mataba tratando de pensar una alternativa con un TAD árbol propio diseñado para el ejemplo.

Saludos,

[escafandra]

...Y yo que me mataba tratando de pensar una alternativa con un TAD árbol propio diseñado para el ejemplo...

Bueno, crear un árbol propio es un excelente ejercicio pero eso si que aumentaría mucho el código, es por eso que eché mano del tan conocido TTreeView. De hecho la idea la propusiste tu mismo... 


Saludos.

[Delphius]

Bueno, crear un árbol propio es un excelente ejercicio pero eso si que aumentaría mucho el código, es por eso que eché mano del tan conocido TTreeView. De hecho la idea la propusiste tu mismo... 

Saludos.

Pues si, después de darme por vencido al tratar de recordar la teoría de árboles (y más sabiendo que yo solamente trabajé, o mejor dicho practiqué en código, con árboles binarios) y llevarlo al concepto genérico de árboles-n es que me decía que aprovechara el TTreeView o algún otro.
La cosa es ya mi cabeza no daba más, era tarde y no había manera de que encendiera siquiera un foquito de 5W.

En lo que me quedé pensando es el peligro de miles de llamadas a la pila. ¿Será práctico implementar recursividad para cuando tenemos una millonada o más de archivos? El punto es que creo que no hay otro modo de hacer una exploración por un directorio sin recursión

Saludos,
PD: Creo que no me vendría mal leerme algo de árboles... para no perder la costumbre de ir recordando concepto que hace tiempo que los tengo oxidados.... incluso, entre ellos, un poquito de recursividad

[monchito_elroro]

Gracias lo probarè.....

[monchito_elroro]

Una consulta amiguitos, si en caso quiero ver estos resultados plasmados en un progressbar, es posible hacerlo con estos procedures y funciones que me han compartido....???

[escafandra]

Colocar un ProgressBar es complicado pues no sabemos de antemano cuantas carpatas y archivos se van a analizar. Podríamos calcularlo, pero eso puede consumir casi tanto tiempo como la función que queremos monitorizar con el ProgressBar (fíjate como falla el mismo Windows en sus cálculos)...

Tienes la opción de colocar una barra de desplazamiento sin fin. Si te interesa lee esto.


Saludos.

[monchito_elroro]

OK gracias amigo..... otra consultita, acabo de probar la modificaciòn que le hiciste al procedure que les enviè...que es este:

En realidad el diseño recursivo no es muy bueno, pero la cuenta si la lleva pues usa una variable global: myfiles.

No funciona porque no terminaste de entender FindFirst y FindNext.
Fíjate como quedaría el código que quieres modificar:

delphi

procedure TotalFilesFolders(Path:string);
var
  SR: TSearchRec;
begin
  ChDir(Path);
  if FindFirst ('*.*', faanyfile, SR )=0 then     // le he puesto anyfile
  repeat
    if ((SR.Attr and fadirectory) = fadirectory) then
    begin
       if (SR.Name <> '.') and (SR.Name <> '..') then
       begin
         myfiles:=myfiles+1;
         //Inc(TotalFolders);
         TotalFilesFolders(Path + '\' + SR.Name );   
       end
    end
    else
      myfiles:=myfiles+1;
      //Inc(TotalFiles);
  until FindNext(SR) <> 0;
  FindClose( SR );
end;

De esta forma funciona, pero yo devolvería el valor en la función en lugar de usar una variable global.


Saludos.

Lo acabo de probar pero al realizar la llamada se cuelga todo el system..... he revisado en el taskmanager y cuado lo ejecuto como que empieza a consumir toda la ram....a que se deberà......???