[Parte 6] Web Scraping

Scraping con expresiones regulares

Expresiones regulares: una introduccion rapida

Expresiones regulares o regex son la navaja suiza del procesamiento de texto y son una parte importante del web scraping. Una vez que se sienta comodo con simplehtmldom es cuando puede embarcarse al uso de las expresiones regulares en sus proyectos de scraping. Este es un tema complejo y se supone que tiene un conocimiento rudimentario de ello. No lo cubrimos en detalle aqui, pero puede ver mas acerca de ello aqui: http://arthusu.blogspot.mx/2013/07/phpexpresiones-regulares-pcre.html
Una rapida vision general de las expresiones regulares sin embargo se presenta en este capitulo.

Las expresiones regulares son una herramienta increiblemente poderosa disponible en la mayoria de los lenguajes de programacion de hoy. Piense en expresiones regulares como un sofisticado sistema que coincide con un patron de texto. Se especifica un patron y luego usa las funciones incorporadas de PHP para aplicar el patron en una cadena de texto para ver si coinciden. PHP es compatible con dos tipos de normas de expresiones regulares,POSIX Extended and Perl-Compatible (PCRE). PCRE es actualmente el tipo preferido para utilizar con
PHP, tiende a ser mas rapido que la opcion POSIX, y utiliza la misma sintaxis de expresiones regulares que PERL. Puede identificar facilmente estas funciones ya que comienzan con el prefijo preg. Ejemplos de funciones de expresiones regulares PCRE en PHP son preg_replace(), preg_split(), preg_match(), y preg_match_all(). Vamos a describir solo las expresiones regulares PCRE en esta parte, y por simplicidad, tambien vamos a limitar nuestra discusion a las funciones mas utilizadas dentro de PHP. Echemos un vistazo a la coincidencia de cadenas en PHP primero. La funcion de PHP a utilizar para expresiones regulares es preg_match(). Considere la cadena:


"las ideas verdes incoloras duermen furiosamente"

Vamos a utilizar la cadena anterior para hacer coincidir con patrones. Aqui esta el primer ejemplo:

$string = "las ideas verdes incoloras duermen furiosamente";
echo preg_match('/verdes/', $string) ; // retorna 1

Aqui estamos buscando el patron 'verdes' en cualquier lugar dentro de la cadena proporcionada. Cada vez que usted este buscando una cierta cadena o patron dentro de una cadena dada, hay que delimitar primero el patron. En general, usted hace esto con el caracter de barra diagonal (/), pero se puede utilizar cualquier otro caracter no alfanumerico. Por lo tanto si usted esta buscando un patron que concuerde con 'verdes' podria configurarlo con /verdes/ o #verdes#, siempre y cuando usted utilice los mismos caracteres en ambos extremos del patron y que no esta entre la cadena patron que esta buscando. Por ejemplo, los siguientes son equivalentes:

preg_match('/Hola/', 'Hola Mundo!'); // devuelve 1
preg_match('#Hola#', 'Hola Mundo!'); // devuelve 1

El formato general de la funcion preg_match() es la siguiente.

int preg_match ( string $pattern , string $subject [, array &$matches [, int $flags = 0 [, int $offset = 0 ]]] )
 
Podriamos haber logrado lo anterior con alguna de las funciones de cadena mas basicas que PHP proporciona, pero la funcion preg_match() tambien viene con algunos cuantificadores en el patron que aumentan el poder de las expresiones regulares, unos pocos seleccionados se muestran a continuacion.

Cuantificadores de patron

^ prueba para el patron al inicio de la cadena
$ prueba para el patron al final de la cadena
. coincide con cualquier caracter (comodin)
\ caracter de escape, se utiliza en la busqueda de otros cuantificadores como cadenas literales
[] rango de caracteres validos: [0-6] significa "entre e incluyendo 0-6"
{} Cuantos caracteres estan permitidos dentro de la regla del patron previamente definido

Con estos cuantificadores, podemos ser mucho mas especificos en lo que estamos buscando y donde lo estamos buscando para ello. He aqui algunos ejemplos:


echo preg_match('/^verdes/', $string) ; // devuelve 0
echo preg_match('/^las ideas/', $string) ; // devuelve 1
echo preg_match('/^duermen/', $string) ; // devuelve 0
echo preg_match('/furiosamente$/', $string) ; // devuelve 1
echo preg_match('/verd.s/', $string) ; // devuelve 1

