Go/Packages - Revision history

Admin: /* Resources */

2018-12-30T08:35:23Z

Resources

← Older revision		Revision as of 08:35, 30 December 2018
Line 169:		Line 169:

	=Resources=		=Resources=

			nice explanation, top-down: https://golang.org/doc/code.html

	https://www.callicoder.com/golang-packages/		https://www.callicoder.com/golang-packages/

Admin: /* Github Packages */

2018-12-30T08:27:50Z

Github Packages

← Older revision		Revision as of 08:27, 30 December 2018
Line 163:		Line 163:

	(Fill in here...)		(Fill in here...)

			=Travis CI Testing of Packages=

			(More details to here)

	=Resources=		=Resources=

Admin: /* Packages in Go */

2018-12-30T08:12:51Z

Packages in Go

← Older revision		Revision as of 08:12, 30 December 2018
Line 159:		Line 159:
	}		}
	</pre>		</pre>

			=Github Packages=

			(Fill in here...)

	=Resources=		=Resources=

Admin: /* Layout of repo and packages */

2018-12-30T05:58:47Z

Layout of repo and packages

← Older revision		Revision as of 05:58, 30 December 2018
Line 50:		Line 50:
	</pre>		</pre>

	===Layout of repo and packages===		===Layout of (existing) repo and packages===

	You can lay out the package as you wish ~~- but~~ remember using "import" will import the library from ~~the source directory,~~ not from ~~the~~ GOPATH.		You can lay out the package as you wish, just remember that using "import" will import the library from <code>$GOPATH/src</code> and not from <code>$GOPATH</code>.

	Typically, we organize related functions into packages, and we keep one or more packages in a repository. We then keep a copy of this repository in our GOPATH.		Typically, we organize related functions into packages, and we keep one or more packages in a repository. We then keep a copy of this repository in our <code>$GOPATH</code>.

	Let's look at an example: suppose we have a package named <code>greasy_grimy_gopher_guts</code> on Github. Then one way of organizing the directory might be:		Let's look at an example: suppose we have a package named <code>greasy_grimy_gopher_guts</code> on Github. Then one way of organizing the directory might be:

Admin: /* Creating a package */

2018-12-21T07:08:03Z

Creating a package

← Older revision		Revision as of 07:08, 21 December 2018
Line 137:		Line 137:
	/home/username/go		/home/username/go
	src/		src/
	~~github.com~~/		greasy_grimy_gopher_guts/
	~~username/~~		# This is the top level of our package's repository
	~~greasy_grimy_gopher_guts/~~		</pre>
	# This is the top level of our package's repository
			In this case, the import statement in our repository's main package get simpler too:

			<pre>
			package main

			import (
			"fmt"
			"greasy_grimy_gopher_guts/numbers"
			)

			func main() {
			for i:=0; i<10; i++ {
			if numbers.IsPrime(i) {
			fmt.Println(i)
			}
			}
			}
	</pre>		</pre>

Admin: /* Adding package to repo */

2018-12-21T07:06:01Z

Adding package to repo

← Older revision		Revision as of 07:06, 21 December 2018
Line 70:		Line 70:
	Then we would have one directory in the repository for each package that we wanted to define. We would also include a main package somewhere in the repository, so we have an entry point for our program. When we tell go to install the main package, it will turn that main package into a command line executable that will execute the main function of this program.		Then we would have one directory in the repository for each package that we wanted to define. We would also include a main package somewhere in the repository, so we have an entry point for our program. When we tell go to install the main package, it will turn that main package into a command line executable that will execute the main function of this program.

	===Adding package to repo===		===Adding a package to the repo dir===

	Suppose we have a package called "primecheck" that just provides a single function to check if a number is prime. Then we can add it to the repository contents like so:		Suppose we have a package called "primecheck" that just provides a single function to check if a number is prime. Then we can add it to the repository contents like so:
Line 128:		Line 128:
	}		}
	</pre>		</pre>


	===An alternate directory layout===		===An alternate directory layout===

Admin: /* Creating a package */

2018-12-21T07:02:36Z

Creating a package

← Older revision		Revision as of 07:02, 21 December 2018
Line 50:		Line 50:
	</pre>		</pre>

	===Layout of ~~the package~~===		===Layout of repo and packages===

	You can lay out the package as you wish - but using "import" will import the library from the source directory, not from the GOPATH.		You can lay out the package as you wish - but remember using "import" will import the library from the source directory, not from the GOPATH.

			Typically, we organize related functions into packages, and we keep one or more packages in a repository. We then keep a copy of this repository in our GOPATH.

	Let's look at an example: suppose we have a package named <code>greasy_grimy_gopher_guts</code> on Github. Then one way of organizing the directory might be:		Let's look at an example: suppose we have a package named <code>greasy_grimy_gopher_guts</code> on Github. Then one way of organizing the directory might be:
