Ошибка file put contents

<?php
    function file_force_contents($dir, $contents){
        $parts = explode('/', $dir);
        $file = array_pop($parts);
        $dir = '';
        foreach($parts as $part)
            if(!is_dir($dir .= "/$part")) mkdir($dir);
        file_put_contents("$dir/$file", $contents);
    }
?>

Benchmark below:

file_put_contents() for 1,000,000 writes - average of 3 benchmarks:

real 0m3.932s
user 0m2.487s
sys 0m1.437s

fopen() fwrite() for 1,000,000 writes, fclose() -  average of 3 benchmarks:

real 0m2.265s
user 0m1.819s
sys 0m0.445s

<?php
function file_force_contents( $fullPath, $contents, $flags = 0 ){
    $parts = explode( '/', $fullPath );
    array_pop( $parts );
    $dir = implode( '/', $parts );

        if( !

is_dir( $dir ) )
        mkdir( $dir, 0777, true );file_put_contents( $fullPath, $contents, $flags );
}file_force_contents( ROOT.'/newpath/file.txt', 'message', LOCK_EX );
?>

<?php

/* set the FTP hostname */

$user = "test";

$pass = "myFTP";

$host = "example.com";

$file = "test.txt";

$hostname = $user . ":" . $pass . "@" . $host . "/" . $file;
/* the file content */

$content = "this is just a test.";
/* create a stream context telling PHP to overwrite the file */

$options = array('ftp' => array('overwrite' => true));

$stream = stream_context_create($options);
/* and finally, put the contents */

file_put_contents($hostname, $content, 0, $stream);

?>

i.e. in concurrent scenarios file_get_contents may return empty if you don't wrap it like this:

<?php
$myfile=fopen('test.txt','rt');
flock($myfile,LOCK_SH);
$read=file_get_contents('test.txt');
fclose($myfile);
?>

If you have code that does a file_get_contents on a file, changes the string, then re-saves using file_put_contents, you better be sure to do this correctly or your file will randomly wipe itself out.

<?phpfunction file_put_contents_atomically($filename, $data, $flags = 0, $context = null) {
    if (file_put_contents($filename."~", $data, $flags, $context) === strlen($contents)) {
        return rename($filename."~",$filename,$context);
    }

    @

unlink($filename."~", $context);
    return FALSE;
}?>

If you want to emulate this function in PHP4, you need to return the bytes written as well as support for arrays, flags.

I can only figure out the FILE_APPEND flag and array support. If I could figure out "resource context" and the other flags, I would include those too.

<?

define('FILE_APPEND', 1);
function file_put_contents($n, $d, $flag = false) {
    $mode = ($flag == FILE_APPEND || strtoupper($flag) == 'FILE_APPEND') ? 'a' : 'w';
    $f = @fopen($n, $mode);
    if ($f === false) {
        return 0;
    } else {
        if (is_array($d)) $d = implode($d);
        $bytes_written = fwrite($f, $d);
        fclose($f);
        return $bytes_written;
    }
}

?>

if (strpos($dir, "../") === 0)
    $dir = str_replace("..", substr(__DIR__, 0, strrpos(__DIR__, "/")), $dir);

More information about using this function without upgrading your version of PHP can be found on the below link:

http://pear.php.net/package/PHP_Compat

<?php

$host = '*****';

$usr = '*****';

$pwd = '**********';        

$local_file = './orderXML/order200.xml';

$ftp_path = 'order200.xml';

$conn_id = ftp_connect($host, 21) or die ("Cannot connect to host");     

ftp_pasv($resource, true);

ftp_login($conn_id, $usr, $pwd) or die("Cannot login");

// perform file upload

ftp_chdir($conn_id, '/public_html/abc/');

$upload = ftp_put($conn_id, $ftp_path, $local_file, FTP_ASCII);

if($upload) { $ftpsucc=1; } else { $ftpsucc=0; }

// check upload status:

print (!$upload) ? 'Cannot upload' : 'Upload complete';

print "n";

// close the FTP stream

ftp_close($conn_id);

?>

    public static function file_force_contents($dir, $contents){
        $parts = explode('/', $dir);
        $file = array_pop($parts);
        $dir = '';

        foreach($parts as $part) {
            if (! is_dir($dir .= "{$part}/")) mkdir($dir);
        }

        return file_put_contents("{$dir}{$file}", $contents);
    }

