Cum pot obține o extensie de fișier în PHP? (Programare, Php, Extensie De Fișier)

Oamenii din alte limbaje de scripting cred întotdeauna că al lor este mai bun pentru că au o funcție încorporată pentru a face asta și nu PHP (mă uit la Pythonistas chiar acum :-)).

De fapt, există, dar puțină lume o cunoaște. Faceți cunoștință cu pathinfo():

$ext = pathinfo($filename, PATHINFO_EXTENSION);

Aceasta este rapidă și încorporată. pathinfo() vă poate oferi și alte informații, cum ar fi calea canonică, în funcție de constanta pe care i-o treceți.

Nu uitați că, dacă doriți să vă puteți ocupa de caractere non ASCII, trebuie să setați mai întâi localele. DE EX:

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

De asemenea, rețineți că acest lucru nu ia în considerare conținutul fișierului sau tipul mime, ci doar extensia. Dar este ceea ce ați cerut.

În cele din urmă, rețineți că acest lucru funcționează numai pentru o cale de fișier, nu pentru o cale de resurse URL, care este acoperită folosind PARSE_URL.

Bucurați-vă de

pathinfo()

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

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

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

A) Nu utilizați unsafe sugerat 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) Utilizați 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'

BONUS: Vizualizați toate exemplele native PHP

Există, de asemenea, și SplFileInfo:

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

De multe ori puteți scrie un cod mai bun dacă treceți un astfel de obiect în loc de un șir de caractere. Codul dvs. este mai vorbitor atunci. Începând cu PHP 5.4, acest lucru este un one-liner:

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

Răspunsul lui E-satis este modul corect de a determina extensia fișierului.

Alternativ, în loc să vă bazați pe o extensie de fișiere, ați putea utiliza funcția fileinfo pentru a determina tipul MIME al fișierelor.

Iată un exemplu simplificat de procesare a unei imagini încărcate de un utilizator:

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

Atâta timp cât nu conține o cale de acces, puteți utiliza și dvs:

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

Unde $fname este un nume de fișier, de exemplu: my_picture.jpg.și rezultatul ar fi: jpg

1) Dacă utilizați (PHP 5 >= 5.3.6)puteți utiliza SplFileInfo::getExtension – Obține extensia fișierului

Exemplu de cod

<?php

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

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

?>

Acest lucru va ieși

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

2) O altă modalitate de a obține extensia, dacă utilizați (PHP 4 >= 4.0.3, PHP 5) este pathinfo

Exemplu de cod

<?php

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

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

?>

Acest lucru va ieși

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

// EDIT: a fost eliminată o paranteză

Uneori este util să nu se utilizeze pathinfo($path, PATHINFO_EXTENSION). De exemplu:

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

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

De asemenea, rețineți că pathinfo nu reușește să manipuleze unele caractere non-ASCII (de obicei, le elimină pur și simplu din ieșire). În cazul extensiilor, acest lucru nu reprezintă de obicei o problemă, dar nu strică să fiți conștienți de acest avertisment.

Faceți-o mai repede.

Apelurile de nivel scăzut trebuie să fie foarte rapide așa că m-am gândit că merită să fac niște cercetări. Am încercat câteva metode (cu diferite lungimi de șiruri, lungimi de extensie, mai multe execuții fiecare), iată câteva rezonabile:

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

Rezultatenu au fost foarte surprinzătoare. Slabă pathinfo este (de departe!) cea mai lentă; chiar și cu PATHINFO_EXTENSION opțiune, se pare că încearcă să analizeze întregul lucru și apoi să renunțe la toate părțile inutile. Pe de altă parte, opțiunea încorporată strrpos este inventată aproape exact pentru această sarcină, nu ia niciun ocol, așa că nu e de mirare că se comportă mult mai bine decât ceilalți candidați:

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

NOTĂ: prima metodă are un efect secundar: returnează întregul nume atunci când nu există o extensie. Cu siguranță nu ar avea sens să o măsori cu un strpos suplimentar pentru a evita acest comportament.

Concluzie

Aceasta pare a fi Calea Samurailor:

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

