Utwórz folder, jeśli jeszcze nie istnieje

W kilku instalacjach WordPress natknąłem się na Bluehost, gdzie napotkałem błędy w moim motywie WordPress, ponieważ folder przesyłania wp-content/uploadsnie był obecny.

Najwyraźniej instalator WordPress Bluehost cPanel nie tworzy tego folderu, choć HostGator tak.

Więc muszę dodać kod do mojego motywu, który sprawdza folder i tworzy go inaczej.

Spróbuj tego, używając mkdir :

if (!file_exists('path/to/directory')) {
    mkdir('path/to/directory', 0777, true);
}

Zauważ, że 0777jest to już domyślny tryb dla katalogów i może nadal być modyfikowany przez bieżący umask.

Oto brakujący element. Musisz przekazać flagę „rekurencyjną” jako trzeci argument (boolean true) w wywołaniu mkdir w następujący sposób:

mkdir('path/to/directory', 0755, true);

Coś bardziej uniwersalnego, ponieważ pojawia się w Google. Chociaż szczegóły są bardziej szczegółowe, tytuł tego pytania jest bardziej uniwersalny.

/** 
 * recursively create a long directory path
 */
function createPath($path) {
    if (is_dir($path)) return true;
    $prev_path = substr($path, 0, strrpos($path, '/', -2) + 1 );
    $return = createPath($prev_path);
    return ($return && is_writable($prev_path)) ? mkdir($path) : false;
}

To pójdzie ścieżką, być może z długim łańcuchem nie utworzonych katalogów, i przejdzie do następnego katalogu, aż dojdzie do istniejącego katalogu. Następnie spróbuje utworzyć następny katalog w tym katalogu i będzie kontynuował, aż utworzą wszystkie katalogi. Zwraca true, jeśli się powiedzie.

Można to poprawić, zapewniając poziom zatrzymania, aby po prostu zawiódł, jeśli wykracza poza folder użytkownika lub coś, i zawiera uprawnienia.

Co z taką funkcją pomocnika:

function makeDir($path)
{
     $ret = mkdir($path); // use @mkdir if you want to suppress warnings/errors
     return $ret === true || is_dir($path);
}

Zwróci, truejeśli katalog został pomyślnie utworzony lub już istnieje i falsejeśli nie można go utworzyć.

Lepszym rozwiązaniem jest to (nie powinny dawać żadnych ostrzeżeń):

function makeDir($path)
{
     return is_dir($path) || mkdir($path);
}

Szybszy sposób na utworzenie folderu:

if (!is_dir('path/to/directory')) {
    mkdir('path/to/directory', 0777, true);
}

Rekurencyjnie utwórz ścieżkę do katalogu:

function makedirs($dirpath, $mode=0777) {
    return is_dir($dirpath) || mkdir($dirpath, $mode, true);
}

Inspirowany Pythonem os.makedirs()

W WordPress istnieje również bardzo przydatna funkcja wp_mkdir_p która rekurencyjnie tworzy strukturę katalogów.

Źródło w celach informacyjnych: -

function wp_mkdir_p( $target ) {
    $wrapper = null;

    // strip the protocol
    if( wp_is_stream( $target ) ) {
        list( $wrapper, $target ) = explode( '://', $target, 2 );
    }

    // from php.net/mkdir user contributed notes
    $target = str_replace( '//', '/', $target );

    // put the wrapper back on the target
    if( $wrapper !== null ) {
        $target = $wrapper . '://' . $target;
    }

    // safe mode fails with a trailing slash under certain PHP versions.
    $target = rtrim($target, '/'); // Use rtrim() instead of untrailingslashit to avoid formatting.php dependency.
    if ( empty($target) )
        $target = '/';

    if ( file_exists( $target ) )
        return @is_dir( $target );

    // We need to find the permissions of the parent folder that exists and inherit that.
    $target_parent = dirname( $target );
    while ( '.' != $target_parent && ! is_dir( $target_parent ) ) {
        $target_parent = dirname( $target_parent );
    }

    // Get the permission bits.
    if ( $stat = @stat( $target_parent ) ) {
        $dir_perms = $stat['mode'] & 0007777;
    } else {
        $dir_perms = 0777;
    }

    if ( @mkdir( $target, $dir_perms, true ) ) {

        // If a umask is set that modifies $dir_perms, we'll have to re-set the $dir_perms correctly with chmod()
        if ( $dir_perms != ( $dir_perms & ~umask() ) ) {
            $folder_parts = explode( '/', substr( $target, strlen( $target_parent ) + 1 ) );
            for ( $i = 1; $i <= count( $folder_parts ); $i++ ) {
                @chmod( $target_parent . '/' . implode( '/', array_slice( $folder_parts, 0, $i ) ), $dir_perms );
            }
        }

        return true;
    }

    return false;
}

Potrzebuję tego samego dla strony logowania. Musiałem stworzyć katalog z dwiema zmiennymi. Katalog $ to główny folder, w którym chciałem utworzyć inny podfolder z numerem licencji użytkownika.

include_once("../include/session.php");
$lnum = $session->lnum; //Users license number from sessions
$directory = uploaded_labels; // Name of directory that folder is being created in

if (!file_exists($directory."/".$lnum)) {
mkdir($directory."/".$lnum, 0777, true);
}

