Retour à Tutoriels PHP

TUTORIAL: envoi d'email via SMTP

  • Bogey
  • Bogey
  • Genius
  • Avatar de l’utilisateur
  • Inscription: Juil 14, 2005
  • Messages: 8212
  • Loc: USA
  • Status: Offline

Message Septembre 27th, 2010, 11:45 pm

1.0 Introduction


Il ya de nombreux cas, lorsque vous (en tant que propriétaire du site web master /) à envoyer à vos utilisateurs un e-mail, ou laisser les utilisateurs envoyer un e-mail d'autres utilisateurs. Évidemment, vous voulez coder certaines autorisations sur cette question et permettre aux utilisateurs de désactiver les autres utilisateurs à envoyer des emails à eux, sinon il pourrait devenir assez laid.

Le principal objectif de ce tutoriel est de briser le code existant en petits morceaux et expliquer ce que chaque ligne ne, alors quand vous utilisez le code, vous seriez capable de l'utiliser et de bien comprendre ce qu'il le fasse.

1.1 Avis du droit d'auteur


Cette classe n'est pas mon original, donc je ne possède pas cette classe. Je l'ai eu comme une simple page PHP et l'a converti en une classe et édité un peu...mais je n'ai pas le créer à partir de zéro.

2,0 serveurs SMTP


La plupart des hôtes de fournir un serveur SMTP (et serveur POP) qui est disponible pour vous à utiliser pour ce but. Dans la plupart des cas, le lien vers le serveur SMTP devrait ressembler à: smtp.myhost.com .

