Questions in: Cgi Perl

$array[1] represents a scalar value.
@array[1] represents array slicing.
@array[1] returns a list with one scalar value.
We should use $ when we want a scalar value.
If we want a list we need to use @.
If we use 'use warnings' then @array[1] will give the warnings
like ,Scalar value @array[1] better written as $array[1].

The above two while loops are used to add the elements into
the end of the array.
But in first while loop we are manually getting the index of
the last element in the array then we are storing the
element into next index.
But push internally performing that operation.
And the push() has some advantages also.
Using push we can add multiple items into an array in a
single instance.
But this is not possible in the fist while loop.

use:
* Object Verification will happen @ Compile Time.
* File will have extention of .pm
* Module location will be set by @ISA Variable.
require:
* Object Verification will happen @ Run TIme.
* Method can be used from and .pm or .pl file.
* Absolute path to be given, if file located in different
dir.

use:
1-its compile time concept & refresh the namespace for
different package loading.
Require:
it is run time concept & does not refresh the namespace for
different package loading.

Windows authentication introduced
thorough "cfntauthenticate" tag
cfcompile utility introduced which used for Sourceless
deployment
Administrator API: Change ColdFusion settings
programmatically, without logging into the CF Administrator.
Gateways: SMS, IM (based on Extensible Messaging and
Presence Protocol) gateways introduced

123eng.com,File guru.com

case 1:
by decalring "my" we are making the variable local.
So you cant access the value of those variable from the
outsite of that block.
case 2:
here you can access the value of the code from the
outside of that code.
"my" is generally used to protect the variable from
mingling.

Perl Installation on Linux/Unix:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
% perl Makefile.PL
% make // nmake for Windows.
% make test
% make install
% make clean
Perl Installation on Windows:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
% perl -MCPAN -e shell
% install <Module Name> Eg: install Net::FTP

doing make test and doing install <mod name> is only
possible if you are a root user or a trusted su user,
otherwise it is not at all possible to install the module in
perl.
but if you want to use that module without actually
installing it, it is possible. first download the tar file
of the module from the CPAN then untar the file in your
desired directory then see that where the .pm file lies copy
that .pm file to your desired location. now you have to see
whether that module is further using any module or not if
not then it is fine but if then you have to do the entire
process for the new module and provide the customized path
to the first module in the use or require, include the
desired pm file as using require lib or pushing the pm at
@INC manually.
push @INC <path to module>;

if we are looking for occurrences of single character in a
string then we can use TR command
syntax: tr///
example:
$string="The lion group will meet me after lunch";
and we are looking for the occurrences of character 'l' in
the given string. then we can write tr like
$count = ($string=~tr/l//);
print "l is coming $count time(s)";
but for multiple characters look up we have to use:
$string = "-9 55 48 -2 23 -76 4 14 -44";
while ($string =~ /-d+/g) { $count++ }
print "There are $count negative numbers in the string";
Donated by :- Kuldip singh behal

while ($string =~ /<pattern>/g) { $count++ }

I did't got ur answer ..!!
Can u explain it a lil Bit ...

open(FH, "file");
@array = <FH>;
%seen = ();
@uniq = grep{!seen{$_}++} @array;

we can also use -c and -d switches to debug our perl scripts
ex:
perl -c sample.pl (for compilation errors)
perl -d sample.pl (for debugging the code line by line)

For debugging perl scripting u can use
1. diagnostic modules - which can help us isolate and
understand problems with our code.
EX- use warning, use strict, use diagnostics
2.perl command line switches - u can create test programm
using the perl command line.
Ex-i) #!user/bin/perl -w
or on the command line like this
>perl -w program.plx
ii) -e = it tells the perl not to load and run a program
file but to run the text following -e as a program.
> perl -e "print "hello World n";"
iii)-c = stops perl from running your program instead ,al it
does is check that code can be complied as valid perl.
its a good way to quickly check that a program has no
glaring syntax errors.
> perl -ce 'print "hello,worldn";'
and so on it will available Google u can search ........
3. debugging techniques and perl de-debugger - how to remove
the problems that we've found.
Using debugger
> perl -d filename.plx

package Test;
sub new
{
$class = shift;
$self = {};
bless $self,$class; # By Mistake earlier i wrote it as
#$ref
return $self;
}
1;
# In perl Script
use Test; # Include the module you have created
$obj=new Test; # creating an onject of Class Test

