PHP foreach loop: två sätt att använda den. Skriver vacker idiomatisk Python

Ofta behöver du gå igenom alla moment PHP-array och utför någon operation på varje element. Till exempel kan du mata ut varje värde till HTML-tabell eller ge varje element ett nytt värde.

I den här lektionen kommer vi att titta på varje konstruktion när vi organiserar en loop över indexerade och associerade arrayer.

Gå igenom elementvärdena

Det enklaste användningsfallet för foreach är att gå igenom värden i en indexerad array. Grundläggande syntax:

Foreach ($array som $value) (// Gör något med $value) // Här exekveras koden efter att slingan är klar

Till exempel upprepar följande skript genom listan över regissörer i en indexerad array och skriver ut namnet på var och en:

$directors = array("Alfred Hitchcock", "Stanley Kubrick", "Martin Scorsese", "Fritz Lang"); foreach ($directors som $director) ( echo $director . "
"; }

Ovanstående kod kommer att mata ut:

Alfred Hitchcock Stanley Kubrick Martin Scorsese Fritz Lang

Key-Value Loop

Hur är det med tillhörande arrayer? När du använder den här typen av array behöver du ofta ha tillgång till nyckeln för varje element samt dess värde. Varje konstruktion har ett sätt att lösa problemet:

Foreach ($array som $key => $value) (// Gör något med $key och/eller $value) // Här exekveras koden efter att loopen är klar

Ett exempel på att organisera en slinga genom en tillhörande array med information om filmer, visa nyckeln för varje element och dess värde i HTML-lista definitioner:

$movie = array("title" => "Bakfönster", "regissör" => "Alfred Hitchcock", "år" => 1954, "minuter" => 112); eka"

"; foreach ($movie som $key => $value) (echo "

$key:

"; eka"

$värde

"; ) echo "

";

När det körs kommer detta skript att mata ut:

Titel: Bakfönsterregissör: Alfred Hitchcock år: 1954 minuter: 112

Ändra värdet på ett element

Vad sägs om att ändra värdet på ett element när slingan går igenom? Du kan prova denna kod:

Foreach ($myArray som $value) ($value = 123;)

Men om du kör det kommer du att upptäcka att värdena i arrayen ändra inte. Anledningen är att foreach fungerar med en kopia matrisvärden, inte med originalet. På så sätt förblir den ursprungliga arrayen intakt.

För att ändra matrisvärden behöver du länk till meningen. För att göra detta måste du sätta ett &-tecken framför värdevariabel i varje konstruktion:

Foreach ($myArray som &$value) ($value = 123;)

Till exempel går följande skript genom varje element (direktörens namn) i $directors-matrisen och använder PHP funktion explode() och listkonstruktionen för att ändra platsen för för- och efternamn:

$directors = array("Alfred Hitchcock", "Stanley Kubrick", "Martin Scorsese", "Fritz Lang"); // Ändra namnformatet för varje element foreach ($directors som &$director) ( list($firstName, $lastName) = explode(" ", $director); $director = "$lastName, $firstName"; ) avaktiverad ($direktör); // Skriv ut det slutliga resultatet foreach ($directors som $director) ( echo $director . "
"; }

Skriptet kommer att mata ut:

Hitchcock, Alfred Kubrick, Stanley Scorsese, Martin Lang, Fritz

Observera att skriptet anropar unset()-funktionen för att ta bort variabeln $director efter att den första loopen är klar. Detta bra övning om du planerar att använda variabeln senare i skriptet i ett annat sammanhang.

Om du inte tar bort referensen riskerar du att ytterligare exekvera kod som av misstag refererar till det sista elementet i arrayen ("Lang, Fritz") om du fortsätter att använda variabeln $director, vilket kommer att leda till oavsiktliga konsekvenser!

Sammanfattning

I den här lektionen tittade vi på hur man använder konstruktionen PHP foreach för att organisera en slinga genom arrayelement. Följande frågor övervägdes:

• Hur man går igenom arrayelement
• Hur man kommer åt nyckeln och värdet för varje element
• Hur man använder en referens för att ändra värden när du går igenom en loop

Ibland är det svårt att hitta rätt, och viktigast av allt relevanta, "bästa metoder" för ett språk på Internet. Dokumentationen innehåller naturligtvis allt nödvändig information, men det är ganska svårt att sålla fram det rätta i stycken i en detaljerad beskrivning (det är därför det är dokumentation). Men nyligen log han mot mig Google Sök och jag hittade några mycket användbara "mönster" Python språk från en av kärnutvecklarna - Raymond Hettinger.

Notera: Alla rekommendationer ges i flera alternativ: de "sämsta" alternativen kommer först, och sedan föreslås det bästa alternativet. Relevanta för språkversion 2.7 skillnader för version 3.3 finns i anmärkningarna om det specifika "mönstret".

Gå igenom en rad siffror

Dåligt: ibland skriver de så här.
för i in : skriv ut i**2
Bra: bäst, med generator. Men vid 32 bitsystem en lista med en miljon nummer kommer att ta upp ~32 mb minne.
för i inom intervallet(6): skriv ut i**2
Bra: mest det bästa alternativet. Till skillnad från den andra returnerar xrange endast ett värde åt gången och är inte nödvändigt extra minne för att lagra hela arrayen.
för i i xrange(6): skriv ut i**2
Notera: I Python 3.3 finns xrange redan i kärnan och kallas helt enkelt range .

Gå igenom en lista

Dåligt: tidigare C-programmerare skriver ofta så här.
färger = ["röd", "grön", "blå", "gul"] för i i intervallet(len(färger)): skriv ut färger[i]
Bra: det bästa alternativet.
färger = ["röd", "grön", "blå", "gul"] för färg i färger: tryckfärg
Men vad händer om du behöver gå igenom listan baklänges?

Dåligt: igen, övergått från C gör sig påmind:
färger = ["röd", "grön", "blå", "gul"] för i i intervallet(len(färger)-1, -1, -1): utskriftsfärger[i]
Bra: men i Python skriver de så här:
färger = ["röd", "grön", "blå", "gul"] för färg i omvänd (färger): tryckfärg

Gå igenom en lista med index

Dåligt samma som ovan.
färger = ["röd", "grön", "blå", "gul"] för i i intervallet(len(färger)): skriv ut i, "-->", färger[i]
Bra: mer elegant alternativ:
färger = ["röd", "grön", "blå", "gul"] för i, färg i enumerate(färger): print i, "-->", färg

Går igenom två listor

Dåligt samma som ovan.
namn = ["raymond", "rachel", "matthew"] färger = ["röd", "grön", "blå", "gul"] n = min(len(namn), len(färger)) för i inom intervall(n): skriv ut namn[i], "-->", färger[i]
Bra: från två listor gör vi en lista med tupler. Problemet är att zip använder mer minne än det första alternativet.
names = ["raymond", "rachel", "matthew"] colors = ["röd", "grön", "blå", "gul"] för namn, färg i zip(namn, färger): trycknamn, " -->", färg
Bra: Till skillnad från zip använder izip caching, vilket hjälper till att avsevärt spara minne.
namn = ["raymond", "rachel", "matthew"] färger = ["röd", "grön", "blå", "gul"] för namn, färg i izip(namn, färger): trycknamn, " -->", färg
Notera Obs: I Python 3.3 ingår izip i kärnan och kallas helt enkelt zip.

Sortera en lista efter algoritm

Dåligt: Använder en funktion för att jämföra.
färger = ["röd", "grön", "blå", "gul"] def compare_length(c1, c2): if len(c1)< len(c2): return -1 if len(c1) >len(c2): return 1 return 0 print sorterad (färger, cmp=compare_length)

Bra: Använder tangenten sortera efter. Använder mycket mindre minne.
färger = ["röd", "grön", "blå", "gul"] utskrift sorterat(färger, nyckel=len)
Notera: Cmp-metoden har tagits bort från Python 3.x-kärnan.

Gå igenom ordboksnycklarna

Det normala sättet returnerar nycklarna. Med en sådan slinga itereras ordboken, så den kan inte ändras under processen.
för k i d: skriv ut k
För att ändra ordboken i en slinga, använd en nyckelslinga (Exempel: ta bort alla nycklar som börjar med R):
för k i d.keys(): om k.startswith("R"): del d[k]
I det här fallet gör d.keys() en kopia av ordboksnycklarna, vilket gör att vi kan arbeta fritt med den ursprungliga strukturen.

Gå igenom nycklarna och värdena i en ordbok

Dåligt: Gå igenom tangenterna och returnera värdet baserat på det sista. Långsam väg:
för k i d: skriv ut k, "-->", d[k]
Bra: Det går snabbare att gå igenom värdena:
för k, v i d.items(): skriv ut k, "-->", v
Bra: Men det bästa och snabbt sättär att använda en iterator:
för k, v i d.iteritems(): skriv ut k, "-->", v

Kombinera två listor till en ordbok

Mycket snabb metod, endast en tuppel används för att generera ordboken.
names = ["raymond", "rachel", "matthew"] colors = ["röd", "grön", "blå"] d = dict(izip(namn, färger)) # d kommer att ha följande värde: # ( "matthew": "blå", "rachel": "grön", "raymond": "röd")

Räkna objekt i en ordbok

Dåligt: det vanliga sättet:
färger = ["röd", "grön", "röd", "blå", "grön", "röd"] d = () för färg i färger: om färg inte är i d: d = 0 d += 1 # ("blå": 1, "grön": 2, "röd": 3)
Bra: använder get()-funktionen:
färger = ["röd", "grön", "röd", "blå", "grön", "röd"] d = () för färg i färger: d = d.get(färg, 0) + 1
Bra: Det mest avancerade sättet är att använda defaultdict() . Men du måste veta hur det fungerar.
d = defaultdict(int) för färg i färger: d += 1

Gruppera listobjekt

Dåligt: om du behöver gruppera listelement enligt något kriterium (i exemplet, stränglängd), används ofta följande metod:
names = ["raymond", "rachel", "matthew", "roger", "betty", "melissa", "judith", "charlie"] d = () för namn i namn: nyckel = len(namn) om nyckel inte i d: d = d.append(name) (5: ["roger", "betty")], 6: ["rachel", "judith"], 7: ["raymond", "matthew", "melissa", "charlie"])
Bra: men det finns ett mycket mer elegant och snabbare sätt:
d = defaultdict(lista) för namn i namn: key = len(name) d.append(name)

Slutsats

Det är allt för idag. Jag hoppas att dessa är triviala, men användbara exempel kommer att hjälpa någon att förbättra sin kod som de hjälpte mig att göra. Deras författare är Raymond Hettinger (

För varje...Nästa loop VBA Excel, dess syntax och beskrivning enskilda komponenter. Exempel på användning av For Every...Next-slingan.

För varje... Nästa loop i VBA Excel är utformad för att exekvera ett block med uttalanden i relation till varje element från en grupp av element (intervall, array, samling). Denna underbara loop används när antalet element i en grupp och deras indexering är okänt, annars är det att föredra att använda .

För varje...Syntax för nästa loop

För varje element I grupp [ statements ] [ Exit For ] [ statements ] Nästa [ element ]

I hakparentes Valfria attribut för slingan För varje...Nästa anges.

Komponenter i en för varje... Nästa loop

*Om en For Every...Next-loop används i VBA Excel för att iterera genom elementen i en samling (Collection-objekt) eller array, kommer variabeln element måste deklareras med en datatyp Variant, annars fungerar inte slingan.

**Om du inte använder din egen kod i en loop går innebörden av att använda en loop förlorad.

Exempel på för varje...Nästa loopar

Slinga över ett antal celler

På det aktiva arket arbetsbok Excel, välj ett cellintervall och kör följande procedur:

Sub test1() Dim element As Range, a As String a = "Data erhållen av For Every... Next:" För varje element I urval innehåller a = a & vbNewLine & "Cell " & element.Address & _ " värdet : " & CStr(element.Value) Nästa MsgBox a End Sub

Informationsfönster MsgBox kommer att visa adresserna till de valda cellerna och deras innehåll, om det finns. Om många celler är markerade, kommer inte fullständig information för alla celler att visas, eftersom maximal längd parameter Promptär cirka 1024 tecken.

Ögla för en samling ark

Kopiera följande VBA-procedur till Excel-arbetsböcker:

Sub test2() Dim element As Worksheet, a As String a = "Lista över ark som finns i detta kalkylblad:" För varje element i arbetsblad a = a & vbNewLine & element.Index _ & ") " & element.Name Next MsgBox a Avsluta Sub

MsgBox-informationsfönstret visar en lista med namn på alla ark i Excel-arbetsboken efter serienummer deras etiketter som motsvarar deras index.

Slinga för en array

Låt oss tilldela en lista med djurnamn till arrayen och skriva dem i en variabel i For Every... Next loop a. MsgBox-informationsfönstret visar en lista över djurnamn från variabeln a.

Sub test3() Dim element Som Variant, en As String, group As Variant group = Array("flodhäst", "elefant", "känguru", "tiger", "mus") "eller så kan du tilldela värdena för cellintervallet för "arbetaren" till arraybladet, till exempel, valt: group = Selection a = "Arrayen innehåller följande värden:" & vbNewLine För varje element I grupp a = a & vbNewLine & element Nästa MsgBox a Avsluta Sub

Låt oss upprepa samma VBA-procedur, men tilldela värdet "Parrot" till alla arrayelement i For Every...Next-loopen. MsgBox-informationsfönstret kommer att visa en lista med djurnamn, som endast består av papegojor, vilket bevisar att det är möjligt att redigera värdena för arrayelement i For Every...Next-loopen.

Sub test4() Dim element Som Variant, en As String, group As Variant group = Array("flodhäst", "elefant", "känguru", "tiger", "mus") "eller så kan du tilldela värden för cellintervallet för "arbetaren" till arraybladet, till exempel den valda: group = Selection a = "Arrayen innehåller följande värden:" & vbNewLine För varje element In group element = "Parrot" a = a & vbNewLine & element Nästa MsgBox a End Sub

Den här koden, liksom alla andra i den här artikeln, testades i Excel 2016.

Gå igenom en samling underkataloger och lämna loopen

I det här exemplet lägger vi till variabeln a namn på underkataloger på disken C din dator. När slingan når mappen Program filer, kommer det att läggas till variabeln a dess titel och meddelande: "Nog, jag kommer inte att läsa mer! Med vänliga hälsningar, din För varje...Nästa cykel."

Sub test5() Dim FSO As Object, myFolders As Object, myFolder As Object, a As String "Skapa ett nytt FileSystemObject och tilldela det till variabeln "FSO" Set FSO = CreateObject("Scripting.FileSystemObject") "Hämta listan med underkataloger på enhet "C" " och tilldela "den till variabeln "myFolders" Ställ in myFolders = FSO.GetFolder("C:\") a = "Mappar på enhet C:" & vbNewLine "Vi går igenom listan med underkataloger och lägg till deras namn till variabeln "a" När vi har nått mappen "Program Files", avslutar vi cykeln för varje myFolder I myFolders.SubFolders a = a & vbNewLine & myFolder.Name Om myFolder.Name = "Program Files" Då är en = a & vbNewLine & vbNewLine & "Det räcker, läs vidare, jag kommer inte att göra det!" FSO = Ingenting MsgBox a End Sub

MsgBox-informationsfönstret visar en lista med underkatalognamn på disken C din dator till mappen Program filer inkluderande och ett meddelande från cykeln om att dess arbete avslutas.

Som ett resultat av programmets funktion kommer inte bara namnen på underkataloger som är synliga när du navigerar till disken i Utforskaren att visas C, men också dolda mappar och servicemappar. För att visa en lista över alla underkataloger på en disk C, kommentera avsnittet av kod från Om innan Avsluta om inklusive och kör proceduren i VBA Excel-redigeraren.

Array in Perl språkär en variabel som innehåller en lista med värden. namn arrayvariabel börjar med @-symbolen. Och detta är ganska logiskt - @-symbolen är baserad på bokstaven a, det är med denna bokstav som ordmatrisen börjar.

En array i Perl kan lagra en lista med värden av vilken typ som helst. Det kan finnas en array som samtidigt lagrar strängar, siffror och något annat.

Array Definition och Element Access

Här är ett enkelt skript med ett exempel på att definiera och använda arrayelement i Perl:

#!/usr/bin/perl använder strikt; använd varningar FATAL => "alla"; använd funktionen "säg"; mina @namn = ("Homer", "Marge", "Bart", "Lisa", "Maggie"); säg $namn; säg $namn;

Om du kör det här skriptet kommer det att visa:

Homer Bart

Vad händer här. I början standardsträng som alla Perl-skript börjar med #!/usr/bin/perl, så finns det kopplingen (användningen) av flera språkfunktioner som gör arbetet med Perl bekvämare. Och sedan skapas variabeln @names och en lista med 5 strängar tilldelas den.

Som i många programmeringsspråk, i Perl är det första elementet i arrayen numrerat 0. Efter att ha utfört denna operation visas följande i variabeln @names:

• denna variabel, nummer 0, lagrar strängen "Homer"
• nummer 1 lagrar strängen "Marge"
• 2 - "Bart"
• 3 - "Lisa"
• 4 - "Maggy"

För att få element nummer 2 från @name-variabeln används en helt idiotisk form - $name. Det är här det är superologiskt att @-symbolen kommer att ersättas med $-symbolen. Den officiella förklaringen till denna dumhet är att vi vill komma åt ett element, och en variabel med ett element börjar med $-symbolen misstag i språkets utformning. Detta har åtgärdats i Perl version 6. Men i Perl version 5 får man leva med detta.

Säg $names;

säger - visa på skärmen vad som finns i arrayen vid nummer 0. Vid nummer 0 i arrayen finns strängen "Homer" - den visas på skärmen.

Definition av arrayer. Tillägg.

Vi har precis definierat en array med kod så här:

Mina @namn = ("Homer", "Marge", "Bart", "Lisa", "Maggie");

När det finns många element i en array är det bekvämare att skriva dem i en kolumn:

Mina @namn = ("Homer", "Marge", "Bart", "Lisa", "Maggie");

Perl har inte JSON-problemet - Perl tillåter ett kommatecken efter det sista elementet:

Mina @namn = ("Homer", "Marge", "Bart", "Lisa", "Maggie");

(Faktum är att om du listar matriselement i en kolumn, bör du alltid sätta ett kommatecken efter det sista elementet - detta gör lättare arbete med koden och gör skillnaden lättare att läsa).

Om arrayen innehåller textrader som inte innehåller mellanslag, så finns det ett ännu enklare sätt att definiera arrayen - använd qw-operatorn:

Mina @namn = qw(Homer Marge Bart Lisa Maggie);

qw-operatorn klipper texten som skickas till den blanksteg och skapar listobjekt.

Om du behöver skapa en array från en lista med på varandra följande nummer kan du använda operatorn..

Min @array = (1..5);

Detta är samma sak som:

Min @array = (1, 2, 3, 4, 5);

Operatören .. arbetar också med bokstäver:

Min @array = ("a".."z");

Denna språkfunktion kan användas i enkel perl one-liner för att generera lösenord:

$ perl -E "@c = ("a".."z", "A".."Z", 0..9); $s .= $c för (1..12); säg $s "eIryv0884sp7

Utmatningsmatriser

Ibland under programutveckling behöver du titta på vad som finns inuti en array. För att göra detta kan du använda Data::Dumper-biblioteket:

#!/usr/bin/perl använder strikt; använd varningar FATAL => "alla"; använd funktionen "säg"; mina @namn = ("Homer", "Marge", "Bart", "Lisa", "Maggie"); använd Data::Dumper; säg Dumper \@namn;

Här är resultatet av detta skript:

$VAR1 = [ "Homer", "Marge", "Bart", "Lisa", "Maggie" ];

Om du har Perl har du Data::Dumper-biblioteket. Men om du dessutom installerar Data::Printer-biblioteket måste du skriva för att visa innehållet i arrayen färre bokstäver:

#!/usr/bin/perl använder strikt; använd varningar FATAL => "alla"; använd funktionen "säg"; mina @namn = ("Homer", "Marge", "Bart", "Lisa", "Maggie"); använd DDP; p\@namn;

Och skriptutdata är mycket trevligare:

Array längd

Uppgift. Vi har en array @names, vi måste ta reda på dess storlek - hur många element som finns i den. Det finns flera sätt att göra detta. Du kan använda en speciell variabel som innehåller indexet för det sista elementet, eller så kan du använda en Perl-funktion som kallas "kontext".

När en array dyker upp visas automatiskt en speciell variabel som pekar på indexet för det sista elementet. Vi har en array @names som innehåller 5 element och för den finns en variabel $#names som innehåller talet 4 (eftersom element är numrerade från 0, inte 1). Om antalet element i arrayen ändras kommer $#names automatiskt att ändras.

Det första sättet att ta reda på antalet element i en array är att ta $#names och lägga till ett:

Säg $#names + 1;

Denna metod fungerar och är helt korrekt, men mer Den rätta vägen- är att använda "sammanhang":

#!/usr/bin/perl använder strikt; använd varningar FATAL => "alla"; använd funktionen "säg"; mina @namn = ("Homer", "Marge", "Bart", "Lisa", "Maggie"); mitt $nummer = @namn; säg $nummer;

Vad händer här? Till en början är allt detsamma som i föregående skript, men sedan körs det:

Mitt $nummer = @namn;

Vi skapar en ny variabel $number I början av namnet på denna variabel finns en $-symbol - detta betyder att typen av denna variabel är en skalär. $-symbolen är helt logisk - det är en symbol som liknar bokstaven s som ordet skalär börjar med. En skalär eller skalär variabel är en variabel som bara innehåller ett värde. Det kan vara en sträng, ett nummer eller något annat.

Och här kommer sammanhanget. Kontext är en mycket viktig sak i programmeringsspråket Perl. I Perl, beroende på sammanhanget (dvs vad som finns i närheten), fungerar olika saker olika. Sammanhang är en knepig sak. Men för att programmera i Perl måste du förstå hur sammanhang fungerar.

Uttrycket mitt $nummer = @namn; betyder att vi tog en array och använde den i ett "skalärt sammanhang". I det skalära sammanhanget för en array är detta antalet element i den, dvs. precis vad vi ville få.

Här är ett annat exempel på hur man använder sammanhang. Du kan använda en array i en listkontext:

My ($man, $woman) = @namn;

Resultatet av denna operation är att den skalära variabeln $man kommer att innehålla strängen "Homer", och den skalära variabeln $woman kommer att innehålla strängen "Marge".

I skriptet tilldelade vi först arrayen till en skalär variabel och skrev sedan ut värdet på denna variabel:

Mitt $nummer = @namn; säg $nummer;

Vad händer om du omedelbart visar värdet för arrayen @names?

Säg @namn

Här är resultatet:

HomerMargeBartLisaMaggy

Denna slutsats skiljer sig mycket från siffran 5. Förklaringen till detta är sammanhang. Säg nyckelordet fungerar i listsammanhang. say visar alla element i listan som skickades till den. Men vi kan uttryckligen indikera att vi vill arbeta med arrayen i ett skalärt sammanhang:

Säg skalära @namn;

I detta fall blir utgången 5.

Arbeta med en array

Det finns uppgifter när du bara behöver skapa en array och sedan bara läsa värden från den. Men oftare finns det uppgifter när arrayen behöver ändras. Det finns flera praktiska funktioner för detta.

Lägga till ett element i slutet av en array:

Min @arr = (1, 2, 3); tryck @arr, "abc";

Resultatet av denna operation är att arrayen @arr kommer att innehålla listan (1, 2, 3, "abc");

Med push kan du lägga till flera element i en array:

Min @arr = (1, 2, 3); push @arr, "abc", "def";

Resultatet av denna operation är att arrayen @arr kommer att innehålla listan (1, 2, 3, "abc", "def");

En intressant funktion med push, som få människor känner till - den här funktionen ändrar inte bara arrayen, utan returnerar också ett nummer - hur många element som finns i arrayen efter att ha lagt till alla angivna element i arrayen. Så problemet med att "hitta antalet element i en array" kan lösas på detta superperverterade sätt:

Mitt $nummer = push(@arr, 1) - 1;

Push-funktionen lägger till ett element (eller element) i slutet av en array. Perl har en funktion för omvänd operation - att hämta det sista elementet från en array. Detta görs med pop-funktionen (du kan inte få flera element med den här funktionen, den här funktionen får bara ett element).

Min @arr = (1, 2, 3); min $smth = pop @arr;

Efter exekvering av koden ovan kommer @arr-arrayen att bestå av två element (1, 2), och variabeln $smth kommer att innehålla siffran 3.

Med push/pop-funktionerna kan du arbeta med en array som om den vore en stack.

Förutom push/pop-funktionerna, som lägger till/ta bort element i slutet av arrayen, finns även shift/unshift-funktionerna, som fungerar från början av arrayen.

Lägg till ett element i början av arrayen:

Min @arr = (1, 2, 3); avskifta @arr, "abc";

Efter att ha utfört dessa kommandon kommer @arr-arrayen att innehålla listan ("abc", 1, 2, 3)

Med unshift kan du lägga till flera element i början av en array:

Min @arr = (1, 2, 3); unshift @arr, "abc", "def";

Efter att ha utfört dessa kommandon kommer @arr-arrayen att innehålla listan ("abc", "def", 1, 2, 3)

Precis som push returnerar unshift ett nummer - antalet element i arrayen efter att ha lagt till alla element där.

Du kan hämta det första elementet från en array med skiftfunktionen:

Min @arr = (1, 2, 3); mitt $element = skift @arr;

Efter att ha utfört dessa åtgärder kommer arrayen att bestå av två element (2, 3), och variabeln $element kommer att innehålla det tidigare första elementet i arrayen - siffran 1.

• unshift lägger till element/element i början av arrayen
• shift får ett element från början av arrayen
• push lägger till element/element i slutet av arrayen
• pop får ett element från slutet av arrayen

Iterera genom en array

Ofta finns det en uppgift - du måste gå igenom alla element i en array och utföra en åtgärd med dem.

Perl, liksom många andra programmeringsspråk, har för slinga. Så här itererar du igenom alla element i en array med använder för:

#!/usr/bin/perl använder strikt; använd varningar FATAL => "alla"; använd funktionen "säg"; mina @namn = ("Homer", "Marge", "Bart", "Lisa", "Maggie"); för (min $i = 0; $i<= $#names; $i++) { say $names[$i]; }

Här är resultatet av detta program:

Homer Marge Bart Lisa Maggie

Allt här är standard och enkelt. Definiera $i = 0, kontrollera att villkoret är sant, exekvera loopkroppen, inkrementera räknaren, kontrollera att villkoret är sant, exekvera loopkroppen, inkrementera räknaren, ...

Men Perl tillhandahåller ett enklare och bekvämare sätt att iterera genom en array:

#!/usr/bin/perl använder strikt; använd varningar FATAL => "alla"; använd funktionen "säg"; mina @namn = ("Homer", "Marge", "Bart", "Lisa", "Maggie"); foreach my $name (@names) ( säg $name; )

I det här alternativet läggs alla element i arrayen in i variabeln $name i tur och ordning. Det här alternativet är lättare att både läsa och skriva.

Perl har en intressant funktion - en standardvariabel. Om du anger en variabel för varje, kommer perl att lägga alla arrayelement i standardvariabeln $_:

Foreach (@names) ( säg $_; )

Och om du inte anger några parametrar för say, så fungerar say med standardvariabeln. Så samma loop kan skrivas så här:

Foreach (@names) ( säg; )

Och i Perl kan du använda postfix-notation för foreach, så samma loop kan skrivas:

Säg föreach @namn;

Perl har medan loop, och den kan också användas för att iterera genom en array. Till exempel, så här (var försiktig, det finns en fara med denna användning):

#!/usr/bin/perl använder strikt; använd varningar FATAL => "alla"; använd funktionen "säg"; mina @namn = ("Homer", "Marge", "Bart", "Lisa", "Maggie"); while (mitt $namn = skift @namn) (säg $namn;)

Det här exemplet fungerar exakt på samma sätt som de andra alternativen i det här avsnittet. Men om arrayen har undef-element, så kommer denna loop inte att gå igenom alla element:

#!/usr/bin/perl använder strikt; använd varningar FATAL => "alla"; använd funktionen "säg"; mina @namn = ("Homer", "Marge", "Bart", "Lisa", undef, "Maggie"); while (mitt $namn = skift @namn) (säg $namn;)

Utdata från detta skript:

Homer Marge Bart Lisa

De där. utan "Maggie". Du kan göra om while-slingan så att den fungerar korrekt, till exempel så här:

#!/usr/bin/perl använder strikt; använd varningar FATAL => "alla"; använd funktionen "säg"; mina @namn = ("Homer", "Marge", "Bart", "Lisa", undef, "Maggie"); while ($#names != -1) (my $name = shift @names; säg $name om $name;)

(Variabeln $#names returnerar -1 om arrayen är tom.)

Men det skulle vara lättare och tydligare att skriva det med foreach:

Foreach (@names) ( säg om $_; )

Funktioner

Arrayer i Perl används när du skriver dina egna funktioner:

#!/usr/bin/perl använder strikt; använd varningar FATAL => "alla"; använd funktionen "säg"; sub say_hello ( my ($name) = @_; säg "Hej, ", $name; ) say_hello "Homer";

Detta definierar en funktion som heter say_hello. När vi kallar den hamnar alla parametrar som vi skickade in i funktionen i en speciell array @_.

Genom att spela in

Mitt ($namn) = @_;

vi sparade det första elementet i arrayen @_ i variabeln $name.

@_ är en array, så du kan arbeta med den på ett annat sätt. Till exempel så här:

Sub say_hello (säg "Hej,", $_; )

Sub say_hello (my $name = shift @_; säg "Hej, ", $name; )

Om du använder shift inuti en sub och inte ger den några parametrar, kommer den att fungera med @_. Så det sista alternativet kan skrivas:

Sub say_hello (my $name = shift; säg "Hej", $name;)