Dans la plupart des cas, un port SMTP normal serait de 25 en un port sécurisé pour SMTP serait 465. Si ce n'est pas ces ports alors l'hôte doit vous dire quels sont les ports les ports SMTP. (Ils vont vous dire les ports, même s'ils sont ces ports).

2.1 Alternatives SMTP


Si, pour quelque raison que votre hébergeur ne vous fournit pas un serveur SMTP pour vous à utiliser, il existe quelques alternatives là-bas que vous pouvez utiliser. Le premier qui me vient à l'esprit est gmail.

Gmail vous permet d'utiliser leur serveur SMTP pour envoyer des messages e-mail gratuitement et sans aucun tracas. Par cela, je veux dire que vous n'avez pas à aller à gmail et permettre SMTP ou quelque chose comme ça...son toujours là tout ce que vous devez faire est de remplir les informations dans le script et cela fonctionne. Voici les informations qui vous permettent d'utiliser leur serveur SMTP:

serveur SMTP : Smtp.gmail.com
Port : 587
Nom d'utilisateur : {Votre e-mail gmail (e. i: myname@gmail.com )}
Mot de passe : {Votre mot de passe pour votre e-mail}

Il n'ya pas que Gmail que vous fournissez avec un serveur SMTP. Une, par exemple, est SMTP.com , Mais comme vous pouvez le voir, c'est un peu plus cher que d'autres gmail.com est.

3. 0 La classe d'initiation


Ive voulait une simple classe pour me permettre d'avoir les utilisateurs envoient aux utilisateurs, envoyez-moi pour les utilisateurs et les utilisateurs qui envoient de moi...J'ai trouvé une fonction qui a limité le service de messagerie pour m'envoyer aux utilisateurs et c'est tout. Il est évident qu'il doit y avoir quelque chose que j'avais à faire, à augmenter les capacités de cette fonction.

La façon dont je voulais utiliser cette fonction est:

PHP Code: [ Select ]
new mail($to, $subject, $message)


Un one-liner, à mon avis, est vraiment un gros plus quand il s'agit de ce...une seule ligne qui renvoie vrai si le message a été envoyé ou faux si le message n'a pas pu être envoyé.

Cela me permet de conclure que l'une chemise avec un if () déclaration et le retour à l'utilisateur l'état de leur message.

3.1 La déclaration des variables


Il ya quelques variables déclarées dans la classe pour faire de cette classe utilisable:
PHP Code: [ Select ]
class mail {
    private $smtpServer = 'smtp.gmail.com';
    private $port = '587';
    private $timeout = 30;
    private $username = 'myname@gmail.com';
    private $password = 'mypassword';
    private $username_email = 'myreceivingemail@gmail.com';
    private $newline = "\r\n";
    private $localdomain = 'http://www.mysite.com';
    private $charset = 'windows-1251';
    private $contentTransferEncoding = false;
 
    // Do not change anything below
    private $smtpConnect = false;
    private $to = false;
    private $subject = false;
    private $message = false;
    private $headers = false;
    private $logArray = array(); // Array response message for debug
    private $Error = '';
    private $from = false;
}
  1. class mail {
  2.     private $smtpServer = 'smtp.gmail.com';
  3.     private $port = '587';
  4.     private $timeout = 30;
  5.     private $username = 'myname@gmail.com';
  6.     private $password = 'mypassword';
  7.     private $username_email = 'myreceivingemail@gmail.com';
  8.     private $newline = "\r\n";
  9.     private $localdomain = 'http://www.mysite.com';
  10.     private $charset = 'windows-1251';
  11.     private $contentTransferEncoding = false;
  12.  
  13.     // Do not change anything below
  14.     private $smtpConnect = false;
  15.     private $to = false;
  16.     private $subject = false;
  17.     private $message = false;
  18.     private $headers = false;
  19.     private $logArray = array(); // Array response message for debug
  20.     private $Error = '';
  21.     private $from = false;
  22. }

Voici les variables ventilées.

  • SMTPServer
    • Le serveur SMTP que vous seriez connexion et l'utilisation d'envoyer des messages
  • port
    • Le port que vous utiliserez pour vous connecter au serveur SMTP
  • timeout
    • longueur de temps (en secondes) que le script essaierait de se connecter avant de décider qu'il ne se connecte pas
  • nom d'utilisateur
    • L'e-mail gmail (à savoir: monnom @ gmail. com ) À laquelle le serveur SMTP est lié à
  • Mot de passe
    • Le mot de passe pour que le courrier électronique pour permettre l'utilisation du serveur SMTP
  • username_email
    • C'est l'e-mail qui recevra les messages de l'utilisateur...n'a pas à être à partir de Gmail.
  • retour à la ligne
    • C'est ainsi que le script fera des sauts de ligne dans les messages d'erreur et de débogage.
  • localdomain
    • Il s'agit d'un lien vers votre site.
  • charset
    • Le jeu de caractères (encodage je crois) qui est utilisé dans ce message
  • contentTransferEncoding
    • Si vrai, il serait mis dans la tête que le contenu est codé (je crois...ne pense pas que ce serait effectivement coder le contenu
      • PHP Code: [ Select ]
      function __construct($to, $subject, $message, $to_admin) {

      La construction déclaration de fonction. Définit les variables dynamiques qui seraient utilisés dans toute la classe.
      PHP Code: [ Select ]
          $this->to = (($to_admin === true) ? $this->username_email : $to );

      C'est la ligne qui détermine le destinataire du message électronique. Si $ To_admin est vraie, alors en son pouvoir pour admin, sinon ce n'est pas à l'admin.
      PHP Code: [ Select ]
          $this->subject = &$subject;

      Eh bien, ce sera l'objet du message.
      PHP Code: [ Select ]
          $this->message = &$message;

      Et c'est ici le message du message.
      PHP Code: [ Select ]
          // Connect to server
          if(!$this->Connect2Server()) {
      1.     // Connect to server
      2.     if(!$this->Connect2Server()) {

      Voici où nous en vérifier le résultat de la tentative de connexion. Vérification spécifique à l'échec. Si c'est un succès que nous n'avons pas besoin (ne doit pas) echo rien.
      PHP Code: [ Select ]
              // Display error message
              echo '<pre>'.trim($this->Error).'</pre>'.$this->newline.'<!-- '.$this->newline;
              print_r($this->logArray);
              echo $this->newline.'-->'.$this->newline;
              return false;
          }
      1.         // Display error message
      2.         echo '<pre>'.trim($this->Error).'</pre>'.$this->newline.'<!-- '.$this->newline;
      3.         print_r($this->logArray);
      4.         echo $this->newline.'-->'.$this->newline;
      5.         return false;
      6.     }

      C'est là que nous imprimons les erreurs à l'écran et le débogage du code source...nous avons également retourner false pour vous permettent d'imprimer un message à l'utilisateur en leur disant que l'envoi de ce message n'a pas fonctionné.
      PHP Code: [ Select ]
          return true;
      }
      1.     return true;
      2. }

      Si la connexion a fonctionné, et l'instruction if qui vérifie l'échec ne déclenche pas, alors nous retourner true pour vous permettre d'imprimer un message à l'utilisateur en leur disant que le message a été envoyé avec succès.

      Ci-dessous est la fonction dans son intégralité.
      PHP Code: [ Select ]
      public function __construct($to, $subject, $message, $to_admin) {
          $this->to_admin = $to_admin;
          $this->to = (($this->to_admin === false) ? $this->username_email : $to );
          $this->from = (($this->to_admin === false) ? $to : $this->username_email );
          $this->subject = &$subject;
          $this->message = &$message;
       
          // Connect to server
          if(!$this->Connect2Server()) {
              // Display error message
              echo '<pre>'.trim($this->Error).'</pre>'.$this->newline.'<!-- '.$this->newline;
              print_r($this->logArray);
              echo $this->newline.'-->'.$this->newline;
              return false;
          }
          return true;
      }
      1. public function __construct($to, $subject, $message, $to_admin) {
      2.     $this->to_admin = $to_admin;
      3.     $this->to = (($this->to_admin === false) ? $this->username_email : $to );
      4.     $this->from = (($this->to_admin === false) ? $to : $this->username_email );
      5.     $this->subject = &$subject;
      6.     $this->message = &$message;
      7.  
      8.     // Connect to server
      9.     if(!$this->Connect2Server()) {
      10.         // Display error message
      11.         echo '<pre>'.trim($this->Error).'</pre>'.$this->newline.'<!-- '.$this->newline;
      12.         print_r($this->logArray);
      13.         echo $this->newline.'-->'.$this->newline;
      14.         return false;
      15.     }
      16.     return true;
      17. }


      3.3 Connexion au serveur SMTP


      Maintenant, ce que nous devons faire est de se connecter au serveur.
      PHP Code: [ Select ]
      private function Connect2Server() {

      Ici, nous lancer la fonction. Nous faisons cette fonction privée depuis que cette classe est censé avoir accès à la fonction.
      PHP Code: [ Select ]
          // Connect to server
          $this->smtpConnect = fsockopen($this->smtpServer,$this->port,$errno,$error,$this->timeout);
      1.     // Connect to server
      2.     $this->smtpConnect = fsockopen($this->smtpServer,$this->port,$errno,$error,$this->timeout);


      Ici, nous nous connecter à un serveur SMTP en utilisant les informations fournies dans les variables déclarées.
      PHP Code: [ Select ]
          $this->logArray['CONNECT_RESPONSE'] = $this->readResponse();

      Ici nous enregistrons la réponse / résultat de la tentative de connexion SMTP.
      PHP Code: [ Select ]
          if (!is_resource($this->smtpConnect)) {
              return false;
          }
      1.     if (!is_resource($this->smtpConnect)) {
      2.         return false;
      3.     }

      Si la connexion a échoué, nous return false. quelque chose de revenir à ce point arrête la fonction de poursuivre et se termine le script.
      PHP Code: [ Select ]
          $this->logArray['connection'] = "Connection accepted";

      Si nous avons atteint ce point, cela signifie que le serveur SMTP est correctement connecté à...il permet de connecter fins de débogage.
      PHP Code: [ Select ]
          // Hi, server!
          $this->sendCommand("HELLO {$this->localdomain}");
          $this->logArray['HELLO'] = $this->readResponse();
      1.     // Hi, server!
      2.     $this->sendCommand("HELLO {$this->localdomain}");
      3.     $this->logArray['HELLO'] = $this->readResponse();

      C'est ici que nous vous présentons notre site sur le serveur SMTP et de stocker la réponse du serveur SMTP pour débogage.
      PHP Code: [ Select ]
          // Let's know each other
          $this->sendCommand('AUTH LOGIN');
          $this->logArray['AUTH_REQUEST'] = $this->readResponse();
      1.     // Let's know each other
      2.     $this->sendCommand('AUTH LOGIN');
      3.     $this->logArray['AUTH_REQUEST'] = $this->readResponse();

      C'est là où le script demande l'autorisation et d'engager la phase nom d'utilisateur / mot de passe du processus de connexion. Nous sommes magasin la réponse fins de débogage.
      PHP Code: [ Select ]
          // My password..
          $this->sendCommand(base64_encode($this->password));
          $this->logArray['REQUEST_PASSWD'] = $this->readResponse();
      1.     // My password..
      2.     $this->sendCommand(base64_encode($this->password));
      3.     $this->logArray['REQUEST_PASSWD'] = $this->readResponse();

      Dans cette phase, nous envoyons le mot de passe, puis de conserver la réponse fins de débogage.
      PHP Code: [ Select ]
          // If error in response auth...
          if (substr($this->logArray['REQUEST_PASSWD'],0,3)!='235') {
              $this->Error .= 'Authorization error! '.$this->logArray['REQUEST_PASSWD'].$this->newline;
              return false;
          }
      1.     // If error in response auth...
      2.     if (substr($this->logArray['REQUEST_PASSWD'],0,3)!='235') {
      3.         $this->Error .= 'Authorization error! '.$this->logArray['REQUEST_PASSWD'].$this->newline;
      4.         return false;
      5.     }

      Voici où nous en vérifier le résultat du processus de connexion. Nous conservons l'erreur dans la variable d'erreur et retourne false, l'arrêt du script.
      PHP Code: [ Select ]
          // "From" mail...
          $this->sendCommand("MAIL FROM: {$this->from}");
          $this->logArray['MAIL_FROM_RESPONSE'] = $this->readResponse();
      1.     // "From" mail...
      2.     $this->sendCommand("MAIL FROM: {$this->from}");
      3.     $this->logArray['MAIL_FROM_RESPONSE'] = $this->readResponse();

      Ici, nous indiquons le serveur SMTP qui le message est envoyé à partir et stocker la réponse fins de débogage.
      PHP Code: [ Select ]
          if (substr($this->logArray['MAIL_FROM_RESPONSE'],0,3)!='250') {
              $this->Error .= 'Mistake in sender\'s address! '.$this->logArray['MAIL_FROM_RESPONSE'].$this->newline;
              return false;
          }
      1.     if (substr($this->logArray['MAIL_FROM_RESPONSE'],0,3)!='250') {
      2.         $this->Error .= 'Mistake in sender\'s address! '.$this->logArray['MAIL_FROM_RESPONSE'].$this->newline;
      3.         return false;
      4.     }

      Vérification du résultat de la validation de l'adresse «De». Si la réponse n'est pas correcte, nous stockons l'erreur dans la variable d'erreur et de fausse déclaration, l'arrêt du script.
      PHP Code: [ Select ]
          // "To" address
          $this->sendCommand("RCPT TO: {$this->to}");
          $this->logArray['RCPT_TO_RESPONCE'] = $this->readResponse();
      1.     // "To" address
      2.     $this->sendCommand("RCPT TO: {$this->to}");
      3.     $this->logArray['RCPT_TO_RESPONCE'] = $this->readResponse();

      Ici, nous indiquons le serveur SMTP de l'adresse à laquelle le message a été écrit pour. Ensuite, nous stockons la réponse fins de débogage.
      PHP Code: [ Select ]
          if(substr($this->logArray['RCPT_TO_RESPONCE'],0,3) != '250')
          {
              $this->Error .= 'Mistake in reciepent address! '.$this->logArray['RCPT_TO_RESPONCE'].$this->newline;
              return false;
          }
      1.     if(substr($this->logArray['RCPT_TO_RESPONCE'],0,3) != '250')
      2.     {
      3.         $this->Error .= 'Mistake in reciepent address! '.$this->logArray['RCPT_TO_RESPONCE'].$this->newline;
      4.         return false;
      5.     }

      Ici nous vérifions le résultat de la validation de l'adresse du destinataire. Stockage de l'erreur et retourne false, l'arrêt du script.
      PHP Code: [ Select ]
          // Send data to server
          $this->sendCommand('DATA');
          $this->logArray['DATA_RESPONSE'] = $this->readResponse();
      1.     // Send data to server
      2.     $this->sendCommand('DATA');
      3.     $this->logArray['DATA_RESPONSE'] = $this->readResponse();

      Ici, nous envoyer les données et le stockage de la réponse fins de débogage.
      PHP Code: [ Select ]
          // Send mail message
          if (!$this->sendMail()) return false;
      1.     // Send mail message
      2.     if (!$this->sendMail()) return false;

      Ici, nous envoyer le message électronique...nous vérifions spécifiquement à l'échec, et si elle a échoué, retourne false, ce qui vous permet d'écrire votre message propre échec.
      PHP Code: [ Select ]
          // Good bye server! =)
          $this->sendCommand('QUIT');
          $this->logArray['QUIT_RESPONSE'] = $this->readResponse();
      1.     // Good bye server! =)
      2.     $this->sendCommand('QUIT');
      3.     $this->logArray['QUIT_RESPONSE'] = $this->readResponse();

      Ici nous nous apprêtons à vous déconnecter du serveur SMTP. Stockage de la réponse fins de débogage.
      PHP Code: [ Select ]
          // Close smtp connect
          fclose($this->smtpConnect);
          return true;
      }
      1.     // Close smtp connect
      2.     fclose($this->smtpConnect);
      3.     return true;
      4. }

      Ici nous sommes en fait déconnecter du serveur SMTP. Puisque nous sommes arrivés à ce point, l'e-mail a été envoyé, et tout a fonctionné correctement, alors nous sommes de retour pour vrai succès.

      La raison pour laquelle nous avons la commande "QUIT" et puis la déconnexion, au lieu de simplement déconnecter, c'est la même raison que vous appuyez sur Arrêter pour éteindre votre ordinateur, au lieu de simplement tirer la prise. (Au moins c'est comme ça que je le vois).

      Maintenant, c'est ici que la fonction dans son intégralité.
      PHP Code: [ Select ]
      private function Connect2Server() {
          // Connect to server
          $this->smtpConnect = fsockopen($this->smtpServer,$this->port,$errno,$error,$this->timeout);
          $this->logArray['CONNECT_RESPONSE'] = $this->readResponse();
       
          if (!is_resource($this->smtpConnect)) {
              return false;
          }
          $this->logArray['connection'] = "Connection accepted";
          // Hi, server!
          $this->sendCommand("HELLO {$this->localdomain}");
          $this->logArray['HELLO'] = $this->readResponse();
          // Let's know each other
          $this->sendCommand('AUTH LOGIN');
          $this->logArray['AUTH_REQUEST'] = $this->readResponse();
          // My name...
          $this->sendCommand(base64_encode($this->username));
          $this->logArray['REQUEST_USER'] = $this->readResponse();
          // My password..
          $this->sendCommand(base64_encode($this->password));
          $this->logArray['REQUEST_PASSWD'] = $this->readResponse();
          // If error in response auth...
          if (substr($this->logArray['REQUEST_PASSWD'],0,3)!='235') {
              $this->Error .= 'Authorization error! '.$this->logArray['REQUEST_PASSWD'].$this->newline;
              return false;
          }
          // "From" mail...
          $this->sendCommand("MAIL FROM: {$this->from}");
          $this->logArray['MAIL_FROM_RESPONSE'] = $this->readResponse();
          if (substr($this->logArray['MAIL_FROM_RESPONSE'],0,3)!='250') {
              $this->Error .= 'Mistake in sender\'s address! '.$this->logArray['MAIL_FROM_RESPONSE'].$this->newline;
              return false;
          }
          // "To" address
          $this->sendCommand("RCPT TO: {$this->to}");
          $this->logArray['RCPT_TO_RESPONCE'] = $this->readResponse();
          if(substr($this->logArray['RCPT_TO_RESPONCE'],0,3) != '250')
          {
              $this->Error .= 'Mistake in reciepent address! '.$this->logArray['RCPT_TO_RESPONCE'].$this->newline;
          }
          // Send data to server
          $this->sendCommand('DATA');
          $this->logArray['DATA_RESPONSE'] = $this->readResponse();
          // Send mail message
          if (!$this->sendMail()) return false;
          // Good bye server! =)
          $this->sendCommand('QUIT');
          $this->logArray['QUIT_RESPONSE'] = $this->readResponse();
          // Close smtp connect
          fclose($this->smtpConnect);
          return true;
      }
      1. private function Connect2Server() {
      2.     // Connect to server
      3.     $this->smtpConnect = fsockopen($this->smtpServer,$this->port,$errno,$error,$this->timeout);
      4.     $this->logArray['CONNECT_RESPONSE'] = $this->readResponse();
      5.  
      6.     if (!is_resource($this->smtpConnect)) {
      7.         return false;
      8.     }
      9.     $this->logArray['connection'] = "Connection accepted";
      10.     // Hi, server!
      11.     $this->sendCommand("HELLO {$this->localdomain}");
      12.     $this->logArray['HELLO'] = $this->readResponse();
      13.     // Let's know each other
      14.     $this->sendCommand('AUTH LOGIN');
      15.     $this->logArray['AUTH_REQUEST'] = $this->readResponse();
      16.     // My name...
      17.     $this->sendCommand(base64_encode($this->username));
      18.     $this->logArray['REQUEST_USER'] = $this->readResponse();
      19.     // My password..
      20.     $this->sendCommand(base64_encode($this->password));
      21.     $this->logArray['REQUEST_PASSWD'] = $this->readResponse();
      22.     // If error in response auth...
      23.     if (substr($this->logArray['REQUEST_PASSWD'],0,3)!='235') {
      24.         $this->Error .= 'Authorization error! '.$this->logArray['REQUEST_PASSWD'].$this->newline;
      25.         return false;
      26.     }
      27.     // "From" mail...
      28.     $this->sendCommand("MAIL FROM: {$this->from}");
      29.     $this->logArray['MAIL_FROM_RESPONSE'] = $this->readResponse();
      30.     if (substr($this->logArray['MAIL_FROM_RESPONSE'],0,3)!='250') {
      31.         $this->Error .= 'Mistake in sender\'s address! '.$this->logArray['MAIL_FROM_RESPONSE'].$this->newline;
      32.         return false;
      33.     }
      34.     // "To" address
      35.     $this->sendCommand("RCPT TO: {$this->to}");
      36.     $this->logArray['RCPT_TO_RESPONCE'] = $this->readResponse();
      37.     if(substr($this->logArray['RCPT_TO_RESPONCE'],0,3) != '250')
      38.     {
      39.         $this->Error .= 'Mistake in reciepent address! '.$this->logArray['RCPT_TO_RESPONCE'].$this->newline;
      40.     }
      41.     // Send data to server
      42.     $this->sendCommand('DATA');
      43.     $this->logArray['DATA_RESPONSE'] = $this->readResponse();
      44.     // Send mail message
      45.     if (!$this->sendMail()) return false;
      46.     // Good bye server! =)
      47.     $this->sendCommand('QUIT');
      48.     $this->logArray['QUIT_RESPONSE'] = $this->readResponse();
      49.     // Close smtp connect
      50.     fclose($this->smtpConnect);
      51.     return true;
      52. }

      3.4 La fonction qui envoie


      C'est la fonction qui fait l'envoi effectif du message.
      PHP Code: [ Select ]
      private function sendMail() {

      Une fois encore nous créer cette fonction en tant que privé.
      PHP Code: [ Select ]
          $this->sendHeaders();

      Voici où nous lancer la fonction qui crée et envoie les en-têtes du message électronique
      PHP Code: [ Select ]
          $this->sendCommand($this->message);
          $this->sendCommand('.');
          $this->logArray['SEND_DATA_RESPONSE'] = $this->readResponse();
      1.     $this->sendCommand($this->message);
      2.     $this->sendCommand('.');
      3.     $this->logArray['SEND_DATA_RESPONSE'] = $this->readResponse();

      Ici, nous envoyons les données et le stockage de la réponse fins de débogage.
      PHP Code: [ Select ]
          if(substr($this->logArray['SEND_DATA_RESPONSE'],0,3)!='250') {
              $this->Error .= 'Mistake in sending data! '.$this->logArray['SEND_DATA_RESPONSE'].$this->newline;
              return false;
          }
      1.     if(substr($this->logArray['SEND_DATA_RESPONSE'],0,3)!='250') {
      2.         $this->Error .= 'Mistake in sending data! '.$this->logArray['SEND_DATA_RESPONSE'].$this->newline;
      3.         return false;
      4.     }

      Ici nous vérifions le processus d'envoi à l'échec. Si elle ne nous stocker l'erreur dans la variable et fausse déclaration, l'arrêt du script.
      PHP Code: [ Select ]
          return true;
      }
      1.     return true;
      2. }

      Puisque nous sommes arrivés à ce point, le message a été envoyé avec succès, nous sommes donc de retour pour vrai succès

      Voici cette fonction dans son intégralité.
      PHP Code: [ Select ]
      private function sendMail() {
          $this->sendHeaders();
          $this->sendCommand($this->message);
          $this->sendCommand('.');
          $this->logArray['SEND_DATA_RESPONSE'] = $this->readResponse();
          if(substr($this->logArray['SEND_DATA_RESPONSE'],0,3)!='250') {
              $this->Error .= 'Mistake in sending data! '.$this->logArray['SEND_DATA_RESPONSE'].$this->newline;
              return false;
          }
          return true;
      }
      1. private function sendMail() {
      2.     $this->sendHeaders();
      3.     $this->sendCommand($this->message);
      4.     $this->sendCommand('.');
      5.     $this->logArray['SEND_DATA_RESPONSE'] = $this->readResponse();
      6.     if(substr($this->logArray['SEND_DATA_RESPONSE'],0,3)!='250') {
      7.         $this->Error .= 'Mistake in sending data! '.$this->logArray['SEND_DATA_RESPONSE'].$this->newline;
      8.         return false;
      9.     }
      10.     return true;
      11. }


      3,5 lecture des réponses


      Nous avons maintenant besoin de créer une fonction qui lit les réponses envoyées par le serveur SMTP.
      PHP Code: [ Select ]
      // Function read response
      private function readResponse() {
      1. // Function read response
      2. private function readResponse() {

      Une fois de plus...fonction privée
      PHP Code: [ Select ]
          $data="";

      Nous initions la variable...ne pouvez pas ajouter à une variable sans qu'il soit premier
      PHP Code: [ Select ]
          while($str = fgets($this->smtpConnect,4096))
          {
              $data .= $str;
              if(substr($str,3,1) == " ") { break; }
          }
      1.     while($str = fgets($this->smtpConnect,4096))
      2.     {
      3.         $data .= $str;
      4.         if(substr($str,3,1) == " ") { break; }
      5.     }

      Nous sommes une boucle à travers la réponse et la récupération des réponses
      PHP Code: [ Select ]
          return $data;
      }
      1.     return $data;
      2. }

      Nous sommes de retour de toutes les réponses que nous avons reçu depuis le serveur SMTP.

      Voici la fonction dans son intégralité.
      PHP Code: [ Select ]
      // Function read response
      private function readResponse() {
          $data="";
          while($str = fgets($this->smtpConnect,4096))
          {
              $data .= $str;
              if(substr($str,3,1) == " ") { break; }
          }
          return $data;
      }
      1. // Function read response
      2. private function readResponse() {
      3.     $data="";
      4.     while($str = fgets($this->smtpConnect,4096))
      5.     {
      6.         $data .= $str;
      7.         if(substr($str,3,1) == " ") { break; }
      8.     }
      9.     return $data;
      10. }


      3.6 Envoi de nos commandes Voici quand nous autoritaire. Nous avons besoin d'une fonction pour envoyer nos commandes pour le serveur SMTP.
      PHP Code: [ Select ]
      // function send command to server
      private function sendCommand($string) {
          fputs($this->smtpConnect,$string.$this->newline);
          return ;
      }
      1. // function send command to server
      2. private function sendCommand($string) {
      3.     fputs($this->smtpConnect,$string.$this->newline);
      4.     return ;
      5. }

      Nous créons une fonction privée, puis envoyer notre commande. Retour rien puisqu'il n'y a rien de revenir.

      [tuthead] 3.7 Créer des en-têtes


      Maintenant nous devons créer les en-têtes à être utilisé dans ce message que vous avez envoyé.
      PHP Code: [ Select ]
      private function sendHeaders() {
          $this->sendCommand("Date: ".date("D, j M Y G:i:s")." +0700");
          $this->sendCommand("From: <{$this->from}>");
          $this->sendCommand("Reply-To: <{$this->from}>");
          $this->sendCommand("To: <{$this->to}>");
          $this->sendCommand("Subject: {$this->subject}");
          $this->sendCommand("MIME-Version: 1.0");
          $this->sendCommand("Content-Type: text/html; charset={$this->charset}");
          if ($this->contentTransferEncoding) $this->sendCommand("Content-Transfer-Encoding: {$this->contentTransferEncoding}");
          return ;
      }
      1. private function sendHeaders() {
      2.     $this->sendCommand("Date: ".date("D, j M Y G:i:s")." +0700");
      3.     $this->sendCommand("From: <{$this->from}>");
      4.     $this->sendCommand("Reply-To: <{$this->from}>");
      5.     $this->sendCommand("To: <{$this->to}>");
      6.     $this->sendCommand("Subject: {$this->subject}");
      7.     $this->sendCommand("MIME-Version: 1.0");
      8.     $this->sendCommand("Content-Type: text/html; charset={$this->charset}");
      9.     if ($this->contentTransferEncoding) $this->sendCommand("Content-Transfer-Encoding: {$this->contentTransferEncoding}");
      10.     return ;
      11. }

      Voici cette fonction privé qui crée les en-têtes. Et ne renvoie rien puisqu'il n'y a rien de revenir.

      3.8 Détruire la classe


      Maintenant, ce que nous devons faire est de détruire la classe.
      PHP Code: [ Select ]
      function __destruct() {
          if (is_resource($this->smtpConnect)) fclose($this->smtpConnect);
      }
      1. function __destruct() {
      2.     if (is_resource($this->smtpConnect)) fclose($this->smtpConnect);
      3. }

      Le but de cette fonction est si en tout cas que la classe est arrêté avant de débrancher le serveur SMTP, nous serait-il débrancher ici.

      3. 9 La classe en elle et #39; ensemble s


      Voici cette classe dans son intégralité (Im pas l'attacher, puisque ce forum a avancé ce bloc qui s'effondre code PHP).

      Permet de sauvegarder cette page en tant que smtp_mail.php
      PHP Code: [ Select ]
      <?php
      class smtp_mail {
          private $smtpServer = 'smtp.gmail.com';
          private $port = '587';
          private $timeout = 30;
          private $username = 'myname@gmail.com';
          private $password = 'mypassword';
          private $username_email = 'myreceivingemail@gmail.com';
          private $newline = "\r\n";
          private $localdomain = 'http://www.mysite.com';
          private $charset = 'windows-1251';
          private $contentTransferEncoding = false;
       
          // Do not change anything below
          private $smtpConnect = false;
          private $to = false;
          private $to_admin = false;
          private $subject = false;
          private $message = false;
          private $headers = false;
          private $logArray = array(); // Array response message for debug
          private $Error = '';
          private $from = false;
       
          public function __construct($to, $subject, $message, $to_admin) {
              $this->to_admin = $to_admin;
              $this->to = (($this->to_admin === false) ? $this->username_email : $to );
              $this->from = (($this->to_admin === false) ? $to : $this->username_email );
              $this->subject = &$subject;
              $this->message = &$message;
       
              // Connect to server
              if(!$this->Connect2Server()) {
                  // Display error message
                  echo '<pre>'.trim($this->Error).'</pre>'.$this->newline.'<!-- '.$this->newline;
                  print_r($this->logArray);
                  echo $this->newline.'-->'.$this->newline;
                  return false;
              }
              return true;
          }
         
          private function Connect2Server() {
              // Connect to server
              $this->smtpConnect = fsockopen($this->smtpServer,$this->port,$errno,$error,$this->timeout);
              $this->logArray['CONNECT_RESPONSE'] = $this->readResponse();
       
              if (!is_resource($this->smtpConnect)) {
                  return false;
              }
              $this->logArray['connection'] = "Connection accepted";
              // Hi, server!
              $this->sendCommand("HELLO {$this->localdomain}");
              $this->logArray['HELLO'] = $this->readResponse();
              // Let's know each other
              $this->sendCommand('AUTH LOGIN');
              $this->logArray['AUTH_REQUEST'] = $this->readResponse();
              // My name...
              $this->sendCommand(base64_encode($this->username));
              $this->logArray['REQUEST_USER'] = $this->readResponse();
              // My password..
              $this->sendCommand(base64_encode($this->password));
              $this->logArray['REQUEST_PASSWD'] = $this->readResponse();
              // If error in response auth...
              if (substr($this->logArray['REQUEST_PASSWD'],0,3)!='235') {
                  $this->Error .= 'Authorization error! '.$this->logArray['REQUEST_PASSWD'].$this->newline;
                  return false;
              }
              // "From" mail...
              $this->sendCommand("MAIL FROM: {$this->from}");
              $this->logArray['MAIL_FROM_RESPONSE'] = $this->readResponse();
              if (substr($this->logArray['MAIL_FROM_RESPONSE'],0,3)!='250') {
                  $this->Error .= 'Mistake in sender\'s address! '.$this->logArray['MAIL_FROM_RESPONSE'].$this->newline;
                  return false;
              }
              // "To" address
              $this->sendCommand("RCPT TO: {$this->to}");
              $this->logArray['RCPT_TO_RESPONCE'] = $this->readResponse();
              if(substr($this->logArray['RCPT_TO_RESPONCE'],0,3) != '250')
              {
                  $this->Error .= 'Mistake in reciepent address! '.$this->logArray['RCPT_TO_RESPONCE'].$this->newline;
              }
              // Send data to server
              $this->sendCommand('DATA');
              $this->logArray['DATA_RESPONSE'] = $this->readResponse();
              // Send mail message
              if (!$this->sendMail()) return false;
              // Good bye server! =)
              $this->sendCommand('QUIT');
              $this->logArray['QUIT_RESPONSE'] = $this->readResponse();
              // Close smtp connect
              fclose($this->smtpConnect);
              return true;
          }
         
          private function sendMail() {
              $this->sendHeaders();
              $this->sendCommand($this->message);
              $this->sendCommand('.');
              $this->logArray['SEND_DATA_RESPONSE'] = $this->readResponse();
              if(substr($this->logArray['SEND_DATA_RESPONSE'],0,3)!='250') {
                  $this->Error .= 'Mistake in sending data! '.$this->logArray['SEND_DATA_RESPONSE'].$this->newline;
                  return false;
              }
              return true;
          }
         
          // Function read response
          private function readResponse() {
              $data="";
              while($str = fgets($this->smtpConnect,4096))
              {
                  $data .= $str;
                  if(substr($str,3,1) == " ") { break; }
              }
              return $data;
          }
         
          // function send command to server
          private function sendCommand($string) {
              fputs($this->smtpConnect,$string.$this->newline);
              return ;
          }
         
          // function send headers
          private function sendHeaders() {
              $this->sendCommand("Date: ".date("D, j M Y G:i:s")." +0700");
              $this->sendCommand("From: <{$this->from}>");
              $this->sendCommand("Reply-To: <{$this->from}>");
              $this->sendCommand("To: <{$this->to}>");
              $this->sendCommand("Subject: {$this->subject}");
              $this->sendCommand("MIME-Version: 1.0");
              $this->sendCommand("Content-Type: text/html; charset={$this->charset}");
              if ($this->contentTransferEncoding) $this->sendCommand("Content-Transfer-Encoding: {$this->contentTransferEncoding}");
              return ;
          }
         
          function __destruct() {
              if (is_resource($this->smtpConnect)) fclose($this->smtpConnect);
          }
      }
      ?>
      1. <?php
      2. class smtp_mail {
      3.     private $smtpServer = 'smtp.gmail.com';
      4.     private $port = '587';
      5.     private $timeout = 30;
      6.     private $username = 'myname@gmail.com';
      7.     private $password = 'mypassword';
      8.     private $username_email = 'myreceivingemail@gmail.com';
      9.     private $newline = "\r\n";
      10.     private $localdomain = 'http://www.mysite.com';
      11.     private $charset = 'windows-1251';
      12.     private $contentTransferEncoding = false;
      13.  
      14.     // Do not change anything below
      15.     private $smtpConnect = false;
      16.     private $to = false;
      17.     private $to_admin = false;
      18.     private $subject = false;
      19.     private $message = false;
      20.     private $headers = false;
      21.     private $logArray = array(); // Array response message for debug
      22.     private $Error = '';
      23.     private $from = false;
      24.  
      25.     public function __construct($to, $subject, $message, $to_admin) {
      26.         $this->to_admin = $to_admin;
      27.         $this->to = (($this->to_admin === false) ? $this->username_email : $to );
      28.         $this->from = (($this->to_admin === false) ? $to : $this->username_email );
      29.         $this->subject = &$subject;
      30.         $this->message = &$message;
      31.  
      32.         // Connect to server
      33.         if(!$this->Connect2Server()) {
      34.             // Display error message
      35.             echo '<pre>'.trim($this->Error).'</pre>'.$this->newline.'<!-- '.$this->newline;
      36.             print_r($this->logArray);
      37.             echo $this->newline.'-->'.$this->newline;
      38.             return false;
      39.         }
      40.         return true;
      41.     }
      42.    
      43.     private function Connect2Server() {
      44.         // Connect to server
      45.         $this->smtpConnect = fsockopen($this->smtpServer,$this->port,$errno,$error,$this->timeout);
      46.         $this->logArray['CONNECT_RESPONSE'] = $this->readResponse();
      47.  
      48.         if (!is_resource($this->smtpConnect)) {
      49.             return false;
      50.         }
      51.         $this->logArray['connection'] = "Connection accepted";
      52.         // Hi, server!
      53.         $this->sendCommand("HELLO {$this->localdomain}");
      54.         $this->logArray['HELLO'] = $this->readResponse();
      55.         // Let's know each other
      56.         $this->sendCommand('AUTH LOGIN');
      57.         $this->logArray['AUTH_REQUEST'] = $this->readResponse();
      58.         // My name...
      59.         $this->sendCommand(base64_encode($this->username));
      60.         $this->logArray['REQUEST_USER'] = $this->readResponse();
      61.         // My password..
      62.         $this->sendCommand(base64_encode($this->password));
      63.         $this->logArray['REQUEST_PASSWD'] = $this->readResponse();
      64.         // If error in response auth...
      65.         if (substr($this->logArray['REQUEST_PASSWD'],0,3)!='235') {
      66.             $this->Error .= 'Authorization error! '.$this->logArray['REQUEST_PASSWD'].$this->newline;
      67.             return false;
      68.         }
      69.         // "From" mail...
      70.         $this->sendCommand("MAIL FROM: {$this->from}");
      71.         $this->logArray['MAIL_FROM_RESPONSE'] = $this->readResponse();
      72.         if (substr($this->logArray['MAIL_FROM_RESPONSE'],0,3)!='250') {
      73.             $this->Error .= 'Mistake in sender\'s address! '.$this->logArray['MAIL_FROM_RESPONSE'].$this->newline;
      74.             return false;
      75.         }
      76.         // "To" address
      77.         $this->sendCommand("RCPT TO: {$this->to}");
      78.         $this->logArray['RCPT_TO_RESPONCE'] = $this->readResponse();
      79.         if(substr($this->logArray['RCPT_TO_RESPONCE'],0,3) != '250')
      80.         {
      81.             $this->Error .= 'Mistake in reciepent address! '.$this->logArray['RCPT_TO_RESPONCE'].$this->newline;
      82.         }
      83.         // Send data to server
      84.         $this->sendCommand('DATA');
      85.         $this->logArray['DATA_RESPONSE'] = $this->readResponse();
      86.         // Send mail message
      87.         if (!$this->sendMail()) return false;
      88.         // Good bye server! =)
      89.         $this->sendCommand('QUIT');
      90.         $this->logArray['QUIT_RESPONSE'] = $this->readResponse();
      91.         // Close smtp connect
      92.         fclose($this->smtpConnect);
      93.         return true;
      94.     }
      95.    
      96.     private function sendMail() {
      97.         $this->sendHeaders();
      98.         $this->sendCommand($this->message);
      99.         $this->sendCommand('.');
      100.         $this->logArray['SEND_DATA_RESPONSE'] = $this->readResponse();
      101.         if(substr($this->logArray['SEND_DATA_RESPONSE'],0,3)!='250') {
      102.             $this->Error .= 'Mistake in sending data! '.$this->logArray['SEND_DATA_RESPONSE'].$this->newline;
      103.             return false;
      104.         }
      105.         return true;
      106.     }
      107.    
      108.     // Function read response
      109.     private function readResponse() {
      110.         $data="";
      111.         while($str = fgets($this->smtpConnect,4096))
      112.         {
      113.             $data .= $str;
      114.             if(substr($str,3,1) == " ") { break; }
      115.         }
      116.         return $data;
      117.     }
      118.    
      119.     // function send command to server
      120.     private function sendCommand($string) {
      121.         fputs($this->smtpConnect,$string.$this->newline);
      122.         return ;
      123.     }
      124.    
      125.     // function send headers
      126.     private function sendHeaders() {
      127.         $this->sendCommand("Date: ".date("D, j M Y G:i:s")." +0700");
      128.         $this->sendCommand("From: <{$this->from}>");
      129.         $this->sendCommand("Reply-To: <{$this->from}>");
      130.         $this->sendCommand("To: <{$this->to}>");
      131.         $this->sendCommand("Subject: {$this->subject}");
      132.         $this->sendCommand("MIME-Version: 1.0");
      133.         $this->sendCommand("Content-Type: text/html; charset={$this->charset}");
      134.         if ($this->contentTransferEncoding) $this->sendCommand("Content-Transfer-Encoding: {$this->contentTransferEncoding}");
      135.         return ;
      136.     }
      137.    
      138.     function __destruct() {
      139.         if (is_resource($this->smtpConnect)) fclose($this->smtpConnect);
      140.     }
      141. }
      142. ?>


      4.0 Utilisation de classe


      Maintenant, nous voulons un moyen simple d'utiliser cette classe SMTP.
      PHP Code: [ Select ]
      if(new smtp_mail($to, $subject, $message, true))
      {
          echo 'Your message has being sent successfully.';
      }
      else
      {
          echo 'There was a problem sending the message';
          // Possibly log this for your reference
      }
      1. if(new smtp_mail($to, $subject, $message, true))
      2. {
      3.     echo 'Your message has being sent successfully.';
      4. }
      5. else
      6. {
      7.     echo 'There was a problem sending the message';
      8.     // Possibly log this for your reference
      9. }

      Simple, non?

      5. 0 Le formulaire


      Maintenant nous avons besoin de la forme à utiliser que les gens vont utiliser pour remplir pour envoyer leur message.

      Permet de sauvegarder cette page en tant que contact.html
      HTML Code: [ Select ]
      <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
      <html>
          <head>
              <title>Contact Form</title>
              <style type="text/css">
                  #contact_form {
                      width: 100%;
                  }
                 
                  .form_col {
                      float: left;
                      margin-left: 10px;
                  }
              </style>
          </head>
          <body>
              <div id="contact_form">
                  <form action="contact.php" method="post">
                      <div class="form_col">
                          <p>Name:<br>
                          Email Address:<br>
                          To:<br>
                          Subject:<br>
                          Message:</p>
                      </div>
                      <div class="form_col">
                          <p><input type="text" name="name" size="30"> Required<br>
                          <input type="text" name="email" size="30"> Required<br>
                          <input type="text" name="to" size="30"> To Administrator <input type="checkbox" name="to2"><br>
                          <input type="text" name="subject" size="30"> Required<br>
                          <textarea name="message" cols="50" rows="10"></textarea><br>
                          <input type="submit" name="submit" value="Submit"> <input type="reset" value="Reset"> The Message is Required</p>
                      </div>
                  </form>
              </div>
              <p style="clear: both;"></p>
          </body>
      </html>
      1. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
      2. <html>
      3.     <head>
      4.         <title>Contact Form</title>
      5.         <style type="text/css">
      6.             #contact_form {
      7.                 width: 100%;
      8.             }
      9.            
      10.             .form_col {
      11.                 float: left;
      12.                 margin-left: 10px;
      13.             }
      14.         </style>
      15.     </head>
      16.     <body>
      17.         <div id="contact_form">
      18.             <form action="contact.php" method="post">
      19.                 <div class="form_col">
      20.                     <p>Name:<br>
      21.                     Email Address:<br>
      22.                     To:<br>
      23.                     Subject:<br>
      24.                     Message:</p>
      25.                 </div>
      26.                 <div class="form_col">
      27.                     <p><input type="text" name="name" size="30"> Required<br>
      28.                     <input type="text" name="email" size="30"> Required<br>
      29.                     <input type="text" name="to" size="30"> To Administrator <input type="checkbox" name="to2"><br>
      30.                     <input type="text" name="subject" size="30"> Required<br>
      31.                     <textarea name="message" cols="50" rows="10"></textarea><br>
      32.                     <input type="submit" name="submit" value="Submit"> <input type="reset" value="Reset"> The Message is Required</p>
      33.                 </div>
      34.             </form>
      35.         </div>
      36.         <p style="clear: both;"></p>
      37.     </body>
      38. </html>

      C'est juste une belle forme de style pour vous à utiliser avec cette classe.

      5.1 Le processeur de formulaire


      Maintenant passons à créer une page PHP qui traite le formulaire ci-dessus.

      Permet de sauvegarder cette page en tant que contact.php
      PHP Code: [ Select ]
      <?php
      // Checking if the form was really submitted
      if(isset($_POST['submit']))
      {
          // We need to initiate the error array
          $error = array();
         
          // Here we are checking if their name was filled in.
          if(empty($_POST['name']))
          {
              // The name field was left empty
              $error[] = "You need to enter a valid name.";
          }
         
          // Checking if a valid email address was filled in.
          if(!preg_match("/(?:[a-zA-Z0-9_\'\^\&\/\+\-])+(?:\.(?:[a-zA-Z0-9_\'\^\&\/\+\-])+)*@(?:(?:\[?(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))\.){3}(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\]?)|(?:[a-zA-Z0-9-]+\.)+(?:[a-zA-Z]){2,}\.?)/", $_POST['email']))
          {
              // An invalid email address was filled in.
              $error[] = "You need to enter a valid email address.";
          }
         
          // We need to determine the recipient of the message
          if(isset($_POST['to_admin']))
          {
              // Even if the to field was given a different email address, this would over-ride that address and be sent to admin.
              $to_admin = true;
              $to = false;
          }
          elseif(preg_match("/(?:[a-zA-Z0-9_\'\^\&\/\+\-])+(?:\.(?:[a-zA-Z0-9_\'\^\&\/\+\-])+)*@(?:(?:\[?(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))\.){3}(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\]?)|(?:[a-zA-Z0-9-]+\.)+(?:[a-zA-Z]){2,}\.?)/", $_POST['to']))
          {
              // If the process reaches here, then the message would be sent to the address put in the to field
              $to_admin = false;
              $to = $_POST['to'];
          }
          else
          {
              // There was an error... it's not sent to the admin OR to anyone...
              $error[] = "You need a valid recipient's (to) email address.";
          }
         
          // Now we need to validate the subject of the message
          if(strlen($_POST['subject']) < 5)
          {
              // The message is under 5 characters.
              $error[] = "The subject needs to be greater then 5 characters";
          }
         
          // Validating the actuall message
          if(strlen($_POST['message']) < 5)
          {
              $error[] = "The message needs to be greater then 5 characters";
          }
         
          // Counting the number of errors there was in the form submittion
          if(count($error) > 0)
          {
              // There were errors... we can't send a message with errors in the form submittion.
             
              // Looping through each error and providing a good list of errors for the user.
              $errors = "<ol>";
              foreach($error as $er)
              {
                  $errors .= "<li>{$er}</li>\n";
              }
              $errors .= "</ol>";
             
              echo $errors;
          }
          else
          {
              // There were no errors, lets submit the actual message
              if(new smtp_mail($to, $_POST['subject'], $_POST['message'], $to_admin))
              {
                  echo "The mail was sent successfully.";
              }
              else
              {
                  echo "There was a problem sending the message.";
              }
          }
      }
      ?>
      1. <?php
      2. // Checking if the form was really submitted
      3. if(isset($_POST['submit']))
      4. {
      5.     // We need to initiate the error array
      6.     $error = array();
      7.    
      8.     // Here we are checking if their name was filled in.
      9.     if(empty($_POST['name']))
      10.     {
      11.         // The name field was left empty
      12.         $error[] = "You need to enter a valid name.";
      13.     }
      14.    
      15.     // Checking if a valid email address was filled in.
      16.     if(!preg_match("/(?:[a-zA-Z0-9_\'\^\&\/\+\-])+(?:\.(?:[a-zA-Z0-9_\'\^\&\/\+\-])+)*@(?:(?:\[?(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))\.){3}(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\]?)|(?:[a-zA-Z0-9-]+\.)+(?:[a-zA-Z]){2,}\.?)/", $_POST['email']))
      17.     {
      18.         // An invalid email address was filled in.
      19.         $error[] = "You need to enter a valid email address.";
      20.     }
      21.    
      22.     // We need to determine the recipient of the message
      23.     if(isset($_POST['to_admin']))
      24.     {
      25.         // Even if the to field was given a different email address, this would over-ride that address and be sent to admin.
      26.         $to_admin = true;
      27.         $to = false;
      28.     }
      29.     elseif(preg_match("/(?:[a-zA-Z0-9_\'\^\&\/\+\-])+(?:\.(?:[a-zA-Z0-9_\'\^\&\/\+\-])+)*@(?:(?:\[?(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))\.){3}(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\]?)|(?:[a-zA-Z0-9-]+\.)+(?:[a-zA-Z]){2,}\.?)/", $_POST['to']))
      30.     {
      31.         // If the process reaches here, then the message would be sent to the address put in the to field
      32.         $to_admin = false;
      33.         $to = $_POST['to'];
      34.     }
      35.     else
      36.     {
      37.         // There was an error... it's not sent to the admin OR to anyone...
      38.         $error[] = "You need a valid recipient's (to) email address.";
      39.     }
      40.    
      41.     // Now we need to validate the subject of the message
      42.     if(strlen($_POST['subject']) < 5)
      43.     {
      44.         // The message is under 5 characters.
      45.         $error[] = "The subject needs to be greater then 5 characters";
      46.     }
      47.    
      48.     // Validating the actuall message
      49.     if(strlen($_POST['message']) < 5)
      50.     {
      51.         $error[] = "The message needs to be greater then 5 characters";
      52.     }
      53.    
      54.     // Counting the number of errors there was in the form submittion
      55.     if(count($error) > 0)
      56.     {
      57.         // There were errors... we can't send a message with errors in the form submittion.
      58.        
      59.         // Looping through each error and providing a good list of errors for the user.
      60.         $errors = "<ol>";
      61.         foreach($error as $er)
      62.         {
      63.             $errors .= "<li>{$er}</li>\n";
      64.         }
      65.         $errors .= "</ol>";
      66.        
      67.         echo $errors;
      68.     }
      69.     else
      70.     {
      71.         // There were no errors, lets submit the actual message
      72.         if(new smtp_mail($to, $_POST['subject'], $_POST['message'], $to_admin))
      73.         {
      74.             echo "The mail was sent successfully.";
      75.         }
      76.         else
      77.         {
      78.             echo "There was a problem sending the message.";
      79.         }
      80.     }
      81. }
      82. ?>


      5. 2 La fonction Magic


      Ce n'est pas nécessaire, mais c'est ce que j'utilise toujours si mal nous le suggérer ici.

      J'ai toujours utiliser la fonction Magic __autoload () pour charger les classes. Ce qui me sauve la ligne 1 à chaque fois que je veux utiliser une classe. De cette façon, je n'ai pas d'inclure le fichier PHP qui contient la classe...il __autoload () s.

      Pour qu'il fonctionne correctement, le fichier PHP a besoin d'être sauvé de la même façon que la classe est nommé...dans ce cas, le nom de classe est smtp_mail et son enregistré en tant que smtp_mail.php. Voici donc cette fonction.
      PHP Code: [ Select ]
      function __autoload($class_name) {
          if(file_exists('includes/' . $class_name . '.php'))
          {
              require_once 'includes/' . $class_name . '.php';
          }
      }
      1. function __autoload($class_name) {
      2.     if(file_exists('includes/' . $class_name . '.php'))
      3.     {
      4.         require_once 'includes/' . $class_name . '.php';
      5.     }
      6. }

      Ce que j'ai cette fonction faire est de vérifier si cette page existe dans le includes / répertoire...cela signifie, que lorsque je démarre cette classe il va essayer de [/ b] comprend smtp_mail.php / [/ b].

      Cela signifie que la structure du répertoire devrait ressembler à ce qui suit:
      • includes / smtp_mail.php
      • contact.html
      • contact.php

      Une autre chose que je recommanderais de faire est d'avoir une page globale qui serait inclus dans chaque page de tous les temps. Jetez un oeil à ce tutoriel pour mieux comprendre ce que Im parle ici.

      Dans ce fichier de configuration, vous mettez cette fonction magique. Si cette astuce consiste à entrer en jeu ici, alors la structure de répertoire est modifié:

      • includes / smtp_mail.php
      • includes / config.php
      • contact.html
      • contact. php

      Donc, si vous regardez la ligne où il comprendrait la classe smtp_mail (en contact.php):
      PHP Code: [ Select ]
              if(new smtp_mail($to, $_POST['subject'], $_POST['message'], $to_admin))

      Vous voyez que ses instancier un nouvel objet "smtp_mail" sans moi y compris smtp_mail.php. Lorsque l'analyseur PHP arrive à cette ligne, il tenterait d'inclure includes / smtp_mail.php être en mesure d'instancier l'objet. C'est la beauté des fonctions magiques.

      Si vous ne souhaitez pas utiliser la fonction magique, il suffit d'inclure smtp_mail. php dans contact.php. N'oubliez pas d'inclure le droit smtp_mail.php avant la ligne qui utilise cette fonction. (Le droit bloc de code PHP ci-dessus présente).
      PHP Code: [ Select ]
      include_once 'includes/smtp_mail.php';


      6.0 Conclusion


      Il est (dans la plupart des cas) une valeur inestimable d'avoir un moyen d'envoyer des messages e-mail à vos utilisateurs, que ce soit pour les bulletins ou tout simplement mises à jour ou que vous ayez besoin d'envoyer un message pour, vous avez maintenant obtenu une manière assez avancée de l'envoi de messages en utilisant un SMTP serveur.
