Basics<\/p>\n
Scripts<\/p>\n
Perl is a script language, which is compiled each time before running. That unix knows that it is a perl script there must be the following header at the topline of every perl script: #!\/usr\/bin\/perl where the path to perl has to be correct and the line must not exeed 32 charachters.
\nComments and Commands<\/p>\n
After the header line: #!\/usr\/bin\/perl there are either empty lines with no effect or commandlines or commentary lines. Everything from and behind a “#” up to the end of the line is comment and has no effect on the program. Commands start with the first non space charachter on a line and end with a “;”. So one can continue a command over several lines and terminates it only with the semicolon.
\nDirect commands and soubroutines<\/p>\n
Normal commands are executed in the order written in the script. But soubroutines can be placed anywhere and will only be evaluated when called from a normal commandline. Perl knows it’s a soubroutine if it the code is preceeded with a “sub” and enclosed in a block like: sub name { command;}
\nOther special lines<\/p>\n
Perl can include other programming code with: require something or with use something.
\nQuotations<\/p>\n
Single quote: ” or: q\/\/
\nDouble quote: “” or: qq\/\/
\nQuote for execution: “ or: qx\/\/
\nQuote a list of words: (‘term1′,’term2′,’term3’) or: qw\/term1 term2 term3\/
\nQuote a quoted string: qq\/”$name” is $name\/;
\nQuote something wich contains “\/”: qq!\/usr\/bin\/$file is readdy!;
\nScalar and list context<\/p>\n
That perl distinguishes between scalar and list context is the big feature, which makes it uniqe and more usful then most other script languages.<\/p>\n
A soubroutine can return lists and not only scalars like in C. Or an array gives the number of elements in a scalar context and the elements itself in a list context.<\/p>\n
The enormous value of that feature should be evident.<\/p>\n
Variables and Operators<\/p>\n
General<\/p>\n
There are scalar variables, one and two dimensional arrays and associative arrays. Instead of declaring a variable one preceeds it with a spcial charachter. $variable is a normal scalar variable. @variable is an array and %variable is an associative array. The user of perl does not have to distinguish between a number and a string in a variable. Perl switches the type if neccessary.
\nScalars<\/p>\n
Fill in a scalar with: $price = 300; $name = “JOHN”; Calculate with it like: $price *= 2; $price = $oldprice * 4; $count++; $worth–; Print out the value of a scalar with: print $price,”\\n”;
\nArrays<\/p>\n
Fill in a value: $arr[0] = “Fred”; $arr[1] = “John”; Print out this array: print join(‘ ‘,@arr),”\\n”;
\nIf two dimensional: $arr[0][0] = 5; $arr[0][1] = 7;
\nHashes (Associative Arrays)<\/p>\n
Fill in a single element with: $hash{‘fred’} = “USA”; $hash{‘john’} = “CANADA”;<\/p>\n
Fill in the entire hash:
\n%a = (
\n‘r1’, ‘this is val of r1’,
\n‘r2’, ‘this is val of r2’,
\n‘r3’, ‘this is val of r3’,
\n);
\nor with:
\n%a = (
\nr1 => ‘this is val of r1’,
\nr2 => ‘this is val of r2’,
\nr3 => ‘this is val of r3’,
\n);
\nAssignements<\/p>\n
Put something into a variable with a “=” or with some combined operator which assignes and and does something at the same time:<\/p>\n
$var = “string”; Puts the string into $var
\n$var = 5; Puts a number into $var<\/p>\n
$var .= “string”; Appends string to $var
\n$var += 5; Adds number to $var
\n$var *= 5; Multipliy with 5
\n$var ||= 5; If $var is 0 make it 5
\n$var x= 3; Make $var to three times $var as string: from a to aaa<\/p>\n
Modify and assigne with:<\/p>\n
($new = $old) =~ s\/pattern\/replacement\/;
\nComparisons<\/p>\n
Compare strings with: eq ne like in: $name eq “mary”.
\nCompare numbers with: == != >= <= <=> like in: $price == 400.<\/p>\n
And\/Or\/Not<\/p>\n
Acct on success or failure of an expression: $yes or die; means exit if $yes is not set.
\nFor AND we have: && and “and” and for OR we have: || or “or”. Not is “!” or “not”.<\/p>\n
AND,OR and NOT are regularly used in if() statements:
\nif($first && $second){….;}
\nif($first || $second){….;}
\nif($first && ! $second{….;} means that $first must be non zero but $second must not be so.
\nBut many NOT’s can be handled more reasonable with the unless() statement. Instead:
\nprint if ! $noway; one uses: print unless $noway;<\/p>\n
.<\/p>\n
Branching<\/p>\n
if<\/p>\n
if(condition){
\ncommand;
\n}elsif(condition){
\ncommand;
\n}else{
\ncommand;
\n}<\/p>\n
command if condition;
\nunless (just the opposite of if)<\/p>\n
unless(condition){
\ncommand;
\n}else{
\ncommand;
\n}<\/p>\n
command unless condition;
\nLooping<\/p>\n
while<\/p>\n
while(condition){
\ncommand;
\n}<\/p>\n
# Go prematurely to the next iteration
\nwhile(condition){
\ncommand;
\nnext if condition;
\ncommand;
\n}<\/p>\n
# Prematureley abort the loop with last
\nwhile(condition){
\ncommand;
\nlast if condition;
\n}<\/p>\n
# Prematureley continue the loop but do continue{} in any case
\nwhile(condition){
\ncommand;
\ncontinue if condition;
\ncommand;
\n}continue{
\ncommand;
\n}<\/p>\n
# Redo the loop without evaluating while(condtion)
\nwhile(condtion){
\ncommand;
\nredo if condition;
\n}<\/p>\n
command while condition;
\nuntil (just the opposite of while)<\/p>\n
until(condition){
\ncommand;
\n}<\/p>\n
until(condition){
\ncommand;
\nnext if condition;
\ncommand;
\n}<\/p>\n
until(condition){
\ncommand;
\nlast if condition;
\n}<\/p>\n
until(condition){
\ncommand;
\ncontinue if condition;
\ncommand;
\n}continue{
\ncommand;
\n}<\/p>\n
command until condtion;
\nfor (=foreach)<\/p>\n
# Iterate over @data and have each value in $_
\nfor(@data){
\nprint $_,”\\n”;
\n}<\/p>\n
# Get each value into $info iteratively
\nfor $info (@data){
\nprint $info,”\\n”;
\n}<\/p>\n
# Iterate over a range of numbers
\nfor $num (1..100){
\nnext if $num % 2;
\nprint $num,”\\n”;
\n}<\/p>\n
# Eternal loop with (;;)
\nfor (;;){
\n$num++;
\nlast if $num > 100;
\n}
\nmap<\/p>\n
# syntax
\nmap (command,list);
\nmap {comm1;comm2;comm3;} list;
\n# example
\nmap (rename($_,lc($_),<*>);
\n.
\nFile Test Operators<\/p>\n
File test operators check for the status of a file: Some examples:
\n-f $file It’s a plain file
\n-d $file It’s a directory
\n-r $file Readable file
\n-x $file Executable file
\n-w $file Writable file
\n-o $file We are owner
\n-l $file File is a link
\n-e $file File exists
\n-z $file File has zero size, but exists
\n-s $file File is greater than zero
\n-t FILEHANDLE This filehandle is connetcted to a tty
\n-T $file Textfile
\n-B $file Binary file
\n-M $file Returns the day number of last modification time<\/p>\n
Regular Expressions<\/p>\n
What it is<\/p>\n
A regular expression is an abstract formulation of a string. Usually one has a search pattern and a match which is the found string. There is also a replacement for the match, if a substitution is made.
\nPatterns<\/p>\n
A pattern stands for either one, any number, several, a particular number or none cases of a character or a charachter-set given literaly, abstractly or octaly.
\nPATTERN MATCH
\n. any character (dot)
\n.* any number on any character (dot asterix)
\na* the maximum of consecutive a’s
\na*? the minimum of consecutive a’s
\n.? one or none of any characters
\n.+ one or more of any character
\n.{3,7} three up to seven of any characters, but as many as possible
\n.{3,7}? three up to seven, but the fewest number possible
\n.{3,} at least 3 of any charachter
\n.{3} exactly 3 times any character
\n[ab] a or b
\n[^ab] not a and also not b
\n[a-z] any of a through z
\n^a
\n\\Aa a at begining of string
\na$
\na\\Z a at end of string
\nA|bb|CCC A or bb or CCC
\ntele(f|ph)one telefone or telephone
\n\\w A-Z or a-z or _
\n\\W none of the above
\n\\d 0-9
\n\\D none of 0-9
\n\\s space or \\t or \\n (white space)
\n\\S non space
\n\\t tabulator
\n\\n newline
\n\\r carridge return
\n\\b word boundary
\n\\bkey matches key but not housekey
\n(?#…….) Comment
\n(?i) Case insensitive match. This can be inside a pattern variable.
\n(?:a|b|c) a or b or c, but without string in $n
\n(?=…..) Match ….. but do not store in $&
\n(?!…..) Anything but ….. and do not store in $&
\nSubstitututions<\/p>\n
One can replace found matches with a replacement with the s\/pattern\/replacement\/; statement.
\nThe “s” is the command. Then there follow three delimiters with first a search pattern and second a replacement between them. If there are “\/” withing the pattern or the replacement then one chooses another delimiter than “\/” for instance a “!”.<\/p>\n
To change the content of a variable do: $var =~ s\/pattern\/replacement\/;
\nTo put the changed value into another variable, without distorting the original variable do:
\n($name = $line) =~ s\/^(\\w+).*$\/$1\/;
\nCOMMAND WHAT it DOES
\ns\/A\/B\/; substitute the first a in a string with B
\ns\/A\/B\/g; substitute every a with a B
\ns\/A+\/A\/g; substitute any number of a with one A
\ns\/^#\/\/; substitute a leading # with nothing. i.e remove it
\ns\/^\/#\/; prepend a # to the string
\ns\/A(\\d+)\/B$1\/g; substitute a followed by a number with b followed by the same number
\ns\/(\\d+)\/$1*3\/e; substitute the found number with 3 times it’s value
\nUse two “e” for to get an eval effect:
\nperl -e ‘$aa = 4; $bb = ‘$aa’; $bb =~ s\/(\\$\\w+)\/$1\/ee; print $bb,”\\n”;’
\ns\/here goes date\/$date\/g; substitute “here goes date” with the value of $date
\ns\/(Masumi) (Nakatomi)\/$2 $1\/g; switch the two terms
\ns\/\\000\/\/g; remove null charachters
\ns\/$\/\\033\/; append a ^M to make it readable for dos
\nInput and Output<\/p>\n
Output a value from a variable<\/p>\n
print $var,”\\n”;
\nOutput a formated string<\/p>\n
printf(“%-20s%10d”,$user,$wage);
\nRead in a value into a variable and remove the newline<\/p>\n
chomp() (perl5) removes a newline if one is there. The chop() (perl4) removes any last character.<\/p>\n
chomp($var = );
\nRead in a file an process it linewise<\/p>\n
open(IN,”<filename”) || die “Cannot open filename for input\\n”;
\nwhile(){
\ncommand;
\n}
\nclose IN;
\nRead a file into an array<\/p>\n
open(AAA,”<infile”) || die “Cannot open infile\\n”;
\n@bigarray = ;
\nclose AAA;
\nOutput into a file<\/p>\n
open(OUT,”>file”) || die “Cannot oben file for output\\n”;
\nwhile(condition){
\nprint OUT $mystuff;
\n}
\nclose OUT;
\nCheck, whether open file would yield something (eof)<\/p>\n
open(IN,”<file”) || die “Cannot open file\\n”;
\nif(eof(IN)){
\nprint “File is empty\\n”;
\n}else{
\nwhile(){
\nprint;
\n}
\n}
\nclose IN;
\nProcess Files mentioned on the Commandline<\/p>\n
The empty filehandle “<>” reads in each file iteratively. The name of the current processed file is in $ARGV. For example print each line of several files prepended with it’s filename:
\nwhile(<>){
\n$file = $ARGV;
\nprint $file,”\\t”,$_;
\nopen(IN,”<$file”) or warn “Cannot open $file\\n”;
\n….commands for this file….
\nclose(IN);
\n}
\nGet Filenames<\/p>\n
Get current directory at once<\/p>\n
@dir = <*>;
\nUse current directory iteratively<\/p>\n
while(<*>){
\n…commands…
\n}
\nSelect files with <><\/p>\n
@files = ;
\nSelect files with glob()<\/p>\n
This is the official way of globbing:
\n@files = glob(“$mypatch\/*$suffix”);<\/p>\n
Readdir()<\/p>\n
Perl can also read a directory itself, without a globbing shell. This is faster and more controllable, but one has to use opendir() and closedir().
\nopendir(DIR,”.”) or die “Cannot open dir.\\n”;
\nwhile(readdir DIR){
\nrename $_,lc($_);
\n}
\nclosedir(DIR);
\nPipe Input and Output from\/to Unix Commands<\/p>\n
Process Data from a Unix Pipe<\/p>\n
open(IN,”unixcommand|”) || die “Could not execute unixcommand\\n”;
\nwhile(){
\ncommand;
\n}
\nclose IN;
\nOutput Data into a Unix Pipe<\/p>\n
open(OUT,”|more”) || die “Could not open the pipe to more\\n”;
\nfor $name (@names){
\n$length = length($name);
\nprint OUT “The name $name consists of $lenght characters\\n”;
\n}
\nclose OUT;
\nExecute Unix Commands<\/p>\n
Execute a Unix Command and forget about the Output<\/p>\n
system(“someprog -auexe -fv $filename”);
\nExecute a Unix Command an store the Output into a Variable<\/p>\n
If it’s just one line or a string:<\/p>\n
chomp($date = qx!\/usr\/bin\/date!); The chomp() (perl5) removes the trailing “\\n”. $date gets the date.<\/p>\n
If it gives a series of lines one put’s the output into an array:<\/p>\n
chomp(@alllines = qx!\/usr\/bin\/who!);
\nReplace the whole perl program by a unix program<\/p>\n
exec anotherprog; But then the perl program is gone.<\/p>\n
The Perl builtin Functions<\/p>\n
String Functions<\/p>\n
Get all upper case with: $name = uc($name);
\nGet only first letter uppercase: $name = ucfirst($name);
\nGet all lowercase: $name = lc($name);
\nGet only first letter lowercase: $name = lcfirst($name);
\nGet the length of a string: $size = length($string);
\nExtract 5-th to 10-th characters from a string: $part = substr($whole,4,5);
\nRemove line ending: chomp($var);
\nRemove last character: chop($var);
\nCrypt a string: $code = crypt($word,$salt);
\nExecute a string as perl code: eval $var;
\nShow position of substring in string: $pos = index($string,$substring);
\nShow position of last substring in string: $pos = rindex($string,$substring);
\nQuote all metacharachters: $quote = quotemeta($string);
\nArray Functions<\/p>\n
Get expressions for which a command returned true: @found = grep(\/[Jj]ohn\/,@users);
\nApplay a command to each element of an array: @new = map(lc($_),@start);
\nPut all array elements into a single string: $string = join(‘ ‘,@arr);
\nSplit a string and make an array out of it: @data = split(\/&\/,$ENV{‘QUERY_STRING’};
\nSort an array: sort(@salery);
\nReverse an array: reverse(@salery);
\nGet the keys of a hash(associative array): keys(%hash);
\nGet the values of a hash: values(%hash);
\nGet key and value of a hash iteratively: each(%hash);
\nDelete an array: @arr = ();
\nDelete an element of a hash: delete $hash{$key};
\nCheck for a hash key: if(exists $hash{$key}){;}
\nCheck wether a hash has elements: scalar %hash;
\nCut of last element of an array and return it: $last = pop(@IQ_list);
\nCut of first element of an array and return it: $first = shift(@topguy);
\nAppend an array element at the end: push(@waiting,$name);
\nPrepend an array element to the front: unshift(@nowait,$name);
\nRemove first 2 chars an replace them with $var: splice(@arr,0,2,$var);
\nGet the number of elements of an array: scalar @arr;
\nGet the last index of an array: $lastindex = $#arr;
\nFile Functions<\/p>\n
Open a file for input: open(IN,”\/path\/file”) || die “Cannot open file\\n”;
\nOpen for appending: open(OUT,”>>$file”) || &myerr(“Couldn’t open $file”);
\nClose a file: close OUT;
\nSet permissions: chmod 0755, $file;
\nDelete a file: unlink $file;
\nRename a file: rename $file, $newname;
\nMake a hard link: link $existing_file, $link_name;
\nMake a symbolic link: symlink $existing_file, $link_name;
\nMake a directory: mkdir $dirname, 0755;
\nDelete a directory: rmdir $dirname;
\nReduce a file’s size: truncate $file, $size;
\nChange owner- and group-ID: chown $uid, $gid;
\nFind the real file of a symlink: $file = readlink $linkfile;
\nGet all the file infos: @stat = stat $file;
\nConversions Functions<\/p>\n
Number to character: chr $num;
\nCharachter to number: ord($char);
\nHex to decimal: hex(0x4F);
\nOctal to decimal: oct(0700);
\nGet localtime from time: localtime(time);
\nGet greenwich meantime: gmtime(time);
\nPack variables into string: $string = pack(“C4”,split(\/\\.\/,$IP));
\nUnpack the above string: @arr = unpack(“C4”,$string);
\nSubroutines (=functions in C++)<\/p>\n
Define a Subroutine<\/p>\n
sub mysub {
\ncommand;
\n}
\nExample:
\nsub myerr {
\nprint “The following error occured:\\n”;
\nprint $_[0],”\\n”;
\n&cleanup;
\nexit(1);
\n}
\nCall a Subroutine<\/p>\n
&mysub;
\nGive Arguments to a Subroutine<\/p>\n
&mysub(@data);
\nReceive Arguments in the Subroutine<\/p>\n
As global variables:
\nsub mysub {
\n@myarr = @_;
\n}
\nsub mysub {
\n($dat1,$dat2,$dat3) = @_;
\n}
\nAs local variables:
\nsub mysub {
\nlocal($dat1,$dat2,$dat3) = @_;
\n}<\/p>\n
Some of the Special Variables<\/p>\n
SYNTAX<\/p>\n
MEANING<\/p>\n
$_ String from current loop. e.g. for(@arr){ $field = $_ . ” ok”; }
\n$. Line number from current file processed with: while(){
\n$0 Programname
\n$$ Process id of current program
\n$< The real uid of current program $> Effektive uid of current program
\n$| For flushing output: select XXX; $| = 1;
\n$& The match of the last patternsearch
\n$1…. The ()-embraced matches of the last patternsearch
\n$` The string to the left of the last match
\n$’ The string to the right of the last match<\/p>\n
Forking<\/p>\n
Forking is very easy! Just fork. One puts the fork in a three way if(){} to separately the parent, the child and the error.
\nif($pid = fork){
\n# Parent
\ncommand;
\n}elsif($pid == 0){
\n# Child
\ncommand;
\n# The child must end with an exit!!
\nexit;
\n}else{
\n# Error
\ndie “Fork did not work\\n”;
\n}<\/p>\n
Building Pipes for forked Children<\/p>\n
Building a Pipe<\/p>\n
pipe(READHANDLE,WRITEHANDLE);
\nFlushing the Pipe<\/p>\n
select(WRITEHANDLE); $| = 1; select(STDOUT);
\nSetting up two Pipes between the Parent and a Child<\/p>\n
pipe(FROMCHILD,TOCHILD); select(TOCHILD); $| = 1; select(STDOUT);
\npipe(FROMPARENT,TOPARENT);select(TOPARENT);$| = 1; select(STDOUT);<\/p>\n
if($pid = fork){
\n# Parent
\nclose FROMPARENT;
\nclose TOPARENT;
\ncommand;
\n}elsif($pid == 0){
\n# Child
\nclose FROMCHILD;
\nclose TOCHILD;
\ncommand;
\nexit;
\n}else{
\n# Error
\ncommand;
\nexit;
\n}
\nBuilding a Socket Connection to another Computer<\/p>\n
# Somwhere at the beginning of the script
\nrequire 5.002;
\nuse Socket;
\nuse sigtrap;<\/p>\n
# Prepare infos
\n$port = 80;
\n$remote = ‘remotehost.domain’;
\n$iaddr = inet_aton($remote);
\n$paddr = sockaddr_in($port,$iaddr);<\/p>\n
# Socket
\nsocket(S,AF_INET,SOCK_STREAM,$proto) or die $!;<\/p>\n
# Flush socket
\nselect(S); $| = 1; select(STDOUT);<\/p>\n
# Connect
\nconnect(S,$paddr) or die $!;<\/p>\n
# Print to socket
\nprint S “something\\n”;<\/p>\n
# Read from socket
\n$gotit = ;<\/s><\/p>\n
# Or read a single character only
\nread(S,$char,1);<\/p>\n
# Close the socket
\nclose(S);
\nGet Unix User and Network Informations<\/p>\n
Get the password entry for a particular user with: @entry = getpwnam(“$user”);
\nOr with bye user ID: @entry = getpwuid(“$UID”);<\/p>\n
One can informations for group, host, network, services, protocols in the above way with the commands: getgrnam, getgrid, gethostbyname, gethostbyaddr, getnetbyname, getnetbyaddr, getservbyname, getservbyport, getprotobyname, getprotobynumber.<\/p>\n
If one wants to get all the entries of a particular categorie one can loop through them by:<\/p>\n
setpwent;
\nwhile(@he = getpwent){
\ncommands…
\n}
\nentpwent;<\/p>\n
For example: Get a list of all users with their homedirectories:
\nsetpwent;
\nwhile(@he = getpwent){
\nprintf(“%-20s%-30s\\n”,$he[0],$he[7]);
\n}
\nendpwent;
\nThe same principle works for all the above data categories. But most of them need a “stayopen” behind the set command.<\/p>\n
Arithmetics<\/p>\n
Addition: +
\nSubtraction: –
\nMultiplication: *
\nDivision: \/
\nRise to the power of: **
\nRise e to the pwoer of: exp()
\nModulus: %
\nSquare root: sqrt()
\nAbsolut value: abs()
\nTangens: atan2()
\nSinus: sin()
\nCosine: cos()
\nRandom number: rand()<\/p>\n
Formatting Output with “format”<\/p>\n
This should be simplification of the printf formatting. One formats once only and then it will be used for every write to a specified filehandle. Prepare a format somwhere in the program:<\/p>\n
format filehandle =
\n@<<<<<<<<<<@###.#####@>>>>>>>>>>@||||||||||
\n$var1, $var3, $var4
\n.<\/p>\n
Now use write to print into that filhandle according to the format:<\/p>\n
write FILEHANDLE;<\/p>\n
The @<<< does left adjustment, the @>>> right adjustment, @##.## is for numericals and @||| centers.<\/p>\n
Command line Switches<\/p>\n
Show the version number of perl: perl -v;
\nCheck a new program without runing it: perl -wc ;
\nHave an editing command on the command line: perl -e ‘command’;
\nAutomatically print while precessing lines: perl -pe ‘command’ ;
\nRemove line endings and add them again: perl -lpe ‘command’ ;
\nEdit a file in place: perl -i -pe ‘command’ ;
\nAutosplit the lines while editing: perl -a -e ‘print if $F[3] =~ \/ETH\/;’ ;
\nHave an input loop without printing: perl -ne ‘command’ ;<\/p>\n","protected":false},"excerpt":{"rendered":"
Basics<\/p>\n
Scripts<\/p>\n
Perl is a script language, which is compiled each time before running. That unix knows that it is a perl script there must be the following header at the topline of every perl script: #!\/usr\/bin\/perl where the path to perl has to be correct and the line must not exeed 32 charachters. Comments […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[64],"tags":[],"_links":{"self":[{"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/posts\/3457"}],"collection":[{"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/mohan.sg\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=3457"}],"version-history":[{"count":1,"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/posts\/3457\/revisions"}],"predecessor-version":[{"id":3458,"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/posts\/3457\/revisions\/3458"}],"wp:attachment":[{"href":"https:\/\/mohan.sg\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=3457"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/mohan.sg\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=3457"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/mohan.sg\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=3457"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}