Câteva cazuri de testare

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

(Ultimul este un pic special; ar putea fi doar o extensie sau o extensie goală, cu numele pur fiind „.htaccess”, nu sunt sigur dacă există o regulă pentru asta. Așa că bănuiesc că puteți merge cu ambele, atâta timp cât știți ce faceți).

Cel mai simplu mod de a obține extensia fișierului în PHP este să utilizați funcția încorporată în PHP pathinfo.

$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

Puteți încerca și acest lucru (funcționează pe PHP 5.* și 7):

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

Sfat: returnează un șir gol dacă fișierul nu are o extensie

Îmi pare rău… „Întrebare scurtă, dar NU răspuns scurt”

Exemplul 1 pentru 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);

Exemplul 2 pentru 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);

Rezultatul exemplului 1:

Name: base.min
Extension: css

Rezultatul exemplului 2:

Name: file.bak
Extension: php

Referințe

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

Iată un exemplu. Să presupunem că $filename este „exemplu.txt”,

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

Deci $ext va fi „.txt”.

pathinfo este o matrice. Putem verifica numele directorului, numele fișierului, extensia, , etc.:

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

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

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

O soluție rapidă ar fi ceva de genul următor.

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

Poți încerca și asta:

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

Am constatat că pathinfo() și SplFileInfo soluții funcționează bine pentru fișierele standard de pe sistemul de fișiere local, dar puteți întâmpina dificultăți dacă lucrați cu fișiere de la distanță, deoarece URL-urile pentru imagini valide pot avea un # (identificatori de fragmente) și/sau ? (parametrii de interogare) la sfârșitul URL-ului, pe care ambele soluții le vor trata (incorect) ca parte a extensiei de fișier.

Am constatat că aceasta este o modalitate fiabilă de a utiliza pathinfo() pe o adresă URL după ce o analizează mai întâi pentru a elimina aglomerația inutilă de după extensia de fișier:

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

Utilizați substr($path, strrpos($path,'.')+1);. Este cea mai rapidă metodă dintre toate comparațiile.

@Kurt Zhong a răspuns deja.

Să verificăm aici rezultatul comparației: https://eval.in/661574

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

aceasta este cea mai bună metodă dacă aveți nume de fișiere de genul nume.nume.nume.nume.ext (urât, dar se întâmplă uneori

Acest lucru va funcționa

$ext = pathinfo($filename, PATHINFO_EXTENSION);

Puteți obține toate extensiile de fișiere dintr-un anumit dosar și puteți face operații cu o anumită extensie de fișier:

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

preg_replace abordare pe care o folosim căutarea și înlocuirea expresiilor regulate. În cadrul funcției preg_replace, primul parametru este modelul de căutare, al doilea parametru $1 este o referință la ceea ce se potrivește cu primul (.*), iar al treilea parametru este numele fișierului.

Într-un alt mod, putem utiliza strrpos pentru a găsi poziția ultimei apariții a unui „.” într-un nume de fișier și să creștem această poziție cu 1, astfel încât să explodeze șirul de caractere de la (.).

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

IMO, aceasta este cea mai bună modalitate dacă aveți nume de fișiere de genul nume.nume.nume.nume.ext (urât, dar se întâmplă uneori):

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

echo $my_ext;

Dacă sunteți în căutarea vitezei (cum ar fi într-un router), probabil că nu doriți să tokenizați totul. Multe alte răspunsuri vor eșua cu /root/my.folder/my.css

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

Deși „cel mai bun mod” este discutabil, cred că acesta este cel mai bun mod din câteva motive:

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

1. Funcționează cu mai multe părți ale unei extensii, de exemplu tar.gz
2. Cod scurt și eficient
3. Funcționează atât cu un nume de fișier, cât și cu o cale completă

De fapt, asta căutam și eu.

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

Am încercat o soluție simplă care ar putea ajuta pe altcineva să obțină doar numele fișierului din URL-ul care are parametrii get

<?php

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

?>

Mulțumesc

Utilizați

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

pentru o recuperare rapidă a extensiei (dacă știți sigur că numele fișierului dvs. are una).