"Bring forth therefore fruits meet for repentance:" Matthew 3:8
  • Anonymous
  • Bot
  • No Avatar
  • Inscription: 25 Feb 2008
  • Messages: ?
  • Loc: Ozzuland
  • Status: Online

Message Septembre 27th, 2010, 11:45 pm

  • Bogey
  • Bogey
  • Genius
  • Avatar de l’utilisateur
  • Inscription: Juil 14, 2005
  • Messages: 8212
  • Loc: USA
  • Status: Offline

Message Novembre 17th, 2010, 1:06 pm

Je viens de trouver où je l'ai eu à partir de...

phpclasses.org page de classe
"Bring forth therefore fruits meet for repentance:" Matthew 3:8
  • Mark709
  • Novice
  • Novice
  • No Avatar
  • Inscription: Sep 30, 2010
  • Messages: 22
  • Status: Offline

Message Janvier 27th, 2011, 8:35 pm

Faut dire cet article est merveilleux - malheureusement, je ne suis qu'un débutant encore je peux voir que si je l'étudie beaucoup d'avantages viendront à moi - et je vous remercie pour vos efforts et il annonce pour nous tous.
  • spork
  • Brewmaster
  • Silver Member
  • Avatar de l’utilisateur
  • Inscription: Sep 22, 2003
  • Messages: 6134
  • Loc: Seattle, WA
  • Status: Offline