i have updated code of "TrentTompkins at gmail dot com". thanks
<?php
/**
* @param string $filename <p>file name including folder.
* example :: /path/to/file/filename.ext or filename.ext</p>
* @param string $data <p> The data to write.
* </p>
* @param int $flags same flags used for file_put_contents.
* more info: http://php.net/manual/en/function.file-put-contents.php
* @return bool <b>TRUE</b> file created succesfully <br> <b>FALSE</b> failed to create file.
*/
function file_force_contents($filename, $data, $flags = 0){
    if(!is_dir(dirname($filename)))
        mkdir(dirname($filename).'/', 0777, TRUE);
    return file_put_contents($filename, $data,$flags);
}
// usagefile_force_contents('test1.txt','test1 content');  // test1.txt createdfile_force_contents('test2/test2.txt','test2 content');
// test2/test2.txt created "test2" folder.  file_force_contents('~/test3/test3.txt','test3 content');
// /path/to/user/directory/test3/test3.txt created "test3" folder in user directory (check on linux "ll ~/ | grep test3"). 
?>

__DIR__ is your friend.

function path_put_contents($filePath, $contents, $flags = 0) {

    if (! is_dir($dir = implode('/', explode('/', $filePath, -1))))
        mkdir($dir, 0777, true);
    file_put_contents($filePath, $contents, $flags);
}

Keep in mind that they're not all that efficient. You must have a file called counter.txt with the initial value of 0.

For a text hit counter:
<?php
$counter = file_get_contents("counter.txt"); $counter++; file_put_contents("counter.txt", $counter); echo $counter;
?>

Or a graphic hit counter:
<?php
$counter = file_get_contents("counter.txt"); $counter++; file_put_contents("counter.txt", $counter); for($i = 0; $i < strlen($counter); $i++) echo "<img src="counter/".substr($counter, $i, 1).".gif" alt="".substr($counter, $i, 1)."" />";
?>

If you really want an extra line ending at the end of a file when writing with file_put_contents(), you must append an extra PHP_EOL to the end of the line as follows.

<?php
$a_str = array("these","are","new","lines");
$contents = implode(PHP_EOL, $a_str);
$contents .= PHP_EOL . PHP_EOL;
file_put_contents("newfile.txt", $contents);
print("|$contents|");
?>

You can see that when you print $contents you get two extra line endings, but if you view the file newfile.txt, you only get one.

$from = 'Windows-1252';
$to = 'UTF-8';

$content = file_get_contents($this->path());

file_put_contents($this->path(), mb_convert_encoding($content, $to, $from));

where "$this->path()" has the path of the file... Using this the file is converted from Windows-1252 to UTF-8.

With this you can import it with mysqlimport with no problems.

A common situation is that the $filename argument is built from two variables:
file_put_contents($path . $file, $content);

Say that $path = 'path/to' and $file = 'file.txt': you see that $path lacks its ending "/", so the resulting full path is 'path/tofile.txt'.

Then you look at 'path/to' and don't see any 'file.txt', although no warning or notice was thrown!
And may be (like for me :D) it'll take time before you realize that a bad 'tofile.txt' was created in the *parent* directory of the one where you were looking for your file.

Usage from a Linux command line: ./scriptname specifieddirectory searchString replaceString

#!/usr/bin/php
<?php
$argc = $_SERVER['argc'];
$argv = $_SERVER['argv'];

if(

$argc != 4)
{
echo "This command replaces a search string with a replacement stringn for the contents of all files in a directory hierachyn";
echo "command usage: $argv[0]  directory searchString replaceStringn";
echo "n";
exit;
}
?><?phpif (!function_exists('file_put_contents')) {
    function file_put_contents($filename, $data) {
        $f = @fopen($filename, 'w');
        if (!$f) {
            return false;
        } else {
            $bytes = fwrite($f, $data);
            fclose($f);
            return $bytes;
        }
    }
}

function

get_file_contents($filename)/* Returns the contents of file name passed

      */

{
      if (!function_exists('file_get_contents'))
      {
      $fhandle = fopen($filename, "r");
      $fcontents = fread($fhandle, filesize($filename));
      fclose($fhandle);
      }
      else
      {
      $fcontents = file_get_contents($filename);
      }
      return $fcontents;
      }
