stat

(PHP 4, PHP 5, PHP 7, PHP 8)

stat — Bir dosya hakkında bilgi döndürür

Açıklama

stat(string $dosyaismi): array|false

dosyaismi ile belirtilen dosyanın istatistiklerini toplar. Eğer dosyaismi bir sembolik bağ ise istatistikler bağ dosyasından değil hedefinden toplanır. PHP 7.4.0 öncesinde, Windows üzerinde, bu durumda, NTS size, atime, mtime ve ctime istatistiklerini sembolik bağdan oluştururdu.

lstat(), sembolik bağların durumunu döndürmesi dışında stat() işlevine eşdeğerdir.

Bağımsız Değişkenler

dosyaismi: Dosyanın yolu.

Dönen Değerler

**stat()** and fstat() sonuç biçemi
İndis	Anahtar	Açıklama
0	dev	aygıt numarası ***
1	ino	dosya düğümü numarası ****
2	mode	dosya düğümü koruma kipi *****
3	nlink	bağ sayısı
4	uid	sahibinin kullanıcı kimliği *
5	gid	sahibinin grup kimliği *
6	rdev	dosya düğümü aygıtı ise aygıt türü
7	size	bayt sayısı
8	atime	son erişim zamanı (Unix zaman damgası)
9	mtime	son değişiklik zamanı (Unix zaman damgası)
10	ctime	dosya düğümü son değişiklik zamanı (Unix zaman damgası)
11	blksize	dosya sisteminin G/Ç blok boyu **
12	blocks	ayrılmış 512 baytlık blokların sayısı **

* Windows üzerinde daima 0'dır.

** Sadece st_blksize türünü destekleyen sistemlerde geçerlidir; diğer sistemlerde (Windows gibi) -1 döner.

*** PHP 7.4.0 öncesinde, Windows üzerinde, bu dosyayı içeren birimin 64 bitlik işaretsiz bir tam sayı olarak seri numarasıdır, bu nedenle taşabilir. Önceden, sürücü harfinin sayısal karşılığıydı (örneğin, C: sürücüsü stat() için 2 ve lstat() için 0 idi).

**** PHP 7.4.0 öncesinde, Windows üzerinde, bu, 64 bitlik işaretsiz bir tam sayı olarak dosyayla ilişkili tanımlayıcıdır, bu nedenle taşabilir. Önceden her zaman 0 idi.

***** Windows'ta, yazılabilir izin biti, salt-okunur yapılır ve tüm kullanıcılar, grup ve sahip için aynı değer kullanılır. is_writable() işlevinin aksine ACL dikkate alınmaz.

Çeşitli işlevler tarafından okunan bilgileri içeren kip değeri. Sekizlik olarak yazıldığında, sağdan başlayarak, ilk üç hane chmod() tarafından döndürülür. Sonraki basamak PHP tarafından yok sayılır. Sonraki iki hane dosya türünü gösterir:

**`kip` dosya türleri**
Sekizlik `kip`	Anlamı
`0140000`	soket
`0120000`	bağ
`0100000`	normal dosya
`0060000`	blok aygıtı
`0040000`	dizin
`0020000`	karakter aygıtı
`0010000`	fifo

Dolayısıyla, örneğin, normal bir dosyanın kipi 0100644 iken dizin için 0040755 olur.

Hata durumunda, stat() false döndürür.

Bilginize: PHP'nin tamsayı türü, işaretli tamsayı türü olduğundan 32 bitlik tamsayıların kullanıldığı sistemlerde bazı dosya sistemi işlevleri 2GB'tan büyük dosyalarda beklenmedik sonuçlar verebilir.

Hatalar/İstisnalar

Başarısızlık durumunda bir E_WARNING çıktılanır.

Sürüm Bilgisi

Sürüm:	Açıklama
7.4.0	Windows üzerinde, aygıt numarası artık dosyayı içeren birimin seri numarası oldu. Evvelce dosya ile ilgili tanımlayıcının düğüm numarası idi.
7.4.0	Sembolik bağların `size`, `atime`, `mtime` ve `ctime` istatistikleri olarak artık hedefin istatistikleri kullanılıyor. Evvelce, bunları NTS sembolik bağdan oluştururdu.