Message Janvier 28th, 2011, 10:53 am

Je ne pense pas que vous comprenez bien le but de les constructeurs et destructeurs dans ce tutoriel. Les constructeurs sont appelés à chaque fois qu'un nouvel objet est créé, leur but est d'initialiser les membres de données et mettre en place l'objet à être utilisé par l'appelant. Ne devriez-vous retourner quelque chose d'un constructeur, la nature de la fonction est de retourner l'objet créé.

L'autre problème est que vous utilisez la création d'objet comme un appel de méthode, alors qu'en réalité, vous devriez être bien la construction de l'objet et le puis permettant à l'appelant à prendre des mesures avec lui. Invoquant l'e-mail () au moment de l'instanciation fonctionnalité n'est pas juste, je devrais être en mesure de créer un objet smtp_mail puis choisissez quand le courrier est envoyé.

Le but d'un destructeur n'est pas à prendre des mesures "au cas où la classe est à l'arrêt»; classes ne peuvent pas «arrêt» ou «aller» (threads et processus peuvent, mais thats un autre sujet). Le but du destructeur est à nettoyer après l'objet quand il est soit directement supprimé ou est hors de portée (ou dans le cas des langues gérées, quand il fait garbage collector).

Je vois aussi des bouts de code HTML et les appels aux fonctions de sortie différents jonché toute la classe, qui associe étroitement la classe à n'importe quelle application l'utilisateur prévoit de l'utiliser en Il serait préférable de permettre à l'utilisateur de lire / mettre à jour des résultats via des accesseurs et des mutateurs telles que l'application utilisant cette classe peut sortir les données comme bon lui semble.

