Flutter 5 - Beginning functions Video Lecture | Flutter: Build beautiful native apps in record time - App Development

everybody this is Brian welcome to the
fifth flutter tutorial all right so
we're gonna jump back into dart here
where we left off and if you remember we
left off on flow control and a lot of
tutorials start things backwards in my
opinion where they will talk about a
variable then instantly jump into
functions and classes which make no
sense at the time so you don't know what
you're doing so what we've done is we've
started with you know what is a variable
was a Const final and then we've gone
into flow control how do you actually
control the flow or the execution of
your program and we did the F else for
loop while break et cetera et cetera
what we're gonna cover now is going to
be functions so what are functions what
believe it or not you've actually worked
with them already this main right here
is a function main is actually the quote
unquote main function or the entry point
of your program what I have here is just
a new dart program and it's straight out
of the template here as soon as you open
it up and you see how it's got this in
calculate here that's also a function so
really all a function does is break up
or chop up the scope of a code so we can
do things like let's get rid of this
because we have talked about that stuff
yet let's say print hello just something
simple like that we just want to print
the word hello well print is also a
function somebody has already written
that code for you and that's how you're
able to call it so let's say we want to
print nine times so we're going to say
for int I equals zero I less than nine
actually i less than eight and i plus
plus
let's do this
one two three four five six seven eight
mmm
check out that wrong one two three four
five six seven I did still I mean I had
it right the first time my brains fried
sorry about that it looked funny that's
why I was like what is going on here all
right so we just printed nine times
we've done this before
and this is old hat but what we're gonna
do now is we're gonna take this guy and
put it into its own function actually
let's not call it test we'll say hello
so what we have here is we have created
our own function called say hello and it
has this weird thing called void in the
front a function is always precluded or
preceded by a return type so we can
return a variable from this function if
you want void means that we're returning
nothing is just void of any return value
so if you see the word void and you're
wondering what the heck to call that you
just simply say the name does the exact
same thing
what we've done now is we've broken up
the scope of this a little bit better if
we flip over here one of the things is
called lexical scope dart is lexically
scoped language which means that the
scope of the variables is determined
statically simply by the layout of the
code and we've talked about this before
right so like here's your top level
which is visible by everything that's
visible by everything but the inside
function is not visible by that that's
called lexical scope we've already
learned that so what we're doing now
with functions is actually breaking this
up even further by saying for example
this eye is not available here we could
even say int age equals 99 and we cannot
here say print oops
age it doesn't know where age is because
of that scope age belongs to this
lexical scope or this block of code so
if you're still new and you're still
trying to wrap your head around scope
that's really what scope means so what a
function is is basically taking scope
chopping it up even further and saying I
want this function to exist and this
function will only know about things
that are inside of this function or this
lexical scope right here so for example
if I say int age well let's not say that
in cats equal and there's nine cats I
don't know I'm fixated on the number
nine today and well here we try to say
print cats well guess what it's not
going to work undefined named cats
because it's not in the same scope so
let's get rid of those I'll get rid of
that so that is a very very bare bone of
you guessed it a function now what we're
gonna do here is we'll say avoid annoy
we all have that one annoying person
right in our lives that just loves
love's loves to talk and we'll say int x
and here we're going to just say for INT
i equal zero I less than x i plus plus I
think my music stopped playing did my
music stop playing I'm just very quiet
for some reason I have to play music in
the background or this wireless headset
will actually shut down on me it's kind
of weird
so some videos you'll actually see me
flip back and forth but so we've got our
four statement here very similar except
for instead of you know just hard coding
it we're doing this so we're going to
say
la so somebody says hello let's actually
leave that the way it is but then the
annoying person I know I and let's say
they come up and they just start talking
bla bla bla bla bla you know we've got a
thousand blahs in there I mean at this
point you just want to like walk away
and tell them to go bye-bye or something
so what we've done here is we've
actually passed a variable to this
believe it or not this is a variable
someone say it's a value but remember
everything in dart is an object
therefore that is actually a variable
under the hood this is called a
parameter right here the cool thing
about parameters is what we're doing
here is we're actually creating another
variable and that variable exists within
the scope of this function you can see
how we're accessing it right here and we
can actually say things like let's get a
little funky here
my phone made a weird noise that I never
heard before so here we're gonna say you
know what number of the number of times
we're supposed to do it and then they're
still talking so let's just run this
again and you can see mm-hmm so we
obviously have access to this variable
and there's really no limit to how many
times you can actually do this so what
we can do here is we can say would
really annoy in times and then we could
just say let's grab this now this may
look a little weird and I wanted to do
this as an example so let's grab this
and let's just comment these out here so
what's going to happen when we execute
this code well really annoys gonna get
called which is this guy here what
really a toy is going to do is it's
going to actually call annoy which is
going to do this so it's five by five
you can see how it does this and it just
goes over and over and over again so
that is a function calling a function
calling a function kind of thing you
have to be kind of careful when you're
writing functions because you have and
some people can argue this isn't really
the case but you have a bit of
encapsulation and what this does is this
gets a little confusing if you're not
used to scope for example in really
annoying we have int x and x is here and
x is here however this x right here
while it's the same value is it probably
not the same variable unless starts
doing something under the hood where
they you know because it's the same
value it moves in memory and blah blah
blah it's not the exact same thing it's
got a completely different scope and
therefore as a different access so we
can actually change this name to blahs
and notice how now we've got to change
it here and here but it does the same
thing so looking at the functions inside
of the tour of dart you can see there's
other things like bool and of course now
that I'm looking for it and there's void
string things like that
so you can actually make some really
cool functions
so what we're doing here is just we're
catenae ting two strings together
actually technically three because this
is also a string and we're turning a
brand new string object so let's go
ahead and do this
okay so we have my first name and my
last name and you can see how it just
prints out the string Brian Karen's
because what we're doing here is we are
calling this function which is taking
two parameters now and returning them as
one variable now if you're wondering
what types of variables you can return
well any type of variable any object
actually you could actually even save
air for unknown type who actually they
can't the return type can't be there I
stand corrected ladies and gentlemen I
thought you could do that but you cannot
which makes me wonder if you can return
an object you can return an object okay
so if you have no idea what you're
returning it's just some thing you can
return an object but in general rule of
thumb is you don't want to do that
because then they have to either know
the type or they have to use something
called reflection to go in and figure
out what type of variable it actually is
dart is a static type language meaning
that you have to declare your variable
types so let's go back to the tour here
there's some really good examples and if
you're not familiar with any of this at
all you should really kind of just play
with some of these and figure out what
they do one thing you can do is default
parameter values and this is really kind
of built into almost just about every
language here and what you can say is
you know your function can use an equal
sign to define the default values for
both the name and the positional
parameters the default values must be
compiled time constants must be compiled
time constants if no default value is
provided the default value is null
meaning because these do not have a
default value they are null null means
there's just nothing there it's like
nothing is it's like when you lose a
puppy you're just empty and void inside
so what we can do here is where to go is
we can turn one of these
into a default value right so let's just
say this hmm not good at call of duty
and it says positional parameters must
be enclosed in square brackets here hmm
so what did we screw up here that's a
good question what did we screw up here
thinks it's optional here
let's try that Brian Cairns now if we
admit this guy here we suddenly get
Brian not good at call of duty so what
we're going on or what we're doing here
is we are saying this will be null we
are not assigning a value to it it must
be assigned in there it is here so if we
just delete this you notice how suddenly
it's gonna freak out and say one
argument is required but zero found
because this is the required argument we
haven't supplied anything and you can't
actually do anything with it so you
could actually pass null which may
actually make this thing explode let's
find out yep see the method blah blah
blah was called on null so we're saying
null
plus these strings so Brian let's just
change this dude it is not because I'm
really not good at Call of Duty I've
been trying to get better at it but I'm
not good at it let's run this again so
we've supplied the first value and it's
not null and then we have this optional
and we are assigning the value to it so
because it's optional and you have to
include any optionals in these brackets
you don't need it you see how there's no
name here but the minute we include it
and let's say just do my name again just
because why not run this then suddenly
it is not using the optional parameter
because we have supplied the value once
this value is in here gets converted to
a variable and it replaces this so think
of this right here is like a temporary
variable and let's say oops hello let's
just call this string extra
let's make that lowercase just because
I'm kind of snobby about that these days
and we're going to add the extra in
there so you can see how we actually can
do this right so we have Brian which
we've supplied Karen's which we've
supplied we did not supply the extra
therefore it's going to use the default
and we could actually take this out
right here and you'll get two of them
see how that works so as you can see
functions are pretty neat there's a lot
of things you can do with them
one thing you should really be aware of
when you're creating your functions
though is the actual scope of the
variable because sometimes things can
get a little squirrely and you're
looking at one function because you've
named the variable the same in many
functions you think that variable goes
everywhere and it really doesn't so
that's all for this tutorial
gonna keep going down there's actually a
lot to cover on function so we're gonna
make a couple of these but if you found
this helpful or even moderately
entertaining go ahead and visit void
rom-com for the source code for this and
all other tutorials and if you're so
inclined go out and join the avoid roams
Facebook group there are seventeen
hundred and twenty members out there
right now all walks of life all
programming languages so definitely
check that out and join up become a
member and help everybody else out
thanks for watching