Funktion substr() i Perl

I programmeringssproget Perl har en indbygget funktion substr(). Du kan bruge denne funktion, når man arbejder med strenge. Ved hjælp af denne funktion, du kan få del af en streng, eller til at erstatte en del af en tekststreng med en anden streng.

Her er et eksempel på at modtage en del af en streng:

▶ Run
#!/usr/bin/perl

my $str = 'Hello, world!';

print "'" . substr($str, 7, 5) . "'";

Dette program viser teksten 'world'. Opkald funktion substr($str, 7, 5)siger du er nødt til at få fra linje $str fem tegn, med start fra den syvende position. I denne brug værdien $str ikke ændres.

Når du bruger substr() med fire argumenter ændrer værdien af en variabel. Her er et eksempel på brug af substr() til at erstatte:

▶ Run
#!/usr/bin/perl

my $str = 'Hello, world!';

print "'" . substr($str, 7, 5, 'you') . "'\n";
print $str;

Outputtet af programmet:

'world'
Hello, you!

Den værdi, der returneres, når du kalder substr($str, 7, 5, 'you') er præcis den samme, som når du kalder substr($str, 7, 5), men den kalder med fire argumenter og selv ændret sig, den værdi af variabel. Ordet world blev erstattet af you. Bemærk bemærk, at udskiftning ikke var korrekte på trods af det faktum, at i de oprindelige ord og nye ord, et andet antal breve.

Argumenter

my $str1 = substr($str, $offset);
my $str2 = substr($str, $offset, $length);
my $str3 = substr($str, $offset, $replacement);

Funktion substr() , skal du angive, to, tre, eller fire argumenter.

I tilfældet, hvis du forsøger at bruge funktionen substr() med ingen argumenter, eller med en argument, vil det fejl:

Not enough arguments for substr at script.pl line 3, near "substr()"
Execution of script.pl aborted due to compilation errors.

Når du bruger to argumenter substr($str, $offset) funktion returnerer alle tegn fra strengen $str , der starter med tegnet på position $offset til slutningen af rækken.

Når du bruger tre argumenter substr($str, $offset, $length) funktion returnerer $length tegn fra en streng $str , der starter med tegnet på position $offset.

Når du bruger substr() med to eller tre argumenter, den oprindelige streng værdi ændrer sig ikke.

Hvis du bruger fire argumenter substr($str, $offset, $replacement)- funktion returnerer den samme som i tilfældet med tre argumenter, men derudover udskift i den oprindelige streng, den værdi, der fremkommer ved $replacement.

Return værdi

Funktion substr() kan vende tilbage til enten undef, eller en streng.

undef er tilbage, hvis du prøver at få element fra strengen indekset, som er større end længden af strengen. Her er en prøve på programmet, der vender tilbage undef:

▶ Run
#!/usr/bin/perl

use Data::Dumper;

my $str = 'Hello, world!';
my $str1 = substr($str, 10000);

warn Dumper $str1;

I tilfælde, hvis i programmet kode ville være use warnings;, vil programmet stadig derudover sat på skærmbilledet advarsel:

substr outside of string at script.pl line 8.

Negative værdier $offset

Funktion substr() giver dig mulighed for at angive negative værdier for det andet argument. Eksempel på program:

▶ Run
#!/usr/bin/perl

my $str = 'Hello, world!';
print substr($str, -3);

Skærmen vil vise den tekst, ld! er de tre sidste tegn fra strengen Hello, world!.

En negativ andet argument tyder på, at den position, der tæller fra den ende af rækken.

Indlæg substr($str, -3) er meget lig substr($str, -3, 3).

Negative værdier $length

Værdien af det tredje argument kan være negativ. Her er eksempel på:

▶ Run
#!/usr/bin/perl

use feature qw(say);

my $str = 'Hello, world!';

say substr($str, 7, -1); # world
say substr($str, 7, -2); # worl
say substr($str, 7, -3); # wor

Officiel dokumentation

Her er outputtet af kommandoen perldoc -f substr:

    substr EXPR,OFFSET,LENGTH,REPLACEMENT
    substr EXPR,OFFSET,LENGTH
    substr EXPR,OFFSET
            Extracts a substring out of EXPR and returns it. First character
            is at offset zero. If OFFSET is negative, starts that far back
            from the end of the string. If LENGTH is omitted, returns
            everything through the end of the string. If LENGTH is negative,
            leaves that many characters off the end of the string.

                my $s = "The black cat climbed the green tree";
                my $color  = substr $s, 4, 5;      # black
                my $middle = substr $s, 4, -11;    # black cat climbed the
                my $end    = substr $s, 14;        # climbed the green tree
                my $tail   = substr $s, -4;        # tree
                my $z      = substr $s, -4, 2;     # tr

            You can use the "substr" function as an lvalue, in which case
            EXPR must itself be an lvalue. If you assign something shorter
            than LENGTH, the string will shrink, and if you assign something
            longer than LENGTH, the string will grow to accommodate it. To
            keep the string the same length, you may need to pad or chop
            your value using "sprintf".

            If OFFSET and LENGTH specify a substring that is partly outside
            the string, only the part within the string is returned. If the
            substring is beyond either end of the string, "substr" returns
            the undefined value and produces a warning. When used as an
            lvalue, specifying a substring that is entirely outside the
            string raises an exception. Here's an example showing the
            behavior for boundary cases:

                my $name = 'fred';
                substr($name, 4) = 'dy';         # $name is now 'freddy'
                my $null = substr $name, 6, 2;   # returns "" (no warning)
                my $oops = substr $name, 7;      # returns undef, with warning
                substr($name, 7) = 'gap';        # raises an exception

            An alternative to using "substr" as an lvalue is to specify the
            replacement string as the 4th argument. This allows you to
            replace parts of the EXPR and return what was there before in
            one operation, just as you can with "splice".

                my $s = "The black cat climbed the green tree";
                my $z = substr $s, 14, 7, "jumped from";    # climbed
                # $s is now "The black cat jumped from the green tree"

            Note that the lvalue returned by the three-argument version of
            "substr" acts as a 'magic bullet'; each time it is assigned to,
            it remembers which part of the original string is being
            modified; for example:

                my $x = '1234';
                for (substr($x,1,2)) {
                    $_ = 'a';   print $x,"\n";    # prints 1a4
                    $_ = 'xyz'; print $x,"\n";    # prints 1xyz4
                    $x = '56789';
                    $_ = 'pq';  print $x,"\n";    # prints 5pq9
                }

            With negative offsets, it remembers its position from the end of
            the string when the target string is modified:

                my $x = '1234';
                for (substr($x, -3, 2)) {
                    $_ = 'a';   print $x,"\n";    # prints 1a4, as above
                    $x = 'abcdefg';
                    print $_,"\n";                # prints f
                }

            Prior to Perl version 5.10, the result of using an lvalue
            multiple times was unspecified. Prior to 5.16, the result with
            negative offsets was unspecified.

Relaterede emner

Andre artikler