Pasta & Arquivo

Os utilitários de pasta e arquivo são classes convenientes para ajudá-lo a ler e gravar/anexar arquivos, listar arquivos dentro de uma pasta e outras tarefas comuns relacionadas ao diretório.

Obsoleto desde a versão 4.0: As classes File e Folder serão removidas na 5.0. Use classes SPL como SplFileInfo ou SplFileObject e classes iterator como RecursiveDirectoryIterator, RecursiveRegexIterator etc.

Uso Básico

Certifique-se de que as classes estejam carregadas:

use Cake\Filesystem\Folder;
use Cake\Filesystem\File;

Com isso podemos configurar uma nova instância da pasta:

$dir = new Folder('/path/to/folder');

e então pesquise todos os arquivos .php dentro dessa pasta usando regex:

$files = $dir->find('.*\.php');

Agora podemos percorrer os arquivos e ler ou escrever/anexar ao conteúdo ou simplesmente excluir o arquivo:

foreach ($files as $file) {
    $file = new File($dir->pwd() . DS . $file);
    $contents = $file->read();
    // $file->write('Estou substituindo o conteúdo deste arquivo');
    // $file->append('Estou adicionando ao final deste arquivo.');
    // $file->delete(); // Estou excluindo este arquivo
    $file->close(); // Certifique-se de fechar o arquivo quando terminar
}

API Pastas

class Cake\Filesystem\Folder(string $path = false, boolean $create = false, string|boolean $mode = false)
// Cria uma nova pasta com as permissões 0755
$dir = new Folder('/path/to/folder', true, 0755);
property Cake\Filesystem\Folder::$path

Caminho da pasta atual. Folder::pwd() retornará a mesma informação.

property Cake\Filesystem\Folder::$sort

Se os resultados da lista devem ou não ser classificados por nome.

property Cake\Filesystem\Folder::$mode

Modo a ser usado ao criar pastas. O padrão é 0755. Não faz nada em máquinas Windows.

static Cake\Filesystem\Folder::addPathElement(string $path, string $element)

Retorna $path com $elemento adicionado, com a barra correta:

$path = Folder::addPathElement('/a/path/for', 'testing');
// $path é igual a /a/path/for/testing

$element também pode ser um array:

$path = Folder::addPathElement('/a/path/for', ['testing', 'another']);
// $path é igual a /a/path/for/testing/another
Cake\Filesystem\Folder::cd($path)

Mude o diretório para $path. Retorna false em caso de falha:

$folder = new Folder('/foo');
echo $folder->path; // Exibe /foo
$folder->cd('/bar');
echo $folder->path; // Exibe /bar
$false = $folder->cd('/non-existent-folder');
Cake\Filesystem\Folder::chmod(string $path, integer $mode = false, boolean $recursive = true, array $exceptions = [])

Altere o modo em uma estrutura de diretório recursivamente. Isso inclui alterar o modo dos arquivos também:

$dir = new Folder();
$dir->chmod('/path/to/folder', 0755, true, ['skip_me.php']);
Cake\Filesystem\Folder::copy(array|string $options = [])

Copie recursivamente um diretório. O único parâmetro $options pode ser um caminho para a cópia ou um conjunto de opções:

$folder1 = new Folder('/path/to/folder1');
$folder1->copy('/path/to/folder2');
// Colocará a pasta1 e todo o seu conteúdo na pasta2

$folder = new Folder('/path/to/folder');
$folder->copy([
    'to' => '/path/to/new/folder',
    'from' => '/path/to/copy/from', // Irá causar a ocorrência de um cd()
    'mode' => 0755,
    'skip' => ['skip-me.php', '.git'],
    'scheme' => Folder::SKIP  // Pule diretórios/arquivos que já existem.
]);

Existem 3 esquemas suportados:

  • Folder::SKIP pule a cópia/movimentação de arquivos e diretórios que existem no diretório de destino.
  • Folder::MERGE mescla os diretórios de origem/destino. Os arquivos no diretório de origem substituirão os arquivos no diretório de destino. O conteúdo do diretório será mesclado.
  • Folder::OVERWRITE sobrescreve os arquivos e diretórios existentes no diretório de destino pelos do diretório de origem. Se ambos contiverem o mesmo subdiretório, o conteúdo do diretório de destino será removido e substituído pelo de origem.
static Cake\Filesystem\Folder::correctSlashFor(string $path)

