php - Maak een map als deze nog niet bestaat

Ik ben een paar gevallen tegengekomen met WordPress-installaties met Bluehostwaar ik ben tegengekomen fouten met mijn WordPress-thema omdat de uploadmap wp-content/uploadsniet aanwezig was.

Blijkbaar maakt het Bluehost cPanelWordPress-installatieprogramma deze map niet aan, hoewel HostGatorwel.

Dus ik moet code aan mijn thema toevoegen die de map controleert en anders maakt.

Antwoord 1, autoriteit 100%

Probeer dit met mkdir:

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

Merk op dat 0777al de standaardmodus is voor mappen en nog steeds kan worden gewijzigd door de huidige umask.

Antwoord 2, autoriteit 12%

Hier is het ontbrekende stuk. U moet de ‘recursieve’ vlag doorgeven als derde argument (boolean true) in mkdirbel als volgt:

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

Antwoord 3, autoriteit 5%

Iets universeler, aangezien dit op Google verschijnt. Hoewel de details specifieker zijn, is de titel van deze vraag universeler.

/** 
 * 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;
}

Dit zal een pad volgen, mogelijk met een lange keten van niet-gecreëerde mappen, en één map omhoog blijven gaan totdat het bij een bestaande map komt. Dan zal het proberen om de volgende map in die map aan te maken, en doorgaan totdat alle mappen zijn gemaakt. Het geeft true terug als het is gelukt.

Kan worden verbeterd door een stopniveau te bieden, zodat het gewoon mislukt als het verder gaat dan de gebruikersmap of zoiets en door machtigingen op te nemen.

Antwoord 4, autoriteit 5%

Hoe zit het met een helperfunctie als deze:

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

Het retourneert trueals de directory met succes is gemaakt of al bestaat, en falseals de directory niet kan worden gemaakt.

Een beteralternatief is dit (mag geen waarschuwingen geven):

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

Antwoord 5, autoriteit 2%

Sneller om een map te maken:

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

Antwoord 6, autoriteit 2%

Recursief directorypad maken:

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

Geïnspireerd door Python’s os.makedirs()

Antwoord 7

Binnen WordPress is er ook de zeer handige functie wp_mkdir_pdie recursief een directorystructuur maakt.

Bron voor referentie:-

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;
}

Antwoord 8

Beter om wp_mkdir_p-functie voor te gebruiken. Deze functie zal recursief maken Een map maken met de juiste machtigingen . Ook kunt u Skip-map voorwaarden voor de voorwaarde omdat deze zal worden gecontroleerd voordat u het maakt.

$path = 'path/to/directory';
if ( wp_mkdir_p( $path ) ) {
    // Directory exists or was created.
}

meer: https://developer.wordpress.org/reference/functions/wp_mkdir_p/ <

Antwoord 9

Ik heb hetzelfde nodig voor een inlogsite. Ik moest een map maken met een twee variabelen.
De directory is de hoofdmap waarbij ik een andere submap wilde maken met het gebruikersnummer van de gebruikers.

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);
}

Antwoord 10

Dit is de meest up-to-date oplossing zonder foutonderdrukking:

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

Antwoord 11

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

Antwoord 12

Een map maken als deze nog niet bestaat

Rekening houdend met de omgeving van de vraag.

WordPress.
Webhosting-server.
Ervan uitgaande dat het Linux is en niet Windows met PHP.

En citeren uit: http://php.net/manual/en/function .mkdir.php

boolmkdir ( string $pathname [, int $mode = 0777 [, bool $recursive =
ONWAAR [, bron $context ]]] )

Handleiding zegt dat de enige vereiste parameter de $pathnameis!

dus we kunnen eenvoudig coderen:

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

Uitleg:

We hoeven geen enkele parameter door te geven of te controleren of een map bestaat of zelfs de modusparameter door te geven, tenzij nodig; om de volgende redenen:

De opdracht maakt de map aan met de machtiging 0755 (de standaardmachtiging van de gedeelde hostingmap) of 0777 de standaardmachtiging van de opdracht.
modewordt genegeerd op Windows Hosting met PHP.
Het mkdircommando heeft al een ingebouwde checker als de map bestaat; dus we moeten alleen de return controleren True|False ; en het is geen fout, het is alleen een waarschuwing, en Waarschuwing is standaard uitgeschakeld op hostingservers.
Afhankelijk van de snelheid is dit sneller als de waarschuwing is uitgeschakeld.

Dit is gewoon een andere manier om naar de vraag te kijken en geen betere of meest optimale oplossing te claimen.

Getest op PHP7, productieserver, Linux

Antwoord 13

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

Antwoord 14

Als je het probleem file_existsVS is_dirwilt vermijden, raad ik je aan te kijken naar hier

Ik heb dit geprobeerd en het maakt alleen de map aan als de map niet bestaat. Het maakt niet uit of er een bestand is met die naam.

/* 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);
}

Antwoord 15

Alsjeblieft.

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'));
    }
}

Antwoord 16

Je kunt ook proberen:

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

Antwoord 17

Gebruik de volgende code voor uw specifieke vraag over WordPress:

if (!is_dir(ABSPATH . 'wp-content/uploads')) wp_mkdir_p(ABSPATH . 'wp-content/uploads');

Functiereferentie: WordPress wp_mkdir_p. ABSPATHis de constante die het pad van de WordPress-werkmap retourneert.

Er is nog een WordPress-functie genaamd wp_upload_dir(). Het geeft het uploadmappad terug en maakt een map aan als deze nog niet bestaat.

$upload_path = wp_upload_dir();

De volgende code is voor PHP in het algemeen.

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

Functiereferentie: PHP is_dir()

Antwoord 18

We moeten onze code altijd modulair maken en ik heb hetzelfde geschreven, bekijk het hieronder…
We controleren eerst de directory, als de directory ontbreekt, maken we de directory aan.

$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;
    }
}

Antwoord 19

U moet eerst controleren of de directory bestaat file_exists('path_to_directory')

Gebruik vervolgens mkdir(path_to_directory)om een directory

te maken

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

Meer over mkdir () hier

Volledige code hier:

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

Antwoord 20

Als aanvulling op de huidige oplossingen, een nutsfunctie.

function createDir($path, $mode = 0777, $recursive = true) {
  if(file_exists($path)) return true;
  return mkdir($path, $mode, $recursive);
}
createDir('path/to/directory');

Het retourneert trueindien al bestaat of met succes is gemaakt. Anders retourneert het false.

Maak een map als deze nog niet bestaat