$oldErrorReportingValue = error_reporting(0);
rename($oldFileName, $newFileName);
# do something else ....
error_reporting($oldErrorReportingValue);

Uyarılar bir nedeni olduğunu unutmayın. En iyi yaklaşım, why işlemi bir uyarı oluşturur içine bakmak ve kod bu durumları işleyebilir dikkat çekmek olacaktır. Yalnızca son çare olarak uyarıları görmezden gerekir.

error_reporting() uyarı mesajları için ayrıntı uygun bir düzeyini ayarlamak için kullanın. uyarılar, bildirimler ve / veya hatalar sadece giriş setleri, onlar görüntülenir olmadığını unutmayın.

Sizin durumunuzda muhtemelen "error_reporting( E_ERROR | E_USER_ERROR );" bu da aslında bir hata değil, sadece bir uyarı ya da gerçekten bir şey bölmez bir uyarı ise sadece bir şey oturum olacaktır.

Tüm bu muhtemelen böyle bir şey yapmak için iyi bir fikirdir:

if (getenv('PHP_DEBUG')=='1')
{
    error_reporting( E_ERROR | E_USER_ERROR );
    ini_set( 'display_errors', true );
}
else
{
    error_reporting( E_ERROR | E_USER_ERROR );
    ini_set( 'display_errors', false );
}

. Ve sonra geliştirme sunucusu üzerinde sizin htaccess veya VirtualHost yönergesinde aşağıdaki satırı olabilir:

SetEnv PHP_DEBUG=1

≠ 1 girilmedi yana üretim tüm ayarlamak gerek yok.

Bir yan not olarak, ben şahsen error_reporting ayarlanır yapmak zorunda tercih:

error_reporting( E_ALL | E_STRICT );

Ben hissediyorum çünkü "Ben belki daha iyi bir iş yapmak için beni zorlamak yanlış yapmış olabilir her şeyi uyarmak" olarak ingilizce okuyabilir ki ben sadece bunu kullanmadan önce bazı şeyler kontrol ve başlatılırken her haber ve uyarı yenebilir değişkenleri düzgün, sonuç muhtemelen en azından biraz daha güvenli olacaktır.

edit: bazı açıklamalar:

Arif sadece mesajı almak değil, emin operasyon başarılı yapmak istemedim beri. Ben olarak yorumlanır Hangi "operasyon çalıştı umurumda değil". Tabii bu konuda giderek daha iyi bir şekilde işlev kütüphanesine aşağıdaki gibi bir şey olacaktır:

/**
 * @author: Kris
 * @license: see http://sam.zoy.org/wtfpl/
 *
 * PLEASE NOTE THAT THE FOLLOWING CODE IS TESTED BY ME, NOT QUALITY ASSURANCE
 */

/**
 * Move a file
 *
 * If uses filename from $source if $destination is a directory
 * 
 * @param string $source
 * @param string $destination
 * @param bool $overwrite
 * @return bool
 */
function my_move_file( $source, $destination, $overwrite = false )
{
    return _internal_my_move_or_copy_file( $source, $destination, true, $overwrite );
}

/**
 * Copy a file
 * 
 * If uses filename from $source if $destination is a directory
 * 
 * @param string $source
 * @param string $destination
 * @param bool $overwrite
 * @return bool
 */
function my_copy_file( $source, $destination, $overwrite = false )
{
    return _internal_my_move_or_copy_file( $source, $destination, false, $overwrite );
}

define( '__internal_my_move_or_copy_file_e_error',  E_USER_ERROR );     // change to E_USER_NOTICE if not meant to be fatal
define( '__internal_my_move_or_copy_file_e_notice', E_USER_NOTICE );

/**
 * Should not be called by userland code, use my_move_file or my_copy_file instead
 *
 * one function to implement both move and copy because almost all of the required validations is identical.
 *
 * @param string $source
 * @param string $destination
 * @param bool $is_move
 * @param bool $overwrite
 * @return bool
 */
