brhue

Pessoal Pouco entendo de analise de algoritmos, mas recentemente foi me informado que essa primeira função recursiva seria melhor em relacao a segunda. Mas, para provar isso, o autor utilizou o debug na IDE Eclipse, mostrando as chamadas sendo empilhadas na stack. No entanto, ao desempilhar, visualmente a primeira desempilha mais rapido, ao contrario da segunda. Com isso, o autor justificou que gastaria menos ciclos do processador para desempilhar, enquanto a segunda funçao gastaria mais. void foo1(int n) { if (n >= 0) { printf("%d\n", n); foo1(n-1); } } void foo2(int n) { if (n >= 0) { foo2(n-1); printf("%d\n", n); } } Quero saber o que voces acham disso, caso ele esteja certo, teria alguma fonte disso ou alguma outra prova empirica ? obs: Nao estamos levando em consideracao a ordem dos resultados, nem o 'big O', pois acho que os dois sao O(n)

Pesquise sobre algoritmo de ordenação, o mais intuitivo e simples seria o Bubble Sort

Talvez isso também te ajuda: http://pt.stackoverflow.com/questions/4731/por-que-em-algumas-situa%C3%A7%C3%B5es-ifs-s%C3%A3o-considerados-ruins/4732 e https://sourcemaking.com/refactoring/smells/switch-statements

@Isaac Carvalho Talvez você possa fazer isso com cURL, pesquise sobre essa biblioteca cURL - Manual cURL - upload example

@manoaj Não vou saber te responder qual a forma mais eficiente, mas em vez do Singleton você pode optar pelo padrão Registry Aqui tem algumas explicação sobre ele: http://forum.imasters.com.br/topic/463107-pdo-registry-design-pattern-phpoo/?p=1896435

Entendi.... Agora em relação em passar os set's pelo construtor não é melhor? pois o File::setUserFile($userfile) tem que ser setado primeiro, mas ai eu penso, se eu quiser fazer varios uploads, vou ter que criar varios objetos. Outra dúvida, então a antiga classe UploadImage, eu criaria apenas classe Image que extenderia File? E Qual seria a melhor maneira de fazer as consistencia, seria mesmo na classe Upload utilizando exceptions? Segue a tentativa: FileInterface interface FileInterface { public function setFilePath($path); public function setFileSize($size); public function setFileType(Array $type); public function setRandomName(Token $token); public function getUserFile(); public function getFilePath(); public function getFileType(); public function getFileSize(); public function getFileName(); public function getExtension(); } File class File implements FileInterface { private $fileName; private $filePath; private $fileType; private $fileSize = 2; protected $userFile; public function __construct($userFile) { $this->userFile = $userFile; } public function setFilePath($path) { $this->filePath = $path; } public function setFileType(Array $type) { $this->fileType = $type; } public function setFileSize($size) { $this->fileSize = (float)$size * 1024 * 1024; } public function setRandomName(Token $token) { $this->fileName = $token->generateToken().'.'.$this->getExtension(); } public function getUserFile() { return $this->userFile; } public function getFilePath() { return $this->filePath; } public function getFileType() { return $this->fileType; } public function getFileSize() { return $this->fileSize; } public function getFileName() { return $this->fileName; } public function getExtension() { return pathinfo($_FILES[$this->userFile]['name'], PATHINFO_EXTENSION); } } Upload class Upload { public function uploadFile(FileInterface $file) { if (!in_array($file->getExtension(), $file->getFileType())) throw new RuntimeException("Extensão de arquivo não permitido."); else if ($file->getFileSize() < $_FILES[$file->getUserFile()]['size']) throw new RuntimeException("Tamanho de arquivo não permitido."); else if (!move_uploaded_file($_FILES[$file->getUserFile()]['tmp_name'], $file->getFilePath().$file->getFileName())) throw new RuntimeException("Falha ao mover arquivo."); } } testeUpload <?php require_once 'autoload.php'; require_once 'display_error.php'; if (isset($_POST['submit'])) { $file = new File('file'); $file->setFilePath('uploads/'); $file->setFileType(array('jpg', 'png', 'gif')); $file->setFileSize(1.0); $file->setRandomName(new Bin2Hex()); echo 'Teste1: '.$file->getFileName().'<br>'; $upload = new Upload(); $upload->uploadFile($file); echo 'Teste2: '.$file->getFileName().'<br>'; } ?> <form action="testeUpload.php" method="post" enctype="multipart/form-data"> <h2>Upload File</h2> <label for="fileSelect">Filename:</label> <input type="file" name="file"><br> <input type="submit" name="submit" value="Upload"> </form>

