In this section, I wanna show you can take a simple test, like startsWith("A"), and
use, the notion of AND, and OR, to combine it with other tests to sort of put
together a more complicated test. So this is called Boolean logic. So the way this
is gonna work, is, in code, the notion of AND is the, the symbol for that two
ampersands run together (&&). And the, the symbol for OR is two vertical bars (||),
put together. So let me show you what that looks like. So here's some code. And it
has, the first test just says if the name starts with "A", just as we've seen before,
and that test is, it's complete and functional. So that is not changed by
adding the notion of Boolean logic. So for Boolean logic, what we do is we take that
test and we follow it with two ampersands. So you would pronounce that as, AND. And
then it's followed by a second test. The second test is also complete and makes
sense on its own. So, what this does is it just takes two tests and it puts them
together, and it says, well. For this overall if-test to be true, both of these
subparts have to be true. So the components are, well here, I'll, I'll run
it. So what this says is, names that begin with "A". That has to be true. And the name
has to end with "y". So if I run it, we just get this, you know, kinda shorter list of
names that begin with "A" and end with "y". Syntactically like I said it has the two
tests, each of which is complete. They're joined with AND or, OR as we'll see in
a minute. And then finally there is still this one set of parentheses, a left most
parentheses and a right most, a right most parenthesis, around the entire thing. So
I'll do a bunch of examples, like this. A couple other, one other thing to point out
about this, in this case what happened is, the test is kind of long, right? I have
this whole startsWith part, and the ampersand, so if I did it all on one line,
it gets a little, a little long. So what's happened in this case is I, actually I hit
return after the ampersand. I went down here and I hit the space bar, to get the
row over here and kind of line it up. So I wrote the second test on a second line.
That's optional but you can do it. Putting in spaces and stuff like that doesn't
upset the code. So, I'm, always my examples I'll sort of neaten up in this
way, Where I'll tend to write one test per line, and then I'll align them this way.
So here's the second test. The only thing that's a little confusing is to note that
there are two parentheses are required here. This, this first one just balances
the parentheses for the endsWith. And then the second one, is the one that covers the
entire test, so it matches up to the, that first one. So if you leave that out,
actually I can illustrate this, so it's a pretty easy error to leave that one out,
'cuz you have to kinda realize alright I need two there. So in that case, not
always, but the run button for the, just for this class, will try to give you an
error message, like oh, it looks like there's a missing parentheses there. So
now form it that way we'll get them, we're still good. As I said before each of
these tests is complete and stand on its own. So just syntactly just the way we did
things before. There's this one form of the code that looks right but is wrong.
And so I'll create that here. So if you just write it this way. So I'll
just sort of pronounce it. row.getField("name"), that startsWith("a") AND
endsWith("y"). So just to the ear to a human, they would know
what that means, but this code does not work. The problem is the second term. On
its own, doesn't make sense. Right? Doesn't just stand on its own like ends
with, well it doesn't make sense. Usually what we need is, we're gonna put in a
cursor here, we would need row.getField("name") or "rank" or whatever it's gonna
be .endsWith. So this is not working. Each, each, to the left and the right of
the ampersand, each task has to be complete. So in this case, I'll just sort
of hit undo in Firefox here, the, if we wanna be talking about name, like we
spell it out for the first test, and then we also just completely spell it out for
the second test. So each test makes sense to the computer. Alrighty, So, I'm gonna
try another example here. Let's see. So right now, if I run this, it just shows
all the "A" names, which is quite a lot. What the problem statement says is, change
the code so it prints the names that start with "A" and the rank is less than 50. So,
oh here's, here's the first test, and I'll add two ampersands, and return let's
say row, that starts, that startsWith("A") is one test and now we're gonna add, I'm
gonna combine it with an AND, with the second test, where I'll say rank, oh let's
say less than or equal to 50. So I think I'll try it, yeah so that works. So
we still get "A" names but now we're just getting up to rank 50. I'm just gonna try
a third example here. Alright, now we'll do an example with OR. Change the code
below, so it prints rows where the following is true. Name starts with "X", or
the name stars with "Y", or the name stars with "C". So if I just run, run it right
now, the code that's there just does "X". So I wanna use OR. And we'll copy this.
So by using an OR-test. You make multiple ways for the overall if-test to
be true. It's like, well, the if-test were true if this one is true, or if this other
thing is true. So it's kind of a widening. So here I'll say, OR row.getField - "Y".
So, for the previous run, we only got "X". Alright? So I'm gonna run this. Oh, so now
we get "X" and "Y". So there's "Yusuf" and "Yeritza". Notice that I, my goal
ultimately was to show "X" or "Y" or "Z", but I think it is kinda nice if you get the code
into a kind of half built state, but where it makes sense. You know, just try running
it and kind of verify, oh that works before going on to do the whole thing.
That's kind of a classic computer code rule of thumb; don't try and do the entire
thing in one step, OR startsWith("Z"). So, I guess partly what I'm showing here is. You
can have multiple ORs and multiple ANDs and string things together. So let's
try that, There it goes, Quite a few "Z" names. So there we have it, "X" or "Y" or" "Z,
so this shows the two vertical bars, and then in this case I have strung together
three things. For this class, I will only, I'll use either a bunch of things
connected with AND or a bunch of things connected with OR. I won't combine them.
Combine them just brings up some other cases that are kind of interesting but I
not, I don't really want to get into. They don't really help a lot. Other thing I
should mention about this, alright so I should just apologize to this. This
ampersand business is sort of a historical accident, or the vertical bar business.
Language, influencial language chose this in, like the mid'70s. And once one
language had chosen this symbol to mean OR, some other languages thought, oh, well
we should just use that convention. And so it just kinda snowballed, where now,
that's a very common convention. So I felt like, well, it's kind of obscure, but.
That's the convention so we should just go ahead and learn that one. Alright, So,
let's scroll down here a little bit. So actually, what I have set up is just a
large number of examples here. And there's a show solution button here, so if you
want practice or to review these examples I've done, you could come back and it's
all sorted here. What I'll is I'll just try the, the first six. So, I'll type in
the code for those and I'll leave the others as kind of extra practice for
people who want it. Okay, so the first one says, name starts with "Ab", or starts with
"Ac". So I'll say there's some code here that we start with already. So it starts
with "Ab". And what was it? OR starts with "Ac". So this one starts with here, So this
should be an OR, Two different or's. Let's try that one. So we got "A", "Ac" Where's
the "Ac" name? Oh. Look I made a bug. I typed "Ab" twice. Okay. There we go.
Ok, there's an "Ac". That showed that interesting example of a bug, where sometimes bugs are
syntax errors where you hit the run button and it, it just, you know, it, it crashes
and you get some red output. But sometimes a bug is just that. I typed
something that does mean something to the computer, but it's not what I intended.
And so then the output is not what I expected, then I'm a little bit confused.
So that's the more higher level kind of bug in this course. It's fairly
common with computers. Okay, let's see, next one. Name starts with "Ab", or
"Ac", or "Al". Oh, I see. So this just extends. This just shows that you can have
three. So I'll say vertical bar. I'll paste this in. So it was "Ac",
so "Ab" and "Ac" doesn't give us a lot but with "Al" you know it's quite a lot.
Okay. So the next one was, name starts with O and ends with A. So I'll say
starts, I'll just translate it. Starts with "O" AND ends with "a". Alright. Let's
try that. Oh, there's only one, "Olivia". How bout, starts with O and gender is girl?
So, we'll just get gender right here, and then we test that is not with startsWith
endsWith, but just with ==. So, O AND girl. Oh, there's only two.
So we get Olive. Okay, name ends with "a" and gender is what?
Change this to name.endsWith("a"), and per my previous example, my previous claim, I'll just cut that out.
Now it's half built right, name ends with "a". But I could run that and sorta verify,
all rigt that's working. And then, take your working thing, and extend it. What
did I want? In this case I wanted oh, names ends with "a" and gender is blank.
Okay. Jesus, Lyle. Girl names neither. Boy. Oh, well, there's a few, Joshua,
Ezra. Okay, I'll do this last one, number six Rank is less than ten, and gender is
girl. So I'll change this to "rank". Instead of endsWith. I'll say, less than or equal to ten.
And, so, Now I'm not using startsWith, or endsWith for either of these but just
notice each one of those is a complete and correct test as we discussed before. That
one is, and that one is and I'm just joining them from there. So rank is less
than ten, and gender in this case is girl. Let's try that. So that makes sense. We
just get one, two, three, four of them. One through ten girl names. This one's
kind of interesting in that this, this I think has a sensible English translation.
What this is, is. What this says is top ten girl names, And then, We can phrase
that as this AND thing. Where rank is less than or equal to ten and gender is girl. Or indeed
ultimately we can phrase it as code. So just get it down to, to where the computer
can actually do it. So there's a few more problems here and the solutions all
available. So this is a good opportunity to come and review what I did or try a
little bit of practice before we do the exercises. Cuz these, in some sense, are -
computer languages have now gotten big enough that I can really we can have a lot
of different [inaudible] alright.