Si $matches es proporcionado, entonces se llena con resultados de la busqueda. $matches[0] contendra el texto que coincidio con el patron completo, $matches[1] tendra el texto que coincidio con el primer sub patron con parentesis capturado, y asi sucesivamente. Vamos a trabajar a traves de un ejemplo completo a continuacion.

Obteniendo la codificacion de caracteres de una pagina web

Cada pagina web tiene una codificacion especial para seleccionar que rangos de caracteres se muestran por el navegador. Hay varias maneras de especificar que codificacion de caracteres seran usadas en el documento. En primer lugar, el servidor web puede incluir la codificacion de caracteres o 'charset' en el protocolo de transferencia de hipertexto (HTTP) en la cabecera Content-Type, que normalmente tiene el siguiente aspecto:

Content-Type: text/html; charset=ISO-8859-1

Para HTML, es posible incluir esta informacion en el interior del elemento head, cerca de la parte superior del documento:

<meta http-equiv="Content-Type" content="text/html; charset=utf-8">

En el siguiente ejemplo breve obtendra la codificacion de caracteres para una pagina web en particular. Vamos a usar las  funciones PHP regex para buscar el contenido requerido. Aqui estamos mirando para el atributo 'charset' que incluye la informacion de codificacion.

<?php
/* Obtenemos el contenido del sitio */
$html = file_get_contents('http://www.microsoft.com/');
// Buscamos el charset en el atributo meta
preg_match('/charset\=.*?(\'|\"|\s)/i', $html, $matches);
//Reemplazamos lo que no necesitamos a vacio
$matches = preg_replace('/(charset|\=|\'|\"|\s)/', '', $matches[0]);
echo strtoupper($matches);
?>

La parte importante del codigo es la expresion regular para buscar el patron 'charset'.

'/charset\=.*?(\'|\"|\s)/i' 

La funcion preg_match se utiliza para encontrar la primera cadena que coincide para el patron anterior. Una vez que se encuentra, la funcion preg_replace solo mantiene el codigo del charset real y devuelve eso. Usted puede haber notado el caracter 'i' en la expresion regular despues del delimitador de cierre. Esto indica que la coincidencia debe ser case insensitive (insensible a mayusculas y minusculas). La funcion preg_match() solo coincide con la primera ocurrencia (coincidencia) encontrada y luego se detiene. La funcion preg_match_all() coincide sin embargo en varias ocasiones hasta que la ultima ocurrencia termina, hasta que no haya mas ocurrencias que encontrar. preg_match_all() funciona exactamente igual que preg_match(); sin embargo, la matriz resultante es multidimensional. Cada entrada de esta matriz es un arreglo de ocurrencias, ya que habria sido devuelta por preg_match().

Agarrando imagenes de una pagina web

Tomemos otro ejemplo. Una de las tareas comunes en web scraping es agarrar las imagenes de una pagina web. Esto se puede lograr facilmente usando el poder de la expresion regular. El siguiente codigo le permite obtener una lista de todas las imagenes de una pagina web junto con sus atributos - como src, height, width, alt etc. Para este ejemplo vamos a separar la parte de la expresion regular desde el script principal como es un poco largo y seria mejor si lo hacemos como una funcion. Llamamos a esta funcion 'parseTag'. La funcion 'parseTag' tambien extrae los atributos de la etiqueta de la imagen. La funcion completa es la siguiente.

function parseTag($tag, $content)
{
$regex = "/<{$tag}\s+([^>]+)>/i";
preg_match_all($regex, $content, $matches);
$raw = array();
//Nosotros tambien queremos los atributos de la etiqueta
foreach($matches[1] as $str)
{
$regex = '/([a-z]([a-z0-9]*)?)=("|\')(.*?)("|\')/is';
preg_match_all($regex, $str, $pairs);
if(count($pairs[1]) > 0) {
$raw[] = array_combine($pairs[1],$pairs[4]);
}
}
return $raw;
}

El trabajo pesado del codigo anterior es la funcion preg_match_all(), que toma todas las etiquetas epecificadas en el parametro de una pagina web. A continuacion se muestra el codigo completo para agarrar los enlaces de la imagen de nuestra template usando la funcion 'parseTag'. Hemos utilizado cURL abajo, pero tambien podriamos utilizar file_get_html(). Ambas versiones se muestran aqui.

