PHP File::getExtension方法代码示例

 /**
  * {@inheritdoc}
  */
 public function buildView(FormView $view, FormInterface $form, array $options)
 {
     parent::buildView($view, $form, $options);
     $data = $form->getData();
     if (is_string($data)) {
         $data = ['filename' => basename($data), 'url' => $data];
     }
     if (is_array($data)) {
         if (!isset($view->var['url']) && isset($data['url'])) {
             $view->vars['url'] = $data['url'];
         }
         if (!isset($view->var['filename']) && isset($data['filename'])) {
             $view->vars['filename'] = $data['filename'];
         }
     }
     // autodetect type of upload
     $uploadtype = $options['uploadtype'];
     if (isset($view->vars['filename'])) {
         $file = new File($view->vars['filename'], false);
         $view->vars['filetype'] = $file->getExtension();
         switch ($file->getExtension()) {
             case 'png':
             case 'jpg':
             case 'jpeg':
             case 'gif':
                 $uploadtype = 'image';
                 break;
             case 'mp4':
                 $uploadtype = 'video';
                 break;
             case 'mp3':
             case 'm4v':
                 $uploadtype = 'audio';
                 break;
             default:
                 break;
         }
     }
     $view->vars['uploadtype'] = $uploadtype;
     $view->vars['placeholdWidth'] = $options['placeholdWidth'];
     $view->vars['placeholdHeight'] = $options['placeholdHeight'];
     $view->vars['placeholdText'] = $options['placeholdText'];
     $view->vars['ratio'] = $options['ratio'];
     $view->vars['remove'] = $options['remove'];
     $pattern = $options['pattern'];
     if ($pattern != null) {
         if (!$this->container->hasParameter($pattern)) {
             throw new \Exception('You must define an existing pattern');
         }
         $patternSize = $this->container->getParameter($pattern);
         $view->vars['label'] .= ' (Max width: ' . $patternSize['width'] . ', Max height: ' . $patternSize['height'] . ')';
     }
 }

 /**
  * @param Contribution $contribution
  * @param File         $file
  *
  * @return string
  */
 public function generateRelativePath(Contribution $contribution, File $file)
 {
     $path = $contribution->getAuthProvider() . DIRECTORY_SEPARATOR;
     $path .= $contribution->getIdentifier();
     $path .= '.' . ($file->guessExtension() ?: $file->getExtension());
     return $path;
 }

 /**
  * Use Symfony components to guess the file extension.
  *
  * @return string
  *         File extension
  */
 public function getExtension()
 {
     if (!is_null($this->extension)) {
         return $this->extension;
     }
     return $this->extension = $this->info->getExtension() ?: $this->info->guessExtension();
 }

 protected static function boot()
 {
     parent::boot();
     static::updating(function ($model) {
         $changed = $model->getDirty();
         if (isset($changed['name'])) {
             $slug = $model->gallery->slug;
             $path = public_path() . '/gallery_assets/galleries/' . $slug;
             //Get old file
             $oldPath = $path . '/' . $model->file;
             $file = new File($oldPath);
             //Set the new file with original extension
             $newName = strtolower(str_slug($model->name) . '_' . str_random(5)) . '.' . $file->getExtension();
             $renamed = $path . '/' . $newName;
             //Rename asset
             if (rename($file, $renamed)) {
                 $model->setAttribute('file', $newName);
                 return true;
             } else {
                 return false;
             }
         }
         return true;
     });
     static::deleting(function ($model) {
         $slug = $model->gallery->slug;
         $path = public_path() . '/gallery_assets/galleries/' . $slug;
         $oldPath = $path . '/' . $model->file;
         $file = new File($oldPath);
         @unlink($file);
         //@ to prevent errors
         return true;
     });
 }

 protected function getExtension()
 {
     $extension = 'jpg';
     if (in_array(strtolower($this->realImage->getExtension()), static::$allowedExtensions)) {
         $extension = strtolower($this->realImage->getExtension());
     }
     return $extension;
 }

 /**
  * Calculate the filename of the resultant file or version.
  *
  * @param File        $original The original file
  * @param string|null $version  The name of the version, or null
  *
  * @return string The resultant filename
  */
 public function getFilename(File $original, $version = null)
 {
     if (is_null($version)) {
         return $original->getBasename();
     }
     $extension = $original->getExtension();
     $base = $original->getBasename($extension);
     return $base . $version . '.' . $extension;
 }

 /**
  * @param \Symfony\Component\HttpFoundation\File\File $img
  * @param string                                      $path
  *
  * @return string
  */
 public function saveImg(File $img, $path)
 {
     $imageLib = new ImageLib();
     $imageLib->load($path . $img->getFilename());
     $outputImgName = md5($img->getFilename() . time()) . '.' . $img->getExtension();
     //$imageLib->resizeImage(100, 100, array('crop', 'tr'), true);
     $imageLib->saveImage($path . $outputImgName, 100);
     return $outputImgName;
 }

 /**
  * Replaces the current file with a new file.
  *
  * @param UploadedFile $file           The target file
  * @param File         $filesystemFile The source file
  */
 public function replaceFromFilesystem(UploadedFile $file, File $filesystemFile)
 {
     $file->setOriginalFilename($filesystemFile->getBasename());
     $file->setExtension($filesystemFile->getExtension());
     $file->setMimeType($filesystemFile->getMimeType());
     $file->setSize($filesystemFile->getSize());
     $storage = $this->getStorage($file);
     if ($filesystemFile->getSize() > $this->container->get("partkeepr_systemservice")->getFreeDiskSpace()) {
         throw new DiskSpaceExhaustedException();
     }
     $storage->write($file->getFullFilename(), file_get_contents($filesystemFile->getPathname()), true);
 }

 /**
  * @param $filename
  *
  * @return string
  */
 public function visualizar_archivo($filename = null)
 {
     if ($filename) {
         $pathFile = $this->uploads_directory_name . '/' . $filename;
         $file = new File($pathFile);
         $img = ['png', 'jpg', 'jpeg', 'gif', 'svg', 'pjpeg'];
         if (in_array($file->getExtension(), $img)) {
             return '<img src="' . $this->packages->getUrl($pathFile) . '" height="60">';
         }
         return '<a href="' . $this->packages->getUrl($pathFile) . '" download>Descargar archivo</a>';
     }
 }

 /**
  * @param string $path Path to the file
  *
  * @return Response
  */
 public function getFile($path)
 {
     if (is_file($path)) {
         $file = new File($path);
         $fileContent = file_get_contents($path);
         $response = new Response($fileContent);
         $response->headers->set('Content-Type', $this->getContentType($file->getExtension()));
         $response->setCharset('UTF-8');
         return $response;
     }
     return new Response('File not found', 404);
 }

 protected function sendFile(Gitiki $gitiki, $file, $responseClass)
 {
     try {
         $fileInfo = new File(__DIR__ . '/../Resources/highlightjs/' . $file);
     } catch (FileNotFoundException $e) {
         $gitiki->abort(404, 'The file "%s" does not exists');
     }
     $response = new $responseClass($fileInfo);
     $request = $gitiki['request'];
     $response->headers->set('content-type', $request->getMimeType($fileInfo->getExtension()));
     $response->setMaxAge(0)->isNotModified($request);
     return $response;
 }

 /**
  * @see Command
  *
  * @throws \InvalidArgumentException When the target directory does not exist
  */
 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->getContainer()->get('kernel')->getRootDir();
     $targetArg = rtrim($input->getArgument('target'), '/') . '/';
     $rootDir = $this->getContainer()->get('kernel')->getRootDir();
     $targetDir = $rootDir . '/../' . $targetArg;
     $confDir = $rootDir . '/config';
     if (!is_dir($targetDir)) {
         throw new \InvalidArgumentException(sprintf('The target directory "%s" does not exist.', $input->getArgument('target')));
     }
     if (!file_exists($confDir . '/assets.json')) {
         throw new \InvalidArgumentException('The file ' . $confDir . '/assets.json does not exist.');
     }
     $output->writeln("Combining assets");
     $assetsFiles = json_decode(file_get_contents($confDir . '/assets.json'), true);
     foreach ($assetsFiles as $type => $combined) {
         foreach ($combined as $name => $files) {
             file_put_contents($targetDir . $files['output'], '');
             $this->assets[$type][$name] = (array) $files['input'];
             foreach ($this->assets[$type][$name] as $value) {
                 file_put_contents($targetDir . $files['output'], file_get_contents($targetDir . $value), FILE_APPEND);
             }
             $file = $targetDir . $files['output'];
             if (is_file($file)) {
                 $f = new File($file);
                 switch ($f->getExtension()) {
                     case 'css':
                         $resource = new AssetCollection(array(new FileAsset($file)), array(new MinifyCssCompressorFilter()));
                         $resource->load();
                         file_put_contents($file, $resource->dump());
                         $output->writeln(sprintf('File <comment>%s</comment> was combined and minified', $file));
                         break;
                     case 'js':
                         $resource = new AssetCollection(array(new FileAsset($file)), array(new JSMinPlusFilter()));
                         $resource->load();
                         file_put_contents($file, $resource->dump());
                         $output->writeln(sprintf('File <comment>%s</comment> was combined and minified', $file));
                         break;
                 }
             }
         }
     }
 }

 /**
  * @param File $file
  * @return string
  */
 protected function getNormalizedFilename(File $file)
 {
     if ($file instanceof UploadedFile) {
         $originalFilename = $file->getClientOriginalName();
         $size = $file->getClientSize();
     } else {
         $originalFilename = $file->getFilename();
         $size = $file->getSize();
     }
     $name = preg_replace(self::REGEX_FILENAME_EXT, '', $originalFilename);
     $name = preg_replace(self::REGEX_INVALID_FILENAME_CHARS, '_', $name);
     $hash = substr(sha1(json_encode(array(time(), $name, $size))), 0, 7);
     $ext = $file->getExtension();
     if (!$ext) {
         $ext = explode('.', $originalFilename);
         $ext = end($ext);
     }
     $filename = sprintf('%s_%s.%s', $name, $hash, $ext);
     return $filename;
 }

 public function documentsAction($filename, $originalName = null)
 {
     $documentManager = $this->get('wealthbot_user.document_manager');
     try {
         $file = new File($this->container->getParameter('uploads_documents_dir') . '/' . $filename);
     } catch (FileNotFoundException $e) {
         throw $this->createNotFoundException('File does not exist.');
     }
     if ($file->getExtension() === 'zip') {
         if (null === $originalName) {
             $originalName = $filename;
         }
     } else {
         $document = $documentManager->findDocumentBy(array('filename' => $filename));
         if (!$document) {
             throw $this->createNotFoundException('Document does not exist.');
         }
         if (null === $originalName) {
             $originalName = $document->getOriginalName();
         }
     }
     return $this->prepareResponse($file, $originalName);
 }

 /**
  * Set file
  *
  * @param File $file
  * @return $this
  */
 public function setFile(File $file = null)
 {
     $this->file = $file;
     if (is_file($this->getAbsolutePath())) {
         $this->temp = $this->getAbsolutePath();
     }
     if (null !== $file) {
         $extension = $file->getExtension() ? $file->getExtension() : $file->guessExtension();
         if ($file instanceof UploadedFile) {
             $this->setOriginalName($file->getClientOriginalName());
             if (!$extension) {
                 $extension = pathinfo($file->getClientOriginalName(), PATHINFO_EXTENSION);
             }
             $filename = sha1($file->getClientOriginalName() . rand(0, 99999)) . '.' . $extension;
             $mimeType = $file->getMimeType();
         } else {
             $this->setOriginalName($file->getFilename());
             $filename = sha1($file->getFilename() . rand(0, 99999)) . '.' . $extension;
             $mimeType = $file->getMimeType();
         }
         $this->setFilename($filename);
         $this->setMimeType($mimeType);
     }
     return $this;
 }