Esta é uma pergunta que você pode ler em qualquer lugar da Web com várias respostas:

$ext = end(explode('.', $filename));
$ext = substr(strrchr($filename, '.'), 1);
$ext = substr($filename, strrpos($filename, '.') + 1);
$ext = preg_replace('/^.*\.([^.]+)$/D', '$1', $filename);

$exts = split("[/\\.]", $filename);
$n    = count($exts)-1;
$ext  = $exts[$n];

etc.

No entanto, sempre existe "o melhor caminho" e deve estar no Stack Overflow.

Pessoas de outras linguagens de script sempre acham que a deles é melhor porque elas têm uma função interna para fazer isso e não o PHP (estou vendo os Pythonistas agora :-)).

De fato, existe, mas poucas pessoas sabem disso. Conheça pathinfo():

$ext = pathinfo($filename, PATHINFO_EXTENSION);

Isso é rápido e embutido. pathinfo()pode fornecer outras informações, como caminho canônico, dependendo da constante que você passar para ele.

Lembre-se de que, se você quiser lidar com caracteres não ASCII, precisará primeiro definir o código do idioma. POR EXEMPLO:

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

Além disso, observe que isso não leva em consideração o conteúdo do arquivo ou o tipo MIME, você só obtém a extensão. Mas é o que você pediu.

Por fim, observe que isso funciona apenas para um caminho de arquivo, não um caminho de recursos de URL, coberto usando PARSE_URL.

Aproveitar

pathinfo()

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

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

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

A) Não use sugestões insegurasPATHINFO :

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) Use 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'

BÔNUS: Veja todos os exemplos nativos do PHP

Há também SplFileInfo:

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

Freqüentemente, você pode escrever um código melhor se passar um objeto assim ao invés de uma string. Seu código está mais falando então. Desde o PHP 5.4, este é um recurso:

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

A resposta do E-satis é a maneira correta de determinar a extensão do arquivo.

Como alternativa, em vez de depender de uma extensão de arquivos, você pode usar o fileinfo para determinar o tipo de MIME dos arquivos.

Aqui está um exemplo simplificado de processamento de uma imagem carregada por um usuário:

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

Contanto que ele não contenha um caminho, você também pode usar:

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

Onde $fnameé um nome do arquivo, por exemplo: my_picture.jpg. E o resultado seria:jpg

1) Se você estiver usando (PHP 5> = 5.3.6), poderá usar SplFileInfo :: getExtension - Obtém a extensão do arquivo

Código de exemplo

<?php

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

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

?>

Isso produzirá

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

2) Outra maneira de obter a extensão se você estiver usando (PHP 4> = 4.0.3, PHP 5) é pathinfo

Código de exemplo

<?php

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

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

?>

Isso produzirá

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

// EDIT: removeu um colchete

Às vezes é útil não usar pathinfo($path, PATHINFO_EXTENSION). Por exemplo:

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

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

Observe também que pathinfofalha ao manipular alguns caracteres não-ASCII (geralmente apenas os suprime da saída). Em extensões que geralmente não são um problema, mas não faz mal estar ciente dessa advertência.

A maneira mais simples de obter extensão de arquivo no PHP é usar a função interna pathinfo do PHP .

$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

Você pode tentar também isso (funciona no PHP 5. * e 7):

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

Dica: retorna uma string vazia se o arquivo não tiver uma extensão

Desculpe ... "Pergunta curta; mas NÃO resposta curta"

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

Exemplo 2 para 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);

Saída do exemplo 1:

Name: base.min
Extension: css

Saída do exemplo 2:

Name: file.bak
Extension: php

Referências

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

Uma solução rápida seria algo assim.

// 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];

Aqui está um exemplo. Suponha que $ filename seja "example.txt",

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

Então $ ext será ".txt".

pathinfo é uma matriz. Podemos verificar o nome do diretório, nome do arquivo, extensão , 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);

Você também pode tentar isso:

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

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

essa é a melhor maneira se você tiver nomes de arquivos como name.name.name.ext (feio, mas às vezes acontece

Isso vai funcionar

$ext = pathinfo($filename, PATHINFO_EXTENSION);

Descobri que as soluções pathinfo()e SplFileInfofuncionam bem para arquivos padrão no sistema de arquivos local, mas você pode ter dificuldades se estiver trabalhando com arquivos remotos, pois os URLs para imagens válidas podem ter um #(identificador de fragmento) e / ou? (parâmetros de consulta) no final do URL, que ambas as soluções (incorretas) tratam como parte da extensão do arquivo.

Eu achei que essa era uma maneira confiável de usar pathinfo()um URL depois de analisá-lo para remover a confusão desnecessária após a extensão do arquivo:

$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()

Use substr($path, strrpos($path,'.')+1);. É o método mais rápido de todas as comparações.

@ Kurt Zhong já respondeu.

Vamos verificar o resultado comparativo aqui: https://eval.in/661574

Você pode obter todas as extensões de arquivo em uma pasta específica e executar operações com uma extensão de arquivo 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);
?>

Faça mais rápido.

As chamadas de baixo nível precisam ser muito rápidas, então pensei que valia a pena pesquisar. Eu tentei alguns métodos (com vários comprimentos de string, comprimentos de extensão, várias execuções cada), eis alguns razoáveis:

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

Os resultados não foram muito surpreendentes. Pobre pathinfoé (de longe!) O mais lento (parece que ele está tentando analisar a coisa toda e depois largar todas as partes desnecessárias) - e method3()(strrpos) é o mais rápido, de longe:

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: o primeiro método tem um efeito colateral: retorna o nome inteiro quando não há extensão. Certamente não faria sentido medi-lo com outras strops para evitar esse comportamento.

Conclusão

Parece o Caminho do Samurai:

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

Se você está procurando velocidade (como em um roteador), provavelmente não deseja tokenizar tudo. Muitas outras respostas falharão com/root/my.folder/my.css

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

Embora o "melhor caminho" seja discutível, acredito que seja o melhor por alguns motivos:

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

1. Funciona com várias partes em uma extensão, por exemplo tar.gz
2. Código curto e eficiente
3. Funciona com um nome de arquivo e um caminho completo

IMO, esta é a melhor maneira se você tiver nomes de arquivos como name.name.name.ext (feio, mas às vezes acontece):

$ext     = explode('.', $filename); // Explode the string
$ext_len = count($ext) - 1; // Count the array -1 (because count() starts from 1)
$my_ext  = $ext[$ext_len]; // Get the last entry of the array

echo $my_ext;

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

preg_replace, estamos usando a pesquisa de expressão regular e substituí-la. Na função preg_replace, o primeiro parâmetro é padrão para a pesquisa, o segundo parâmetro $ 1 é uma referência ao que for correspondido pelo primeiro (. *) E o terceiro parâmetro é o nome do arquivo.

Outra maneira, também podemos usar strrpos para encontrar a posição da última ocorrência de um '.' em um nome de arquivo e aumente essa posição em 1 para que ela exploda a string de (.)

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

Na verdade, eu estava procurando por isso.

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

Usar

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

para uma recuperação rápida da extensão (se você souber com certeza o nome do seu arquivo).