Operaciones de Concatenación y Comparación de Strings en Intérprete

Curso de Creación de Lenguajes de Programación: Intérpretes

Contenido del curso

Introducción al desarrollo de intérpretes y lenguajes de programación

Construcción del lexer o tokenizador

Construcción del parser o analizador sintáctico

Evaluación o análisis semántico

Mejora del intérprete

Siguientes pasos

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0016:00

Operaciones de Concatenación y Comparación de Strings en Intérprete

Curso de Creación de Lenguajes de Programación: Intérpretes

Clase 54 de 58

Clase 54 / 58

Recursos

¿Cómo trabajar con strings en un intérprete?

Trabajar con strings en un intérprete puede parecer simple en la superficie, pero en realidad involucra varias etapas claves de procesamiento, desde la declaración de tokens hasta la evaluación de objetos. Ahora bien, una vez que se tiene esta base, es hora de realizar operaciones reales con los strings. La operación más importante y comúnmente utilizada es la concatenación, que permite unir varios strings según las necesidades. Además, la comparación de strings es igualmente esencial para verificar si un string es igual o distinto de otro. Aquí exploraremos cómo implementar estas operaciones de concatenación y comparación, especialmente en contextos donde las operaciones son infixas. También es crucial el manejo de errores semánticos en situaciones donde, a pesar de que la sintaxis sea correcta, la operación carezca de sentido.

¿Cómo manejar las operaciones de strings y errores semánticos?

En el desarrollo de un lenguaje de programación, es fundamental diferenciar entre sintaxis y semántica. Operaciones como sumar dos strings significan concatenación, mientras que restar dos strings carece de sentido semántico. Nuestro intérprete debe reconocer estas diferencias y lanzar errores cuando una operación no válida se intente ejecutar. Por ejemplo, aunque la sintaxis de foo - bar sea correcta, semánticamente no significa nada. Manejar estos errores ayuda a crear un lenguaje robusto y confiable.

¿Qué pruebas son necesarias para garantizar las operaciones correctas?

Es esencial realizar pruebas para garantizar que las operaciones implementadas funcionen como se espera. Aquí te dejo algunas pruebas críticas a considerar:

Pruebas de concatenación de strings: Un test clave es unir strings como foo + bar y verificar que el resultado sea foobar. También podemos evaluar concatenaciones más complejas, como hello + " " + world, que debería dar hello world.

def test_string_concatenation():
    # Concatenamos strings y verificamos el resultado
    resultado = evaluar('foo + bar')  # Esperamos 'foobar'
    assert resultado == 'foobar'

    resultado = evaluar('hello + " " + world')
    assert resultado == 'hello world'

Pruebas de comparación de strings: Comparar a == a debe ser verdadero, mientras que a != a es falso. Comparaciones como a == b deben devolver falso y a != b verdadero. Las comparaciones son esenciales para el control lógico dentro del intérprete.

def test_string_comparison():
    assert evaluar('a == a') is True
    assert evaluar('a != a') is False
    assert evaluar('a == b') is False
    assert evaluar('a != b') is True

¿Cómo integrar las funciones de evaluación de strings?

Después de establecer las pruebas, se debe modificar el evaluador para incluir estas operaciones. Aprovechamos el método evaluate_infix_expression para procesar las operaciones entre strings. Allí identificamos los tipos y, dependiendo del operador, decidimos la acción:

Para la suma (+), concatenamos los strings.
Para igualdad (==) o desigualdad (!=), devolvemos un objeto booleano verdadero o falso.

def evaluate_string_infix_expression(operator, left, right):
    left_val = left.value
    right_val = right.value

    if operator == "+":
        return StringObject(value=left_val + right_val)
    elif operator == "==":
        return BooleanObject(value=left_val == right_val)
    elif operator == "!=":
        return BooleanObject(value=left_val != right_val)
    else:
        # Genera un error para operadores desconocidos
        return ErrorObject(message=f"Unknown infix operator: {operator}")

