El operador Like de VBA en Excel — coincidencia con comodines y la trampa de la cadena entera

TL;DR — text Like pattern devuelve un Boolean: ¿coincide la cadena entera con el patrón de comodines? Los comodines son * (cualquier serie de caracteres), ? (exactamente un carácter), # (exactamente un dígito), [abc] (un carácter de un conjunto) y [!abc] (un carácter que no está en el conjunto). Dos cosas muerden: Like coincide con la cadena entera, así que probar una subcadena necesita "*abc*", no "abc"; y su distinción de mayúsculas se fija en todo el módulo con Option Compare, sin una marca por llamada como la que tiene InStr.

Sub LikeBasics()
    Debug.Print "Excel"   Like "Ex*"        ' True  - empieza con "Ex"
    Debug.Print "Excel"   Like "*x*"        ' True  - contiene una "x"
    Debug.Print "Excel"   Like "?????"      ' True  - exactamente cinco caracteres
    Debug.Print "A-1234"  Like "[A-Z]-####" ' True  - letra, guion, cuatro digitos
    Debug.Print "cat"     Like "[!0-9]*"    ' True  - no empieza con un digito

    Debug.Print "Excel"   Like "x"          ' False - Like coincide con la cadena ENTERA
    Debug.Print "Excel"   Like "excel"      ' False - distingue mayusculas por defecto
End Sub

Lo que aprenderás

• El modelo mental — Like es una prueba de forma, no una búsqueda
• Cada uno de los cinco comodines y exactamente qué coincide con cada uno
• Por qué Like comprueba la cadena entera, así que una prueba de subcadena necesita * alrededor
• Por qué la distinción de mayúsculas es un interruptor Option Compare de todo el módulo, no una marca por llamada
• Cómo coincidir con un *, ?, # o [ literal con el escape de corchetes
• Like frente a InStr frente a los comodines de hoja, y cuál usar

El modelo mental: Like es una prueba de forma, no una búsqueda

Like no busca dentro de tu cadena algo. Coloca el patrón sobre la cadena de extremo a extremo y hace una sola pregunta de sí o no: ¿tiene esta cadena entera esta forma? Ese es un trabajo distinto del de InStr, que busca una subcadena e informa de dónde está, y del de una expresión regular, que puede encontrar, contar y extraer piezas. Like no devuelve más que True o False.

Ese encuadre te dice cuándo encaja: tienes una forma fija y quieres un veredicto. ¿Es un SKU válido ("[A-Z][A-Z]-####")? ¿Termina este nombre de archivo en .xlsx ("*.xlsx")? ¿Contiene este código solo dígitos (Not (s Like "*[!0-9]*"))? Cada una de esas es una pregunta de forma, y Like la responde en una línea legible — sin objeto que crear, sin bucle, sin aritmética de posiciones.

Los comodines, y qué coincide con cada uno

Cinco fichas especiales, y todo lo demás en el patrón es un literal que debe aparecer exactamente:

Los rangos dentro de corchetes van de menor a mayor ([A-Z], [0-9]), y puedes combinar conjuntos ([A-Za-z0-9]). El comodín # es una comodidad de VBA sin equivalente en los comodines de hoja, y la negación [!...] es la herramienta detrás de la mayoría de la validación real — "*[!0-9]*" significa «contiene al menos un carácter que no es dígito en algún lugar», que niegas para afirmar «solo dígitos».

Trampa 1: Like comprueba la cadena entera, no una subcadena

Esta es la pregunta número uno de «Like no coincide», y viene de esperar un comportamiento de búsqueda:

Debug.Print "Invoice 2026" Like "2026"     ' False - la cadena no es SOLO "2026"
Debug.Print "Invoice 2026" Like "*2026*"   ' True  - contiene "2026" en cualquier lugar
Debug.Print "Invoice 2026" Like "Invoice*" ' True  - empieza con "Invoice"

El patrón tiene que describir la cadena desde el primer carácter hasta el último. Si solo te importa que un fragmento aparezca en algún lugar, envuélvelo en * por ambos lados. Si de verdad solo quieres «¿esto contiene ese texto literal?», InStr es la herramienta más directa — InStr(s, "2026") > 0 — y es más rápida porque no hay ningún patrón que interpretar. Usa Like cuando importa la forma (anclada al inicio, un dígito aquí, una letra allá), no meramente la presencia de una subcadena.

Trampa 2: el caso depende de Option Compare, sin anulación por llamada

Por defecto, un módulo usa Option Compare Binary, así que Like distingue mayúsculas:

Debug.Print "Excel" Like "excel"   ' False bajo Option Compare Binary (el valor por defecto)

Pon Option Compare Text en la parte más alta del módulo (encima de cada procedimiento) y cada comparación de cadenas de ese módulo — =, Like, InStr sin un argumento explícito — se vuelve insensible a mayúsculas:

Option Compare Text          ' de todo el modulo, en la parte superior del modulo

Sub CaseInsensitive()
    Debug.Print "Excel" Like "excel"   ' True ahora
End Sub

Aquí está la diferencia clara con sus primas: Like no tiene marca de caso por llamada. InStr y Filter toman ambos vbTextCompare como argumento, así que puedes ignorar las mayúsculas en una llamada y seguir distinguiéndolas en todas las demás. Like no puede — su comportamiento de caso es una propiedad de todo el módulo. Si necesitas coincidencia insensible a mayúsculas en un solo sitio sin voltear el módulo, pliega tú mismo el caso con UCase: UCase(s) Like "EXCEL". Eso mantiene el efecto local y obvio, en vez de esconderlo en una línea Option cien líneas más allá.