Estou continuando meus estudos sobre oop e SOLID, e queria saber se minhas classes estão violando algum principio do SOLID. Segue a tentativa: Upload.class.php <?php class Upload { private $fileName; private $fileSize = 2.0; private $fileType; private $filePath; private $token; protected $userFile; public function __construct(Token $token) { $this->token= $token; } public function setFileSize($maxSize) { $this->fileSize = (float)$maxSize * 1024 * 1024; } public function setFileType(Array $type) { $this->fileType = $type; } public function setFilePath($path) { $this->filePath = $path; } public function setUserFile($userFile) { $this->userFile = $userFile; } public function getFileName() { if (is_null($this->fileName)) $this->randomName(); return $this->fileName; } public function uploadFile() { if (!in_array($this->getExtension(), $this->fileType)) throw new RuntimeException("Extensão de arquivo não permitido."); else if ($this->fileSize < $_FILES[$this->userFile]['size']) throw new RuntimeException("Tamanho de arquivo não permitido."); else if (!move_uploaded_file($_FILES[$this->userFile]['tmp_name'], $this->filePath.$this->getFileName())) throw new RuntimeException("Falha ao mover arquivo."); } private function randomName() { $this->fileName = $this->token->generateToken().'.'.$this->getExtension(); } private function getExtension() { return pathinfo($_FILES[$this->userFile]['name'], PATHINFO_EXTENSION); } } ?> Esses sets, seria ideal colocar tudo no construtor? Token.php <?php interface Token { public function generateToken(); } ?> Bin2Hex.class.php class Bin2Hex implements Token { public function generateToken() { return bin2hex(openssl_random_pseudo_bytes(32)); } } UploadImage.class.php <?php class UploadImage extends Upload { private $height; private $width; public function setImageHeight($height) { $this->height = $height; } public function setImageWidth($width) { $this->width = $width; } public function uploadFile() { list($height, $width) = getimagesize($_FILES[$this->userFile]['tmp_name']); if ($this->height < $height) { throw new RuntimeException("Altura da imagem não permitida."); } else if ($this->width < $width) { throw new RuntimeException("Largura da imagem não permitida."); } parent::uploadFile(); } } ->A ideia aqui seria uma classe mais especifica para imagem... E a maior dúvida é se nessa parte viola o LSP (herança). index.php $upload = new UploadImage(new Bin2Hex()); $upload->setUserFile('photo'); $upload->setFilePath('uploads/'); $upload->setFileType(array('jpg', 'png')); $upload->setFileSize(1.0); $upload->setImageHeight(800); $upload->setImageWidth(600); try { $upload->uploadFile(); } catch (RuntimeException $e) { echo $e->getMessage(); }

Muito obrigado a todos, vou implementar isso.....