<?php
/* version cURL */
$url = 'http://localhost/scrape/template/index.html';
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_TIMEOUT, 6);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$html = curl_exec($ch);
/* Esto grabara todos los datos de la etiqueta <img> */
$links = parseTag('img', $html);
print_r($links);
?>

La version file_get_html() se muestra a continuacion. Como se puede ver, es mas concisa que la version cURL. 
 
<?php
/* version file_get_html  */
$url = 'http://localhost/scrape/template/index.html';
$html = file_get_html($url);
/* Esto grabara todos los datos de la etiqueta <img> */
$links = parseTag('img', $html);
print_r($links);
?>

Esto devolvera la siguiente matriz. Tenga en cuenta los atributos adicionales devueltos incluyendo los nombres de las clases de las imagenes. Esto puede ser util cuando solo se necesita encontrar imagenes con un nombre de clase determinada o etiqueta alt.

Array
(
[0] => Array
(
[src] => images/flower1.jpg
[class] => imageb
[alt] => flower 1
)
[1] => Array
(
[src] => images/flower2.jpg
[class] => imageb
[alt] => flower 2
)
[2] => Array
(
[src] => images/flower3.jpg
[class] => imageb
[alt] => flower 3
)
)

Tambien puede imprimir el atributo src de cada imagen dentro de un bucle for.

foreach($links as $link) {
echo $link['src'] . '<br>';
}

Como se puede ver las expresiones regulares junto a simplehtmldom pueden ayudar a raspar cualquier contenido web que usted desee. Por supuesto, las expresiones regulares son mas complejas que el uso de una libreria como simplehtmldom, pero ofrecen mas flexibilidad y potencia si se utiliza correctamente. Pero el principal inconveniente es la curva de aprendizaje que exige. Si se diseña incorrectamente las expresiones regulares puede ser una fuente de errores sutiles. Por estas razones, prefiero usar simplehtmldom siempre que sea posible y solo recurrir a expresiones regulares en casos raros.

[Parte 5] CURL en PHP

Funciones interesantes

curl_multi_init

Una de las extensiones mas usadas en PHP es cURL, y es genial para devolver documentos remotos. Para situaciones donde necesitas devolver multiples documentos se usa curl_multi_init y curl_multi_exec trabajan mejor con multiples documentos.

La funcion curl_multi_exec es muy poderosa, pero en la documentacion de PHP la hacen ver mas dificil de lo que realmente es. Aqui una demostracion usando Google, Bing y Facebook todos devueltos:

 $urls = array('http://www.google.com/', 'http://www.facebook.com/', 'http://www.bing.com/');
$url_count = count($urls); // cuenta el numero de urls

$curl_array = array(); // creamos un array llamado curl_array
$ch = curl_multi_init(); // iniciamos un multirecurso curl
// para las urls hay una clave que contiene su url
foreach($urls as $count => $url) {

 $curl_array[$count] = curl_init($url); // establecemos la url en una sesion curl refiriendonos a cada 1 con su clave
 curl_setopt($curl_array[$count], CURLOPT_FOLLOWLOCATION, 1); // le damos una opcion de seguir el header location
 curl_setopt($curl_array[$count], CURLOPT_RETURNTRANSFER, 1); // devolvemos el contenido
 curl_multi_add_handle($ch, $curl_array[$count]); // añadimos a cada url con sus opciones en el multirecurso
}
// mientras se esten ejecutando las urls realiza lo siguiente
do {
 curl_multi_exec($ch, $exec);
} while($exec > 0);

En este ejemplo hay 3 urls establecidas para devolverse al mismo tiempo. 

curl_multi_getcontent

Para leer el contenido de las peticiones que hicimos anteriormente podriamos usar la funcion curl_multi_getcontent. Vamos a ver como podemos hacerlo... (el codigo siguiente se puede añadir al anterior):

 //para cada url devolvemos el contenido junto con la url

foreach($urls as $count => $url) {
 $returned = curl_multi_getcontent($curl_array[$count]);
 echo "$url - $returned";
}

Cerrar el manejador de cURL

Algunos programadores prefieren usar curl_close() despues de haberlo usado. Usted en lugar de utilizar curl_close() deberia utilizar curl_multi_close(), y curl_multi_remove_handle() despues de que el contenido se haya devuelto. Veamos un ejemplo:

