¿Cómo obtengo una extensión de archivo en PHP?

Las personas de otros lenguajes de scripting siempre piensan que el suyo es mejor porque tienen una función incorporada para hacer eso y no PHP (estoy viendo Pythonistas en este momento :-)).

De hecho, existe, pero pocas personas lo saben. Reunirse pathinfo():

$ext = pathinfo($filename, PATHINFO_EXTENSION);

Esto es rápido e integrado. pathinfo() puede darle otra información, como la ruta canónica, dependiendo de la constante que le pase.

Recuerde que si desea poder tratar con caracteres que no sean ASCII, primero debe establecer la configuración regional. P.EJ:

setlocale(LC_ALL,'en_US.UTF-8');

Además, tenga en cuenta que esto no tiene en cuenta el contenido del archivo o el tipo mime, solo obtiene la extensión. Pero es lo que pediste.

Por último, tenga en cuenta que esto solo funciona para una ruta de archivo, no una ruta de recursos URL, que se cubre con PARSE_URL.

Disfrutar

pathinfo()

$path_info = pathinfo('/foo/bar/baz.bill');

echo $path_info['extension']; // "bill"

URL de ejemplo: http://example.com/myfolder/sympony.mp3?a=1&b=2#XYZ

A) No use inseguro sugerido PATHINFO:

pathinfo($url)['dirname']   🡺 'http://example.com/myfolder'
pathinfo($url)['basename']  🡺 'sympony.mp3?a=1&b=2#XYZ'         // <------- BAD !!
pathinfo($url)['extension'] 🡺 'mp3?a=1&b=2#XYZ'                 // <------- BAD !!
pathinfo($url)['filename']  🡺 'sympony'

B) Uso PARSE_URL:

parse_url($url)['scheme']   🡺 'http'
parse_url($url)['host']     🡺 'example.com'
parse_url($url)['path']     🡺 '/myfolder/sympony.mp3'
parse_url($url)['query']    🡺 'aa=1&bb=2'
parse_url($url)['fragment'] 🡺 'XYZ'

BONIFICACIÓN: Ver todos los ejemplos nativos de PHP

También hay SplFileInfo:

$file = new SplFileInfo($path);
$ext  = $file->getExtension();

A menudo, puede escribir un código mejor si pasa un objeto de este tipo en lugar de una cadena. Tu código habla más entonces. Desde PHP 5.4, esta es una línea simple:

$ext  = (new SplFileInfo($path))->getExtension();

La respuesta de E-satis es la forma correcta de determinar la extensión del archivo.

Alternativamente, en lugar de depender de una extensión de archivo, puede usar la fileinfo para determinar el tipo de archivos MIME.

A continuación, se muestra un ejemplo simplificado del procesamiento de una imagen cargada por un usuario:

// Code assumes necessary extensions are installed and a successful file upload has already occurred

// Create a FileInfo object
$finfo = new FileInfo(null, '/path/to/magic/file');

// Determine the MIME type of the uploaded file
switch ($finfo->file($_FILES['image']['tmp_name'], FILEINFO_MIME)) {        
    case 'image/jpg':
        $im = imagecreatefromjpeg($_FILES['image']['tmp_name']);
    break;

    case 'image/png':
        $im = imagecreatefrompng($_FILES['image']['tmp_name']);
    break;

    case 'image/gif':
        $im = imagecreatefromgif($_FILES['image']['tmp_name']);
    break;
}

Siempre que no contenga una ruta, también puede usar:

array_pop(explode('.', $fname))

Dónde $fname es un nombre del archivo, por ejemplo: my_picture.jpg. Y el resultado sería: jpg

1) Si está utilizando (PHP 5> = 5.3.6) puedes usar SplFileInfo :: getExtension - Obtiene la extensión del archivo

Código de ejemplo

<?php

$info = new SplFileInfo('test.png');
var_dump($info->getExtension());

$info = new SplFileInfo('test.tar.gz');
var_dump($info->getExtension());

?>

Esto dará salida

string(3) "png"
string(2) "gz"

2) Otra forma de obtener la extensión si está utilizando (PHP 4> = 4.0.3, PHP 5) is información de ruta

Código de ejemplo

<?php

$ext = pathinfo('test.png', PATHINFO_EXTENSION);
var_dump($ext);

$ext = pathinfo('test.tar.gz', PATHINFO_EXTENSION);
var_dump($ext);

?>

Esto dará salida

string(3) "png"
string(2) "gz"

// EDITAR: eliminado un corchete

A veces es útil no usar pathinfo($path, PATHINFO_EXTENSION). Por ejemplo:

$path = '/path/to/file.tar.gz';

echo ltrim(strstr($path, '.'), '.'); // tar.gz
echo pathinfo($path, PATHINFO_EXTENSION); // gz