Örnekler

Örnek 1 - stat() örneği

<?php
/* Dosya durumunu alalım */
$stat = stat('C:\php\php.exe');

/*
 * Dosya erişim zamanını basalım.
 * Bu, fileatime() çağrısına eşdeğerdir.
 */
echo 'Erişim zamanı: ' . $stat['atime'];

/*
 * Dosya değişiklik zamanını basalım.
 * Bu, filemtime() çağrısına eşdeğerdir.
 */
echo 'Değişiklik zamanı: ' . $stat['mtime'];

/* Aygıt numarasını basalım */
echo 'Aygıt numarası: ' . $stat['dev'];

Örnek 2 - stat() bilgisinin touch() ile birlikte kullanımı

<?php
/* Dosya durumunu alalım */
$stat = stat('C:\php\php.exe');

/* Bilgiyi alırken başarısız olduk mu? */
if(!$stat) {
    echo 'Stat çağrısı başarısız oldu...';
} else {
    /*
     * Mevcut erişim zamanı 1 hafta öncesi olsun
     */
    $atime = $stat['atime'] + 604800;

    /* Dosyaya dokunalım */
    if (!touch('some_file.txt', time(), $atime)) {
        echo 'Dosyaya erişilemedi...';
    } else {
        echo 'Dosyaya başarıyla erişildi...';
    }
}
?>

Notlar

Bilginize:
Zaman çözünürlüğünün dosya sistemine göre farklı olabileceğini unutmayın.

Bilginize: Bu işlevin sonuçları önbelleğe kaydedilir. Daha ayrıntılı bilgi clearstatcache() işlevinde bulunabilir.

İpucu

PHP 5.0.0 sürümünden itibaren bu işlev bazı URL sarmalayıcıları ile kullanılabilmektedir. stat() ailesini destekleyen sarmalayıcıların listesi Desteklenen Protokoller ve Sarmalayıcılar başlığı altında bulunabilir.

Ayrıca Bakınız

lstat() - Bir dosya veya sembolik bağ hakkında bilgi verir
fstat() - Bir açık dosya tanıtıcısı kullanarak bir dosya hakkında bilgi döndürür
filemtime() - Dosyanın değişiklik zamanını döndürür
filegroup() - Dosyanın sahibi olan grubu döndürür
SplFileInfo

Found A Problem?

Learn How To Improve This Page • Submit a Pull Request • Report a Bug

＋add a note

User Contributed Notes 18 notes

down

webmaster at askapache dot com ¶

11 years ago

On GNU/Linux you can retrieve the number of currently running processes on the machine by doing a stat for hard links on the '/proc' directory like so:

$ stat -c '%h' /proc
118

You can do the same thing in php by doing a stat on /proc and grabbing the [3] 'nlink' - number of links in the returned array.

Here is the function I'm using, it does a clearstatcache() when called more than once.

<?php

/**
 * Returns the number of running processes
 *
 * @link http://php.net/clearstatcache
 * @link http://php.net/stat  Description of stat syntax.
 * @author http://www.askapache.com/php/get-number-running-proccesses.html
 * @return int
 */
function get_process_count() {
  static $ver, $runs = 0;
  
  // check if php version supports clearstatcache params, but only check once
  if ( is_null( $ver ) )
    $ver = version_compare( PHP_VERSION, '5.3.0', '>=' );
 
  // Only call clearstatcache() if function called more than once */
  if ( $runs++ > 0 ) { // checks if $runs > 0, then increments $runs by one.
    
    // if php version is >= 5.3.0
    if ( $ver ) {
      clearstatcache( true, '/proc' );
    } else {
      // if php version is < 5.3.0
      clearstatcache();
    }
  }
  
  $stat = stat( '/proc' );
 
  // if stat succeeds and nlink value is present return it, otherwise return 0
  return ( ( false !== $stat && isset( $stat[3] ) ) ? $stat[3] : 0 );
}

