Crea una carpeta si aún no existe

Me he encontrado con algunos casos con las instalaciones de WordPress con Bluehost donde he encontrado errores con mi tema de WordPress porque la carpeta de cargas wp-content/uploadsno estaba presente.

Aparentemente, el instalador de Bluehost cPanel WordPress no crea esta carpeta, aunque HostGator sí.

Por lo tanto, necesito agregar código a mi tema que verifique la carpeta y la cree de otra manera.

Prueba esto, usando mkdir :

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

Tenga en cuenta que 0777ya es el modo predeterminado para los directorios y aún puede ser modificado por la umask actual.

Aquí está la pieza que falta. Debe pasar el indicador 'recursivo' como tercer argumento (boolean true) en la llamada mkdir de esta manera:

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

Algo un poco más universal ya que esto aparece en google. Si bien los detalles son más específicos, el título de esta pregunta es más universal.

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

Esto tomará una ruta, posiblemente con una larga cadena de directorios no creados, y seguirá subiendo un directorio hasta que llegue a un directorio existente. Luego intentará crear el siguiente directorio en ese directorio y continuará hasta que haya creado todos los directorios. Devuelve verdadero si tiene éxito.

Podría mejorarse proporcionando un nivel de detención, por lo que simplemente falla si va más allá de la carpeta de usuario o algo así e incluye permisos.

¿Qué pasa con una función auxiliar como esta:

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

Volverá truesi el directorio se creó correctamente o si ya existe, y falsesi el directorio no se pudo crear.

Una mejor alternativa es esta (no debería dar ninguna advertencia):

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

Forma más rápida de crear una carpeta:

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

Crear recursivamente la ruta del directorio:

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

Inspirado por Python os.makedirs()

Dentro de WordPress también existe la función muy útil wp_mkdir_p que creará recursivamente una estructura de directorio.

Fuente de referencia: -

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

Necesito lo mismo para un sitio de inicio de sesión. Necesitaba crear un directorio con dos variables. El directorio $ es la carpeta principal donde quería crear otra subcarpeta con el número de licencia de los usuarios.

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

Esta es la solución más actualizada sin supresión de errores:

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

Si desea evitar el problema de file_existsVS is_dir, le sugiero que mire aquí

Intenté esto y solo crea el directorio si el directorio no existe . No le importa que haya un archivo con ese nombre.

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

Puedes probar también:

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

Para crear una carpeta si aún no existe

Teniendo en cuenta el entorno de la pregunta.

• WordPress
• Servidor de alojamiento web.
• Suponiendo que su Linux no Windows ejecute PHP.

Y citando: http://php.net/manual/en/function.mkdir.php

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

Manual dice que el único parámetro requerido es el $pathname!

entonces, simplemente podemos codificar:

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

Explicación:

No tenemos que pasar ningún parámetro o verificar si existe la carpeta o incluso pasar el parámetro del modo a menos que sea necesario; por las siguientes razones:

• El comando creará la carpeta con el permiso 0755 (permiso predeterminado de la carpeta de alojamiento compartido) o 0777 el predeterminado del comando.
• modese ignora en el Alojamiento de Windows que ejecuta PHP .
• El mkdircomando ya tiene un checker incorporado si la carpeta existe; entonces necesitamos verificar el retorno solo True | False; y no es un error, es solo una advertencia, y la Advertencia está deshabilitada en los servidores de alojamiento de forma predeterminada.
• Según la velocidad, esto es más rápido si la advertencia está deshabilitada.

Esta es solo otra forma de analizar la pregunta y no reclamar una solución mejor o más óptima.

Probado en PHP7, Servidor de producción, Linux

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

Siempre debemos modularizar nuestro código y he escrito lo mismo, verifíquelo a continuación ... Primero verificamos el directorio, si el directorio está ausente creamos el directorio.

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

Primero debe verificar si el directorio existe file_exists('path_to_directory')

Luego use mkdir(path_to_directory)para crear un directorio

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

Más acerca de mkdir () aquí

Código completo aquí:

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

Aqui tienes.

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

La respuesta aceptada funciona pero no es la solución correcta debido a los permisos. Los permisos 0777 permiten a todos acceder / leer / escribir en el directorio. Esto no es lo que queremos para cargar el directorio en el servidor web. Aquí está la solución correcta y completa sugerida.

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

0644 son los permisos correctos para el directorio de cargas porque generalmente no queremos que se carguen en el servidor.

verdadero es el tercer parámetro para establecer la propiedad recursiva en verdadero o falso. Permite la creación de directorios anidados especificados en la ruta.