//para cada url eliminamos el manejador, cerramos la peticion multi recurso y cada peticion de una sesion curl la cerramos 

foreach($urls as $count => $url) {
 curl_multi_remove_handle($ch, $curl_array[$count]);
}

curl_multi_close($ch); 

foreach($urls as $count => $url) {
 curl_close($curl_array[$count]);
}

Como anteriormente dijimos el codigo anterior puede añadirse a lo que habiamos puesto antes... de esta manera todo el codigo quedaria asi:

 <?php
$urls = array('http://www.google.com/', 'http://www.facebook.com/', 'http://www.bing.com/');
$url_count = count($urls);

$curl_array = array();
$ch = curl_multi_init();

foreach($urls as $count => $url) {
 $curl_array[$count] = curl_init($url);
 curl_setopt($curl_array[$count], CURLOPT_FOLLOWLOCATION, 1);
 curl_setopt($curl_array[$count], CURLOPT_RETURNTRANSFER, 1);
 curl_multi_add_handle($ch, $curl_array[$count]);
}

do {
 curl_multi_exec($ch, $exec);
} while($exec > 0);
foreach($urls as $count => $url) {
 $returned = curl_multi_getcontent($curl_array[$count]);
 echo "$url - $returned";
}
foreach($urls as $count => $url) {
 curl_multi_remove_handle($ch, $curl_array[$count]);
}

curl_multi_close($ch); 

foreach($urls as $count => $url) {
 curl_close($curl_array[$count]);
}
?>

Fuente: http://www.fusionswift.com/2011/08/php-curl_multi_exec-example/

curl_setopt_array()

Con esta funcion podemos configurar multiples opciones para una transferencia cURL. Veamos un ejemplo:

 <?php
 // creamos un nuevo recurso curl
 $ch = curl_init();
 // establecemos las opciones apropiadas para la url
 $options = array(
  CURLOPT_URL => 'http://www.google.com/',
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_USERAGENT => 'Googlebot/2.1 (+http://www.google.com/bot.html)',
  CURLOPT_RETURNTRANSFER => true
  );
 curl_setopt_array($ch, $options);
 $output = curl_exec($ch);
 curl_close($ch);
 echo $output;
?>

curl_getinfo()

Esta funcion obtiene informacion relativa a una transferencia especifica. Los valores que devuelve son los siguientes:

• "url"

• "content_type"

• "http_code"

• "header_size"

• "request_size"

• "filetime"

• "ssl_verify_result"

• "redirect_count"

• "total_time"

• "namelookup_time"

• "connect_time"

• "pretransfer_time"

• "size_upload"

• "size_download"

• "speed_download"

• "speed_upload"

• "download_content_length"

• "upload_content_length"

• "starttransfer_time"

• "redirect_time"

• "certinfo"

• "request_header" 

curl_version()

Obtiene la informacion de la version de cURL

cURL File

Como veíamos en la parte 4 de curl, subiamos un archivo con el uso de @, pero apartir de PHP 5.5.0 ese prefijo esta obsoleto, por lo que se recomienda utilizar esta funcion.

CURLFile::__Construct--curl_file_create - Crea un objeto CURLFile

Estilo orientado a objetos:

public CURLFile::__construct ( string $filename [, string $mimetype [, string $postname ]] )

Estilo orientado a procedimientos:

CURLFile curl_file_create ( string $filename [, string $mimetype [, string $postname ]] )

Crea un objeto CurlFile, utilizado para transferir (upload) un fichero con CURLOPT_POSTFIELDS.

filename - indica la ruta de acceso al fichero a ser transferido
mimetype - Tipo mime del fichero
postname - nombre del fichero

Ejemplo, estilo orientado a objetos:

 <?php
/* http://example.com/upload.php:
<?php var_dump($_FILES); ?>
*/

// Crea un gestor cURL
$ch = curl_init('http://example.com/upload.php');

// Crea un objeto CURLFile
$cfile = new CURLFile('cats.jpg','image/jpeg','test_name');

// Asigna los datos POST 
$data = array('test_file' => $cfile);
curl_setopt($ch, CURLOPT_POST,1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);

// Ejecuta el gestor
curl_exec($ch);
?>

Estilo por procedimientos:

 <?php
/* http://example.com/upload.php:
<?php var_dump($_FILES); ?>
*/

// Crea un gestor cURL
$ch = curl_init('http://example.com/upload.php');