?>

Example #1 get_process_count() example

<?php
$num_procs = get_process_count();
var_dump( $num_procs );
?>

The above example will output:

int(118)

Which is the number of processes that were running.

down

webmaster at askapache dot com ¶

16 years ago

down

admin at smitelli dot com ¶

19 years ago

There's an important (yet little-known) problem with file dates on Windows and Daylight Savings. This affects the 'atime' and 'mtime' elements returned by stat(), and it also affects other filesystem-related functions such as fileatime() and filemtime().

During the winter months (when Daylight Savings isn't in effect), Windows will report a certain timestamp for a given file. However, when summer comes and Daylight Savings starts, Windows will report a DIFFERENT timestamp! Even if the file hasn't been altered at all, Windows will shift every timestamp it reads forward one full hour during Daylight Savings.

This all stems from the fact that M$ decided to use a hackneyed method of tracking file dates to make sure there are no ambiguous times during the "repeated hour" when DST ends in October, maintain compatibility with older FAT partitions, etc. An excellent description of what/why this is can be found at http://www.codeproject.com/datetime/dstbugs.asp

This is noteworthy because *nix platforms don't have this problem. This could introduce some hard-to-track bugs if you're trying to move scripts that track file timestamps between platforms.

I spent a fair amount of time trying to debug one of my own scripts that was suffering from this problem. I was storing file modification times in a MySQL table, then using that information to see which files had been altered since the last run of the script. After each Daylight Savings change, every single file the script saw was considered "changed" since the last run, since all the timestamps were off by +/- 3600 seconds.

This one-liner is probably one of the most incorrect fixes that could ever be devised, but it's worked flawlessly in production-grade environments... Assuming $file_date is a Unix timestamp you've just read from a file:

<?php
    if (date('I') == 1) $file_date -= 3600;
?>

That will ensure that the timestamp you're working with is always consistently reported, regardless of whether the machine is in Daylight Savings or not.

down

mao at nospam dot com ¶

20 years ago

If you have ftp (and the related sftp) protocols disabled on your remote server, it can be hard figuring out how to 'stat' a remote file. The following works for me:

<?php  

$conn = ssh2_connect($host, 22);
ssh2_auth_password($conn, $user, $password);
$stream = ssh2_exec($conn, "stat $fileName > $remotedest");
ssh2_scp_recv($conn, $remotedest, $localdest);
$farray = file($localdest);
print_r($farray);
?>

down

salisbm at hotmail dot com ¶

22 years ago

I was curious how I could tell if a file was a directory... so I found on http://www.hmug.org/man/2/stat.html the following information about the mode bits:
#define S_IFMT 0170000           /* type of file */
#define        S_IFIFO  0010000  /* named pipe (fifo) */
#define        S_IFCHR  0020000  /* character special */
#define        S_IFDIR  0040000  /* directory */
#define        S_IFBLK  0060000  /* block special */
#define        S_IFREG  0100000  /* regular */
#define        S_IFLNK  0120000  /* symbolic link */
#define        S_IFSOCK 0140000  /* socket */
#define        S_IFWHT  0160000  /* whiteout */
#define S_ISUID 0004000  /* set user id on execution */
#define S_ISGID 0002000  /* set group id on execution */
#define S_ISVTX 0001000  /* save swapped text even after use */
#define S_IRUSR 0000400  /* read permission, owner */
#define S_IWUSR 0000200  /* write permission, owner */
#define S_IXUSR 0000100  /* execute/search permission, owner */

Note that these numbers are in octal format.  Then, to check to see if the file is a directory, after calling fstat, I do:

if ($fstats[mode] & 040000)
  ... this must be a directory

down

ian at eiloart dot com ¶

26 years ago

Here's what the UNIX man page on stat has to say about the difference between a file change and  a file modification:



st_mtime  Time when data was last modified.  Changed by  the following  functions:   creat(),  mknod(), pipe(), utime(), and write(2).



st_ctime  Time when file status was last  changed.   Changed by  the  following  functions: chmod(), chown(), creat(), link(2), mknod(), pipe(), unlink(2), utime(), and write().



So a modification is a change in the data, whereas a change also happens if you modify file permissions and so on.

down

digitalaudiorock at hotmail dot com ¶

16 years ago

Regarding the stat() on files larger than 2GB on 32 bit systems not working, note that the behavior appears to differ between Linux and Windows.  Under Windows there's so way to know whether or not this failed.

It's been my experience that under Linux, performing a stat() on files that are too large for the integer size generates a warning and returns false.  However under Windows it silently truncates the high order bits of the size resulting in an incorrect number.  The only way you'd ever know it failed is in the event that the truncation happened to leave the sign bit on resulting in a negative size.  That is, there is _no_ reliable way to know it failed.

This is true of filesize() as well.

Tom

down

mail4rico at gmail dot com ¶

17 years ago

In response to the note whose first line is:
Re note posted by "admin at smitelli dot com"

I believe you have the conversion backwards. You should add an hour to filemtime if the system is in DST and the file is not. Conversely, you should subtract an hour if the file time is DST and the current OS time is not.

Here's a simplified, corrected version:
<?php
    function getmodtime($file) { //returns the time a file was modified.
        $mtime = filemtime($file);
        //date('I') returns 1 if DST is on and 0 if off.
        $diff = date('I')-date('I', $mtime);
        //diff =  0 if file-time and os-time are both in the same DST setting
        //diff =  1 if os is DST and file is not
        //diff = -1 if file is DST and os is not
        return $mtime + $diff*3600;
    }
?>
Here's a test:
<?php
    //create two dummy files:
    $file0 = 'file1.txt';
    $file1 = 'file2.txt';
    file_put_contents($file0, '');
    file_put_contents($file1, '');
    
    $time0=strtotime('Jan 1 2008 10:00'); echo 'Date0 (ST): ' . date(DATE_COOKIE, $time0)."\n";
    $time1=strtotime('Aug 1 2008 10:00'); echo 'Date1 (DT): ' . date(DATE_COOKIE, $time1)."\n";
    touch($file0, $time0); //set file0 to Winter (Non-DST)
    touch($file1, $time1); //set file1 to Summer (DST)
    
    $ftime0 = filemtime($file0);
    $ftime1 = filemtime($file1);
    echo "\nUncorrected: \n";
    echo 'File 0: ' . ($ftime0-$time0) ."\n";
    echo 'File 1: ' . ($ftime1-$time1) ."\n";
    //if your system adjusts for DST, then _one_ of the above should be 3600 or -3600, depending on the time of year
    
    $ftime0 = getmodtime($file0); //use filemtime correction
    $ftime1 = getmodtime($file1); //use filemtime correction
    echo "\nCorrected: \n";
    echo 'File 0: ' . ($ftime0-$time0) ."\n";
    echo 'File 1: ' . ($ftime1-$time1) ."\n";
    //both of the corrected values output should be 0.
?>

Output:
------------------------------
(when run in summer)
------------------------------
Date0 (ST): Tuesday, 01-Jan-08 10:00:00 EST
Date1 (DT): Friday, 01-Aug-08 10:00:00 EDT

Uncorrected: 
File 0: -3600
File 1: 0

Corrected: 
File 0: 0
File 1: 0
------------------------------
(when run in winter--dates omitted)
------------------------------
Uncorrected: 
File 0: 0
File 1: 3600

Corrected: 
File 0: 0
File 1: 0

In response to Re note posted by "admin at smitelli dot com",  your version below gives the following output when substituted into my test:
------------------------------
(when run in summer--dates omitted)
------------------------------
Uncorrected: 
File 0: -3600
File 1: 0

Corrected: 
File 0: -7200
File 1: 0
------------------------------
You can see that the operation is the opposite of what it should be.

down

com dot gmail at algofoogle ¶

20 years ago

Re note posted by "salisbm at hotmail dot com":

S_IFDIR is not a single-bit flag. It is a constant that relies on the "S_IFMT" bitmask. This bitmask should be applied to the "mode" parameter before comparing with any of the other "S_IF..." constants, as indicated by stat.h:

#define S_ISDIR(m)  (((m) & S_IFMT) == S_IFDIR)

That is, this approach is incorrect:

<?php
define('S_IFDIR',040000);
if ($mode & S_IFDIR)
{
  /*
    incorrect!
    format could be S_IFDIR, but also
    S_IFBLK, S_IFSOCK, or S_IFWHT.
  */
}
?>

...and should instead be:

<?php
define('S_IFMT',0170000);
define('S_IFDIR',040000);
if (S_IFDIR == ($mode & S_IFMT)) {  /* ... */  }
?>

As pointed out by "svend at svendtofte dot com", however, there is also the "is_dir" function for this purpose, along with "is_file" and "is_link" to cover the most common format types...

down

marting.dc AT gmail.com ¶

19 years ago

If you want to know a directory size, this function will help you:



<?php

function dir_size($dir)

{

    $handle = opendir($dir);

    

    while ($file = readdir($handle)) {

        if ($file != '..' && $file != '.' && !is_dir($dir.'/'.$file)) {

            $mas += filesize($dir.'/'.$file);

            } else if (is_dir($dir.'/'.$file) && $file != '..' && $file != '.') {

            $mas += dir_size($dir.'/'.$file);

        }

    }

    return $mas;

}

echo dir_size('DIRECTORIO').' Bytes';

?>

down

JulieC ¶

18 years ago

The dir_size function provided by "marting.dc AT gmail.com" works great, except the $mas variable is not initialized.  Add:

   $mas = 0;

before the while() loop.

down

svend at svendtofte dot com ¶

21 years ago

To the note of how you can figure out if a file is a folder or not, there is also the handy "is_dir" function.

down

Hellhound ¶

17 years ago

To ignore index number or name specifics.. use:

list($dev, $ino, $mode, $nlink, $uid, $gid, $rdev, $size, $atime, $mtime, $ctime, $blksize, $blocks)
         = lstat($directory_element);

down

carlos [at] encore-lab [dot] com ¶

10 years ago

stat() may not work on mounted CIFS' in 32 bit systems if you do not specify the option noserverino when mounting. E.g:

mount -t cifs -o user="user",password="password",noserverino //example.local/share /mnt/mount-point

Other functions based on stat() data such as file time functions and is_dir() are affected the same way.

This happens because if you do not specify the option noserverino the remote inode may be 64 bit-based and thus the local system cannot handle it.

down

Ray.Paseur sometimes uses Gmail ¶

4 years ago

A good explanation of the "mode" bits is given here:
https://www.php.net/manual/en/function.fileperms.php

down

Anonymous ¶

19 years ago

Re note posted by "admin at smitelli dot com"

I'm not sure how that can work all year round since you have to modify both opposing inside and outside DST based on the actual files themselves, as well as the current DST setting for the system.

e.g. using filemtime, same thing for stat.

<?php

$mtime = filemtime($file);

if (date('I') == 1) {
    // Win DST is enabled, adjust standard time 
    // files back to 'real' file UTC.
    if (date('I', $mtime) == 0) {
        $mtime -= 3600;
    }
} else {
    // Win DST is disabled, adjust daylight time 
    // files forward to 'real' file UTC.
    if (date('I', $mtime) == 1) {
        $mtime += 3600;
    }
}

echo gmdate('Y-m-d H:i:s', $mtime);

?>

Just another example of why 'not' to use windows in a server room.

down

-2

antonixyz at gmx dot net ¶

17 years ago

<?php

$stat = stat($filepath);

$mode = $stat[2];

?>

is identical to:

<?php $mode = fileperms($filepath); ?>



at least on my linux box.

down

-3

Anonymous ¶

20 years ago

If the 2GB limit is driving you crazy, you can use this complete hack.  use in place of filesize()

function file_size($file) {
  $size = filesize($file);
  if ( $size == 0)
    $size = exec("ls -l $file | awk '{print $5}'");
  return $size;
}

＋add a note