Pour cette classe pour être utile dans une application, il doit être conforme à une interface qui me permettrait de l'utiliser comme ceci:

PHP Code: [ Select ]
<?php
 
$myMailer = new SmtpMailer(new SmtpMailerCredentials(...));
 
// a class such as SmtpMailerCredentials could help
// organize and decouple the non-essential aspects of
// the mail from the mailer class
 
// don't assume only one recipient
$myMailer->addToAddress("someone@domain.com");
$myMailer->addToAddress("someoneelse@domain.com");
 
// ...and don't assume everyone will be on the "to" line!
$myMailer->addCcAddress("athirdperson@domain.com");
 
$myMailer->setSubject("This is a test message");
$myMailer->setBody("This is the body of the message.");
 
// do some other stuff. perhaps add this mailer
// object to a queue of mail to be sent, or do
// whatever else I need to do before the email goes out
 
// now I choose exactly when to send the mail
$mailer->send();
 
?<
  1. <?php
  2.  
  3. $myMailer = new SmtpMailer(new SmtpMailerCredentials(...));
  4.  
  5. // a class such as SmtpMailerCredentials could help
  6. // organize and decouple the non-essential aspects of
  7. // the mail from the mailer class
  8.  
  9. // don't assume only one recipient
  10. $myMailer->addToAddress("someone@domain.com");
  11. $myMailer->addToAddress("someoneelse@domain.com");
  12.  
  13. // ...and don't assume everyone will be on the "to" line!
  14. $myMailer->addCcAddress("athirdperson@domain.com");
  15.  
  16. $myMailer->setSubject("This is a test message");
  17. $myMailer->setBody("This is the body of the message.");
  18.  
  19. // do some other stuff. perhaps add this mailer
  20. // object to a queue of mail to be sent, or do
  21. // whatever else I need to do before the email goes out
  22.  
  23. // now I choose exactly when to send the mail
  24. $mailer->send();
  25.  
  26. ?<