Line 67:		Line 69:

	Then we would have one directory in the repository for each package that we wanted to define. We would also include a main package somewhere in the repository, so we have an entry point for our program. When we tell go to install the main package, it will turn that main package into a command line executable that will execute the main function of this program.		Then we would have one directory in the repository for each package that we wanted to define. We would also include a main package somewhere in the repository, so we have an entry point for our program. When we tell go to install the main package, it will turn that main package into a command line executable that will execute the main function of this program.

			===Adding package to repo===

	Suppose we have a package called "primecheck" that just provides a single function to check if a number is prime. Then we can add it to the repository contents like so:		Suppose we have a package called "primecheck" that just provides a single function to check if a number is prime. Then we can add it to the repository contents like so:
Line 139:		Line 143:
	# This is the top level of our package's repository		# This is the top level of our package's repository
	</pre>		</pre>







	=Resources=		=Resources=

Admin: Created page with "=Packages in Go= Every Go source file is part of some package. To declare what package it is a part of, you use `package` at the top of the file:
2018-12-21T07:00:54Z

Created page with "=Packages in Go= Every Go source file is part of some package. To declare what package it is a part of, you use <code>package <packagename></code> at the top of the file: <p..."

New page
=Packages in Go=

Every Go source file is part of some package. To declare what package it is a part of, you use <code>package <packagename></code> at the top of the file:

<pre>
package main
</pre>

The above package declaration must be the first line of code in your Go source file. All the functions, types, and variables defined in your Go source file become part of the declared package.

Variables and functions can be public or private.

==Using a package==

To use a package, e.g., the "fmt" package in the standard Go library, you import it:

<pre>
package main

import "fmt"
</pre>

Import multiple libraries using multiple import statements, or putting () around the package names:

<pre>
package main

// either
import "fmt"
import "math"

// or
import (
"fmt"
"math"
)
</pre>

==Creating a package==

To create a package, start in your Go workspace. This is set by <code>GOPATH</code> (see [[Go/Installing#Paths]] for more on these environment variables).

All import paths are relative to the src directory of your Go workspace. Suppose your GOPATH is at <code>~/go</code>. Then your Go workspace will be organized like this:

<pre>
/home/username/go
pkg/ # holds package archives
bin/ # holds binary executables
src/ # holds source code
</pre>

===Layout of the package===

You can lay out the package as you wish - but using "import" will import the library from the source directory, not from the GOPATH.

Let's look at an example: suppose we have a package named <code>greasy_grimy_gopher_guts</code> on Github. Then one way of organizing the directory might be:

<pre>
/home/username/go
src/
github.com/
username/
greasy_grimy_gopher_guts/
# This is the top level of our repository,
# which contains one or more packages
</pre>

Then we would have one directory in the repository for each package that we wanted to define. We would also include a main package somewhere in the repository, so we have an entry point for our program. When we tell go to install the main package, it will turn that main package into a command line executable that will execute the main function of this program.

Suppose we have a package called "primecheck" that just provides a single function to check if a number is prime. Then we can add it to the repository contents like so:

<pre>
/home/username/go/src/github.com/username/greasy_grimy_gopher_guts/
numbers/
primecheck.go
</pre>

Here is the prime number check function in <code>primecheck.go</code>:

<pre>
package numbers

import "math"

// Checks if a number is prime or not
func IsPrime(num int) bool {
for i := 2; i <= int(math.Floor(math.Sqrt(float64(num)))); i++ {
if num%i == 0 {
return false
}
}
return num > 1
}
</pre>

Next we will add a Go file with a main package, and use go install to turn the main method into a command line utility.

Let's write a main method that prints out all prime numbers under 10, and make it into a command line utility called <code>gopherguts</code>. Here is the directory structure:

<pre>
/home/username/go/src/github.com/username/greasy_grimy_gopher_guts/
numbers/
primecheck.go
gopherguts/
app.go
</pre>

Here is the contents of the app.go file. Here we are going to import the numbers package we created:

<pre>
package main

import (
"fmt"
"github.com/username/greasy_grimy_gopher_guts/numbers"
)

func main() {
for i:=0; i<10; i++ {
if numbers.IsPrime(i) {
fmt.Println(i)
}
}
}
</pre>

===An alternate directory layout===

Alternatively, we could go with a simpler directory layout:

<pre>
/home/username/go
src/
github.com/
username/
greasy_grimy_gopher_guts/
# This is the top level of our package's repository
</pre>

=Resources=

https://www.callicoder.com/golang-packages/

=Flags=

{{GoFlag}}