Trampa 3: coincidir con un asterisco, una interrogación o un corchete literales

Tarde o temprano necesitas coincidir con un * o un ? de verdad — un nombre de archivo con un comodín dentro, un cuadro de búsqueda que contiene literalmente #. Escapa un carácter especial poniéndolo dentro de corchetes:

Debug.Print "3*4"  Like "*[*]*"   ' True  - contiene un asterisco literal
Debug.Print "OK?"  Like "*[?]"    ' True  - termina con un signo de interrogacion literal
Debug.Print "C#"   Like "*[#]"    ' True  - almohadilla literal (no "un digito")
Debug.Print "a[1]" Like "*[[]*"   ' True  - corchete de apertura literal

Ten en cuenta que esto no es la convención de hoja. Range.Find, Application.Match y COUNTIF escapan un comodín con una tilde inicial (~*, ~?), y no entienden # ni [!list] en absoluto. Dos dialectos de comodines distintos viven en el mismo producto, y confundirlos — usar ~* en un patrón Like, o [*] en un Find — es una fuente sutil y silenciosa de coincidencias que nunca se disparan.

Like frente a InStr frente a los comodines de hoja

La decisión de una línea, para que dejes de usar la herramienta equivocada:

• InStr — quieres saber si y dónde aparece una subcadena literal. El más rápido para «contiene este texto exacto».
• Like — quieres un sí o no sobre una forma: anclada, posicional, dígito frente a letra, un conjunto acotado. Un Boolean, la cadena entera.
• Range.Find / comodines de hoja — coincides contra celdas de una hoja, y el dialecto es *, ? y ~ para escapar. Otra herramienta, otros comodines.
• RegExp — la forma tiene recuentos de repetición, alternancia (this|that) o un grupo que necesitas sacar. Eso está más allá de lo que Like puede expresar.

Cuando el patrón le queda pequeño a Like — describe el trabajo en su lugar

Like es un placer hasta el punto en que la forma deja de ser fija. En el momento en que la regla se convierte en «tres a cinco letras, luego un guion, luego un número variable de dígitos, y saca los dígitos», estás escribiendo bucles alrededor de Like, o atornillándole Mid e InStr, y la intención desaparece en la fontanería. Esa es la señal para o bien subir a un patrón de verdad — o saltarte el código por completo. ExcelMaster te deja enunciar la regla en español llano — «conserva las filas cuyo código sea tres letras y luego cuatro dígitos, y pon los dígitos en la columna D» — y genera Python que aplica la coincidencia, respalda tu archivo primero y escribe el resultado. Tú describes la forma; él se encarga de los comodines, el caso y los bordes.

Preguntas frecuentes

¿Qué hace el operador Like en VBA?

Like compara una cadena con un patrón y devuelve True si la cadena entera coincide. El patrón puede contener comodines: * (cualquier serie de caracteres), ? (un carácter), # (un dígito), [list] (un carácter de un conjunto) y [!list] (un carácter que no está en el conjunto). Devuelve un Boolean, así que se usa dentro de condiciones If y Do While.

¿Por qué mi comparación Like de VBA no coincide?

Dos causas habituales. Primera, Like coincide con la cadena entera, así que "Invoice 2026" Like "2026" es False — envuelve el fragmento en asteriscos: "*2026*". Segunda, distingue mayúsculas bajo el Option Compare Binary por defecto, así que "Excel" Like "excel" es False hasta que añades Option Compare Text a la parte superior del módulo o pliegas el caso con UCase.

¿Cómo hago que Like de VBA sea insensible a mayúsculas?

Pon Option Compare Text en la parte superior del módulo — hace que cada comparación de cadenas de ese módulo sea insensible a mayúsculas, Like incluido. Like no tiene un argumento de caso por llamada como InStr y Filter, así que para una coincidencia insensible a mayúsculas puntual sin cambiar el módulo, compara cadenas plegadas en su lugar: UCase(value) Like "PATTERN".

¿Cómo coincido con un asterisco o una interrogación literales con Like?

Envuelve el carácter especial en corchetes: [*] coincide con un asterisco literal, [?] con una interrogación literal, [#] con una almohadilla literal y [[] con un corchete de apertura literal. Por ejemplo "3*4" Like "*[*]*" es True. Este escape con corchetes es específico de Like; las herramientas de hoja como Range.Find usan una tilde inicial (~*) en su lugar.

¿Cuándo debo usar Like en vez de una expresión regular en VBA?

Usa Like cuando la forma es fija y solo necesitas un sí o no: una extensión de archivo, un código de longitud fija, una comprobación de solo dígitos. Echa mano de una RegExp cuando el patrón tiene repetición variable (\d{2,4}), alternancia (cat|dog) o un grupo de captura que necesitas extraer. Like no puede contar repeticiones ni devolver las piezas coincidentes; una expresión regular sí.

Probado en

Probado en: Excel 365 (Windows 11), VBA 7.1 — última verificación el 04/09/2026.

Guías relacionadas: VBA IsNumeric · VBA Regex · VBA InStr · VBA Find · VBA UCase y LCase