To jest najbardziej aktualne rozwiązanie bez tłumienia błędów:

if (!is_dir('path/to/directory')) {
    mkdir('path/to/directory');
}

Jeśli chcesz uniknąć problemu file_existsVS is_dir, radzę zajrzeć tutaj

Próbowałem tego i tworzy katalog tylko wtedy, gdy katalog nie istnieje . Nie obchodzi go to, że istnieje plik o tej nazwie.

/* Creates the directory if it does not exist */
$path_to_directory = 'path/to/directory';
if (!file_exists($path_to_directory) && !is_dir($path_to_directory)) {
    mkdir($path_to_directory, 0777, true);
}

if (!is_dir('path_directory')) {
    @mkdir('path_directory');
}

Możesz spróbować również:

$dirpath = "path/to/dir";
$mode = "0777";
is_dir($dirpath) || mkdir($dirpath, $mode, true);

Aby utworzyć folder, jeśli jeszcze nie istnieje

Biorąc pod uwagę środowisko pytania.

• WordPress.
• Serwer WWW.
• Zakładając, że jego Linux nie jest systemem Windows z uruchomionym PHP.

I cytowanie z: http://php.net/manual/en/function.mkdir.php

bool mkdir (string $ pathname [, int $ mode = 0777 [, bool $ recursive = FALSE [, $ $ kontekst]]])

Instrukcja mówi, że jedynym wymaganym parametrem jest $pathname!

więc możemy po prostu kodować:

<?php
error_reporting(0); 
if(!mkdir('wp-content/uploads')){
   // todo
}
?>

Wyjaśnienie:

Nie musimy przekazywać żadnego parametru ani sprawdzać, czy folder istnieje, ani nawet parametru trybu przejścia, chyba że jest to konieczne; z następujących powodów:

• Polecenie utworzy folder z uprawnieniem 0755 (domyślne uprawnienie do współdzielonego folderu hostingowego) lub 0777 domyślnym poleceniem.
• modejest ignorowany na Windows Hosting z PHP .
• Już mkdirkomenda posiada wbudowany w sprawdzający czy folder istnieje; więc musimy sprawdzić zwrot tylko True | False; i to nie jest błąd, to tylko ostrzeżenie, a Ostrzeżenie jest domyślnie wyłączone na serwerach hostingowych.
• Zgodnie z prędkością jest to szybsze, jeśli ostrzeżenie jest wyłączone.

To tylko kolejny sposób, aby spojrzeć na pytanie i nie domagać się lepszego lub najbardziej optymalnego rozwiązania.

Testowane na PHP7, Production Server, Linux

$upload = wp_upload_dir();
$upload_dir = $upload['basedir'];
$upload_dir = $upload_dir . '/newfolder';
if (! is_dir($upload_dir)) {
   mkdir( $upload_dir, 0700 );
}

Powinniśmy zawsze modulować nasz kod, a ja napisałem to samo sprawdź go poniżej ... Najpierw sprawdzamy katalog, jeśli go nie ma, tworzymy katalog.

$boolDirPresents = $this->CheckDir($DirectoryName);

if (!$boolDirPresents) {
        $boolCreateDirectory = $this->CreateDirectory($DirectoryName);
        if ($boolCreateDirectory) {
        echo "Created successfully";
      }
  }

function CheckDir($DirName) {
    if (file_exists($DirName)) {
        echo "Dir Exists<br>";
        return true;
    } else {
        echo "Dir Not Absent<br>";
        return false;
    }
}

function CreateDirectory($DirName) {
    if (mkdir($DirName, 0777)) {
        return true;
    } else {
        return false;
    }
}

Najpierw musisz sprawdzić, czy katalog istnieje file_exists('path_to_directory')

Następnie użyj, mkdir(path_to_directory)aby utworzyć katalog

mkdir( string $pathname [, int $mode = 0777 [, bool $recursive = FALSE [, resource $context ]]] ) : bool

Więcej informacji o mkdir () tutaj

Pełny kod tutaj:

$structure = './depth1/depth2/depth3/';
if (!file_exists($structure)) {
    mkdir($structure);
}

Proszę bardzo.

if (!is_dir('path/to/directory')) {
    if (!mkdir('path/to/directory', 0777, true) && !is_dir('path/to/directory')) {
        throw new \RuntimeException(sprintf('Directory "%s" was not created', 'path/to/directory'));
    }
}

Przyjęta odpowiedź działa, ale ze względu na uprawnienia nie jest to właściwe rozwiązanie. Uprawnienia 0777 umożliwiają każdemu dostęp do / odczyt / zapis katalogu. Nie tego chcemy dla katalogu wysyłania na serwerze internetowym. Oto sugerowane prawidłowe i kompletne rozwiązanie.

$path_to_directory = 'path/to/directory';
if (!file_exists($path_to_directory) && !is_dir($path_to_directory)) {
    mkdir($path_to_directory, 0644, true);
}

0644 są odpowiednimi uprawnieniami do katalogu uploads, ponieważ zazwyczaj nie chcemy, aby przesyłano go na serwer, aby tam był wykonywany.

true to trzeci parametr służący do ustawiania właściwości rekurencyjnej na true lub false. Pozwala na tworzenie zagnieżdżonych katalogów określonych w nazwie ścieżki.