Este enfoque asegura que nuestro intérprete procese correctamente las operaciones sobre strings y refuerza un control lógico robusto al manejar errores semánticos. Mantente motivado y sigue explorando cómo estas funciones pueden expandirse con nuevas características, como las librerías estándares o los built-ins, que estaremos explorando en siguientes etapas. ¡El conocimiento es un viaje interminable, y cada paso te acerca más a ser un experto en programación y diseño de lenguajes!

Introducción al desarrollo de intérpretes y lenguajes de programación

Construcción de Intérpretes de Software en Python 3.8

Creación de Compiladores e Intérpretes con Lenguaje Platzi

Construcción del lexer o tokenizador

Análisis Léxico: Construcción de un Léxer para Intérpretes

Definición de Tokens en Lenguaje de Programación Platzi

Desarrollo de un Lexer con Test-Driven Development

Pruebas de Operadores, Delimitadores y Fin de Archivo en Lexer Python

Lexer: Identificación de Keywords y Tokens Complejos

Reconocimiento de Funciones en Lexer de Lenguaje de Programación

Implementación de Operadores y Condicionales en Lexer de Platzi

Implementación de Operadores de Dos Caracteres en Lexer

Creación de un REPL en Python para Lenguaje de Programación

Construcción del parser o analizador sintáctico

Construcción de un Parser para el Lenguaje Platzi

Definición de Nodos Abstractos para Árbol de Sintaxis (AST) en Python

Desarrollo de un AST en Python: Creación de la Clase Programa

Parseo de Let Statements en Lenguaje Platzi

Implementación de funciones advanced y expected tokens

Manejo de Errores en Parsers con Test Driven Development

Parseo de Return Statements en Lenguaje Platzi

Técnicas de Parsing: Top-Down y Bottom-Up

Pruebas de AST para Let y Return Statements en Parsers

Pratt Parsing: Implementación y Registro de Funciones en Python

Parseo de Identificadores en Lenguajes de Programación

Parseo de Expression Statements en Platzi Parser

Parseo de Enteros en Lenguaje Platzi

Implementación de Operadores Prefijo en Parsers

Operadores InFix en Expresiones: Implementación y Pruebas

Implementación de Operadores InFix en un Parser

Expresiones Booleanas en el Lenguaje de Programación Platzi

Evaluación de Precedencia y Testeo de Booleanos en Parsers

Evaluación de Expresiones Agrupadas en un Parser

Parseo de Condicionales en Lenguaje Platzi

Implementación de Condicionales en Parser de Lenguaje

Parsing de Funciones en Lenguaje Platzi: Creación de Nodos AST

Construcción de nodos de función en un parser AST

Llamadas a Funciones en Lenguajes de Programación

Implementación de llamadas a funciones en un parser con AST

Parseo de Expresiones en LET y RETURN Statements

Implementación de REPL para Árbol de Sintaxis Abstracta

Evaluación o análisis semántico

Evaluación Semántica en Lenguajes de Programación

Estrategias de Evaluación en Lenguajes de Programación

Representación de Nodos AST y Objetos en Python

Evaluación de Expresiones en JavaScript y Python

Implementación del Patrón Singleton para Booleanos y Nulos

Evaluación de Prefijos en Lenguaje de Programación Platzi

Evaluación de Expresiones Infix en Lenguaje Platzi

Evaluación de Condicionales en Lenguaje de Programación Platzi

Evaluación y Uso del Return Statement en Programación

Manejo de Errores Semánticos en Lenguaje Platzi

Declaración y Gestión de Variables en Lenguajes de Programación

Manejo de Ambientes y Variables en Lenguajes de Programación

Declaración de Funciones en Lenguaje de Programación Platzi

Implementación de Llamadas a Funciones en PlatziLang

Mejora del intérprete

Implementación de Strings en un Intérprete de Lenguaje de Programación

Operaciones de Concatenación y Comparación de Strings en Intérprete

Implementación de Funciones Built-in en Python

Implementación de Built-ins en el Lenguaje Platzi

Siguientes pasos

Desarrollo de Lenguaje de Programación y Estructuras de Datos en Python

Construcción de un Intérprete en Python desde Cero

Operaciones de Concatenación y Comparación de Strings en Intérprete