PHP är väl inriktat på informationsbehandling. Språkets syntax representeras av en fullfjädrad uppsättning jämförelsefunktioner, strängbearbetning och jämförelseoperatorer.
Vilken algoritm som helst är en sekvens av val och åtgärder. Men innan du gör ett val måste du jämföra något med något. Strängar är den mest rymliga, effektiva och praktiska mekanismen för att styra en algoritm. Rader är ett alternativ för datarepresentation. Och data är huvudproblemet för alla algoritmer.
I allmänhet gör språket inga speciella skillnader i data till exempel i PHP, att jämföra en sträng och ett nummer är inte mycket annorlunda. Ett nummer är också en sträng när det bara innehåller siffror, en punkt och inga tecken som inte används för att representera talet i någon form (matematisk notation).
I fallet med innehåll slås numret automatiskt samman i strängen utan onödiga frågor och inga dolda fel, även om funktionen gettype() returnerar "integer" eller "double".
Det finns dock en skillnad mellan att använda funktionen is_int() och is_numeric(). Den första ger true när parametern bara är ett heltal, den andra när den är ett valfritt tal eller en numerisk sträng (variabeln är av typen "sträng", men innehåller allt som tillhandahålls av den matematiska notationen).
Detta enkla exempel är ett bra exempel på hur PHP-strängjämförelseoperatorer ("==", "===", "!=", ...) kan slänga upp många överraskningar. Variabler kan ändra sin typ de är inte alltid siffror, men de kan nästan alltid gjutas till en sträng. I extrema fall kommer det att vara en tom sträng.
Baserat på ovanstående är strängjämförelsefunktionen den mest populära i PHP. Det är upp till utvecklaren att bestämma vilken som ska väljas. Det finns många alternativ tillgängliga, inklusive reguljära uttryck.
PHP-jämförelse av två strängar görs bra av strpos()-funktionen - det billigaste, mest exakta och praktiska alternativet. Om funktionen är ett tal så är den ena strängen definitivt lika med den andra eller så ingår den i den andra.
Ett radikalt motsatt, men också helt korrekt tillvägagångssätt är användningen av reguljära uttryck.
Om funktionsanropet $cResult = scCheckFileName($cStr) returnerar "true", är strängen namnet på en Word-fil. Det kommer bara att ha ett tilläggsalternativ ".docx" och inga symboler i namnet: endast bokstäver, siffror och tecken "_", "-".
Funktionen kan enkelt konverteras till andra typer av filer: $cPtr = "/^((4,239))\.(html|js|css|png|jpg|docx|txt)(1)$/u". Det här alternativet för att kontrollera en sträng utökar utbudet av laddade (till exempel i PHP används strängjämförelse "för att ladda upp filer till servern, utan en enda chans för ett inmatningsfel") till html, js, css, .. .
Att använda strpos() och preg_match() är extremer. De är inte direkt relaterade till frågan om termjämförelse. Men frågan om algoritmen är en fråga om att tillämpa en kombination av stilar och använda alla möjligheter för att uppnå ett tillförlitligt och korrekt resultat.
Språkets strängjämförelsearsenal innehåller inte bara rena jämförelsefunktioner, utan även en kombination med sök eller ersätt direkt. Handlingen behöver inte alltid vara densamma som en jämförelse, eftersom den senare inte nödvändigtvis ändrar någon rad. Ofta behöver du välja en eller annan gren av algoritmen.
Den vanliga PHP-versionen: strängjämförelse utförs av funktionen int strcmp (s1, s2).
Funktionsresultat:
I praktiken innebär det att den första strängen ingår i den andra, från vilken PHP-funktionen (strängjämförelse) fattar ett beslut. En mer begränsad variant av strpos(), eftersom i det senare fallet kan platsen för förekomsten vara känd.
Strcmp()-funktionen är skiftlägeskänslig. Om du behöver jämföra strängar på ett skiftlägesokänsligt sätt, föreslår PHP att du använder strcasecmp(). Syntaxen är liknande.
I praktiken är det ofta nödvändigt att inte arbeta med hela strängen, utan bara med en del av den. För att göra detta inkluderar uppsättningen PHP-funktioner (strängjämförelse) strncmp (s1, s2, N). Den tredje parametern anger att endast N-byte ska jämföras. Resultatet är detsamma som strcmp().
Data representeras nästan alltid som strängar. Om vi betraktar arrayer, objekt eller informationsstrukturer, så är dessa helt enkelt olika kombinationer av enklare strängstrukturer.
Strängarrayer och strängar kan representeras på ett komplementärt sätt. Omvandla en array till en sträng med hjälp av implode(array, symbol)-funktionen, till exempel: $margins1 = implode(", ", $style->getInnerMargin()); ... algoritmens/användarens arbete...; $margins2 = implode(", ", $style->getInnerMargin()) låter dig slå samman alla objektpositioner till en positionssträng.
Du kan sedan göra en PHP-strängjämförelse och i ett svep: $check = strcmp ($margins1, $margins2) och se till att algoritmen eller användaren har ändrat något (eller inte). Om du utför jämförelsen på vanligt sätt måste du iterera över elementen i arrayerna. Detta tar längre tid och ser krångligare ut.
En ännu mer kraftfull användning av PHP (strängjämförelse) kan implementeras genom objektorienterade idéer.
Den moderna idén om objekt antar att de har egenskaper och metoder. De förra representeras vanligtvis av siffror, strängar, arrayer och andra objekt. De senare inkluderar ofta metoder för att skriva (sätta) till en sträng och återställa från en sträng (get).
Till skillnad från arrayer, fungerar ett objekt på sina egna egenskaper och interagerar med andra objekt. Ett objekt är "kompetent" i vilka egenskaper hos det som har verklig betydelse för algoritmen, programmet som helhet.
Denna punkt ger grunden och möjligheten att vid inspelning endast registrera den nödvändiga informationen i en rad, och vid återställning från en linje, återställa alla arbetsegenskaper till önskat tillstånd. Vanligtvis innehåller alla objekt väsentlig och operativ (tillfällig) information. Genomförandet av denna idé låter dig spara inte bara minne, diskutrymme och databasposter, utan gör det också möjligt att jämföra strängar med enklare och mer exakta metoder.
PHP utvecklas dynamiskt och dess funktionalitet, både när det gäller att jämföra strängar och bearbeta dem, förbättras ständigt. Inget hindrar dock utvecklaren från att flytta tyngdpunkten till semantikens område.
Utan tvekan är funktionaliteten bra, men dess användning kan överföras till den semantiska delen av koden, till objekt. När en algoritm presenteras som ett system för interaktion mellan objekt, ser det mycket bättre ut än en sekvens av jämförelser och åtgärder i en rak sekventiell, klassisk stil.
Det här kapitlet beskriver jämförelseoperatorer. Dessa operatorer testar för likhet (som lika med, mindre än, identiskt lika med, etc.) mellan två värden och returnerar sant eller falskt beroende på hur operanderna är relaterade. Jämförelseoperatorer returnerar alltid booleska värden, och dessa värden används oftast i satser som , while eller for för att styra flödet av programkörning.
| Exempel | Namn | Resultat |
|---|---|---|
| $i == $y | Lika | TRUE om $i är lika med $y efter datatypkonvertering. |
| $i === $y | Identiskt | TRUE om $i är lika med $y och har samma datatyp. |
| $i != $y | Inte lika | |
| $i<>$y | Inte lika | TRUE om $i inte är lika med $y efter datatypkonvertering. |
| $i !== $y | Inte identisk | SANT om $i inte är lika med $y eller om de är av olika typer. |
| $i< $y | Mindre | TRUE om $i är strikt mindre än $y. |
| $i > $y | Mer | TRUE om $i är strikt större än $y. |
| $i<= $y | Mindre än eller lika med | TRUE om $i är mindre än eller lika med $y. |
| $i >= $y | Större än eller lika med | TRUE om $i är större än eller lika med $y. |
Obs: om du försöker visa resultatet av en jämförelseoperation på skärmen kommer värdet sant att visas i webbläsarfönstret som 1. Värdet false motsvarar siffran 0 och visas inte på skärmen (i princip du bör komma ihåg detta från beskrivningen av den booleska typen). Om du vill se resultatet som sant eller falskt, använd var_dump()-funktionen.
Det är också värt att notera: om en sträng med ett nummer eller två strängar som innehåller siffror jämförs, kommer varje sträng att omvandlas till ett tal, och de jämförs som siffror.
Operatorn == (likhet) accepterar operander av vilken typ som helst om de två operanderna är lika, returnerar den sant, annars returnerar den falskt.
Om operanderna är av olika datatyper, kommer PHP att försöka konvertera dem till samma datatyp innan de jämförs, till exempel kommer uttrycket "4" == 4 att returnera sant eftersom PHP automatiskt castar de värden som jämförs med samma datatyp. På liknande sätt kommer uttrycket $a == 1 att returnera sant om variabeln $a innehåller värdet 1. Om du vill undvika implicit typkonvertering vid jämförelse bör du använda identitetsoperatorn, som kommer att diskuteras senare.
Operatören === (identitet) accepterar operander av vilken typ som helst och returnerar sant om deras värden är samma (lika) och falskt om de är olika. Hur skiljer den sig från jämställdhetsoperatören? Identitetsoperatören testar två operander för "identitet" baserat på en strikt definition av en matchning, vilket innebär att förutom att värdena på själva operanderna är lika måste de också vara av samma datatyp. Som ett exempel, betrakta ett uttryck som 5 === "5" , resultatet av detta uttryck kommer att vara falskt eftersom värdet till vänster är ett tal och värdet till höger är en sträng, det vill säga dessa värden har olika datatyper. Kom ihåg att operatorerna == och === betyder "lika med" och "identiska/identiskt lika".
Ojämlikhetsoperatör har två typer: != och<>. Det är motsatsen till operatorn == och returnerar sant om operanderna inte är lika. Olikhetsoperatorn returnerar falskt endast om värdena på vardera sidan av den är lika med varandra.
$var2); // return false var_dump("Hem"<>"hem"); // return true ?>
Operatorn !== (icke-identitet) utför exakt motsatsen till operatorn ===. Det returnerar sant om operandvärdena inte är lika med varandra eller inte är av samma datatyp. Som ett exempel kan du tänka på följande uttryck: 7 !== "7" , operatorn "icke-identitet" returnerar sant eftersom värdet till vänster är ett tal och värdet till höger är en sträng, vilket betyder att de är olika datatyper. Härifrån kommer det att vara lätt att komma ihåg att operatorerna != och !== betyder "inte lika" och "inte identiska/identiska inte lika."
När du använder operatorn > (större än) returnerar jämförelsen bara sant om värdet till vänster om operatorn är större än värdet till höger om den. Precis som andra operatorer fungerar operatorn > inte bara med numeriska värden utan även med strängvärden. Men hur kan en linje vara större än en annan?
När du arbetar med strängar är en liten bokstav större än en stor bokstav. När du jämför strängar kontrollerar PHP först den första bokstaven i strängen för att se om den inte matchar. Om ingen skillnad hittas, flyttas den till nästa tecken, och så vidare, tills en skillnad hittas eller slutet av raden nås. Om de två värdena på vardera sidan om operatorn > är lika, kommer operatorn också att returnera false .
3); // return true var_dump("Hej" > "hej"); // returnera false var_dump(1 > 1); // returnera falskt ?>
Operatör< (меньше ) является функциональной противоположностью оператора «больше». Он возвращает true , когда значение слева от него меньше значения, находящегося справа, и false , если значение левого операнда больше правого или значения равны.
Operatör >= ( större än eller lika med) skiljer sig något från jämförelseoperatorerna som diskuterades tidigare. Det lägger till möjligheten för två värden på vardera sidan av den att vara lika, det vill säga för att sann ska kunna returneras måste värdet till vänster om operatören vara större än eller lika med värdet till höger om det. Operatorn större än eller lika med returnerar falskt endast om värdet till vänster om det är mindre än värdet till höger.
= 5); // return true var_dump("hej" >= "hej"); // returnera true var_dump(1 >= 2); // returnera falskt ?>
Operatör<= (меньше или равно) похож на оператор «больше или равно». Чтобы оператор <= вернул true , значение слева от оператора должно быть меньше или равно значению справа от него. Он возвращает false , только если значение слева от него больше, чем значение справа.
Jämför strängar.
Syntax:
Int strcmp(sträng str1, sträng str2)
substr_compare()
Binärsäker jämförelse av 2 strängar med offset, skiftlägeskänslig eller skiftlägesokänslig (PHP 5)
Beskrivning:
Int substr_compare (string main_str, string str, int offset [, int length [, bool case_sensitivity]])
substr_compare() jämför strängen main_str med början på tecknet som anges av offset-argumentet med strängen str. Jämförelsen omfattar maximalt längd tecken.
Returnerar talet 0 om det är större än str, och 0 om strängarna är lika. Om längden är större än eller lika med längden på main_str och offset passeras, utfärdar substr_compare() en varning och returnerar FALSE.
Om skiftlägeskänslighet är TRUE är jämförelsen skiftlägeskänslig.
Exempel på användning av substr_compare()
echo substr_compare("abcde", "bc", 1, 2); // 0
echo substr_compare("abcde", "bcg", 1, 2); // 0
echo substr_compare("abcde", "BC", 1, 2, sant); // 0
echo substr_compare("abcde", "bc", 1, 3); // 1
echo substr_compare("abcde", "cd", 1, 2); // -1
echo substr_compare("abcde", "abc", 5, 1); // varning
?>
Jämför början av strängar.
Syntax:
Int strncmp(sträng str1, sträng str2, int len)
Denna funktion skiljer sig från strcmp() genom att den inte jämför hela ordet, utan de första len-bytena. Om len är mindre än längden på den minsta strängen jämförs hela strängen.
Denna funktion jämför två strängar tecken för tecken (mer exakt, byte byte) och returnerar:
0 - om strängarna helt matchar;
1 - om strängen str1 är lexikografiskt mindre än str2;
1 - om, tvärtom, str1 är "större" än str2.
Eftersom jämförelsen är byte-för-byte, påverkar fallet med tecken resultaten av jämförelser.
strcasecmp
Jämför strängar på ett skiftlägesokänsligt sätt.
Syntax:
Int strcasecmp(sträng str1, sträng str2)
Samma som strcmp(), bara det tar inte hänsyn till fallet med bokstäver.
$str1 = "Hej!";
$str2 = "hej!";
if(!strcesecmp($str1, $str2))
echo "$str1 == $str2 vid jämförelse av skiftlägesokänsliga strängar";
strncasecmp
Jämför början av strängar på ett skiftlägesokänsligt sätt.
Syntax:
Int strncasecmp(sträng str1, sträng str2, int len)
Funktionen strncasecmp() är en kombination av funktionerna strcasecmp() och strncmp().
strnatcmp
Utför en "naturlig" strängjämförelse.
Syntax:
Int strnatcmp(sträng str1, sträng str2)
Den här funktionen simulerar strängjämförelsen som en människa skulle använda.
$arr1 = $arr2 = array("img12.png", "img10.png", "img2.png", "img1.png");
eko "Normal sortering";
usort($arr1, "strcmp");
print_r($arr1);
eko "nNaturlig sortering";
usort($arr2, "strnatcmp");
print_r($arr2);
Detta skript kommer att mata ut följande:
Normal sortArray(
=> img1.png
=> img10.png
=> img12.png
=> img2.png
)
Natural sortArray(
=> img1.png
=> img2.png
=> img10.png
=> img12.png
)
strnatcasecmp
Utför en "naturlig" skiftlägesokänslig strängjämförelse.
Syntax:
Int strnatcasecmp(sträng str1, sträng str2)
Samma som strnatcmp(), men ignorerar skiftläge.
liknande_text
Bestämmer likheten mellan två strängar.
Syntax:
Int liknande_text(sträng först, sträng andra [, dubbel procent])
Liknande_text()-funktionen beräknar likheten mellan två strängar med hjälp av algoritmen som beskrivs av Oliver.
Men istället för en stack (som i Olivers pseudokod) använder den rekursiva anrop.
Algoritmens komplexitet gör funktionen långsam, och dess hastighet är proportionell mot (N^3), där N är längden på den största strängen.
Funktionen returnerar antalet tecken som matchade i båda strängarna. När den tredje valfria parametern skickas med referens lagras procentandelen strängmatchningar.
levenshstein
Bestämma Levenshtein-skillnaden för två strängar.
Syntax:
Int levenshtein(sträng str1, sträng str2)
int levenshtein(sträng str1, sträng str2, int cost_ins, int cost_rep, int cost_del)
int levenshtein(sträng str1, sträng str2, funktionskostnad)
Levenshtein-skillnaden är det minsta antalet tecken som skulle behöva ersättas, infogas eller raderas för att förvandla str1 till str2. Algoritmens komplexitet är proportionell mot produkten av längderna på strängarna str1 och str2, vilket gör funktionen snabbare än similar_text().
Den första formen av funktionen returnerar antalet nödvändiga operationer på strängtecken för att transformera str1 till str2.
Den andra formen har ytterligare tre parametrar: kostnaden för insättnings-, ersättnings- och raderingsoperationer, vilket gör den mer lämpad för beräkning, men samtidigt mindre snabb. Den integrerade indikatorn på transformationskomplexitet returneras.
Det tredje alternativet låter dig specificera funktionen som används för att beräkna komplexiteten i transformationen.
Kostnadsfunktionen anropas med följande argument:
tillämpad operation (infoga, ändra, ta bort): "I*, "R", "D";
faktiska första radens tecken
faktiska tecken på andra raden
linjeposition 1
linjeposition 2
återstående radlängd 1
återstående linjelängd 2
Den anropade funktionen kommer att behöva returnera kostnaden för denna operation.
Om en av strängarna är längre än 255 tecken, returnerar levenshtein() -1.
men denna längd är mer än tillräckligt.
strcoll()
Jämför strängar baserat på aktuell lokalitet (PHP 4 >= 4.0.5, PHP 5)
Beskrivning:
Int strcoll (sträng str1, sträng str2)
Returnerar ett positivt tal om str1 är mindre än str2; ett negativt tal om str1 är större än str2 och 0 om strängarna är lika. strcoll() använder inställningarna för den aktuella lokalen vid jämförelse. Om lokalen är C eller POSIX är den här funktionen samma som strcmp().
Observera att den här funktionen är skiftlägeskänslig och, till skillnad från strcmp(), inte binärsäker.
