end, we introduce you to several different
programming languages, and we aren’t able to cover
them in nearly as much depth as we’re able to cover
C earlier in the course. The goal here is not to give
you a complete rundown of what these languages do, but to
give you enough of the basics and show you enough of
the parallels to things that you already know so that you
can go forth and really flesh out your knowledge of these
different languages. And another one of these we’re going
to cover right now is JavaScript. Now, similar to other
languages we’ve discussed, it is a modern programming language
that is derived from C’s syntax. So if you’re familiar
with C, you’re going to be able to pick up
JavaScript pretty quickly. It’s been around just
about as long as Python. It was invented a few years
afterwards in the mid 1990s. Now what’s really important about
JavaScript, as well as HTML and CSS, which we’ve discussed
in other videos, is that those three languages pretty
much make up the core user experience of what it means to be online. So understanding how to use and
work with JavaScript, HTML, and CSS will allow you to really
create websites that users will enjoy visiting, because you’ll
be able to create a great user experience for them with
these three languages. To write JavaScript, it’s really easy. Open up a file with a
dot js file extension, and start writing in
JavaScript right away. If you’re familiar with
a language like PHP, you know that you have to
sort of bind your code up in these delimiters– bracket,
question mark, PHP, and all that stuff. We don’t have to do that in JavaScript. We literally just start writing
our code in a JavaScript file, which is pretty nice. Our website will also know that
what our file is is JavaScript, because we’re going to
tell it in an HTML tag. We’re going to say, I have a
script that is of type JavaScript, and it is a file with a
dot js file extension. Pretty straightforward. Now, unlike Python, which runs on the
server side– that is, on the side that is hosting the website,
JavaScript applications run client side on your own machine
when you are visiting a website. To include JavaScript in
your HTML, it’s pretty easy. Just like when we include
CSS with style tags, we can include JavaScript
in between script tags. So we can have an open
script tag and literally start writing JavaScript right in
our HTML, which is kind of cool. But also like CSS,
where we have link tags, we can write our JavaScript
in a different file and connect it using the source
attribute of a script tag. In CS50, and really
probably more generally, this is definitely the preferred
way to go, particularly if you have a JavaScript
file that might be used– or the contents of which might be used–
on different pages of your website. You don’t have to write the
JavaScript between the script tags on every single page. You want to be able to just
refer to an outside file and link that in every single time. So let’s quickly run down
some of the fundamentals that you might use in JavaScript. So, variables– they’re really similar
to Python variables and really similar to C variables. No type specifier is required. And if you want a local variable,
you preface it with the var keyword. So in Python, we would say
something like this– x equals 44. We don’t want to do that in
JavaScript, because that would actually create a global variable, if you
were to put a semicolon at the end. We would want this– var x equals 44. That creates a local variable
called x in JavaScript, and stores the value 44 in it. Conditionals– all of the old favorites
from C are available for you to use. If, else if, else, switch, question
mark colon– all of those are fair game. We’re not going into
detail on those at all, because we’ve covered
them in our videos on C. But they’re all here
to use in JavaScript, and behave pretty much exactly the same. Loops, meanwhile– all of ones
we’re familiar with from C are also still available–
while loops, do-while loops, and for loops, although we do
have a couple of other variations that we’ll talk about
in just a little bit. Now, functions in JavaScript are all
introduced with the function keyword. So it’s a function. Write a function name
and parameters, and then we define our function between curly
braces just like we would in C, except in C, of course, we’re
not using the function keyword. But there’s also a catch
with JavaScript, which is that functions can be anonymous. Meaning you don’t have
to give them a name. Now, you might be asking yourself,
wait, how can I call a function If it doesn’t have a name? Well, we’ll talk about
that in just a little bit, and we’ll talk about what I mean in
particular here when I’m describing binding things to HTML elements. We’ll talk about that in the video
on the document object model, but we’ll talk about anonymous
functions in just another minute. I’ll give you an example
and you can see how they might be useful in certain contexts. And those contexts actually
do kind of materialize a lot in JavaScript programming. JavaScript, like C, and like Python,
are analogous to Python’s lists. Has arrays, and you
can declare an array. It’s pretty straightforward. For example, var nums
creates a local array. And then I have square
brackets, and I just have a comma-separated list of all the
values that I want to put in the array. I can also mix types. I don’t have to have all integers,
or all floats, or all strings, like I do in C. I can have different
types mixed together there. JavaScript has the ability to
behave a few different ways. That’s why it can be a little bit tricky
as the very first language to learn, because a sets up a bunch of rules
for itself and then breaks them. It is very, very flexible,
but perhaps almost a little too flexible
as a first language. But it can behave as an
object-oriented programming language. Object-oriented might be a
term that you’ve heard before, but if not, we’ll try to give a
quick little crash course here. An object is really similar
in spirit to a structure that we are familiar with,
hopefully, from C. Now, in C, structures can have a number
of different fields or members. Another term for those that we see
commonly in object-oriented programming are properties. But those properties, or
fields, or members, just like in C, can never stand on their own. So for example, if we define the
structure for a car like this– struct car, and inside of that, there
are two different fields or members– int year and char model tens,
or a 10-character string that we can use to
store the cars’ model. We can do things like this. We can say struct car
Herbie, which declares a variable of type
struct car named Herbie, and then we can say Herbie
dot year equals 1963. Hurbie dot model equals Beetle. That’s totally fine. That’s valid C. But we
can never say this in C– we can never say, year equals
1963, model equals Beetle. Now, we can’t say that because year
and model are so fundamental to what it means to be a struct car. They are part of a struct car. And so if we’re ever
using year and model– we can’t use them in the abstract. We always have to associate those
things with a particular struct car. So that is not OK. Objects, in addition to having
fields, or members, or properties, also have something
called methods, which is sort of like if a C structure had
a function that could only ever apply to that structure. So it’s as if we have a function where
structures are the only things that need to be passed in. Now, that, we have in C. But we can’t define a function inside
of the curly braces of a struct. That is more– that is
object-oriented programming. That is different from here. But just like properties, methods
don’t stand on their own either. It’s not like a function that
just exists in the abstract. It is a function that only exists in
the context of, in this case, an object. So where we might do this in
C– function parentheses object, where object is a parameter
to the function being called– that is not object-oriented styling. Object oriented means the object
is at the core of everything, and instead, we’re going to call this
function that is a part of the object. OK? So this is what object-oriented
programming looks like in a very, very basic form, is, there are functions
that are affiliated or associated with objects, and we call those
functions as follows– by specifying the object and
saying we want some function to execute on that object, like this. The fields and methods of an
object are really similar in spirit to the idea of a dictionary,
which you may be familiar with or recall from Python. So we could, for example, have something
like this– var Herbie equals– curly braces, now, not square
brackets, it’s curly braces– and then, a comma-separated
list of key value pairs, where year 1963 is sort of like saying
Herbie dot year equals 1963 in C, and Herbie dot model equals Beetle. This is akin to how we would do
the same thing in JavaScript, by creating an object and giving it
a couple of properties right away. All right. Now, let’s go back to loops,
because I mentioned earlier, there are a couple of different new
loops that we can use in JavaScript. So now that we have this object,
how would we maybe iterate across all of the key value
pairs of that object? Or in fact, how we iterate across
all of the elements of an array, if we wanted to do that, besides
using a for loop, a while loop, or a do-while loop? So in Python, we saw
something like this– for key in list, and then we would
have some code where we would use key every point from there on down– a stand in for the i-th
element of the list. You can’t do that in JavaScript, but
we can do something pretty similar for var key in object. And then open curly brace. And between those curly braces, we
can use object square bracket key to refer to the key-th
element of the object, or the key-th key in a key
value pair set of the object. We also have a slightly
different variation for var key of object, which,
instead of having to use object square bracket
key, we can now refer to iterating across all of the values– as opposed to this, which
iterates across all the keys, this would iterate across the values. So we can cover both sides of a
key value pair using for var key in, or for var key of. Here’s an example of
an array where we’re going to use these two
different types of loop. So we have here a week array
that has 7 elements in it– Monday, Tuesday, Wednesday,
Thursday, Friday, Saturday, Sunday. And I want to use a four
var day in week array. So I want to use a for in loop,
and I want to console dog log. Console dot log is the
JavaScript equivalent of print f. You can access it using developer
tools in most modern browsers. What’s going to happen
when they print this out? It’s going to print out a
list of all of the keys. Well, in this array, there’s really
no keys– there’s a bunch of indices. So this will print out
0, 1, 2, 3, 4, 5, 6, because there are seven
elements of my array, and I am logging which
element I’m talking about. If I wanted to print out the days
instead, I would use a for of loop, and I would get the following
printed out to the console– Monday, Tuesday, Wednesday,
Thursday, Friday, Saturday, Sunday. What if I want to
concatenate information? So remember, we can tie
different strings together. We could do that in Python. We can do it as well here in JavaScript. And we do that by using plus. So if I want to console dot log a
bunch of different strings concatenated together, I just use plus to do it. But here’s a little
bit of a catch, right? If I’m using plus, now it
means two different things. I want to concatenate strings together,
but maybe here, I want to add. I really encourage you
to take a look at what happens if you write the week
array into some JavaScript, and then have a loop that iterates
across and console dot logs this. You might find that you get
something that you don’t expect. And so, JavaScript is
making its best guess, and it’s assuming that day and
1 are both strings, when really, what I want to do is add them together,
literally, because they’re numbers. But fortunately JavaScript
gives us a way around that by using a function called parse int. Now, this is going to give
us what we expect to see. This, on the other hand,
is going to give us something we don’t expect to see. But it’s just, again, a case of,
we’re using the same operator to mean two different things,
and the language sometimes has to make a best guess. So it’s not always a great thing
that languages nowadays don’t often require us to specify a data type– if we were able to
specify a data type here, we would be able to disambiguate this. But here with JavaScript, it thinks
it’s being very helpful for us by not specifying a type. And it’s going to make our best
guess as to what we want to do, but sometimes it guesses wrong. But it gives us ways to work around
it if it does indeed guess wrong. So arrays are actually a
special case of an object. And, actually, in JavaScript, everything
is a special case of an object. X, any variable, var x equals 44– that’s an object that just
happens to have one property. Arrays are an object that happens
to have a number of properties, and also some certain methods
that can be applied to them. So we can call the size method,
or pop, or push, or shift. And I’ll leave you to figure
out, or to do some research into, what those different things are. But suffice it to say that they
are functions that are basically so baked into what it
means to be an array that we can just call
them without having to write them in the first place. That’s pretty cool. Here’s another cool
thing that you can do with arrays– there’s another
method for them called map, which basically allows us to apply
a function to every single element of an array. And in particular,
this is a great example for using an anonymous function. So let’s take a look at how we
might use an anonymous function and why it might be useful to do so. Here’s an array called nums. It has five elements in it– 1, 2, 3, 4, and 5. Now, what I want to do is, I want
to map some function on to them. So what I’m saying
here is, nums equals– so I’m going to do something to nums. I’m going to reassign that back to nums. Nums equals nums dot map– and remember, map takes in a function. It’s a function that I want to apply
to all of the elements of that array. One thing I could do is just write
this function somewhere else, and give it a name, say I called it– what’s going to happen here is,
every value’s going to be doubled. Let’s say that I wrote a
function called double numbers. I could say, nums equals nums dot
map parentheses double numbers, and it would just double every number. That would be fine. But here, notice I’m using
that function key word, and I’m giving a list of
parameters– in this case, num– but I’m not giving that function a name. Why am I not giving
that function a name? Well, I’m just doing this mapping here. I’m never going to need to
double these numbers again. Why am I going to clutter
up the name space, and give it some name when
I’m never going to use it again outside of this context? It’s kind of convenient that we can
actually use the function in this case, then, without having to
give it a name, and still have it do what we want to do. So all I’m doing here inside of
those parentheses of maps is, the open parentheses on
the first line there– and that close parentheses is
actually on the third line. And in between the parentheses, where
I’m specifying the parameter to map, I’m literally defining an
entire function in there. And then if I execute this line of
code, what’s going to happen to nums? Well, you can probably guess, it’s going
to just double every element of nums. All right, one more thing I want to
touch on really quick about JavaScript, and that is the notion of events. So an event is something that goes
hand in hand with HTML on JavaScript, and it is a response to a user
doing something on a web page. So for example, perhaps
they click a button. Perhaps the page has finished
loading after the user hits refresh, for example. Maybe they hover over a portion of
the page, or something like that. All of those things are events. And JavaScript has support for what
is called an event handler, which is some JavaScript
code that will execute once that event has taken place. So it allows our site page
to be very interactive. We type in a box, for example– we could have an event handler,
that pops up a message that says, please enter your password. So it’s just a complete– it’s an
empty field that says nothing at all. You start to type in
it, and then this box pops up because you started typing,
which is an event on the page. And it tells you to do something
that is a JavaScript event handler taking effect. Many elements of HTML have support
for events as an attribute. So here’s an example of
some really basic HTML. I have my head and my body, and inside
of the body, there are two buttons. And they have this
attribute called on click. On click is a definition,
basically, for an event handler. So I want something to happen
when I click the buttons. Right now it’s nothing, but
I can put something in there so that when I click on
either of those buttons, that function that’s in between the
quotation marks there would get called. We can write a really generic
event handler in JavaScript, for example, that
creates an event object, and will tell us which of
those two buttons were clicked. And it might look something like this. Button on click equals alert name event. If we do this, we have
basically set up our HTML, so that when either button one is
clicked or button two is clicked, the alert name function will be
called, and an event will be passed in. The event is automatically
generated by the page, and it basically contains all of the
information about what just happened. And from that information, we
can extract more information. So for example, here what the
alert name function might look like, and notice that here, I’m
also accepting an event parameter. What am I doing then? I’m getting a new JavaScript
local variable called trigger, and I’m asking for that
event’s source element. And what that is
basically telling me is, what is the element on the
page that was interacted with that triggered this event? Or rather, put another way,
what element effectively was passed in to this function. Because, again, this is
automatically generated. The page knows which button
we touched, and so, basically, what’s happening here is, that button–
whichever one of the two it was– is getting passed into this function. Then– and you’ll see a little bit more
of this when we talk about the document object model– I can access that trigger’s inner HTML
to figure out which button was clicked. Now, what is inner HTML? Let me jump back a couple
of slides for a second here. The inner HTML is what is
between the button tags. In this case, button one is inner HTML
and button two is also inner HTML. So what happens when I click on those
buttons is, it will alert to me, you clicked on button one if I
happened to click on button one, or, you clicked on button two, if
you happened to click on button two. Now, again, we are just scratching
the surface of JavaScript, but I wanted to give you a sense
of some of the different things that you can do, so that you can then
go forward, look at the documentation, and see the very wide range of
things that you can do as well, by just applying some
of the basic tenets that we’ve learned about in
CS50, and really expanding your knowledge exponentially. I’m Doug Lloyd. This is CS50.

Tags:, ,


Add a Comment

Your email address will not be published. Required fields are marked *