The Beer Monocle. Classy.
  • Bogey
  • Bogey
  • Genius
  • Avatar de l’utilisateur
  • Inscription: Juil 14, 2005
  • Messages: 8212
  • Loc: USA
  • Status: Offline

Message Janvier 28th, 2011, 9:22 pm

Merci pour le Spork avis. Je m'en souviens création de la classe à partir d'un fouillis de code écrit comme une fonction (que je pourrais avoir tort cette classe pour une autre). Je l'ai trouvé dans mon répertoire de dépôt de classe sur mon ordinateur et depuis il fonctionne parfaitement pour moi (je ne peux que faire des cours débutants de travail :lol: Je ne suis pas tellement avancé gif "title =":(" alt =" Sad "> ) Alors j'ai décidé de faire une promenade à travers-tutoriel.

Ill le corriger dès que de se conformer à votre interface proposée et la modification de certaines portions de code pour corriger les problèmes que vous avez publiés. Merci pour le heads up.
"Bring forth therefore fruits meet for repentance:" Matthew 3:8
  • pagebot
  • Novice
  • Novice
  • No Avatar
  • Inscription: Nov 17, 2010
  • Messages: 16
  • Loc: USA
  • Status: Offline

Message Avril 13th, 2011, 6:19 pm

Très beau tutoriel, je peux envoyer des pièces jointes de cette manière et comment puis-je bloquer certaines extensions? Merci
  • Mark709
  • Novice
  • Novice
  • No Avatar
  • Inscription: Sep 30, 2010
  • Messages: 22
  • Status: Offline

