Bummer! You have been redirected as the page you requested could not be found.
Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll
Well done!
You have completed Go Language Overview!
You have completed Go Language Overview!
Preview
A Go program is split into several libraries, called packages.
- Each file begins with
packagedeclaration- Packages are often used to set up a library for other programs to use. But there's a special package that provides a starting point for Go programs to run: the
mainpackage.
- Packages are often used to set up a library for other programs to use. But there's a special package that provides a starting point for Go programs to run: the
-
importmakes other package contents available for use in the current source file - Package contents
- Variables, functions, and other things declared at package level will be accessible anywhere in the package.
- Again, there's a special starting point for Go programs to run: the
mainfunction.
- Using imported packages
- To refer to names of variables/constants/functions in another package, need to qualify the name:
fmt.Println,welcome.English. - No need to qualify names declared in current package
- To refer to names of variables/constants/functions in another package, need to qualify the name:
package main
// We'll be calling functions from these two packages.
// So we need to import them here.
// Note the parentheses: this syntax lets you import
// multiple packages at once.
import (
"fmt"
"math"
)
// Declare a variable that will be accessible throughout
// the current package.
var myNumber = 1.23
func main() {
// Call the Ceil function from the "math" package.
// Then, assign it to a variable. This is the "short
// variable declaration" syntax, which we'll talk
// about in the "Variables" video.
roundedUp := math.Ceil(myNumber)
// Call the Floor function from the "math" package.
roundedDown := math.Floor(myNumber)
// Call the Println function from the "fmt" package.
fmt.Println(roundedUp, roundedDown)
}
Related Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign upRelated Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign up
A Go program is split into several
libraries called packages.
0:00
Each file begins with
a package declaration.
0:05
Packages are often use to set up
a library for other programs to use.
0:08
But there's a special package that
provides a starting program for
0:12
Go programs to run, the main package.
0:14
We see this here at the start
of our hello Go sample program.
0:17
Following the package declaration,
each go file includes an import statement,
0:21
which states the names of several other
packages that it needs to import.
0:25
Once you've imported a package, you can
use functions, constants, variables, and
0:30
other things of declares
within your current file.
0:35
Then following the import statement
comes the actual package contents.
0:38
This consists of variables, functions, and
0:41
various other things you want
your package to include.
0:44
Anything that you declare
up here at package level
0:47
will be accessible anywhere
else within this package.
0:49
Again, if you're writing a Go program
that's going to be run from a command
0:53
line, there's a special starting point,
the main function Basically when a go
0:56
program starts running, it looks for
a function named main and invokes that.
1:00
To refer to the names of variables,
constants or
1:05
functions that we've imported from another
package we need to qualify the name.
1:07
So for example this Println function
was imported from the format package.
1:11
To use it, we need to qualify it by
placing the format package name before it,
1:16
so we say fmt followed by a dot And
1:21
then the name of the function that we
want to call from the other package.
1:24
If we were to write a function
elsewhere in this package though.
1:28
Let's say a function named otherFunction.
1:31
And we wanted to call this from here
within our main function we wouldn't need
1:36
to qualify that name since
it's here in the same package.
1:40
We can just say otherFunction.
1:43
Let's try creating another Go program
that uses a couple of different packages.
1:47
Since this is a program that is meant to
be run directly from the command line
1:51
we're going to put it in
the main package again.
1:54
And now I'm going to use a slightly
different form of the import statement so
1:56
that we can import two different packages.
2:02
You'll notice that I put parentheses
here at the end of the import line and,
2:06
I'm going to include the couple different
lines here with the names of a couple
2:11
different packages I want import.
2:15
So as before, we're going to
import the format package so
2:17
that we can use its print line function.
2:20
And then in addition to that,
I'm going to import the math package so
2:23
that we can use a couple
functions from that.
2:27
Now up here, outside of any functions
we're working at the package level.
2:30
I'm going to declare a variable here.
2:34
We'll talk more about
variables in a little bit, but
2:35
any variable that I declare here
is going to be visible within
2:39
any function in the package,
here in the main path.
2:43
So I'm going to declare a variable
named myNumber and I'll just assign it
2:46
the initial value of 1.23 Now let's
create a main function again.
2:51
Remember this will be kicked off
as soon as our program is run.
2:57
I'll create a main function and
3:03
let's call a couple of
functions from the math packet.
3:06
I'm going to call
the ceiling function first.
3:10
Math, remember we need to qualify
the function name with the package name
3:12
since we're getting this
from another package.
3:17
And then I'll call the ceiling function,
ceil, that's an abbreviation.
3:21
And, as I mentioned, the my number
variable was declared a package level, so
3:26
we can access it from here
within the main function.
3:30
So, I'm going to type my number.
3:34
And that'll round my number
up to the next whole number.
3:39
I'm then going to take
the result of that and
3:42
I'm going to assign that to
another variable called roundedUp.
3:45
Now since this variable was
defined within a function,
3:49
it's going to be accessible only
here within the main function.
3:53
We'll talk more about variable
scope in a little bit.
3:58
Then lets call another function
from the math package.
4:01
I'll call math dot floor, which rounds the
number down to the nearest whole number.
4:03
And we'll assign the results back to
another variable named rounded down.
4:10
Then we will just print
both of those numbers out.
4:17
So we'll call the format packages,
print line, function,
4:20
and we'll pass it,
round it up, and round it down.
4:25
Save that.
4:34
Let's try running it real quick.
4:34
Go run temp.go, which I've named my file.
4:37
And it prints out 2 1.
4:42
The first value here is
the result of rounding
4:43
1.23 up to the nearest whole number.
4:48
And the second value here is the result
of rounding it down to the nearest whole
4:52
number.
4:57
Unlike in some other languages,
4:58
it's actually compile error to import
a package and then not use it.
5:00
In other languages, large programs tended
to accumulate many unused library imports
5:04
which slowed compile times.
5:08
So Go doesn't allow that in order
to help your development team
5:10
keep your apps compilation fast.
5:13
So let's try importing another
package into the program here.
5:16
And then we won't actually use it.
5:20
So up here in the import statement
I'm going to add the time package.
5:21
Now let's try running it,
down here on the console.
5:26
And we'll actually see
a compile error this time.
5:30
Imported and not used, time.
5:32
So as I say, make sure to only import
packages that you're going to actually use
5:35
in your program.
5:39
If we remove that again and
rerun our program it should run this time.
5:40
To define a new package
you simply create one or
5:45
more .go files within a single directory.
5:48
Each file needs to begin with
the package declaration,
5:51
which includes the name of the package
a package name should be all lower case.
5:54
And by convention it should
be a single word if possible.
5:58
Then within the package body you declare
one or more constants, variables, or
6:02
functions that you want
your package to include.
6:06
Constants variables or functions that are
named with a capital letter are exported
6:10
from your package and that means
they'll be visible to other packages.
6:14
By contrast, if a constant variable or
function is named with a lower case,
6:18
if it begins with a lower case letter,
it'll be unexported.
6:23
And that means that you can't
use it from other packages.
6:26
So these two constants up here,
their names begin with capital letters,
6:30
that means they'll be
visible from other packages.
6:33
And this one down here,
that's not ready for public use, so
6:35
it's named with a lower case letter.
6:38
And that means it'll be unexported.
6:40
You need to sign up for Treehouse in order to download course files.
Sign upYou need to sign up for Treehouse in order to set up Workspace
Sign up