function _internal_my_move_or_copy_file( $source, $destination, $is_move, $overwrite )
{
// what we'll be returning
    $result = false;

    // input sanity checks
    if ( !is_string( $source ) || !is_callable( $source, '__toString' ) )
    {
        trigger_error( 
            "_internal_my_move_or_copy_file: expects \$source to be a string.", 
            __internal_my_move_or_copy_file_e_error );
        return false;
    }
    elseif ( !is_string( $destination ) || !is_callable( $destination, '__toString' ) )
    {
        trigger_error( 
            "_internal_my_move_or_copy_file: expects \$destination to be a string.", 
            __internal_my_move_or_copy_file_e_error );
        return false;
    }
    elseif ( ! is_bool( $is_move ) )
    {
        trigger_error( 
            "_internal_my_move_or_copy_file: expects \$is_move to be a bool.", 
            __internal_my_move_or_copy_file_e_error );
        return false;
    }
    elseif ( ! is_bool( $overwrite ) )
    {
        trigger_error( 
            "_internal_my_move_or_copy_file: expects \$overwrite to be a bool.", 
            __internal_my_move_or_copy_file_e_error );
        return false;
    }

    $action_word = $is_move ? 'move' : 'copy';

    if ( file_exists( $source ) && is_readable( $source ) )
    {
        $to = preg_split( '/\//', $destination, -1, PREG_SPLIT_NO_EMPTY );
        $destination = '/'.implode( '/', $to );

        if ( is_dir( $destination ) )
        {
        // make sure we don't accidentally allow ../ etc
            if ( in_array( '..', $to ) || in_array( '.', $to ) )
            {
                trigger_error( "my_{$action_word}_file: \$destination does not allow path traversion using /../ or /./", $e_error_code );
            }

            // make sure we have a filename on $destination
            if ( is_dir( $destination ) )
            {
            // user gave a directory but no filename so use the filename in $source
                $to[] = basename( $source );
                $destination = '/'.implode( '/', $to );
            }
        }

        if ( file_exists( $destination ) && is_writable( $destination ) )
        {
            if ( ! $overwrite )
            {
                trigger_error(
                    "my_{$action_word}_file: \$destination already exists and I am instructed not to overwrite.", 
                    __internal_my_move_or_copy_file_e_notice );
                return false;
            }
        }
        elseif ( is_dir( dirname( $destination ) ) || is_writable( dirname( $destination ) ) )
        {
        // we can write
        }
        else // all allowable situations are already passed
        {
            trigger_error( 
                "my_{$action_word}_file: $destination directory does not exist or cannot be written to.", 
                __internal_my_move_or_copy_file_e_error );
        }


        if ( $is_move )
        {
        // if we are going to move a file the source also needs to be writable
            if ( ! is_writable( $source ) )
            {
                trigger_error( 
                    "my_{$action_word}_file: Cannot {$action_word} \$source because it cannot be written.", 
                    __internal_my_move_or_copy_file_e_error );
            }

            $result = rename( $source, $destination );
        }
        else
        {
            $result = copy( $source, $destination );
        }

        // see if what php's built in function gave us is acceptible
        if ( $result === false )
        {
            trigger_error( 
                "my_{$action_word}_file: unexpected failure to {$action_word} \$source to \$destination.", 
                __internal_my_move_or_copy_file_e_error );
        }

        // postflight check if the work we did was successful
        if ( !file_exists( $destination ) )
        {
            trigger_error( 
                "my_{$action_word}_file: unexpected failure to {$action_word} \$destination does not exist after {$action_word} operation.", 
                __internal_my_move_or_copy_file_e_error );
        }
    }
    else // file does not exists or is unreadable 
    {
        trigger_error( 
            "my_{$action_word}_file: \$source \"$source\" does not exist or cannot be read.", 
            __internal_my_move_or_copy_file_e_error );
    }

    return $result; 
}