// Crea un objeto CURLFile
$cfile = curl_file_create('cats.jpg','image/jpeg','test_name');

// Asigna los datos POST
$data = array('test_file' => $cfile);
curl_setopt($ch, CURLOPT_POST,1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);

// Ejecuta el gestor
curl_exec($ch);
?>

Usar cURL con Expresiones regulares

Como en ejemplos anteriores usabamos la funcion preg_match y preg_match_all para ver si se encontraba determinado texto o link para poder mostrar el resultado que necesitabamos, para mas informacion sobre expresiones regulares por favor consulte:
http://www.arthusu.com.mx/2013/07/phpexpresiones-regulares-pcre.html

Como en el ejemplo de subidas de archivos en la parte 4  de curl, veíamos un upload con el cual sacábamos los links usando expresiones regulares:

 <?php
   set_time_limit(0);
   $url = "http://www0.xup.in/exec/xupload.php?uid=&key=";
   $user_agent = "Mozilla/5.0 (Windows NT 6.1; rv:28.0) Gecko/20100101 Firefox/28.0";
   $referer = "http://www.xup.in/";
   $directory=dirname(__FILE__).'\files/';
   if(isset($_FILES['f1'])){
      move_uploaded_file($_FILES['f1']['tmp_name'],"files/".$_FILES['f1']['name']);
      $ch = curl_init();
      curl_setopt($ch, CURLOPT_USERAGENT, $user_agent);
      curl_setopt($ch, CURLOPT_REFERER, $referer);
      curl_setopt($ch, CURLOPT_URL, $url);
      curl_setopt($ch, CURLOPT_POSTFIELDS, array("F1"=>"@".$directory.$_FILES['f1']['name']));
      curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
      curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
      $result = curl_exec($ch);
      if(curl_errno($ch))
  {
      echo 'Curl error: ' . curl_error($ch);
  }
      curl_close($ch);
      unlink($directory.$_FILES['f1']['name']);
      //echo $result;
      preg_match_all('/<input type="text" name="t1" size="90" class="inp" value="(.*?)" onclick="highlight\(this\);" \/>/', $result, $matches);
      //echo '<p><img src="'.$matches[1][0].'" alt="img" /></p>';
      echo '<p><b>Link: <a href="'.$matches[1][0].'" target="_blank">Archive Link</a></p>';
      //print_r($matches);
   }else{
      echo '
         <form action="upload_curl.php" method="post" enctype="multipart/form-data">
            <label for="f1">Filename:</label>
            <input type="file" name="f1" id="f1"><br>
            <input type="submit" name="submit" value="Submit">
         </form>

      ';   
   }
?>

 

[PHP]Expresiones regulares PCRE

Que es una expresión regular

Una expresión regular, a menudo llamada también patrón, es una expresión que describe un conjunto de cadenas sin enumerar sus elementos. Por ejemplo, el grupo formado por las cadenas Handel, Händel y Haendel se describe mediante el patrón "H(a|ä|ae)ndel". La mayoría de las formalizaciones proporcionan los siguientes constructores: una expresión regular es una forma de representar a los lenguajes regulares (finitos o infinitos) y se construye utilizando caracteres del alfabeto sobre el cual se define el lenguaje.
En informática, las expresiones regulares proveen una manera muy flexible de buscar o reconocer cadenas de texto.

¿Por que PCRE?

Perl Compatible Regular Expressions (PCRE, Expresiones Regulares Compatibles con Perl en español) es una librería de C de expresiones regulares inspirada por Perl, fue escrita por Philip Hazel. La sintaxis de PCRE es mucho más poderosa y flexible que cualquier variante de expresiones regulares provistas por POSIX y otras muchas clásicas librerías de expresiones regulares. El nombre es un poco inexacto, debido al hecho de que PCRE y Perl tienen capacidades que no comparten entre ambos.

 Funciones que son utilizadas en PCRE

• preg_filter — Realiza una búsqueda y sustitución de una expresión regular
• preg_grep — Devuelve entradas de matriz que coinciden con el patrón
• preg_last_error — Devuelve el código de error de la última ejecución de expresión regular PCRE
• preg_match_all — Realiza una comparación global de una expresión regular
• preg_match — Realiza una comparación con una expresión regular
• preg_quote — Escapar caracteres en una expresión regular
• preg_replace_callback — Realiza una búsqueda y sustitución de una expresión regular usando una llamada de retorno
• preg_replace — Realiza una búsqueda y sustitución de una expresión regular
• preg_split — Divide una cadena mediante una expresión regular

 Sintaxis para un patrón