Message Avril 17th, 2011, 7:59 pm

Révision de cet article de Bogey me fait encore réaliser à quel point nous sommes chanceux d'avoir comme membres Bogey et Spork et d'autres (sans nom) qui s'intéressent assez d'autres à écrire un tel bien - article CONSTRUITS et clair.

Si vous avez le temps pourrait également envisager de vous - y compris - la façon d'utiliser le code ci-dessus et INSERT - une capacité à exécuter ce que
1. une tâche cron
2. d'envoyer une e-mail toutes les 10 secondes
et / ou (ce qui n'est jamais le moindre - important en tant que serveur doit passer d'un hôte à un autre Co)
3. un maximum de...e-mails par heure

RAISON - il ya beaucoup, beaucoup d'utilisateurs qui sont en permanence à des problèmes autour de ces 3 éléments et que je n'ai pas encore vu une telle explication claire de la manière de contourner les problèmes que beaucoup se plaignent de leurs arrêts cron (à dire 500 e-mails dans le premier heure) pour dire que leur travail consiste à envoyer des emails 5000 - leur sort est de savoir comment relancer sans faire / envoyer les 500 premiers e-mails une deuxième fois.

Apprécierait vos idées sur la façon de résoudre ce genre de questions et je vous remercie beaucoup pour les explications du segment CHAQUE - vous êtes un grand professeur et un exemple pour nous "newbies"

Page 1 sur 1

Afficher de l'information

  • Total des messages de ce sujet: 8 messages
  • Modérateur: Tutorial Writers
  • Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 3 invités
  • Vous ne pouvez pas poster de nouveaux sujets
  • Vous ne pouvez pas répondre aux sujets
  • Vous ne pouvez pas éditer vos messages
  • Vous ne pouvez pas supprimer vos messages
  • Vous ne pouvez pas joindre des fichiers
 
 

© 2011 Unmelted, LLC. Ozzu® est une marque déposée de Unmelted, LLC