Message-ID: <828817802.9688.1414230372431.JavaMail.firstname.lastname@example.org> Subject: Exported From Confluence MIME-Version: 1.0 Content-Type: multipart/related; boundary="----=_Part_9687_687724508.1414230372431" ------=_Part_9687_687724508.1414230372431 Content-Type: text/html; charset=UTF-8 Content-Transfer-Encoding: quoted-printable Content-Location: file:///C:/exported.html
Groovy requires Java, so you need to have a version available (while gro= ovy 1.6 supported JDK 1.4 or greater, for groovy 1.7 onwards, minimum JDK 1= .5 is needed). Here are the steps if you don't already have Java installed:=
Download the Groovy installer or binaries from the downloa= ds page and follow the installation instructions. (There is curre= ntly an issue where you cannot have spaces in the path where Groovy is inst= alled under windows. So, instead of accepting the default installatio= n path of "c:\Program Files\Groovy" you will want to change the p= ath to something like "c:\Groovy")
You may wish to obtain optional jar files, either corresponding to Groov= y modules (see module documentation for details) or corresponding to other = Java classes you wish to make use of from Groovy. Some possibilities are li= sted below:
Database driver for SQL Server and/or Sybase<= /p>
Database driver for HSQLDB, a 100% Java datab= ase
The recommended way for making Groovy be aware of your additional jar fi=
les is to place them in a predefined location. Your Groovy install should i=
nclude a file called
groovy-starter.conf. Within that file, ma=
ke sure a line such as
is not commented out. The
.home system property is set by your operating system. (Mine is
(Note: as an alternative, y= ou can set up a CLASSPATH variable and make sure it mentions all of your ad= ditional jar files, otherwise Groovy works fine with an empty or no CLASSPA= TH variable.)
In the top part of the window of the groovyConsole, type the following= p>
And then type <CTRL-R>.
= Notice that the text gets printed out in the OS console window (the black o= ne behind the groovyConsole window) and the bottom part of the groovyConsol= e says:
The line starting with "groovy&= gt;" is just the text of what the console processed. The "null&qu= ot; is what the expression "evaluated to". Turns out the expressi= on to print out a message doesn't have any "value" so the groovyC= onsole printed "null".
Next try something with an actual va= lue. Replace the text in the console with:
or your favorite arithmetic expressi= on, and then type <CTRL-R> (I'm going to stop telling you to hit <= CTRL-R>, I think you get the idea). Now the "value" printed at= the bottom of the groovyConsole has more meaning.
You can assign values to variables for later use. Try the following:
The Groovy language has built-in support for two important data types, l= ists and maps (Lists can be operated as arrays in Java language). Lists are= used to store ordered collections of data. For example an integer list of = your favorite integers might look like this:
You can access a given item in the l= ist with square bracket notation (indexes start at 0):
Should result in this output:
You can get the length of the list w= ith the "size" method:
Should print out:
But generally you shouldn't need the= length, because unlike Java, the preferred method to loop over all the ele= ments in an list is to use the "each" method, which is described = below in the "Code as Data" section.
Another native data st= ructure is called a map. A map is used to store "associative arrays&qu= ot; or "dictionaries". That is unordered collections of heterogen= eous, named data. For example, let's say we wanted to store names with IQ s= cores we might have:
Note that each of the values stored = in the map is of a different type. Brett's is an integer, Pete's is a strin= g, and Andrew's is a floating point number. We can access the values in a m= ap in two main ways:
Should produce the output:
To add data to a map, the syntax is = similar to adding values to an list. For example, if Pete re-took the IQ te= st and got a 3, we might:
Then later when we get the value bac= k out, it will be 3.
should print out 3.
Also as an= aside, you can create an empty map or an empty list with the following:
To make sure the lists are empty, yo= u can run the following lines:
Should print a size of 0 for the Lis= t and the Map.
One of the most important features of any programming language is the ab= ility to execute different code under different conditions. The simplest wa= y to do this is to use the '''if''' construct. For example:
Don't worry too much about the first= line, it's just some code to determine whether it is currently before noon= or after. The rest of the code executes as follows: first it evaluates the= expression in the parentheses, then depending on whether the result is '''= true''' or '''false''' it executes the first or the second code block. See = the section below on boolean expressions.
Note that the "else&qu= ot; block is not required, but the "then" block is:
There is a special data type in most programming languages that is used = to represent truth values, '''true''' and '''false'''. The simplest boolean= expression are simply those words. Boolean values can be stored in variabl= es, just like any other data type:
A more complex boolean expression us= es one of the boolean operators:
Most of those are probably pretty in= tuitive. The equality operator is '''=3D=3D''' to distinguish from the assi= gnment operator '''=3D'''. The opposite of equality is the '''!=3D''' opera= tor, that is "not equal"
So some examples:
Boolean expressions are especially u= seful when used in conjunction with the '''if''' construct. For example:
An especially useful test is to test= whether a variable or expression is null (has no value). For example let's= say we want to see whether a given key is in a map:
Generally null is used to indicate t= he lack of a value in some location.
One of the things that makes Groovy different than most compiled languag= es is that you can create functions that are first class objects. That is y= ou can define a chunk of code and then pass it around as if it were a strin= g or an integer. Check out the following code:=20 =20
The curly braces around the expression "it * it" tells the Gro= ovy compiler to treat this expression as code. In the software world, this = is called a "closure". In this case, the designator "it"= ; refers to whatever value is given to the function. Then this compiled fun= ction is assigned to the variable "square" much like those above.= So now we can do something like this:=20 =20
and get the value 81.=20
This is not very interesting until we find that we can pass this functio= n "square" around as a value. There are some built in functions t= hat take a function like this as an argument. One example is the "coll= ect" method on arrays. Try this:=20 =20
This expression says, create an array with the values 1,2,3 and 4, then = call the "collect" method, passing in the closure we defined abov= e. The collect method runs through each item in the array, calls the closur= e on the item, then puts the result in a new array, resulting in:=20 =20
For more methods you can call with closures as arguments, see the Groovy GDK documentation.=20
By default closures take 1 parameter called "it", you can also= create closures with named parameters. For example the method Map.each() c= an take a closure with two variables, to which it binds the key and associa= ted value:=20 =20
Here are a few more closure examples. This first one shows a couple of t= hings. First, the closure is interacting with a variable outside itself. Th= at is, the closure's purpose is to put together the parts of a stock order = held in the array orderParts, by adding (appending) it to the variable full= String. The variable fullString is not in the closure. The second thing tha= t is different about this example is that the closure is "anonymous&qu= ot;, meaning that it is not given a name, and is defined in the place where= the each method is called.=20 =20
You can probably guess what this prints out.=20
The next example is another anonymous closure, this time, summing up the= values stored in a map.=20 =20
Reading data from files is relatively simple. First create a text file, = and call it myfile.txt. It doesn't matter what's in it, just type some rand= om text into it and save it on your C: drive in the \temp directory. Then t= ype the following code in the groovyConsole:=20 =20
This should print out every line in the file prefixed with "File li= ne: ". The first two lines of the code simply declare variables to spe= cify where the file is located. The variable names don't have any special s= ignificance, and as you can see, all we do is combine them when we use them= . Note that because the backslash character has special meaning in groovy, = you have to use two of them to tell it that you '''really''' mean a backsla= sh.=20
The next line that starts "myFile =3D" creates a new File obje= ct. An object is simply a collection of related methods and data. For examp= le, a file object might have data describing its location, in this case &qu= ot;C:\temp\myfile.txt", and maybe a method to delete the file if it ex= ists. In this case the only method we are going to use is the eachLine meth= od, which we call in the last line of code. The line before that is a simpl= e closure definition, that you have seen several times by this point.= =20
Strings in Groovy have all the same functionality of Java strings. That = is, a Groovy string is just a Java string with a few extra things added to = it. Because of that, we can refer to the Java documentation for the String class to find out some of the i= nteresting things we can do with it. For example, look in the section entit= led '''Method Summary''' at the description for the '''split''' method. Thi= s method does something very useful, which is to split a string based on a = regular expression. We will talk more about regular expressions later, but = for now the only thing you have to know is that the simplest regular expres= sion is a single character. So let's say that we want to split up the compo= nents of the date "2005-07-04", so that we can add one to the yea= r to get the date of next fourth of July. We might:=20 =20
This code brings together a bunch of things we have talked about before.= There are two new things, first is the use of the split method on a String= . Second is the call of toInteger() on a String. This call to toInteger sim= ply tells Groovy that you want to treat that data as a number rather than a= String. See what happens if you run the same code without ".toInteger= ()" at the end of the third line.=20
Another thing you might notice is that toInteger is not listed in the Ja= va documentation for string. That is because it is one of the extra feature= s that Groovy has added to Strings. You can also take a look at the documen= tation for the Groovy extensions to Java objects.<= /p>=20