También tenga en cuenta que pathinfo no puede manejar algunos caracteres que no son ASCII (por lo general, simplemente los suprime de la salida). En extensiones, eso generalmente no es un problema, pero no está de más ser consciente de esa advertencia.

Házlo más rápido.

Las llamadas de bajo nivel deben ser muy rapido así que pensé que valía la pena investigar un poco. Probé algunos métodos (con varias longitudes de cadena, longitudes de extensión, múltiples ejecuciones cada uno), aquí hay algunos razonables:

function method1($s) {return preg_replace("/.*\./","",$s);} // edge case problem
function method2($s) {preg_match("/\.([^\.]+)$/",$s,$a);return $a[1];}
function method3($s) {$n = strrpos($s,"."); if($n===false) return "";return substr($s,$n+1);}
function method4($s) {$a = explode(".",$s);$n = count($a); if($n==1) return "";return $a[$n-1];}
function method5($s) {return pathinfo($s, PATHINFO_EXTENSION);}

Resultados no fueron muy sorprendentes. Pobre pathinfo es (¡de lejos!) el más lento; incluso con el PATHINFO_EXTENSION opción, parece que está tratando de analizar todo y luego eliminar todas las partes innecesarias. Por otro lado, el incorporado strrpos La función se inventó casi exactamente para este trabajo, no toma desvíos, por lo que no es de extrañar que funcione mucho mejor que otros solicitantes:

Original filename was: something.that.contains.dots.txt
Running 50 passes with 10000 iterations each
Minimum of measured times per pass:

    Method 1:   312.6 mike  (response: txt) // preg_replace
    Method 2:   472.9 mike  (response: txt) // preg_match
    Method 3:   167.8 mike  (response: txt) // strrpos
    Method 4:   340.3 mike  (response: txt) // explode
    Method 5:  2311.1 mike  (response: txt) // pathinfo  <--------- poor fella

NOTA: el primer método tiene un efecto secundario: devuelve el nombre completo cuando no hay extensión. Seguramente no tendría sentido medirlo con strpos adicionales para evitar este comportamiento.

Conclusión

Este parece ser el Camino del Samurái:

function fileExtension($s) {
    $n = strrpos($s,".");
    return ($n===false) ? "" : substr($s,$n+1);
}

Algunos casos de prueba

File name            fileExtension()
----------------------------------------
file                 ""
file.                ""
file.txt             "txt"
file.txt.bin         "bin"
file.txt.whatever    "whatever"
.htaccess            "htaccess"

(El último es un poco especial; podría ser solo una extensión, o una extensión vacía con el nombre puro como ".htaccess", no estoy seguro de si hay una regla para eso. Así que supongo que puedes usar ambos , siempre que sepa lo que está haciendo).

La forma más sencilla de obtener la extensión de archivo en PHP es utilizar la función incorporada de PHP información de ruta.

$file_ext = pathinfo('your_file_name_here', PATHINFO_EXTENSION);
echo ($file_ext); // The output should be the extension of the file e.g., png, gif, or html

También puede probar esto (funciona en PHP 5. * y 7):

$info = new SplFileInfo('test.zip');
echo $info->getExtension(); // ----- Output -----> zip

Consejo: devuelve una cadena vacía si el archivo no tiene extensión

Lo siento ... "Pregunta corta; pero NO respuesta corta"

Ejemplo 1 para PATH

$path = "/home/ali/public_html/wp-content/themes/chicken/css/base.min.css";
$name = pathinfo($path, PATHINFO_FILENAME);
$ext  = pathinfo($path, PATHINFO_EXTENSION);
printf('<hr> Name: %s <br> Extension: %s', $name, $ext);

Ejemplo 2 de URL

$url = "//www.example.com/dir/file.bak.php?Something+is+wrong=hello";
$url = parse_url($url);
$name = pathinfo($url['path'], PATHINFO_FILENAME);
$ext  = pathinfo($url['path'], PATHINFO_EXTENSION);
printf('<hr> Name: %s <br> Extension: %s', $name, $ext);

Salida del ejemplo 1:

Name: base.min
Extension: css

Salida del ejemplo 2:

Name: file.bak
Extension: php

Referencias

1. https://www.php.net/manual/en/function.pathinfo.php

2. https://www.php.net/manual/en/function.realpath.php

3. https://www.php.net/manual/en/function.parse-url.php

Aquí hay un ejemplo. Supongamos que $ filename es "example.txt",

$ext = substr($filename, strrpos($filename, '.', -1), strlen($filename));

Entonces $ ext será ".txt".

información de ruta es una matriz. Podemos comprobar nombre de directorio, nombre de archivo, extensión, etc .:

$path_parts = pathinfo('test.png');