Galera por exemplo: eu tehno um PostDAO e nessa classe tenho: class PostDAO implements IPostDAO { private $db; private $table = 'posts'; public function __construct($instance) { $this->db = $instance; } public function findById($id) { //code here //... } public function findAll() { //code here //... } public function insert(Post $post) { //code here //... } //... } Até aqui tudo certo... Mas, por exemplo se eu quiser pesquisar os posts por titulo ai crio PostDAO::findByTitle($title) mas se eu quiser fazer uma consulta no banco ordenado crescente? Ou limitar as buscas na query ? Terei que criar outros metodos para isso, como por exemplo: PostDAO::findByTitleAsc($title) ou PostDAO::findByTitleDesc($title) Não sei se ficou claro minha dúvida, pois basicamente quero saber se pra cada tipo de consulta no banco terei que ter um metodo diferente.

Obrigado pela dica, nos meus próximos códigos vou implementar phpDoc. Nesses últimos dias estou desenvolvendo classe UserService e a classe Session, queria opinião de vocês a respeito dos principios do S.O.L.I.D. UserService.class.php class UserService implements IUserService { private $validator; public function __construct(UserServiceValidator $validator) { $this->validator = $validator; } public function login(IUserDAO $userDAO, $email, $password) { $this->validator->validateUser('email', $email); $this->validator->validateUser('password', $password); if ($this->validator->getError() > 0) { return false; } $result = $userDAO->checkLoginByCredentials($email, $password); if ($result > 0) { $this->setSession($userDAO->getUser($email)); return true; } return false; } public function register(IUserDAO $userDAO, User $user) { $this->validator->validateUser('name', $user->getName()); $this->validator->validateUser('lastname', $user->getLastname()); $this->validator->validateUser('email', $user->getEmail()); $this->validator->validateUser('password', $user->getPassword()); if ($this->validator->getError() > 0) { return false; } $result = $userDAO->insert($user); return $result; } public function logoff() { Session::destroy(); } private function setSession($user) { Session::create(); Session::set('id', $user->id); Session::set('name', $user->name); Session::set('lastname', $user->lastname); Session::set('email', $user->email); } public function getCurrentUser() { $id = Session::get('id'); $name = Session::get('name'); $lastname = Session::get('lastname'); $email = Session::get('email'); return new User($name, $lastname, $email, null, $id); } public function isLogged() { Session::create(); if (!is_null(Session::get('email'))) { return true; } return false; } } -> Nessa classe, não sabia como validar os dados do usuário então criei a classe UserServiceValidator para fazer as consistência. A parte do Session esta correto? Não sei se fere o principio de SRP. UserServiceValidator.class.php class UserServiceValidator { private $error; public function validateUser($option, $field) { $this->error = 0; // code } public function getError() { return $this->error; } } -> Aqui ainda não foi implementada, mas a ideia é cada opção ('username, email, password, etc...') fazer uma consistencia. Session.class.php class Session { public static function create() { if (!isset($_SESSION)) { session_start(); } } public static function destroy() { self::create(); $_SESSION = array(); session_destroy(); } public static function set($key, $value) { $_SESSION[$key] = $value; } public static function get($key) { self::create(); if (isset($_SESSION[$key])) { return $_SESSION[$key]; } return null; } public static function delete($key) { $_SESSION[$key] = null; } } -> Não sei se foi implementada corretamente essa classe na UserService, pois ela foi chamada estaticamente. ... Caso vocês puderem me dizer o que esta errado... Obrigado a todos...

- Gostei bastante desse padrão, depois vou tentar botar ele em prática. - Bastante útil. - Como assim desperdício de memória? desculpe a ignorância, não entendi muito bem. - Não é necessário a classe User ? - Pesquisei sobre DAO e tentei implementar, segue a tentativa: index.php <?php require_once 'config.php'; require_once 'autoload.php'; $db = new PDO('mysql:host='.DB_HOST.';dbname='.DB_NAME, DB_USER, DB_PASS); $userDAO = new UserDAO($db); $user = new User('Fulano', 'Silva', 'fulanosilva@email.com', '123456'); $userDAO->insert($user); ?> IDAO.class.php <?php interface IDAO { public function findById($pk); public function listAll(); public function insert($object); public function update($object); public function delete($pk); } ?> obs: A interface aqui é necessária ? Me pareceu correto ser implementada.... UserDAO.class.php <?php require_once 'IDAO.class.php'; class UserDAO implements IDAO { private $db; private $table = 'cadastro'; public function __construct($db) { $this->db = $db; } public function findByPk($pk) { //code } public function listAll() { //code } public function insert($object) { $sql = "INSERT INTO {$this->table} (name, lastname, email, password) VALUES (:name, :lastname, :email, :password)"; $stmt = $this->db->prepare($sql); $stmt->bindParam(':name', $object->getName()); $stmt->bindParam(':lastname', $object->getLastname()); $stmt->bindParam(':email', $object->getEmail()); $stmt->bindParam(':password', sha1(md5($object->getPassword()))); return $stmt->execute(); } public function update($object) { //code } public function delete($pk) { //code } } ?> User.class.php <?php class User { private $id; private $name; private $lastname; private $email; private $password; public function __construct($name = null, $lastname = null, $email = null, $password = null) { $this->name = $name; $this->lastname = $lastname; $this->email = $email; $this->password = $password; } //gets e sets //... } ?> Ainda sobre DAO, para cada classe (User, Client, etc, etc...) terei que ter um DAO referente ? Obrigado a todos por enquanto, estou lendo e revendo todas as informações !!!

Estou estudando php e por consequência orientação objetos. Nesses últimos dias, me deparei com os princípios do SOLID (Single responsibility, Open-closed, Liskov substitution, Interface segregation and Dependency inversion) e tive algumas dúvidas. Como por exemplo, na tentativa de criar um "registration system", não consegui implementar os conceitos do SOLID, principalmente o SRP e OCP. Com isso me deparei com algumas dúvidas, por exemplo: Como escolher os nomes das classes e suas funções (objetivo, etc) ? Como relacionar os objetos (banco de dados, usuario, etc) ? Como deve ser a estrutura de classes(ex: DataBase, User, User Service) para um 'registration system' ou similar ? Como saber se estou violando ou não os principios do SOLID (dicas, etc) ? Como deveria ser implementada as classes abaixo, principalmente a DataBase ? Segue a tentativa: DataBase.class.php <?php require_once 'config.php'; class DataBase { private $DB; private $table = 'cadastro'; public function __construct() { $this->DB = new PDO('mysql:host='.DB_HOST.';dbname='.DB_NAME, DB_USER, DB_PASS); } public function insertUser($name, $lastname, $email, $password) { $sql = "INSERT INTO {$this->table} (name, lastname, email, password) VALUES (:name, :lastname, :email, :password)"; $stmt = $this->DB->prepare($sql); $stmt->bindParam(':name', $name, PDO::PARAM_STR); $stmt->bindParam(':lastname', $lastname, PDO::PARAM_STR); $stmt->bindParam(':email', $email, PDO::PARAM_STR); $stmt->bindParam(':password', $password, PDO::PARAM_STR); return $stmt->execute(); } public function findUserByEmail($email) { //... } public function findAll() { //... } //... } ?> User.class.php <?php class User { private $id; private $name; private $lastname; private $email; private $password; public function __construct($name = null, $lastname = null, $email = null, $password = null) { $this->name = $name; $this->lastname = $lastname; $this->email = $email; $this->password = $password; } public function getId() { return $this->id; } public function setId($id) { $this->id = $id; } public function getName() { return $this->name; } public function setName($name) { $this->name = $name; } public function getLastname() { return $this->lastname; } public function setLastname($lastname) { $this->lastname = $lastname; } public function getEmail() { return $this->email; } public function setEmail($email) { $this->email = $email; } public function getPassword() { return $this->password; } public function setPassword($password) { $this->password = $password; } } ?> UserAction.class.php <?php class UserAction { public function register($user, $database) { return $database->insertUser($user->getName(), $user->getLastname(), $user->getEmail(), $user->getPassword()); } /* public function login($user, $database) { //... } */ //... } ?> register.php <?php require_once 'autoload.php'; $name = (isset($_POST['name']))?$_POST['name']:null; $lastname = (isset($_POST['lastname']))?$_POST['lastname']:null; $email = (isset($_POST['email']))?$_POST['email']:null; $password = (isset($_POST['password']))?$_POST['password']:null; $user = new User($name, $lastname, $email, $password); $database = new DataBase(); $action = new UserAction(); $action->register($user, $database); //... ?> Se puderem me indicar materias ou exemplos para prática ficarei grato. Obrigado !