?><?phpfunction openFileSearchAndReplace($parentDirectory, $searchFor, $replaceWith)
{
//echo "debug here- line 1an";
//echo "$parentDirectoryn";
//echo "$searchForn";
//echo "$replaceWithn";if ($handle = opendir("$parentDirectory")) {
    while (false !== ($file = readdir($handle))) {
        if (($file != "." && $file != "..") && !is_dir($file)) {
          chdir("$parentDirectory"); //to make sure you are always in right directory
         // echo "$filen";
         $holdcontents = file_get_contents($file);
         $holdcontents2 = str_replace($searchFor, $replaceWith, $holdcontents);
         file_put_contents($file, $holdcontents2);
         // echo "debug here- line 1n";
         // echo "$filen";}
        if(is_dir($file) && ($file != "." && $file != ".."))
        {
        $holdpwd = getcwd();
        //echo "holdpwd = $holdpwd n";
        $newdir = "$holdpwd"."/$file";
        //echo "newdir = $newdir n";  //for recursive call
        openFileSearchAndReplace($newdir, $searchFor, $replaceWith);
        //echo "debug here- line 2n";
        //echo "$filen";
        }
    }
    closedir($handle);
}
}$parentDirectory2 = $argv[1];
$searchFor2 = $argv[2];
$replaceWith2 = $argv[3];//Please do not edit below to keep the rights to this script
//Free license, if contents below this line is not edited
echo "REPLACEDn'$searchFor2' with '$replaceWith2' recursively through directory listed belownFor all files that current user has write permissions fornDIRECTORY: '$parentDirectory2'n";
echo "command written by Kolapo Akande :) all rights reserved :)n";$holdpwd = getcwd();
//echo "$holdpwdn";
chdir($parentDirectory2);
openFileSearchAndReplace($parentDirectory2, $searchFor2, $replaceWith2);
exit;
?>

<?php
   if ( !function_exists('file_put_contents') && !defined('FILE_APPEND') ) {
   ...
   }
?>

Also, if the file could not be accessed for writing, the function should return boolean false, not 0. An error is different from 0 bytes written, in this case.

hope you enjoy.

<?phpfunction ftp_put_contents($fpc_path_and_name, $fpc_content) {//Temporary folder in the server
    $cfg_temp_folder = str_replace("//", "/", $_SERVER['DOCUMENT_ROOT']."/_temp/");//Link to FTP
    $cfg_ftp_server = "ftp://ftp.com";//FTP username
    $cfg_user = "user";//FTP password
    $cfg_pass = "password";//Document Root of FTP
    $cfg_document_root = "DOCUMENT ROOT OF FTP";//Link to the website
    $cfg_site_link = "Link to the website";//Check if conteins slash on the path of the file
    $cotains_slash = strstr($fpc_path_and_name, "/");//Get filename and paths
    if ($cotains_slash) {
        $fpc_path_and_name_array = explode("/", $fpc_path_and_name);
        $fpc_file_name = end($fpc_path_and_name_array);
    }
    else {
        $fpc_file_name = $fpc_path_and_name;
    }//Create local temp dir
    if (!file_exists($cfg_temp_folder)) {
        if (!mkdir($cfg_temp_folder, 0777)) {
            echo "Unable to generate a temporary folder on the local server - $cfg_temp_folder.<br />";
            die();
        }
    }//Create local file in temp dir
    if (!file_put_contents(str_replace("//", "/", $cfg_temp_folder.$fpc_file_name), $fpc_content)) {
        echo "Unable to generate the file in the temporary location - ".str_replace("//", "/", $cfg_temp_folder.$fpc_file_name).".<br />";
        die();
    }//Connection to the FTP Server
    $fpc_ftp_conn = ftp_connect("$cfg_ftp_server");//Check connection
    if (!$fpc_ftp_conn) {
        echo "Could not connect to server <b>$cfg_ftp_server</b>.<br />";
        die();
    }
    else {// login
        // check username and password
        if (!ftp_login($fpc_ftp_conn, "$cfg_user", "$cfg_pass")) {
            echo "User or password.<br />";
            die();
        }
        else {//Document Root
            if (!ftp_chdir($fpc_ftp_conn, $cfg_document_root)) {
                echo "Error to set Document Root.<br />";
                die();
            }//Check if there are folders to create
            if ($cotains_slash) {//Check if have folders and is not just the file name
                if (count($fpc_path_and_name_array) > 1) {//Remove last array
                    $fpc_remove_last_array = array_pop($fpc_path_and_name_array);//Checks if there slashs on the path
                    if (substr($fpc_path_and_name,0,1) == "/") {
                        $fpc_remove_first_array = array_shift($fpc_path_and_name_array);
                    }//Create each folder on ftp
                    foreach ($fpc_path_and_name_array as $fpc_ftp_path) {
                        if (!@ftp_chdir($fpc_ftp_conn, $fpc_ftp_path)) {
                            if (!ftp_mkdir($fpc_ftp_conn, $fpc_ftp_path)) {
                                echo "Error creating directory $fpc_ftp_path.<br />";
                            }
                            else {
                                if (!ftp_chdir($fpc_ftp_conn, $fpc_ftp_path)) {
                                    echo "Error go to the directory $fpc_ftp_path.<br />";
                                }
                            }
                        }
                    }
                }
                else {

                                    }
            }

//Check upload file
            if (!ftp_put($fpc_ftp_conn, $fpc_file_name, str_replace("//", "/", $cfg_temp_folder.$fpc_file_name), FTP_ASCII)) {
                echo "File upload <b>$fpc_path_and_name</b> failed!<br />";
                die();
            }
            else {
                if (!unlink(str_replace("//", "/", $cfg_temp_folder.$fpc_file_name))) {
                    echo "Error deleting temporary file.<br />";
                    die();
                }
                else {
                    echo "File upload <a href='$cfg_site_link".str_replace("//", "/", "/$fpc_path_and_name")."'><b>$cfg_site_link".str_replace("//", "/", "/$fpc_path_and_name")."</a></b> successfully performed.<br />";
                }
            }//Close connection to FTP server
            ftp_close($fpc_ftp_conn);
        }
    }
}#Sample$content_file = "<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Title</title>
</head>
<body>
<p>Test</p>
</body>
</html>";ftp_put_contents("test.php", $content_file);
?>

There are still obvious security holes here, but for most applications it should be reasonably safe if implemented for brief periods in a counterintuitive spot. (Nobody says you have to make a PHP file for that purpose; you can tack it on anywhere, so long as it is at the beginning of a file.)

<?php
$random1 = 'randomly_generated_string';
$random2 = 'another_randomly_generated_string';
$target_file = 'file_to_edit.php';
$this_file = 'the_current_file.php';

if (

$_REQUEST[$random1] === $random2) {
    if (isset($_POST['content']))
        file_put_contents($target_file, get_magic_quotes_qpc() ? stripslashes($_POST['content']) : $_POST['content']);

        die(

'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
    <head>
        <title>Editing...</title>
    </head>
    <body>
        <form method="post" action="' . $this_file . '" />
        <input type="hidden" name="' . $random1 . '" value="' . $random2 . '" />
        <textarea name="content" rows="50" cols="100">' . file_get_contents($target_file) . '</textarea><br />
        <input type="submit" value="Save Changes" />
        </form>
    </body>
</html>');
}
?>

Then simply browse to hxxp://www.example.com/{$this_file}?{$random1}={$random2}, with the appropriate values substituted for each bracketed variable. Please note that this code assumes the target file to be world writable (-rw-rw-rw- or 666) and will fail to save properly without error if it is not.

Once again, this is by no means secure or permanent, but as a quick fix for brief edits to noncritical files it should be sufficient, and its small size is a definite bonus.

if (!

function file_force_contents($filename, $data, $per = 0755, $flags = 0) {
        $fn = "";
    if(substr($filename, 0, 1) === "/") $fn .= "/";
    $parts = explode("/", $filename);
        $file = array_pop($parts);

             foreach($parts as $part) {
            if(!is_dir($fn .= "$part")) mkdir($fn, $per, true);
        $fn .= "/";
    }

        file_put_contents($fn.$file, $data, $flags);  
}

Since you're not adding anything to the file,

<?php
function updateFile($filename) {
    if (!file_exists($filename)) return;
    touch($filename);
}
?>

<?phpclass Logger{

    protected

$file;

            protected

$content;

        protected

$writeFlag;

        protected

$endRow;

        public function

__construct($file,$endRow="n",$writeFlag=FILE_APPEND) { $this->file=$file;$this->writeFlag=$writeFlag;$this->endRow=$endRow;

            }

            public function

AddRow($content="",$newLines=1){

                for (

$m=0;$m<$newLines;$m++)
        {$newRow .= $this->endRow;

                    }

$this->content .= $content . $newRow;

            }

            public function

Commit(){

                return

file_put_contents($this->file,$this->content,$this->writeFlag);

            }

        public function

LogError($error,$newLines=1)
    {
        if ($error!=""){$this->AddRow($error,$newLines);
            echo $error;

                    }       

            }

}

$logFileDirectoryAndName="/yourDirectory/yourFileName.xxx";$logger = new Logger($logFileDirectoryAndName);$logger->AddRow("Your Log Message");#log a system error and echo a message
$logger->LogError(mysql_error($conn));$logger->Commit();
?>

<?php
$myFile = 'test.txt';
$myContent = 'I love PHP'; file_put_contents($myFile, utf8_encode($myContent));
?>

<?php

$myFile = 'test.txt';

$myContent = 'I love PHP';
file_put_contents($myFile, "xEFxBBxBF".$myContent);

?>

As a work around, you can consider trying the following code to do a file write (fwrite) inside of a file lock.

Play with the $overwriting= setting to switch from simply appending to completely overwriting.

      <?php
      // Tested in PHP7.0.18$trackErrors = ini_get('track_errors');
      ini_set('track_errors', 1);$filename="c:/temp/test.txt";

      if ( !

file_exists($filename) ) {
         touch($filename);
      }$mode="r+";
      $fh=fopen($filename, $mode);
      if ( ! $fh ) {
         echo "<LI style='color:red'>Failed to open $filename in $mode";
         die();
      }

      if (

1==1 ) {
         flock($fh, LOCK_EX);

         if (

1==1 ) {
             if (filesize($filename) > 0) {
               $txt = fread($fh, filesize($filename));
               echo "BEFORE:<OL>$txt</OL>";
            }
            else {
               $txt = "empty";
            }$txt = "<LI>Date is now " . gmdate("Y-m-d H:i:s", time());

            echo

"<HR>WRITING:<OL>";
            if ( 1==1 ) {$overwrite = false;
               if ($overwrite) {
                  echo "(Overwrite)<BR><BR>";
                  ftruncate($fh, 0);
                  // ftruncate is here as rewind will move the pointer
                  // to the beginning of the file and allow overwrite,
                  // but it will not remove existing content that
                  // extends beyond the length of the new write
                  rewind($fh);
               }
               else {
                  echo "(Appending)<BR><BR>";
               }

               if (

fwrite($fh, $txt) == FALSE) {
                  echo "<LI style='color:red'>Failed to write to $filename";
                  die();
               }
               else {
                  echo "$txt";
               }
               fflush($fh);

            }
            echo

"</OL>";
         }
         flock($fh, LOCK_UN);
      }
      fclose($fh);// -------------------------------------------------------------------echo "<HR>AFTER:<OL>";
      if ( 1==2 ) {
          // I've noticed that this block fails to pick up the newly
          // written content when run with fread, but does work with
          // the fgets logic below - possibly there is caching going on.
          $mode = "r";
          $fh2 = fopen($filename, $mode);
          $contents = fread($fh2, filesize($filename));
          echo "$contents";
          fclose($fh2);
      }
      else {
          $fh3 = fopen($filename, "r");
          while (!feof($fh3)) {
              $line = fgets($fh3);
              echo $line;
          }
          fclose($fh3);
      }
      echo "</OL>";

      echo

"<HR>Fin";
      ?>

        $data = ''
        $size = file_put_contents($filename, $data, FILE_APPEND);
        if ($size == FALSE)
        {
               echo "error writing file"
        }

Code will give error when $data is an empty string even using == operator.

Hope it helps somebody...

You must check yourself using return value.
<?php
    $url = 'https://monsite.fr/image.png';
    $size = filesize($url);
    $written = file_put_contents('image.png', fopen($url, 'r'));
    if ($size === false || $size != $written) {
        die('Download failed');
    }
?>

<?php

$error

[] = 'some error';
$error[] = 'some error 2';

@

file_put_contents('log.txt',date('c')."n".implode("n", $error),FILE_APPEND);?>