echo $path_parts['extension'], "\n";
echo $path_parts['dirname'], "\n";
echo $path_parts['basename'], "\n";
echo $path_parts['filename'], "\n";

substr($path, strrpos($path, '.') + 1);

Una solución rápida sería algo como esto.

// Exploding the file based on the . operator
$file_ext = explode('.', $filename);

// Count taken (if more than one . exist; files like abc.fff.2013.pdf
$file_ext_count = count($file_ext);

// Minus 1 to make the offset correct
$cnt = $file_ext_count - 1;

// The variable will have a value pdf as per the sample file name mentioned above.
$file_extension = $file_ext[$cnt];

También puedes probar esto:

 pathinfo(basename($_FILES["fileToUpload"]["name"]), PATHINFO_EXTENSION)

Encontré que el pathinfo() y SplFileInfo Las soluciones funcionan bien para archivos estándar en el sistema de archivos local, pero puede tener dificultades si trabaja con archivos remotos, ya que las URL de imágenes válidas pueden tener un # (identificadores de fragmentos) y / o ? (parámetros de consulta) al final de la URL, que ambas soluciones (incorrectamente) tratarán como parte de la extensión del archivo.

Descubrí que esta era una forma confiable de usar pathinfo() en una URL después de analizarla por primera vez para eliminar el desorden innecesario después de la extensión del archivo:

$url_components = parse_url($url); // First parse the URL
$url_path = $url_components['path']; // Then get the path component
$ext = pathinfo($url_path, PATHINFO_EXTENSION); // Then use pathinfo()

Utilice la herramienta substr($path, strrpos($path,'.')+1);. Es el método más rápido de todas las comparaciones.

@Kurt Zhong ya respondió.

Comprobemos el resultado comparativo aquí: https://eval.in/661574

ltrim(strstr($file_url, '.'), '.')

esta es la mejor manera si tiene nombres de archivo como name.name.name.ext (feo, pero a veces sucede

Esto funcionará

$ext = pathinfo($filename, PATHINFO_EXTENSION);

Puede obtener todas las extensiones de archivo en una carpeta en particular y realizar operaciones con una extensión de archivo específica:

<?php
    $files = glob("abc/*.*"); // abc is the folder all files inside folder
    //print_r($files);
    //echo count($files);
    for($i=0; $i<count($files); $i++):
         $extension = pathinfo($files[$i], PATHINFO_EXTENSION);
         $ext[] = $extension;
         // Do operation for particular extension type
         if($extension=='html'){
             // Do operation
         }
    endfor;
    print_r($ext);
?>

$ext = preg_replace('/^.*\.([^.]+)$/D', '$1', $fileName);

En el enfoque preg_replace usamos la búsqueda y reemplazo de expresiones regulares. En la función preg_replace, el primer parámetro es el patrón de la búsqueda, el segundo parámetro $ 1 es una referencia a lo que coincide con el primer (. *) Y el tercer parámetro es el nombre del archivo.

De otra forma, también podemos usar strrpos para encontrar la posición de la última aparición de un '.' en un nombre de archivo e incrementar esa posición en 1 para que explote la cadena de (.)

$ext = substr($fileName, strrpos($fileName, '.') + 1);

En mi opinión, esta es la mejor manera si tiene nombres de archivo como name.name.name.ext (feo, pero a veces sucede):

$ext     = explode('.', $filename); // Explode the string
$my_ext  = end($ext); // Get the last entry of the array

echo $my_ext;

Si está buscando velocidad (como en un enrutador), probablemente no desee tokenizar todo. Muchas otras respuestas fallarán con /root/my.folder/my.css

ltrim(strrchr($PATH, '.'),'.');

Aunque la "mejor manera" es discutible, creo que esta es la mejor manera por algunas razones:

function getExt($path)
{
    $basename = basename($path);
    return substr($basename, strlen(explode('.', $basename)[0]) + 1);
}

1. Funciona con varias partes en una extensión, p. Ej. tar.gz
2. Código corto y eficiente
3. Funciona tanto con un nombre de archivo como con una ruta completa.

De hecho, estaba buscando eso.

<?php

$url = 'http://example.com/myfolder/sympony.mp3?a=1&b=2#XYZ';
$tmp = @parse_url($url)['path'];
$ext = pathinfo($tmp, PATHINFO_EXTENSION);

var_dump($ext);

Probé una solución simple que podría ayudar a otra persona a obtener solo el nombre de archivo de la URL que tiene parámetros de obtención

<?php

$path = "URL will be here";
echo basename(parse_url($path)['path']);

?>

Muchas Gracias

Utilice la herramienta

str_replace('.', '', strrchr($file_name, '.'))

para una recuperación rápida de la extensión (si está seguro de que el nombre de su archivo tiene una).