Delimitadores:

Los delimitadores como su nombre lo dicen lo que hacen es delimitar el patrón, es decir, lo encapsulan, de esta manera después de tal delimitador es posible usar modificadores que veremos mas adelante, los delimitadores mas comunes son estos dos: / y #

/aquivaelpatron/
#aquivaelpatron#

Si en el patrón se encuentra un delimitador hay que escaparlo usando \

Meta-Caracteres

Son caracteres que son interpretados de manera especial en un patron.
Los meta-caracteres son:

\ - Caracter de escape
^ - Inicio de la cadena
$ - Final de una cadena
. - Coincide con cualquier carácter excepto nueva linea
[ - Inicio de declaracion de la clase caracter
| - Inicio de la rama alternativa es como un OR
( - Inicio de un sub-patron
) - Final de un sub-patron
? - Cuantificador 0 o 1
* - Cuantificador 0 o mas
+ - Cuantificador 1 o mas
{ - Inicio de cuantificador min/max

Dentro de los corchetes o inicio de la clase caracter algunos meta-caracteres pueden ser interpretados de diferentes formas, como son estos:

\ - Caracter de escape general
- Define rango de caracteres
] - Finaliza la clase

Secuencias de escape

Con esto podemos hacer que caracteres que tienen un significado especial tomen su significado literal. Por ejemplo:

\* - seria igual a *

Otro uso que se les puede dar es poder codificar caracteres no imprimibles, por ejemplo:

\f - salto de pagina (0c hex)
\n - nueva linea (0a hex)
\r - retorno de carro (0d hex)
\t - tabulador (09 hex)

Otro uso que se les puede dar es para especificar tipos de caracteres genericos, por ejemplo:

\d - cualquier digito decimal
\D - cualquier caracter que no es un digito decimal
\s - cualquier caracter espacio en blanco
\S - cualquier caracter que no es un espacio en blanco
\w - cualquier caracter palabra
\W - cualquier caracter que no es palabra

Modificadores

Los modificadores son las opciones que puede tener un patron, por ejemplo:

i - puede contener mayusculas o minusculas
m - trata una cadena como una sola linea aunque contenga varias lineas
s - si se usa un metacaracter . y este modificador acepta todos los caracteres incluyendo nuevas lineas



Creando nuestros patrones

Ahora crearemos un par de patrones para validar algunas cosas que podrian ser importantes... para ello como las expresiones regulares son un poco confusas muchas veces usaremos http://gskinner.com/RegExr/ tambien existe una version para escritorio.
Esto nos hace mas fácil algunas cosas como ver expresiones regulares que ya están creadas por la comunidad, como crear nuestra expresión y ponerla a prueba viendo si coincide una palabra con el patrón. Veamos algunos ejemplos, antes quiero decirles que no todos son seguros es por eso que hay que hacerlos los mas seguros posibles, ahora veamos un ejemplo:

Ahora vemos la imagen de la izquierda
podemos ver como el patron es el sig:

\w+@\w+\.\w{2,4}

este patron indica lo siguiente:

puede contener cualquier palabra 1 o mas veces
luego un arroba
luego cualquier palabra 1 o mas veces
luego un punto . (gracias al caracter de escape)
luego cualquier palabra 2 veces como min 4 como maximo


Como podemos ver pusimos algunas palabras
las que estan en azul quiere decir que coinciden
es decir que son correctas o validas con el patron
anterior, entonces arthusu@gmail.com es el unico correcto, y los demas
patrones como arthusutest, arthusu@,arthusu@gmail.informacion,arthusu@gmail-com no coinciden segun el patron anterior es decir no son validos :D

como podemos ver le hemos agregado algunos modificadores aunque el unico que funcionaria en php seria el modificador i que es insensible a mayusculas o minusculas, ahora podriamos aplicar esto en un php, veamos un video de ejemplo:

Aqui les dejo un video de demostracion:

[JavaScript] Validar Email

Bueno esto se utiliza en javascript para no sobrecargar el servidor con tantas peticiones por lo cual lo creamos en javascript antes que nada les recomiendo leerse algo sobre expresiones regulares:

Expresiones Regulares W3Schools

Ahora les cito un pequeñó articulo: