Dateityp von Datei herausfinden und wieder anhängen.

Einklappen
X
 
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • Dateityp von Datei herausfinden und wieder anhängen.

    Guten Abend

    Ich habe nun ein kleines Uploadscript zusammengebastelt und habe es so gemacht, dass er bei dem Upload eine zufälligen dateinamen zuweist. Leider kann man die Datei aber nach dem Upload nichtmehr aufrufen, da er nichtmehr die alte Dateiendung anhängt. Ich habe schon die suche benutzt und Google aber irgendwie keinen einleichtende Hilfe gefunden.

    Könntet ihr mir helfen?

    MFG
    Domme

  • #2
    Ja häng die Endung halt wieder an, wenn du sie brauchst. Ich frage mich allerdings, was der ganze Zauber soll. Warum bekommt die Datei einen zufälligen Namen?

    Kommentar


    • #3
      Ant

      Ja der ändert den Dateinamen, da es ein kleiner Upload für mich und ein paar Freunde ist. Also, dort kann man Bilder hochladen. Und damit wir nicht mal außversehen andere Bilder überschreiben, habe ich es so gelöst, damit er einfach wieder jeder Datei einen neuen Namen gibt.

      Habe es einfach so gemacht:
      PHP-Code:
      $newname rand(1,99999999); 
      Und nun ist halt die Sache, dass er da die Dateiendung wegnimmt. Ich würde diese aber gerne beibehalten, finde aber leider nicht, wie ich es machen kann.

      Kommentar


      • #4
        ach, und rand() gibt niemals wieder den selben Wert raus?

        nimm microtime()

        Dateiendung:
        PHP-Code:
        $orgname "blab blub.jpg";
        $hack explode("."$orgname);
        $n=count($hack)-1;

        $dateiendung $hack[$n];

        ### Zusammenfassung

        $new_name str_replace(" """microtime()).".".$dateiendung
        h.a.n.d.
        Schmalle

        http://impressed.by
        http://blog.schmalenberger.it



        Wichtige Anmerkung: Ich habe keine Probleme mit Alkohol ...
        ... nur ohne :-)

        Kommentar


        • #5
          Wenn die Endung weg ist, ist sie weg. Du kannst sie nicht wiederhervorzaubern[1].

          Du kannst aber dein Uploadscript so ändern, dass die orginale Endung (so sie vorhanden ist) an deinen zufälligen (warum auch immer) Dateinamen angehängt wird.

          Beim Zerlegen des ursprünglichen Dateinamens hilft dir pathinfo().

          Zusammenkleben kannst du die Bestandteile aber hoffentlich noch selbst.


          --
          [1] Es sei denn, du willst eine Endung nach dem Typ der Datei. Dann musst du den Datentyp aus den Binärdaten selbst bestimmen. Für Grafik-Dateien könntest du getimagesize() benutzen, oder eine eigene Funktion basteln.
          Klingon function calls do not have “parameters”‒they have “arguments”‒and they always win them!

          Kommentar


          • #6
            Die Originaldateiendung zu verwenden ist imho genauso katastrophal, wie den Dateitypen nicht zu validieren. Wenn es nur um Bilder geht, wie fireweasel schon sagte, getimagesize verwenden und Erweiterung entsprechend anfügen.

            Kommentar


            • #7
              Ant

              Hoffst du es, dass ich die alleine Zusammenkleben kann?^^

              Weil irgendwie habe ich nichtmals einen Anfang um ehrlich zu sein wenn ich mir das durchlese


              Also so gesagt, würde ich es halt egrne einfach so machen, dass die Bilddatei einen zufälligen Namen zugewiesen bekommt aber ihren ursprünglichen Typ beibehält.

              Sprich:
              Wird die Datei DSC0001.jpg hochgeladen, dass dort dann die Datei 334555.jpg oder so rauswird.
              Zuletzt geändert von dommeliveaol; 06.04.2009, 14:01.

              Kommentar


              • #8
                Re: Ant

                Original geschrieben von dommeliveaol
                Hoffst du es, dass ich die alleine Zusammenkleben kann?^^
                Yep. Ist nicht sooo schwer.

                Weil irgendwie habe ich nichtmals einen Anfang um ehrlich zu sein wenn ich mir das durchlese
                Oweia, was wird dann erst, wenn du das Folgende durchliest?

                Was du eigentlich willst, sind nicht zufällige sondern eindeutige Dateinamen.
                PHP erledigt das Erzeugen eines eindeutigen Namens beim Dateipload schon für dich.
                Ein erfolgreicher Beispiel-Upload. Var_dump($_FILES) liefert in etwa Folgendes:

                Code:
                hash(1) {
                    ['file'] => hash(5) {
                        ['name'] => string(39) 'vom-browser-gesendeter-dateiname.jpg'
                        ['type'] => string(8) 'image/jpeg'
                        ['tmp_name'] => string(25) 'C:\blubb\Temp\php0815.tmp'
                        ['error'] => integer() 0
                        ['size'] => integer() 11503
                    }
                }
                Du siehst im Eintrag 'name' den Namen der hochgeladenen Datei, so wie sie der Browser gesendet hat.

                Im Eintrag 'tmp_name' siehst du den eindeutigen Dateinamen für die hochgeladene Datei. Die befindet sich in einem bestimmten Verzeichnis, das PHP für alle temporären Dateien benutzt.

                Aus beiden Bestandteilen kannst du nun einen eigenen Dateinamen zusammenbauen. Du brauchst vom 'name'-Feld die Endung und vom 'tmp_name'-Feld den Dateinamen ohne dessen '.tmp'-Endung.

                Für letzteres hat PHP die Funktion basename():
                PHP-Code:
                // entfernt pfad und die Endung '.tmp':
                $temp_basename basename($_FILES['file']['tmp_name'], '.tmp'
                Das Herauspulen der Endung habe ich anders gelöst:
                PHP-Code:
                $tag preg_match('/\.[^.\/\x5c]+/'$_FILES['files']['name'], $hits)
                     ? 
                $hits[0] :
                     
                ''
                Es wird das letzte Stück eines Dateipfades,
                beginnend beim letzten gefundenen Punkt '.',
                der von beliebigen Zeichen --
                außer des Punktes '.', des Slashes '/' oder des Backslashes '\' --,
                gefolgt werden darf,
                herausgeschnitten.

                Lies dir das so lange durch, bis du es kapiert hast.

                Für den Fall, dass kein Punkt und somit keine Endung gefunden wurde, wird ein Leerstring zurückgegeben.

                Beide Teile klebst du mit dem Punkt-Operator '.' zusammen. Den kennst du hoffentlich:
                PHP-Code:
                $mein_einzigartiger_dateiname $temp_basename $tag
                Und weil der Dateiname alleine nicht ausreicht, kann man gleich noch den Pfad zum endgültigen Uploadverzeichnis davorsetzen:

                PHP-Code:
                $upload_file_path $endgueltiges_uploadverzeichnis .
                                    
                DIRECTORY_SEPARATOR .
                                    
                $mein_eindeutiger_dateiname
                Weiter unten ist das ein wenig komplizierter gelöst, weil das endgültige Uploadverzeichnis auch mit einem Verzeichnistrenner am Ende geliefert werden könnte.

                Am besten packen wir den ganzen Kram in eine Funktion. Die nimmt zwei Argumente entgegen:
                * Das erste ist das endgültige Uploadverzeichnis, also das Verzeichnis, wo die
                hochgeladene Datei am Schluss hin soll.
                * Das zweite ist die gleiche Zeichenkette, die du im Upload-Formular als
                'name'-Attribute für das <input type="file" ... />-Tag eingetragen hast.

                Die beiden Werte werden geprüft. Waren sie in Ordnung, wird der neue Dateiname zusammengebaut und die hochgeladene Datei ins endgültige Upload-Verzeichnis verschoben.

                Traten irgendwelche Fehler auf, gibt die Funktion FALSE zurück.
                Ging alles gut, gibts ein TRUE.

                PHP-Code:
                /// create unique filename and move uploaded temp-file
                /// return BOOL success
                function file_upload_unique_name(
                  
                $upload_dir,
                  
                $fitfn 'file' /// STR form>input>type>file>name attribute
                ) {
                  if (!isset(
                $_FILES[$fitfn]['name'])) {
                    
                // keine Datei hochgeladen (oder anderer Upload-Fehler)
                    
                return FALSE;
                  }

                  
                // Das endgültige Upload-Verzeichnis sollte natürlich vorhanden sein
                  
                if (FALSE === $upload_dir realpath($upload_dir)) {
                    
                // Upload-Verzeichnis existiert nicht oder ist kein Verzeichnis
                    
                return FALSE;
                  }
                  
                // falls ein Upload-Fehler aufgetreten ist, beenden wir hier
                  
                if ($_FILES[$fitfn]['error']) {
                    return 
                FALSE;
                  }
                  
                  
                // die Dateiendung holen, sofern eine existiert
                  
                $tag preg_match('/\.[^.\/\x5c]+/'$_FILES[$fitfn]['name'], $hits) ? $hits[0] : '';

                  
                // vom temporären Upload-Pfad
                  // den Dateinamen extrahieren und die Endung '.tmp' entfernen,
                  // die Endung $tag dahinter-
                  // und den Pfad zum Uploadverzeichnis davorkleben
                  
                $dst_path preg_replace('/[\/\x5c]\z/'''$upload_dir) .
                              
                DIRECTORY_SEPARATOR .
                              
                basename($_FILES[$fitfn]['tmp_name'], '.tmp') .
                              
                $tag;
                  return 
                move_uploaded_file($_FILES[$fitfn]['tmp_name'], $dst_path);

                Beim Dateiupload treten manchmal Fehler auf. Die Fehlernummern allein sind nicht wirklich aussagekräftig. Also bauen wir uns eine Funktion, die entsprechenden Fehlermeldungen im (englischen) Klartext zurückgibt:

                PHP-Code:
                /// get error description for given uploaded file
                /// return STR
                function file_upload_error_description(
                  
                $fitfn 'file' /// STR form>input>type>file>name attribute
                ) {
                  static 
                $errors = array (
                      
                => 'There is no error, the file uploaded with success.',
                      
                => 'The uploaded file exceeds the upload_max_filesize directive in php.ini.',
                      
                => 'The uploaded file exceeds the MAX_FILE_SIZE directive '.
                           
                'that was specified in the HTML form.',
                      
                => 'The uploaded file was only partially uploaded.',
                      
                => 'No file was uploaded.',
                      
                => 'Missing a temporary folder.'// Introduced in PHP 4.3.10 and PHP 5.0.3.
                      
                => 'Failed to write file to disk.'// Introduced in PHP 5.1.0.
                      
                => 'File upload stopped by extension.'// Introduced in PHP 5.2.0.
                  
                );
                  if (!isset(
                $_FILES[$fitfn])) {
                    return 
                'There is no uploaded file "' $fitfn '"';
                  }
                  if (!isset(
                $errors[$_FILES[$fitfn]['error']])) {
                    return 
                'Unknown error during file upload';
                  }
                  return 
                $errors[$_FILES[$fitfn]['error']];

                Und mit einem lustigen Affenformular testen wir das Ganze:

                PHP-Code:
                <?php
                $upload_dir 
                'f:/';   // destination directory for uploaded files
                $fitfn 'file';       // name attribute given for the input-(type=file)-element
                $max_file_size 5555// max. upload file size in bytes

                if (FALSE === $success file_upload_unique_name($upload_dir$fitfn)) {
                  echo 
                file_upload_error_description($fitfn));
                  die(
                'Fehler beim Dateiupload oder keine Datei hochgeladen!');
                }

                ?>
                <form action="" method="post" enctype="multipart/form-data">
                <input type="xhidden" name="MAX_FILE_SIZE" value="<?php echo($max_file_size); ?>" />
                <input type="file" name="<?php echo($fitfn); ?>" size="20" maxlength="<?php echo($max_file_size); ?>" accept="text/html">
                <hr />
                <input type="submit" />
                </form>
                ?>
                Zuletzt geändert von fireweasel; 07.04.2009, 21:26.
                Klingon function calls do not have “parameters”‒they have “arguments”‒and they always win them!

                Kommentar


                • #9
                  OffTopic:
                  Macht gar kein Spaß mehr fireweasel´s Beiträge zu lesen, die werden ja immer länger

                  Kommentar


                  • #10
                    Original geschrieben von PHP-Desaster
                    OffTopic:
                    Macht gar kein Spaß mehr fireweasel´s Beiträge zu lesen, die werden ja immer länger
                    OffTopic:

                    Morgen bin ich wieder an der frischen Luft -- da werden sie garantiert kürzer.

                    ... oder ganz ausfallen.



                    Aber das alles Newbie-tauglich mit einfachen Worten zu erklären wäre sooo umständlich, in der Zeit klopp ich lieber ein paar Codezeilen in die Tastatur.
                    Klingon function calls do not have “parameters”‒they have “arguments”‒and they always win them!

                    Kommentar

                    Lädt...
                    X