Say Pachage is My Package
package MyPackage;
sub method() {
}
Then U can create Object
$myobject = new MyPackage();
and u can call any method of object like:
$myobject->method();

Create a .pm file eg xyz.pm and you can have subroutines or
what ever you want can be placed there.
#content of xyz.pm
package xyz;
sub Printit{
print "In module xyz...";
}
1;
#end of xyz.pm
for using this perl module in ur perl program eg abc.pl
# content of abc.pl
use xyz;
xyz->Printit();
#end pf abc.pl
hope this helps :)

Package Module_name;
require Exporter;
@ISA = qw(list of base classes);
@Export = qw(list of symbols );
#------------code---------------------
#at the end of module
1;

You can catch the errros by using eval function.
Keep your code in eval block some thing like shown below.
Eg.,
#################################
eval {
my $a = 0;
my $b = $a/0; #Dividing 0 with 0 is definitely an error
};
if ($@) {
print "n Error in your code";
}
############################
-> Eval block always ends with a semi-colon. $@ will catch
the errors persent.
-> If any errors are present $@ will be set otherwise $@
will not be set
-> Unfortunately in Perl we don't have Explicit Error
handling techniques like some other languages like java etc
I mean like IOException etc.,

#Ist trapping the error in a block
eval {
# perl code goes here
};
if ($@) { # $@ is a special variable containing the error
if any else blank
print "Print your own error If u want";
}
# 2nd
# use if or unless for a loop ;ike below
if(chk some condition)
{
die"$!n"; # if the condition success
}
system generated error is printed and the scirpt is exited
}

The question is not clear, if i am picking you up
correctly, here is the answer.
If you want to check the particular part of a code ran fine
or not,you can put it in a eval block and then check for $@
(if $@ set, something wrong) and accordingly print the
message in the log file.
If not helpful,can you pls explain the questions properly.

Could you pelase let me know how to justified the test is
pass or not.

- A module is a .pm file containing some Perl code.
- A package is a declaration of the name of the current
scope, e.g.:
package Math::Complex
- Which can occur in the code of a module or a script.
- A module can be used, because it is a physical
'thing', but a package cannot.
- A module may contain several packages:

Modules and packages are usually used interchangeably. But
there is a difference.
a. Packages are perl files with .pm extn and is considered
a separate namespace. So a package is nothing but group of
related scalars,arrays,hashes and subroutines for a
specific purpose.Once a package is included in a .plx file
(using "use") and you want to call one of the subroutines
of the package, you may have to use the scope resolution
operator &package::subroutine1 ( as the subroutine of the
package is in a separate name space).
b. Modules are packages but which has the capabilities of
exporting selective subroutines/scalars/arrays/hashes of
the package to the namespace of the main package itself. So
for the interpreter these look as though the subroutines
are part of the main package itself and so there is no need
to use the scope resolution operator while calling them.
This is usually done like:
use Exporter;
our @ISA=('Exporter');
our @EXPORT=('$x','@arr',subroutine)
(you are exporting a scalar, array and a sub-routine from
the package). So if some .plx is using the above package
they need not use the scope resolution to call these.
A direct access like "print $x" would work even without
using the scope resolution.

Simple guys here we go :-).........
#!/usr/bin/perl -w
use strict;
my($test,$number) = ("","");
$test = "12344tyyyyy456";
$number = ($test =~ tr/[0-9]/[0-9]/);
print "Number of digits in variable is :- $number ";
exit;

($test,$number) = ("","");
$test = "12344tyyyyy456";
@test=split('',$test);
foreach(@test)
{
if ($_ =~ /d/)
{$number++;
}
}
print $number;

# Correction to my above post
$infile = 'errorlog.txt';
$outfile = 'analysys.txt';
open(INFILE,"$infile") || die "Unable to Open $infile-$!";
open(OUTFILE,">$outfile") || die "Unable to Open $outfile-
$!";
while ( <INFILE> ) {
print OUTFILE $_ if (/error/);
}
close INFILE;
close OUTFILE;

## Go to that Directory
my $file_output = "output";
open(OUTFILEHANDLE,">$file_output") || die "Unable to open
the file : $file_output";
foreach my $input_file (`ls -1`) {
open(INFILEHANDLE,"$input_file") || die "Unable to
open the file : $input_file";
while (<INFILEHANDLE>) {
print OUTFILEHANDLE $_ if (/print header/);
}
}