Retorna um conjunto correto de barras para o $path fornecido (‘' para caminhos do Windows e ‘/’ para outros caminhos).

Cake\Filesystem\Folder::create(string $pathname, integer $mode = false)

Crie uma estrutura de diretório recursivamente. Pode ser usado para criar estruturas de caminho mais profundo como /foo/bar/baz/shoe/horn:

$folder = new Folder();
if ($folder->create('foo' . DS . 'bar' . DS . 'baz' . DS . 'shoe' . DS . 'horn')) {
    // As pastas aninhadas foram criadas com sucesso
}
Cake\Filesystem\Folder::delete(string $path = null)

Remova diretórios recursivamente se o sistema permitir:

$folder = new Folder('foo');
if ($folder->delete()) {
    // Foo foi excluído com sucesso e também suas pastas aninhadas
}
Cake\Filesystem\Folder::dirsize()

Retorna o tamanho em bytes desta pasta e seu conteúdo.

Cake\Filesystem\Folder::errors()

Obtenha o erro do método mais recente.

Cake\Filesystem\Folder::find(string $regexpPattern = '.*', boolean $sort = false)

Retorna uma matriz de todos os arquivos correspondentes no diretório atual:

// Encontre todos os .png em sua pasta webroot/img/ e classifique os resultados
$dir = new Folder(WWW_ROOT . 'img');
$files = $dir->find('.*\.png', true);
/*
Array
(
    [0] => cake.icon.png
    [1] => test-error-icon.png
    [2] => test-fail-icon.png
    [3] => test-pass-icon.png
    [4] => test-skip-icon.png
)
*/

Nota

Os métodos find e findRecursive da pasta só encontrarão arquivos. Se você gostaria de obter pastas e arquivos, consulte Folder::read() ou Folder::tree()

Cake\Filesystem\Folder::findRecursive(string $pattern = '.*', boolean $sort = false)

Retorna uma matriz de todos os arquivos correspondentes dentro e abaixo do diretório atual:

// Encontre arquivos recursivamente começando com teste ou índice
$dir = new Folder(WWW_ROOT);
$files = $dir->findRecursive('(test|index).*');
/*
Array
(
    [0] => /var/www/cake/webroot/index.php
    [1] => /var/www/cake/webroot/test.php
    [2] => /var/www/cake/webroot/img/test-skip-icon.png
    [3] => /var/www/cake/webroot/img/test-fail-icon.png
    [4] => /var/www/cake/webroot/img/test-error-icon.png
    [5] => /var/www/cake/webroot/img/test-pass-icon.png
)
*/
Cake\Filesystem\Folder::inCakePath(string $path = '')

Retorna true se o arquivo está em um determinado CakePath.

Cake\Filesystem\Folder::inPath(string $path = '', boolean $reverse = false)

Retorna true se o arquivo está no caminho fornecido:

$Folder = new Folder(WWW_ROOT);
$result = $Folder->inPath(APP);
// $result = false, /var/www/example/src/ não está em /var/www/example/webroot/

$result = $Folder->inPath(WWW_ROOT . 'img' . DS, true);
// $result = true, /var/www/example/webroot/img/ está em /var/www/example/webroot/
static Cake\Filesystem\Folder::isAbsolute(string $path)

Retorna true se o $path fornecido for um caminho absoluto.

static Cake\Filesystem\Folder::isSlashTerm(string $path)

Retorna true se o $path termina em uma barra (ou seja, termina com uma barra):

$result = Folder::isSlashTerm('/my/test/path');
// $result = false
$result = Folder::isSlashTerm('/my/test/path/');
// $result = true
static Cake\Filesystem\Folder::isWindowsPath(string $path)

Retorna true se o $path fornecido for um caminho do Windows.

Cake\Filesystem\Folder::messages()

Obtenha as mensagens do método mais recente.

Cake\Filesystem\Folder::move(array $options)

Move recursivamente o diretório.

static Cake\Filesystem\Folder::normalizeFullPath(string $path)

Retorna um caminho com barras normalizadas para o sistema operacional.

Cake\Filesystem\Folder::pwd()

Retorna o caminho atual

Cake\Filesystem\Folder::read(boolean $sort = true, array|boolean $exceptions = false, boolean $fullPath = false)

Retorna uma matriz do conteúdo do diretório atual. A matriz retornada contém duas submatrizes e uma de diretórios e uma de arquivos:

$dir = new Folder(WWW_ROOT);
$files = $dir->read(true, ['files', 'index.php']);
/*
Array
(
    [0] => Array // Folders
        (
            [0] => css
            [1] => img
            [2] => js
        )
    [1] => Array // Files
        (
            [0] => .htaccess
            [1] => favicon.ico
            [2] => test.php
        )
)
*/
Cake\Filesystem\Folder::realpath(string $path)

Pegue o caminho real (levando “..” em consideração).

static Cake\Filesystem\Folder::slashTerm(string $path)

Retorna $path com barra de terminação adicionada (corrigido para Windows ou outro sistema operacional).

Cake\Filesystem\Folder::tree(null|string $path = null, array|boolean $exceptions = true, null|string $type = null)

Retorna uma matriz de diretórios e arquivos aninhados em cada diretório.

API de Arquivos

class Cake\Filesystem\File(string $path, boolean $create = false, integer $mode = 755)
// Cria um novo arquivo com as permissões 0644
$file = new File('/path/to/file.php', true, 0644);
property Cake\Filesystem\File::$Folder

O objeto Folder do arquivo.

property Cake\Filesystem\File::$name

O nome do arquivo com a extensão. É diferente de File::name() que retorna o nome sem a extensão.

property Cake\Filesystem\File::$info

Uma matriz de informações do arquivo. Ao invés disso use File::info().

property Cake\Filesystem\File::$handle

Contém o recurso de manipulador de arquivo se o arquivo for aberto.

property Cake\Filesystem\File::$lock

Habilite o bloqueio para leitura e gravação de arquivos.

property Cake\Filesystem\File::$path

O caminho absoluto do arquivo atual.

Cake\Filesystem\File::append(string $data, boolean $force = false)

Anexe a string de dados fornecida ao arquivo atual.

Cake\Filesystem\File::close()

Fecha o arquivo atual se estiver aberto.

Cake\Filesystem\File::copy(string $dest, boolean $overwrite = true)

Copie o arquivo para o caminho absoluto $dest.

Cake\Filesystem\File::create()

Cria o arquivo.

Cake\Filesystem\File::delete()

Apaga o arquivo;

Cake\Filesystem\File::executable()

Returna true se o arquivo for executável

Cake\Filesystem\File::exists()

Retorna true se o arquivo existe.

Cake\Filesystem\File::ext()

Retorna a extensão do arquivo.

Cake\Filesystem\File::Folder()

Retorna a pasta atual.

Cake\Filesystem\File::group()

Retorna o grupo do arquivo, ou false em caso de erro.

Cake\Filesystem\File::info()

Retorna as informações do arquivo.

Cake\Filesystem\File::lastAccess()

Retorna a hora do último acesso.

Cake\Filesystem\File::lastChange()

Retorna a hora da última modificação ou false em caso de erro.

Cake\Filesystem\File::md5(integer|boolean $maxsize = 5)

Obtenha o MD5 Checksum do arquivo com a verificação anterior do tamanho do arquivo, ou false no caso de um erro.

Cake\Filesystem\File::name()

Retorna o nome do arquivo sem extensão.

Cake\Filesystem\File::offset(integer|boolean $offset = false, integer $seek = 0)

Define ou obtém o deslocamento do arquivo aberto no momento.

Cake\Filesystem\File::open(string $mode = 'r', boolean $force = false)

Abre o arquivo atual com o $mode fornecido.

Cake\Filesystem\File::owner()

Retorna o proprietário do arquivo.

Cake\Filesystem\File::perms()

Retorna o “chmod” (permissões) do arquivo.

static Cake\Filesystem\File::prepare(string $data, boolean $forceWindows = false)

Prepara uma string ascii para escrita. Converte as terminações de linha no terminador correto para a plataforma atual. Para Windows, será usado “\r\n”, para todas as outras plataformas “\ n”.

Cake\Filesystem\File::pwd()

Retorna o caminho completo do arquivo.

Cake\Filesystem\File::read(string $bytes = false, string $mode = 'rb', boolean $force = false)

Retorne o conteúdo do arquivo atual como uma string ou retorne false em caso de falha.

Cake\Filesystem\File::readable()

Retorna true se o arquivo é legível.

Cake\Filesystem\File::safe(string $name = null, string $ext = null)

Torna o nome do arquivo seguro para salvar.

Cake\Filesystem\File::size()

Retorna o tamanho do arquivo em bytes.

Cake\Filesystem\File::writable()

Retorna true se o arquivo for gravável.

Cake\Filesystem\File::write(string $data, string $mode = 'w', boolean$force = false)

Grave os dados fornecidos no arquivo atual.

Cake\Filesystem\File::mime()

Pega o tipo MIME do arquivo, retorna false em caso de falha.

Cake\Filesystem\File::replaceText($search, $replace)

Substitui o texto em um arquivo. Retorna false em caso de falha e true em caso de sucesso.