Solución:
Intente agregar algunos paréntesis para agrupar las cosas de manera lógica:
IF (DL-CLASS-STANDING = 'First Yr' OR 'Second Yr') AND
(GRAD-STAT-IN = ' ' OR 'X')
usted mayo Quiero ver cómo se expande por completo esa expresión abreviada, ya que es posible que la expansión no sea lo que usted piensa cuando hay muchas cláusulas; a menudo es mucho mejor ser explícito.
Sin embargo, que I haría es usar el 88 Variables de nivel para hacer esto más legible: estos eran niveles especiales para permitir que las condiciones se especificaran en la división de datos directamente en lugar de usar condiciones explícitas en el código.
En otras palabras, ponga algo como esto en su división de datos:
03 DL-CLASS-STANDING PIC X(20).
88 FIRST-YEAR VALUE 'First Yr'.
88 SECOND-YEAR VALUE 'Second Yr'.
03 GRAD-STAT-IN PIC X.
88 GS-UNKNOWN VALUE ' '.
88 GS-NO VALUE 'X'.
Entonces puedes usar el 88 variables de nivel en tus expresiones:
IF (FIRST-YEAR OR SECOND-YEAR) AND (GS-UNKNOWN OR GS-NO) ...
Esto es, en mi opinión, más legible y el objetivo de COBOL después de todo, parecía un inglés legible.
Lo primero que hay que tener en cuenta es que el código que se muestra es el código que estaba funcionando, y el código modificado que no dio el resultado deseado nunca se mostró. Como apéndice, ¿por qué, si solo quedara una persona, sería necesaria más selección? Para resumir eso, la pregunta real no es clara más allá de decir “No sé cómo usar OR en COBOL. No sé cómo usar AND en COBOL”.
Más allá de eso, había dos preguntas reales:
-
¿Lo hice demasiado complejo para el compilador?
-
¿Existe una manera más fácil de omitir cosas? [is there a clearer way to write conditions]?
Para el primero, la respuesta es No. Está muy lejos de ser difícil para el compilador. El compilador sabe exactamente cómo manejar cualquier combinación de OR, AND (y NOT, que veremos más adelante). El problema es, ¿puede el escritor / lector humano codificar una condición con éxito de modo que el compilador sepa lo que quiere, en lugar de simplemente dar el resultado del compilador siguiendo sus reglas (que no tienen en cuenta las múltiples interpretaciones humanas posibles de una línea? de código)?
Por tanto, la segunda pregunta se convierte en:
¿Cómo escribo una condición compleja que el compilador entenderá de manera idéntica a mi intención como autor y de manera idéntica para cualquier lector del código con alguna experiencia en COBOL?
En primer lugar, una reorganización rápida del código (de trabajo) en la pregunta:
IF DL-CLASS-STANDING = 'First Yr' OR 'Second Yr'
AND GRAD-STAT-IN = ' ' OR 'X'
Y del código sugerido en una de las respuestas:
IF (DL-CLASS-STANDING = 'First Yr' OR 'Second Yr')
AND (GRAD-STAT-IN = ' ' OR 'X')
La segunda versión es más clara, pero (o y) es idéntica a la primera. No hizo que ese código funcionara, permitió que ese código siguiera funcionando.
La respuesta fue abordar la resolución del problema de una condición que tiene su complejidad aumentada: corchetes / paréntesis (simplemente simplificar la complejidad es otra posibilidad, pero sin el ejemplo no funcional es difícil hacer sugerencias).
El código original funciona, pero cuando necesita ser más complejo, las ruedas comienzan a caerse.
El código sugerido funciona, pero no resuelve (completamente) el problema de extender la complejidad de la condición, porque, en menor medida, repite el problema, entre paréntesis, de extender la complejidad de la condición.
¿Cómo es esto así?
Una simple condición:
IF A EQUAL TO "B"
Una condición un poco más compleja:
IF A EQUAL TO "B" OR "C"
Una ligera, pero no completa, simplificación de eso:
IF (A EQUAL TO "B" OR "C")
Si la condición tiene que volverse más compleja, con un AND, puede ser simple para los humanos (al compilador no le importa, no se puede engañar):
IF (A EQUAL TO "B" OR "C")
AND (E EQUAL TO "F")
¿Pero que hay de esto?
IF (A EQUAL TO "B" OR "C" AND E EQUAL TO "F")
Colocar el Y dentro de los corchetes ha permitido replicar el problema original para los humanos. ¿Qué significa eso y cómo funciona?
Una respuesta es esta:
IF (A EQUAL TO ("B" OR "C") AND E EQUAL TO "F")
Quizás más claro, pero no para todos, y nuevamente el problema original aún existe, en la menor.
Entonces:
IF A EQUAL TO "B"
OR A EQUAL TO "C"
Simplificado, para la primera parte, pero aún ese problema en la menor (solo agregue Y …), entonces:
IF (A EQUAL TO "B")
OR (A EQUAL TO "C")
Llevando a:
IF ((A EQUAL TO "B")
OR (A EQUAL TO "C"))
Y:
IF ((A EQUAL TO "B")
OR (A EQUAL TO C))
Ahora, si alguien quiere aumentar con AND, es fácil y claro. Si se hace al mismo nivel que una de las partes de la condición, solo se adhiere a eso. Si se hace en el nivel más externo, se adhiere a ambos (todos).
IF (((A EQUAL TO "B")
AND (E EQUAL TO "F"))
OR (A EQUAL TO "C"))
o
IF (((A EQUAL TO "B")
OR (A EQUAL TO "C"))
AND (E EQUAL TO "F"))
¿Qué pasa si alguien quiere insertar el Y dentro de los corchetes? Bueno, porque dentro de los corchetes es simple y la gente no tiende a hacer eso. Si lo que está dentro de los corchetes ya es complicado, tiende a agregarse. Parece que algo que es simple por estar solo tiende a no complicarse, mientras que algo que ya es complicado (más de una cosa, no solo) tiende a hacerse más complejo sin pensarlo mucho más.
COBOL es un idioma antiguo. Muchos programas antiguos escritos en COBOL todavía se están ejecutando. Muchos programas COBOL deben enmendarse, o simplemente leerse para comprender algo, y eso muchas veces a lo largo de sus vidas de muchos años.
Al cambiar el código, agregando algo a una condición, es mejor si no es necesario “alterar” las partes originales de la condición. Si la complejidad se deja entre paréntesis, es más probable que sea necesario alterar el código, lo que aumenta la cantidad de tiempo para comprender (es más complejo) y cambiar (se necesita más cuidado, se necesitan más pruebas porque el código está alterado) .
Muchos programas antiguos serán ejemplos de malas prácticas. No hay mucho que hacer al respecto, excepto tener cuidado con ellos.
No hay excusa para escribir código nuevo que requiera más mantenimiento y cuidado en el futuro de lo absolutamente necesario.
Ahora, los ejemplos anteriores pueden considerarse prolijos. Es COBOL, ¿verdad? ¿Mucho mecanografiado? Pero COBOL ofrece una inmensa flexibilidad en las definiciones de datos. COBOL tiene, como parte de eso, el Nivel 88, el Nombre de la condición.
Aquí hay definiciones de datos para parte de lo anterior:
01 A PIC X.
88 PARCEL-IS-OUTSIZED VALUE "B" "C".
01 F PIC X.
88 POSTAGE-IS-SUFFICIENT VALUE "F".
La condición se convierte en:
IF PARCEL-IS-OUTSIZED
AND POSTAGE-IS-SUFFICIENT
En lugar de solo valores literales, todos los valores literales relevantes ahora tienen un nombre, de modo que el codificador puede indicar lo que realmente significan, así como los valores reales que llevan ese significado. Si se deben agregar más categorías a PARCEL-IS-OUTSIZED, se extiende la cláusula VALUE en el nivel 88.
Si se va a combinar otra condición, es mucho más sencillo hacerlo.
¿Es todo esto cierto? Bueno, sí. Míralo de esta manera.
COBOL opera sobre los resultados de una condición donde se codifica.
If condition
Las condiciones simples se pueden agravar mediante el uso de corchetes, para hacer una condición:
If condition = If (condition) = If ((condition1) operator (condition2))...
Y así sucesivamente, hasta los límites del compilador.
El humano solo tiene que lidiar con la condición que desea para el propósito en cuestión. Para un flujo lógico general, observe la condición If. Para la verificación, mire el más mínimo detalle. Para un subconjunto, observe la parte de la condición relevante para el subconjunto.
Utilice condiciones simples. Simplifique las condiciones mediante corchetes / paréntesis. Cree condiciones complejas, cuando sea necesario, combinando condiciones simples. Utilice nombres de condición para realizar comparaciones con valores literales.
O y Y han sido tratados hasta ahora. NOT se ve a menudo como algo para tratar con cautela:
IF NOT A EQUAL TO B
IF A NOT EQUAL TO B
IF (NOT (A EQUAL TO B)), remembering that this is just IF condition
Entonces NOT no da miedo, si se hace simple.
A lo largo, he estado editando espacios. Debido a que los corchetes están ahí, me gusta ponértelos en la cara. Me gusta estructurar y sangrar las condiciones para enfatizar el significado que les he dado.
Entonces:
IF ( ( ( condition1 )
OR ( condition2 ) )
AND
( ( condition3 )
OR ( condition4 ) ) )
(y más esculpido que eso también). Al estructurar, espero que a) me equivoque menos yb) cuando / si me equivoco, alguien tenga más posibilidades de darse cuenta.
Si las condiciones no se simplifican, entender el código es más difícil. Cambiar el código es más difícil. Para las personas que están aprendiendo COBOL, mantener las cosas simples es un beneficio a largo plazo para todos.