ghostscriptsharp pdf to image c# : Changing font size in pdf form field application control tool html web page wpf online 05-welling-php-mysql-web18-part63

147
Understanding Scope
A variable’s scope controls where that variable is visible and usable. Different pro-
gramming languages have different rules that set the scope of variables. PHP has fairly
simple rules:
n
Variables declared inside a function are in scope from the statement in which they
are declared to the closing brace at the end of the function.This is called function
scope.These variables are called local variables.
n
Variables declared outside functions are in scope from the statement in which they
are declared to the end of the file, but not inside functions.This is called global scope.
These variables are called global variables.
n
The special superglobal variables are visible both inside and outside functions.(See
Chapter 1,“PHP Crash Course,”for more information on these variables.)
n
Using 
require()
and 
include()
statements does not affect scope. If the statement
is used within a function,function scope applies.If it is not inside a function, glob-
al scope applies.
n
The keyword 
global
can be used to manually specify that a variable defined or
used within a function will have global scope.
n
Variables can be manually deleted by calling 
unset($variable_name)
.A variable
is no longer in scope if it has been unset.
The following examples might help to clarify scope further.
The following code produces no output.Here,you declare a variable called 
$var
inside the function 
fn()
.Because this variable is declared inside a function, it has func-
tion scope and exists only from where it is declared until the end of the function.When
you again refer to 
$var
outside the function,a new variable called 
$var
is created.This
new variable has global scope and will be visible until the end of the file.Unfortunately,
if the only statement you use with this new 
$var
variable is 
echo
,it will never have a
value.
function fn()
{
$var = ‘contents’;
}
fn();
echo $var;
The following example is the inverse.Here, you declare a variable outside the function
and then try to use it within a function:
function fn()
{
echo ‘inside the function, $var = ‘.$var.’<br />’;
$var = ‘contents 2’;
echo ‘inside the function, $var = ‘.$var.’<br />’;
}
Changing font size in pdf form field - C# PDF Field Edit Library: insert, delete, update pdf form field in C#.net, ASP.NET, MVC, Ajax, WPF
Online C# Tutorial to Insert, Delete and Update Fields in PDF Document
add fields to pdf; change font size pdf form reader
Changing font size in pdf form field - VB.NET PDF Field Edit library: insert, delete, update pdf form field in vb.net, ASP.NET, MVC, Ajax, WPF
How to Insert, Delete and Update Fields in PDF Document with VB.NET Demo Code
adding text to pdf form; pdf create fillable form
148
Chapter 5 Reusing Code and Writing Functions
$var = ‘contents 1’;
fn();
echo ‘outside the function, $var = ‘.$var.’<br />’;
The output from this code is as follows:
inside the function, $var =
inside the function, $var = contents 2
outside the function, $var = contents 1
Functions are not executed until they are called,so the first statement executed is 
$var
= ‘contents 1’;
.This statement creates a variable called 
$var
,with global scope and
the contents 
“contents 1”
.The next statement executed is a call to the function 
fn()
.
The lines inside the statement are executed in order.The first line in the function refers
to a variable named 
$var
.When this line is executed,it cannot see the previous 
$var
that was created,so it creates a new one with function scope and echoes it.This creates
the first line of output.
The next line within the function sets the contents of 
$var
to 
“contents 2”
.
Because you are inside the function,this line changes the value of the local 
$var
,not the
global one.The second line of output verifies that this change worked.
The function is now finished,so the final line of the script is executed.This 
echo
statement demonstrates that the global variable’s value has not changed.
If you want a variable created within a function to be global,you can use the 
keyword 
global
as follows:
function fn()
{
global $var;
$var = ‘contents’;
echo ‘inside the function, $var = ‘.$var.’<br />’;
}
fn();
echo ‘outside the function, $var = ‘.$var.’<br />’;
In this example,the variable 
$var
is explicitly defined as global,meaning that after the
function is called, the variable will exist outside the function as well.The output from
this script follows:
inside the function, $var = contents
outside the function, $var = contents
Note that the variable is in scope from the point in which the line 
global $var;
is
executed.You could declare the function above or below where you call it.(Note that
function scope is quite different from variable scope!) The location of the function dec-
laration is inconsequential;what is important is where you call the function and there-
fore execute the code within it.
C# PDF Convert to Tiff SDK: Convert PDF to tiff images in C#.net
Supports tiff compression selection. Supports for changing image size. RasterEdge. Imaging.Font.dll. zoomValue, The magnification of the original PDF page size.
create a fillable pdf form from a word document; create a pdf form in word
VB.NET PDF File Merge Library: Merge, append PDF files in vb.net
Merge PDF without size limitation. function will put the two target PDF together and save as new PDF, without changing the previous RasterEdge.Imaging.Font.dll.
add form fields to pdf; pdf form maker
149
Passing by Reference Versus Passing by Value
You can also use the 
global
keyword at the top of a script when a variable is first
used to declare that it should be in scope throughout the script.This is possibly a more
common use of the 
global
keyword.
You can see from the preceding examples that it is perfectly legal to reuse a variable
name for a variable inside and outside a function without interference between the two.
It is generally a bad idea,however,because without carefully reading the code and think-
ing about scope,people might assume that the variables are one and the same.
Passing by Reference Versus Passing by Value
If you want to write a function called 
increment()
that allows you to increment a
value,you might be tempted to try writing it as follows:
function increment($value, $amount = 1)
{
$value = $value +$amount;
}
This code is of no use.The output from the following test code will be 
10
:
$value = 10;
increment ($value);
echo $value;
The contents of 
$value
have not changed because of the scope rules.This code creates a
variable called 
$value
,which contains 10.It then calls the function 
increment()
.The
variable 
$value
in the function is created when the function is called.One is added to
it,so the value of 
$value
is 11 inside the function,until the function ends;then you
return to the code that called it. In this code,the variable 
$value
is a different variable,
with global scope,and therefore unchanged.
One way of overcoming this problem is to declare 
$value
in the function as global,
but this means that to use this function,the variable that you wanted to increment
would need to be named 
$value
.A better approach would be to use pass by reference.
The normal way that function parameters are called is through an approach dubbed
pass by value.When you pass a parameter, a new variable is created containing the value
passed in. It is a copy of the original.You are free to modify this value in any way,but
the value of the original variable outside the function remains unchanged.
The better approach is to use pass by reference.Here,when a parameter is passed to a
function,instead of creating a new variable, the function receives a reference to the orig-
inal variable.This reference has a variable name,beginning with a dollar sign (
$
),and can
be used in exactly the same way as another variable.The difference is that instead of hav-
ing a value of its own,it merely refers to the original.Any modifications made to the
reference also affect the original.
You specify that a parameter is to use pass by reference by placing an ampersand (
&
)
before the parameter name in the function’s definition. No change is required in the
function call.
150
Chapter 5 Reusing Code and Writing Functions
You can modify the preceding 
increment()
example to have one parameter passed
by reference,and it will work correctly:
function increment(&$value, $amount = 1)
{
$value = $value +$amount;
}
You now have a working function and are free to name the variable you want to incre-
ment anything you like.As already mentioned,it is confusing to humans to use the same
name inside and outside a function,so you can give the variable in the main script a
new name.The following test code now echoes 10 before the call to 
increment()
and 11 afterward:
$a = 10;
echo $a.’<br />’;
increment ($a);
echo $a.’<br />’;
Returning from Functions
The keyword 
return
stops the execution of a function.When a function ends because
either all statements have been executed or the keyword 
return
is used,execution
returns to the statement after the function call.
If you call the following function,only the first 
echo
statement will be executed:
function test_return()
{
echo ‘This statement will be executed’;
return;
echo ‘This statement will never be executed’;
}
Obviously,this is not a very useful way to use 
return
.Normally,you want to return
from the middle of a function only in response to a condition being met.
An error condition is a common reason to use a 
return
statement to stop execution
of a function before the end.If,for instance,you write a function to find out which of
two numbers is greater,you might want to exit if any of the numbers are missing:
function larger( $x, $y )
{
if (!isset($x)||!isset($y))
{
echo ‘This function requires two numbers’;
return;
}
if ($x>=$y)
151
Returning from Functions
echo $x;
else
echo $y;
}
The built-in function 
isset()
tells you whether a variable has been created and given a
value.This code gives an error message and returns if either of the parameters has not
been set with a value.You test it by using 
!isset()
,meaning “NOT 
isset()
,”so the 
if
statement can be read as “if x is not set or if y is not set.”The function returns if either
of these conditions is true.
If the 
return
statement is executed,the subsequent lines of code in the function will
be ignored.Program execution returns to the point at which the function was called.If
both parameters are set,the function will echo the larger of the two.
The output from the code
$a = 1;
$b = 2.5;
$c = 1.9;
larger($a, $b);
larger($c, $a);
larger($d, $a);
is as follows:
2.5
1.9
This function requires two numbers
Returning Values from Functions
Exiting from a function is not the only reason to use 
return
.Many functions use
return
statements to communicate with the code that called them.Instead of echoing
the result of the comparison in the 
larger()
function,the function might have been
more useful if it returned the answer.This way, the code that called the function can
choose if and how to display or use it.The equivalent built-in function 
max()
behaves in
this way.
You can write the 
larger()
function as follows:
function larger ($x, $y)
{
if (!isset($x)||!isset($y))
return false;
else if ($x>=$y)
return $x;
else
return $y;
}
152
Chapter 5 Reusing Code and Writing Functions
Here, the function returns the larger of the two values passed in.It returns an obviously
different value in the case of an error.If one of the numbers is missing,it returns 
false
.
(The only caveat with this approach is that programmers calling the function must test
the return type with 
===
to make sure that 
false
is not confused with 0.)
For comparison,the built-in function 
max()
returns nothing if both variables are not
set and,if only one was set,returns that one.
The code
$a = 1; $b = 2.5; $c = 1.9;
echo larger($a, $b).’<br />’;
echo larger($c, $a).’<br />’;
echo larger($d, $a).’<br />’;
produces this output because 
$d
does not exist and 
false
is not visible:
2.5
1.9
Functions that perform some task but do not need to return a value often return 
true
or 
false
to indicate whether they succeeded or failed.The boolean values 
true
and
false
can be represented with integer values 1 and 0, respectively, although they are of
different types.
Code Blocks
You declare that a group of statements is a block by placing them within curly braces.
This does not affect most of the operation of your code but has specific implications,
including the way control structures such as loops and conditionals execute.
The following two examples work very differently:
Example without code block:
for($i = 0; $i < 3; $i++ )
echo ‘Line 1<br />’;
echo ‘Line 2<br />’;
Example with code block:
for($i = 0; $i < 3; $i++ )
{
echo ‘Line 1<br />’;
echo ‘Line 2<br />’;
}
In both examples,the 
for
loop is iterated through three times.In the first example,only
the single line directly below this is executed by the 
for
loop.The output from this
example is as follows:
Line 1
Line 1
153
Returning Values from Functions
Line 1
Line 2
The second example uses a code block to group two lines together.This means that both
lines are executed three times by the 
for
loop.The output from this example is as fol-
lows:
Line 1
Line 2
Line 1
Line 2
Line 1
Line 2
Because the code in these examples is properly indented,you can probably see the dif-
ference between them at a glance.The indenting of the code is intended to give readers
a visual interpretation of what lines are affected by the 
for
loop.However,note that
spaces do not affect how PHP processes the code.
In some languages,code blocks affect variable scope.This is not the case in PHP.
Implementing Recursion
Recursive functions are supported in PHP.A recursive function is one that calls itself.These
functions are particularly useful for navigating dynamic data structures such as linked lists
and trees.
Few web-based applications,however,require a data structure of this complexity,so
you have minimal use for recursion.It is possible to use recursion instead of iteration in
many cases because both of these processes allow you to do something repetitively.
However,recursive functions are slower and use more memory than iteration, so you
should use iteration wherever possible.
In the interest of completeness,let’s look at the brief example shown in Listing 5.5.
Listing 5.5 recursion.php—Reversing a String Using Recursion and Iteration
function reverse_r($str)
{
if (strlen($str)>0)
reverse_r(substr($str, 1));
echo substr($str, 0, 1);
return;
}
function reverse_i($str)
{
154
Chapter 5 Reusing Code and Writing Functions
for ($i=1; $i<=strlen($str); $i++)
{
echo substr($str, -$i, 1);
}
return;
}
Listing 5.5 implements two functions.Both of them print a string in reverse.The func-
tion 
reverse_r()
is recursive,and the function 
reverse_i()
is iterative.
The 
reverse_r()
function takes a string as a parameter.When you call it,it proceeds
to call itself,each time passing the second to last characters of the string.For example,if
you call
reverse_r(‘Hello’);
it will call itself a number of times,with the following parameters:
reverse_r(‘ello’);
reverse_r(‘llo’);
reverse_r(‘lo’);
reverse_r(‘o’);
reverse_r(‘’);
Each call the function makes to itself makes a new copy of the function code in the
server’s memory,but with a different parameter.It is like pretending that you are actually
calling a different function each time.This stops the instances of the function from get-
ting confused.
With each call,the length of the string passed in is tested.When you reach the end of
the string (
strlen()==0
),the condition fails.The most recent instance of the function
(
reverse_r(‘’)
) then goes on and performs the next line of code,which is to echo the
first character of the string it was passed;in this case,there is no character because the
string is empty.
Next, this instance of the function returns control to the instance that called it,name-
ly 
reverse_r(‘o’)
.This function then prints the first character in its string—
”o”
—and
returns control to the instance that called it.
The process continues—printing a character and then returning to the instance of the
function above it in the calling order—until control is returned to the main program.
There is something very elegant and mathematical about recursive solutions. In most
cases,however,you are better off using an iterative solution.The code for such a solution
is also shown in Listing 5.5.Note that it is no longer (although this is not always the case
with iterative functions) and does exactly the same thing.The main difference is that the
recursive function makes copies of itself in memory and incurs the overhead of multiple
function calls.
Listing 5.5 Continued
155
Further Reading
You might choose to use a recursive solution when the code is much shorter and
more elegant than the iterative version,but it does not happen often in this application
domain.
Although recursion appears more elegant,programmers often forget to supply a ter-
mination condition for the recursion.This means that the function will recur until the
server runs out of memory,or until the maximum execution time is exceeded, whichev-
er comes first.
Further Reading
The use of 
include()
,
require()
,
function
,and 
return
are also explained in the
online manual.To find out more details about concepts such as recursion, pass by value
or reference, and scope that affect many languages,you can look at a general computer
science textbook,such as Dietel and Dietel’s C++ How to Program.
Next
Now that you are using include files, require files,and functions to make your code
more maintainable and reusable,the next chapter addresses object-oriented software and
the support offered in PHP.Using objects allows you to achieve goals similar to the con-
cepts presented in this chapter,but with even greater advantages for complex projects.
Documents you may be interested
Documents you may be interested