Sa bahaging ito ay pag-uusapan natin ang tungkol sa mga function para sa pagtatrabaho sa impormasyon ng teksto na maaaring magamit sa mga query at program code sa wikang PL/SQL.

Function CONCAT(strl, str2)

Pinagsasama ng function na ito ang mga string na strl at str2. Kung ang isa sa mga argumento ay NULL, ito ay itinuturing bilang isang walang laman na string. Kung ang parehong mga argumento ay NULL, ang function ay nagbabalik ng NULL. Halimbawa:

SELECT CONCAT("May aso ang pari") x1,
CONCATCTest" , NULL) x2,
CONCAT(NULL, "Pagsusulit") x3,
CONCAT(NULL, NULL) x4
MULA sa dalawahan

May aso ang pari

Upang pagsama-samahin ang mga string, sinusuportahan ng Oracle ang isang espesyal na concatenation operator na "||" na gumagana katulad ng CONCAT function, halimbawa:

SELECT CONCAT("Ang pari "may aso") x1, "Ang pari " || "may aso" x2
MULA sa dalawahan

Ang concatenation operator na "||", na katumbas ng pagtawag sa CONCAT function, ay hindi dapat malito sa "+" operator na ginagamit sa mga operasyon ng aritmetika. Sa Oracle ito ay iba't ibang mga operator, ngunit dahil sa awtomatikong uri ng paghahagis, ang mga banayad na error ay posible, halimbawa:

PILIIN ang "5" + "3" x1
MULA sa dalawahan

Sa kasong ito, ibinalik ang numeric na value na 8 kaysa sa text string na "53". Ito ay dahil kapag nakita ng Oracle ang arithmetic operator na "+", awtomatikong sinusubukan ng Oracle na i-cast ang mga argumento upang i-type ang NUMBER.

Function LOWER(str)

Kino-convert ng LOWER function ang lahat ng character sa str sa lowercase. Halimbawa:

SELECT LOWER("TeXt DATA") X
MULA sa dalawahan

FunctionUPPER(str)

Kino-convert ng UPPER function ang lahat ng character sa string str sa uppercase. Halimbawa:

SELECT UPPER("TeXt DATA") X
MULA sa dalawahan

INITCAP(str) function

Ibinabalik ang string str na may mga unang titik ng lahat ng salita na na-convert sa uppercase. Ang function ay maginhawa para sa pag-format ng buong pangalan kapag bumubuo ng mga ulat. Halimbawa:

PILIIN ANG INITCAPCIVANOV peter sidorovich") X
MULA sa dalawahan

Mga pag-andarLTRIM(str [,set])AtRTIM(str [,set])

Tinatanggal ng LTRIM function ang lahat ng character mula sa simula ng isang string hanggang sa unang character na wala sa set ng character set. Bilang default, ang set ay binubuo ng isang espasyo at maaaring hindi tinukoy. Ang RTRIM function ay katulad ng LTRIM, ngunit nag-aalis ng mga character simula sa dulo ng string. Tingnan natin ang ilang halimbawa:

PUMILI LTRIM(" TEXt DATA") X1,
LTRIM(" _ # TeXt DATA", " #_") X2,
LTRIM(" 1234567890 TEXt DATA", " 1234567890") X3
MULA sa dalawahan

Function REPLACE(str, search_str, [,replace_str])

Ang REPLACE function ay naghahanap ng search_str pattern sa string str at pinapalitan ang bawat pangyayari na natagpuan ng replace_str. Bilang default, ang replace_str ay ang walang laman na string, kaya ang pagtawag sa REPLACE na may dalawang argumento ay nag-aalis ng lahat ng nakitang paglitaw. Ang paghahanap para sa isang substring ay case sensitive. Halimbawa:

SELECT REPLACE("May aso ang pari", "aso", "pusa") x1,
REPLACE("Ang pari ay may masamang aso", "masama") x2,
REPLACE("May aso ang pari", "Aso", "Pusa") x3
MULA sa dalawahan

May pusa ang pari	May aso ang pari	May aso ang pari

Function TRANSLATE(str, from_mask, to_mask)

Pina-parse ng TRANSLATE function ang string str at pinapalitan ang lahat ng character na lumalabas sa from_mask string ng mga kaukulang character mula sa to_mask. Para gumana nang tama ang function, dapat na magkapareho ang haba ng from_mask at to_mask string, o dapat na mas mahaba ang from_mask string kaysa to_mask. Kung ang from_mask ay mas mahaba kaysa sa to_mask, at habang pinoproseso ang string str, makikita ang mga character na tumutugma sa isa sa mga character na from_mask, at walang tugma para sa mga ito sa to_mask, pagkatapos ay aalisin ang mga naturang character mula sa string str. Kung pumasa ka from_mask o to_mask katumbas ng NULL, ang function ay magbabalik ng NULL. Ang paghahambing ay ginawang case-sensitive.

SELECT TRANSLATE("Test 12345", "e2\"E!") x1,
TRANSLATE("Test 12345", "e234", "E") x2
MULA sa dalawahan

Ang function na ito ay maginhawa para sa paglutas ng ilang praktikal na problema na may kaugnayan sa conversion ng character o paghahanap ng mga ipinagbabawal na character. Halimbawa, kailangan mong suriin ang isang password at alamin kung naglalaman ito ng hindi bababa sa isang digit. Ang pagpapatupad ng pagsusuring ito gamit ang TRANSLATE ay ganito ang hitsura:

IF TRANSLATE(PassWd, "0123456789", "*") = PassWd THEN
ADD_ERR0R("Error - Ang password ay dapat maglaman ng hindi bababa sa isang digit!");
RETURN 1;
ENDIF;

Isa pang halimbawa: ang isang numero ay inihahanda para sa conversion nito sa NUMBER. Kinakailangang palitan ang mga decimal separator na "," at "." sa "." at alisin ang mga puwang. Ang pagpapatupad ng operasyong ito gamit ang TRANSLATE ay ganito ang hitsura:

SELECT TRANSLATE("123 455.23", "., ", " . . ") x1,
TRANSLATE("-123 455.23", "., ", " . . ") x2
MULA sa dalawahan

Function na SUBSTR(str, m [,n])

Ang SUBSTR function ay nagbabalik ng isang fragment ng string str, simula sa character m, na may haba na n character. Maaaring tanggalin ang haba - sa kasong ito, ibabalik ang string mula sa character na m hanggang sa dulo ng string str. Ang mga character ay binibilang simula sa 1. Kung tinukoy mo ang m = 0, magsisimula pa rin ang pagkopya mula sa unang character. Ang pagtukoy ng negatibong halaga para sa m ay nagiging sanhi ng pagbibilang ng mga character mula sa dulo ng string kaysa sa simula. Ang pagtukoy ng mga halaga ng m na mas malaki sa ganap na halaga kaysa sa haba ng string ay nagiging sanhi ng pagbabalik ng NULL.

SELECT SUBSTR("May aso ang pari", 13) x1,
SUBSTR("May aso ang pari", -6) x2,
SUBSTR("Ito ang test text", 5, 8) x3,
SUBSTR("May aso ang pari", 150) x4
MULA sa dalawahan

		text

Function INSTR(str, search_str [,n[,m]])

Ibinabalik ng INSTR function ang posisyon ng unang character na m-ro ng string fragment str na tumutugma sa search_str. Ang paghahambing ay isinasagawa mula sa nth character ng string str; Bilang default, n = m = 1, iyon ay, ang paghahanap ay isinasagawa mula sa simula ng linya at ang posisyon ng unang fragment na natagpuan ay ibinalik. Kung ang paghahanap ay hindi matagumpay, ang function ay nagbabalik ng 0.

SELECT INSTR("y butt was a dog", "dog") x1,
INSTR("y butt was a dog", "cat") x2,
INSTR("Ito ay teksto upang ipakita ang paghahanap ng teksto", "teksto", 1, 2) x3,
INSTR(‘11111000000001", "1", 7) x4
MULA sa dalawahan

Gamit ang function na ito, pati na rin sa lahat ng iba pa sa Oracle, madalas na ginagawa ang mga karaniwang error na nauugnay sa paghawak ng NULL values. Kung str=NULL, ang function ay magbabalik ng NULL, hindi zero! Dapat itong isaalang-alang kapag nagtatayo ng iba't ibang mga kondisyon. Halimbawa, hindi isinasaalang-alang ng fragment na ito ng isang PL/SQL program ang feature na ito:

KUNG INSTR(TXT_VAR,"*") = 0 TAPOS
...
WAKASKUNG;

Sa kasong ito, magiging tama na magsulat ng ganito:

KUNG NVL(INSTR(TXT_VAR, "*"), 0) = 0 THEN
...
ENDIF;

LENGTH (str) at LENGTHB (str) function

Ang LENGTH(str) function ay nagbabalik ng haba ng string str sa mga character. Para sa isang walang laman na string at isang NULL na halaga, ang function ay nagbabalik ng NULL, kaya inirerekomenda na gamitin ang NVL kasabay ng function na ito.

SELECT LENGTH("May aso ang pari") x1,
LENGTH("") x2,
LENGTH(NULL) x3,
NVL(LENGTH(""), 0) x4
MULA sa dalawahan

Ang LENGTHB function ay katulad ng LENGTH function, ngunit ibinabalik ang haba ng string sa bytes.

ASCII(str) function

Ibinabalik ang ASCII value ng unang character ng string str kapag gumagamit ng ASCII character encoding, at ang value ng unang byte ng multibyte character kapag gumagamit ng multibyte character encoding. Halimbawa:

PUMILI NG ASCII("Pagsusulit") x1 MULA sa dalawahan

Function CHR(n)

Nagbabalik ng character sa pamamagitan ng code nito.

PUMILI CHR(64) x1
MULA sa dalawahan

Sa iba. Mayroon itong sumusunod na syntax:

CONV(numero,N,M)

Pangangatwiran numero ay nasa base N. Kino-convert ito ng function sa base M at ibinabalik ang halaga bilang isang string.

Halimbawa 1

Kino-convert ng sumusunod na query ang numero 2 mula decimal patungo sa binary:

PUMILI NG CONV(2,10,2);

Resulta: 10

Upang i-convert ang numero 2E mula sa hexadecimal sa decimal, ang sumusunod na query ay kinakailangan:

SELECT CONV("2E",16,10);

Resulta: 46

Function CHAR() nagko-convert ng ASCII code sa mga string. Mayroon itong sumusunod na syntax:

CHAR(n1,n2,n3..)

Halimbawa 2

PUMILI CHAR(83,81,76);

Resulta: SQL

Ang mga sumusunod na function ay nagbabalik ng haba ng isang string:

• LENGTH(string);
• OCTET_LENGTH(string);
• CHAR_LENGTH(string);
• CHARACTER_LENGTH(string).

Halimbawa 3

SELECT LENGTH("MySQL");

Resulta: 5

Minsan ang function na ito ay kapaki-pakinabang BIT_LENGTH(string), na nagbabalik ng haba ng string sa mga bit.

Halimbawa 4

SELECT BIT_LENGTH("MySQL");

Resulta: 40

Mga function para sa pagtatrabaho sa mga substring

Ang substring ay karaniwang bahagi ng isang string. Kadalasan kailangan mong malaman ang posisyon ng unang paglitaw ng isang substring sa isang string. Tatlong function ang lutasin ang problemang ito sa MySQL:

• LOCATE(substring, string [,posisyon]);
• POSITION(substring, string);
• INSTR(string, substring).

Kung ang substring ay hindi nakapaloob sa string, ang lahat ng tatlong function ay nagbabalik ng 0. Ang INSTR() function ay naiiba sa iba pang dalawa sa pagkakasunud-sunod ng mga argumento nito. Ang LOCATE() function ay maaaring maglaman ng ikatlong argumento posisyon, na nagbibigay-daan sa iyong maghanap para sa isang substring sa isang string hindi mula sa simula, ngunit mula sa isang tinukoy na posisyon.

Halimbawa 5

SELECT LOCATE("Topaz", "open joint stock company Topaz");

Resulta: 31

SELECT POSITION("Topaz", "open joint stock company Topaz");

Resulta: 31

SELECT INSTR("open joint stock company Topaz",'Topaz');

Resulta: 31

SELECT LOCATE("Topaz", "Topaz Plant and Topaz LLC", 9);

Resulta: 20

SELECT LOCATE("Almaz", "Topaz Open Joint Stock Company");

Resulta: 0

Mga pag-andar KALIWA(linya, N) At KANAN(string, N) ibalik ang pinakakaliwa at pinakakanang N character sa string, ayon sa pagkakabanggit.

Halimbawa 6

SELECT LEFT("MySQL DBMS", 4);

Resulta: DBMS

PUMILI NG KANAN("MySQL DBMS", 5);

Resulta: MySQL

Minsan kailangan mong kumuha ng substring na magsisimula sa ilang partikular na posisyon. Ang mga sumusunod na function ay ginagamit para dito:

• SUBSTRING(string, posisyon, N);
• MID(linya, posisyon, N).

Ang parehong mga function ay nagbabalik ng N character ng ibinigay na string, simula sa tinukoy na posisyon.

Halimbawa 7

SELECT SUBSTRING("MySQL DBMS is one of the most popular DBMS", 6.5);

Resulta: MySQL

Ang tampok na ito ay lubhang kapaki-pakinabang kapag nagtatrabaho sa mga email address at website address. SUBSTR_INDEX(). Ang function ay may tatlong argumento:

SUBSTR_INDEX(string, delimiter, N).

Ang N argumento ay maaaring maging positibo o negatibo. Kung ito ay negatibo, makikita ng function ang Nth na paglitaw ng separator, na binibilang mula sa kanan. Pagkatapos ay ibabalik nito ang substring na matatagpuan sa kanan ng nahanap na delimiter. Kung positibo ang N, hahanapin ng function ang Nth na paglitaw ng delimiter sa kaliwa at ibinabalik ang substring na matatagpuan sa kaliwa ng nahanap na delimiter.

Halimbawa 8

SELECT SUBSTRING_INDEX("www.mysql.ru",".,2);

Resulta: www.mysql

SELECT SUBSTRING_INDEX("www.mysql.ru",".",-2);

Resulta: mysql.ru

Function PALITAN(string, substring1, substring2) ay nagpapahintulot sa iyo na palitan ang lahat ng mga paglitaw ng substring1 na may substring2 sa isang string.

Ang mga pangunahing string function at operator ay nagbibigay ng iba't ibang kakayahan at nagbabalik ng string value bilang resulta. Ang ilang mga function ng string ay dalawang elemento, ibig sabihin, maaari silang gumana sa dalawang string nang sabay-sabay. Sinusuportahan ng pamantayang SQL 2003 ang mga function ng string.

Operator ng concatenation

Tinukoy ng SQL 2003 ang concatenation operator (||), na nagsasama ng dalawang magkahiwalay na string sa iisang string value.

Platform ng DB2

Sinusuportahan ng DB2 platform ang SQL 2003 concatenation operator pati na rin ang kasingkahulugan nito, ang CONCAT function.

MySQL platform

Sinusuportahan ng MySQL platform ang CONCATQ function, isang kasingkahulugan para sa SQL 2003 concatenation operator.

Oracle at PostgreSQL

Sinusuportahan ng mga platform ng PostgreSQL at Oracle ang SQL 2003 double vertical bar concatenation operator.

Platform ng SQL Server

Ang platform ng SQL Server ay gumagamit ng plus sign (+) bilang isang kasingkahulugan para sa SQL 2003 concatenation operator ay may isang parameter ng system na CONCAT_NULL_YIELDS_NULL na kumokontrol sa kung paano kumikilos ang system kung ang mga NULL na halaga ay nakatagpo kapag pinagsama ang mga halaga ng string.

/* SQL 2003 syntax */

stringl || string2 || string3

string1string2string3

/* Para sa MySQL */

CONCAT("stringl", "string2")

Kung ang alinman sa mga pinagsama-samang halaga ay walang laman, pagkatapos ay isang walang laman na string ang ibabalik. Bukod pa rito, kung ang isang numeric na halaga ay kasangkot sa pagsasama-sama, ito ay tahasang kino-convert sa isang string na halaga.

SELECT CONCAT("My ", "bologna", " has", "a", "first", "name...");

Ang aking bologna ay may unang pangalan

SELECT CONCAT("My ", NULL, " has", "first", "name...");

I-CONVERT at Isalin

Binabago ng function na CONVERT ang pagpapakita ng string ng character sa loob ng set ng character at collation. Halimbawa, ang CONVERT function ay maaaring gamitin upang baguhin ang bilang ng mga bit bawat character.

Ang TRANSLATE function ay nagsasalin ng string value mula sa isang character set papunta sa isa pa. Halimbawa, ang TRANSLATE function ay maaaring gamitin upang i-convert ang isang value mula sa English character set sa Kanji (Japanese) o Cyrillic (Russian) character set. Ang pagsasalin mismo ay dapat na umiiral na - alinman sa tinukoy bilang default o nilikha gamit ang CREATE TRANSLATION command.

SQL 2003 syntax

CONVERT (character_value USING character_conversion_name)

TRANSLATE(character_value USING translation_name)

Ang CONVERT function ay nagko-convert ng value ng character sa set ng character na may tinukoy na pangalan sa parameter na character_conversion_name. Ang TRANSLATE function ay nagko-convert ng character value sa character set na tinukoy sa translation_name.

Sa mga platform na sinuri, tanging ang Oracle ang sumusuporta sa mga function na CONVERT at TRANSLATE gaya ng tinukoy sa pamantayan ng SQL 2003 na ang pagpapatupad ng Oracle ng TRANSLATE function ay halos kapareho ng, ngunit hindi katulad ng, SQL 2003. Sa pagpapatupad na ito, ang function ay tumatagal lamang ng dalawang argumento at nagsasalin lamang sa pagitan ng database character set at ng locale-enabled na character set.

Ang pagpapatupad ng MySQL ng function na CONV ay nagko-convert lamang ng mga numero mula sa isang base patungo sa isa pa. Ang pagpapatupad ng SQL Server ng function na CONVERT ay lubos na mayaman sa mga kakayahan at binabago ang uri ng data ng expression, ngunit sa lahat ng iba pang aspeto ay naiiba ito sa SQL 2003 standard na CONVERT function na Ang PostgreSQL platform ay hindi sumusuporta sa CONVERT function, at ang pagpapatupad ng ang TRANSLATE function ay nagko-convert ng lahat ng paglitaw ng isang string ng character sa anumang isa pang string ng character.

DB2

Ang DB2 platform ay hindi sumusuporta sa CONVERT function, at ang suporta para sa TRANSLATE function ay hindi ANSI compliant. Ang TRANSLATE function ay ginagamit upang ibahin ang anyo ng mga substring at dati nang naging kasingkahulugan ng UPPER function dahil kamakailan lamang naidagdag ang UPPER function sa DB2. Kung ang TRANSLATE function ay ginagamit sa DB2 na may isang argumento bilang expression ng character, ang resulta ay ang parehong string na na-convert sa uppercase. Kung ginagamit ang function na may maraming argumento, gaya ng TRANSLATE(ucmo4HUK, replace, match), iko-convert ng function ang lahat ng character sa source na nasa parameter din ng tugma. Ang bawat character sa source na nasa parehong posisyon tulad ng sa parameter ng tugma ay papalitan ng character mula sa replace parameter. Nasa ibaba ang isang halimbawa.

TRANSLATE("Hello, World!") "HELLO; MUNDO!"

TRANSLATE("Hello, World1", "wZ", "1W") "Hewwo, Zorwd1

MySQL

Ang MySQL platform ay hindi sumusuporta sa TRANSLATE at CONVERT function.

Oracle

Sinusuportahan ng Oracle platform ang sumusunod na syntax para sa CONVERT at TRANSLATE function.

Sa pagpapatupad ng Oracle, ibinabalik ng CONVERT function ang text ng isang character value na na-convert sa target_charset_set. Ang parameter na char_value ay ang string na iko-convert, ang target_charset_set ay ang pangalan ng set ng character kung saan iko-convert ang string, at ang source_charset na parameter ay ang set ng character kung saan orihinal na nakaimbak ang halaga ng string.

Ang TRANSLATE function sa Oracle ay sumusunod sa ANSI syntax, ngunit maaari ka lamang pumili ng isa sa dalawang character set: ang database character set (CHARJCS) at ang national language character set (NCHARJZS).

Sinusuportahan din ng Oracle ang isa pang function, na tinatawag ding TRANSLATE (nang hindi gumagamit ng USING keyword). Ang TRANSLATE function na ito ay walang kinalaman sa conversion ng set ng character.

Ang mga pangalan ng target at source na set ng character ay maaaring ipasa alinman bilang string constants o bilang isang reference sa isang column ng talahanayan. Tandaan na kapag nagko-convert ng string sa isang set ng character na hindi ipinapakita ang lahat ng mga character na kino-convert, maaari mong palitan ang mga kapalit na character.

Sinusuportahan ng Oracle ang ilang karaniwang set ng character, na kinabibilangan ng US7ASCII at WE8DECDEC. WE8HP, F7DEC, WE8EBCDIC500, WE8PC850u WE8ISO8859PI. Halimbawa:

PUMILI NG CONVERT("Gro2", "US7ASCII", "WE8HP") MULA SA DUAL;

PostgreSQL

Sinusuportahan ng PostgreSQL platform ang ANSI standard CONVERT statement, at ang mga conversion dito ay maaaring tukuyin gamit ang CREATE CONVERSION command. Ang pagpapatupad ng PostgreSQL ng TRANSLATE function ay nagbibigay ng pinahabang hanay ng mga function na nagbibigay-daan sa iyong baguhin ang anumang teksto sa ibang teksto sa loob ng isang tinukoy na string.

TRANSLATE (character string, from_text, to_text)

Narito ang ilang halimbawa:

SELECT TRANSLATE("12345abcde", "5a", "XX"); "1234XXbcde" SELECT TRANSLATE(title, "Computer", "PC") FROM titles WHERE type="Personal_computer" SELECT CONVERT("PostgreSQL" USING iso_8859_1_to_utf_8) "PostgreSQL"

SQL Server

Ang platform ng SQL Server ay hindi sumusuporta sa TRANSLATE function. Ang pagpapatupad ng function na CONVERT sa SQL Server ay hindi sumusunod sa pamantayan ng SQL 2003 Ang function na ito sa SQL Server ay katumbas ng function na CAST.

CONVERT (data_type[(haba) | (precision, scale)], expression, style])

Ginagamit ang style clause upang tukuyin ang format ng conversion ng petsa. Para sa higit pang impormasyon, tingnan ang dokumentasyon ng SQL Server. Nasa ibaba ang isang halimbawa.

PUMILI ng pamagat, CONVERT(char(7), ytd_sales) MULA sa mga pamagat ORDER BY title GO

Nasa ibaba ang isang buong listahan ng mga string function na kinuha mula sa BOL:

ASCII	NCHAR	SOUNDEX
CHAR	PATINDEX	SPACE
CHARINDEX	PALITAN	STR
PAGKAKAIBA	QUOTENAME	BAGAY
KALIWA	GUMULI	SUBSTRING
LEN	REVERSE	UNICODE
MABABA	TAMA	ITAAS
RTRIM	RTRIM

Magsimula tayo sa dalawang magkaugnay na function - ASCII at CHAR:

Ang ASCII function ay nagbabalik ng ASCII code value ng pinakakaliwang character ng isang character expression, bilang isang function argument.

Narito ang isang halimbawa ng paraan upang matukoy kung gaano karaming iba't ibang mga titik kung saan nagsisimula ang mga pangalan ng mga barko sa talahanayan ng Ships ay:

PUMILI NG BILANG(DISTINCT ASCII(pangalan)) MULA SA Mga Barko

Ang resulta ay 11. Upang malaman kung ano ang mga titik na ito, maaari naming gamitin ang CHAR function na nagbabalik ng isang character sa pamamagitan ng isang kilalang halaga ng ASCII code (mula 0 hanggang 255):

PUMILI NG DISTINCT CHAR(ASCII(pangalan)) MULA SA Mga Barko ORDER NG 1

Dapat nating tandaan na ang magkatulad na resulta ay maaaring maging mas simple gamit ang isa pang function - KALIWA na mayroong sumusunod na syntax:

KALIWA (<character_expression>, <integer_expression>)

at ibinabalik ang bahagi ng isang string ng character na nagsisimula sa isang tinukoy na bilang ng mga character mula sa kaliwa. Kaya,

PUMILI NG DISTINCT LEFT(pangalan, 1) MULA SA Mga Barko ORDER NG 1

At ito ang paraan upang makuha ang talahanayan ng mga code ng lahat ng alpabetikong character:

SELECT CHAR(ASCII("a")+ num-1) letter, ASCII("a")+ num - 1 FROM

(PUMILI 1 a UNION LAHAT PILI 2 UNION LAHAT PILI 3 UNION LAHAT PILI 4 UNION LAHAT PILI 5) x
CROSS JOIN
CROSS JOIN
)x
SAAN ASCII("a")+ num -1 SA PAGITAN ng ASCII("a") AT ASCII("z")

Para sa mga walang kamalayan sa pagbuo ng numerical sequence sumangguni ako sa kaukulang artikulo.

Alam na ang mga halaga ng code ng maliliit na titik at malalaking titik ay magkakaiba. Iyon ang dahilan kung bakit upang makuha ang buong hanay nang hindi muling isinusulat sa itaas ng query; ito ay sapat na upang isulat ang magkaparehong code sa nabanggit:

UNYON
SELECT CHAR(ASCII("A")+ num-1) letter, ASCII("A")+ num - 1
MULA SA
PUMILI 5*5*(a-1)+5*(b-1) + c AS num MULA
(PUMILI 1 a UNION LAHAT PILI 2 UNION LAHAT PILI 3 UNION LAHAT PILI 4 UNION LAHAT PILI 5) x
CROSS JOIN
(PUMILI 1 b UNION LAHAT PILI 2 UNION LAHAT PILI 3 UNION LAHAT PILI 4 UNION LAHAT PILI 5) y
CROSS JOIN
(PUMILI 1 c UNION LAHAT SELECT 2 UNION LAHAT PILI 3 UNION LAHAT PILI 4 UNION LAHAT PILI 5) z
)x
SAAN ASCII("A")+ num -1 SA PAGITAN ng ASCII("A") AT ASCII("Z")

Ngayon isaalang-alang natin ang gawain ng paghahanap ng isang substring sa isang string expression. Ang dalawang function ay maaaring gamitin para dito: CHARINDEX at PATINDEX.

Pareho silang nagbabalik ng panimulang posisyon (isang posisyon ng unang character ng isang substring) ng isang substring sa isang string ng character. Ang function na CHARINDEX ay may sumusunod na syntax: CHARINDEX ()

string_expression , target_expression [ , start_location ] Narito ang isang opsyonal na parameter ng integer start_location tumutukoy sa isang posisyon sa a string_expression , kung saan naghahanap a target_expression tumutukoy sa isang posisyon sa a nagsisimula sa. Kung aalisin ang argumentong ito, magsisimula ang paghahanap sa simula ng a

.

Halimbawa, ang query

PUMILI ng pangalan MULA SA Mga Barko KUNG SAAN CHARINDEX("sh", pangalan) > 0

lalabas ang mga barko na mayroong pagkakasunod-sunod ng mga character na "sh" sa kanilang mga pangalan. Dito ginagamit namin ang katotohanan na kung ang isang substring na mahahanap ay hindi natagpuan, ang function na CHARINDEX ay nagbabalik ng 0. Ang resulta ng pagsasagawa ng query ay maglalaman ng mga sumusunod na barko:

pangalan

Kirishima

Musashi , kung saan naghahanap a Washington tumutukoy sa isang posisyon sa a Dapat nating tandaan na kung a

o

ay NULL, ang resulta ng function ay NULL din.
Tinutukoy ng susunod na halimbawa ang mga posisyon ng una at pangalawang paglitaw ng karakter na "a" sa pangalan ng barkong "California"

PILIIN ang CHARINDEX("a",pangalan) first_a,

CHARINDEX("a", pangalan, CHARINDEX("a", pangalan)+1) second_a PATINDEX Bigyang-pansin na sa pagtukoy ng pangalawang pangyayari ang panimulang posisyon, na ginagamit sa pag-andar, ay ang posisyon ng isang karakter sa tabi ng unang "a" - CHARINDEX("a", pangalan)+1. Ang pagiging angkop ng resulta - 2 at 10 - ay madaling masuri.

Ang function ay may sumusunod na syntax:)

PATINDEX (

"%pattern%", string_expression

Ang pangunahing pagkakaiba ng function na ito mula sa CHARINDEX ay ang isang string sa paghahanap ay maaaring maglaman ng mga wildcard na character - % at _. Kinakailangan ang mga nangunguna at nagtatapos na character na "%". Halimbawa, ang paggamit ng function na ito sa unang halimbawa ay magiging ganito

PUMILI ng pangalan MULA SA Mga Barko KUNG SAAN PATINDEX("%sh%", pangalan) > 0
At nariyan ang paraan upang mahanap ang mga pangalan ng mga barko na naglalaman ng pagkakasunud-sunod ng tatlong character, una at huli ay "e":

PUMILI ng pangalan MULA SA Mga Barko

PUMILI ng pangalan MULA SA Mga Barko KUNG SAAN CHARINDEX("sh", pangalan) > 0

SAAN PATINDEX("%e_e%", pangalan) >0

Ang resulta ng pagpapatupad ng query na ito ay ganito ang hitsura:

CHARINDEX("a", pangalan, CHARINDEX("a", pangalan)+1) second_a TAMA Paghihiganti KALIWA Maharlikang Soberano

na nagpupuno<character_expression>,<integer_expression>)

nagbabalik ng tinukoy na bilang ng mga character mula sa kanan ng expression ng character:

TAMA(
Narito, halimbawa, ang paraan upang matukoy ang mga pangalan ng mga barko na nagsisimula at nagtatapos sa parehong titik:

Ang bagay na nakuha namin ng isang walang laman na resultang set ay nangangahulugan na ang mga naturang barko ay wala sa aming database. Kumuha tayo ng kumbinasyon - isang klase at isang pangalan ng isang barko.

Ang pagsasama-sama ng dalawang halaga ng string sa isa ay tinatawag pagsasama-sama, at sa SQL Server ang sign na "+" ay ginagamit para sa operasyong ito ("||" sa pamantayan).

Kaya,
)x

PUMILI * MULA SA (

Dito namin pinaghihiwalay ng espasyo ang klase at ang pangalan ng barko. Bukod dito, upang hindi maulit ang buong konstruksiyon sa argumento ng function, gumagamit kami ng subquery. Magiging ganito ang resulta:

cn

Iowa Missouri

North Carolina Washington

Kaya,
At paano kung ang isang string expression ay maglalaman lamang ng isang character? Ilalabas ito ng query. Madali mo itong masusuri sa pamamagitan ng pagsulat
PUMILI ng klase +" "+ pangalan AS cn FROM Ships
)x
UNION LAHAT PUMILI ng "a" bilang nc

WHERE LEFT(cn, 1)=RIGHT(cn, 1) Upang ibukod ang kasong ito, isa pang kapaki-pakinabang na function tumutukoy sa isang posisyon sa a) LEN(

Kaya,
At paano kung ang isang string expression ay maglalaman lamang ng isang character? Ilalabas ito ng query. Madali mo itong masusuri sa pamamagitan ng pagsulat
maaaring gamitin. Ibinabalik nito ang bilang ng mga character sa isang string. Itali tayo sa kaso, kapag ang bilang ng mga character ay higit sa isa:
)x
UNION LAHAT PUMILI ng "a" bilang nc

WHERE LEFT(cn, 1)=RIGHT(cn, 1) AT LEN(cn)>1

May mga gawain sa website na nangangailangan ng pag-normalize (hanapin ang maximum atbp.) sa isang numerical na pagkakasunud-sunod ng isang halaga na kinakatawan sa isang string format, halimbawa, isang numero ng upuan sa isang eroplano ("2d") o isang bilis ng CD ( "24x"). Ang problema ay nakasalalay sa isang katotohanan na ang teksto ay nag-uuri tulad nito (pataas)
11a
1a

2a
PUMILI "1a" BILANG lugar
UNION ALL SELECT "2a"
UNION ALL SELECT "11a"

ORDER NG 1

Kung kinakailangan ang pag-uuri ng mga lugar ayon sa pagtaas ng mga hilera, ang pagkakasunud-sunod ay dapat na ganito:
1a
1a

11a
Upang makakuha ng ganoong pagkakasunud-sunod, kailangan ang pag-uuri ayon sa isang numerong halaga sa teksto. Iminumungkahi ko ang sumusunod na algorithm:
1. I-extract ang isang numero mula sa string.
2. I-convert ito sa isang numeric na format.

3. Magsagawa ng pag-uuri ayon sa na-convert na halaga.

Tulad ng alam natin na mayroon lamang isang letra sa string, at upang kunin ang isang numero maaari nating gamitin ang sumusunod na konstruksyon na hindi nakadepende sa isang bilang ng mga numero sa isang numero ng upuan:

LEFT(lugar, LEN(lugar)-1)

Kung itali lang natin ito, makukuha natin

lugar

1a

11a

2a

Ang pag-convert sa isang numeric na format ay maaaring magmukhang sumusunod:

CAST (LEFT(lugar, LEN(lugar)-1) AS INT)

Kaya,
Ngayon dapat lang tayong magsagawa ng pag-uuri
PUMILI "1a" BILANG lugar
UNION ALL SELECT "2a"
PUMILI "1a" BILANG lugar

) x ORDER NG CAST(LEFT(place, LEN(place)-1) AS INT)

Noong nakaraan, ginamit namin ang LEFT function upang kunin ang isang numero mula sa isang string expression, dahil alam namin ang isang priori kung gaano karaming mga character ang dapat alisin mula sa kanan (isa). At paano kung dapat nating kunin ang isang string mula sa isang substring hindi sa kilalang posisyon ng isang character, ngunit sa pamamagitan ng isang character mismo? Halimbawa, i-extract ang lahat ng mga character bago ang unang titik na "x" (isang halaga ng bilis ng CD).

Sa dati nitong kaso maaari rin nating gamitin ang itinuturing na CHARINDEX function na nagbibigay-daan sa amin upang matukoy ang hindi kilalang posisyon ng character:

PUMILI ng modelo, LEFT(cd, CHARINDEX("x", cd) -1) MULA SA PC

SUBSTRING function

SUBSTRING (<pagpapahayag> ,<simulan>,<haba>)

Ang function na ito ay nagpapahintulot sa amin na kunin mula sa isang expression ang bahagi nito ng isang tinukoy na haba, simula sa isang tinukoy na paunang posisyon. Ang expression ay maaaring isang character o isang binary string, at maaari ding magkaroon ng isang text o uri ng imahe. Halimbawa, kung kailangan nating kumuha ng 3 character sa pangalan ng barko, simula sa 2nd character, hindi ito masyadong madaling gawin nang walang SUBSTRING function. At kaya sumulat kami:

PUMILI ng pangalan, SUBSTRING(pangalan, 2, 3) MULA SA Mga Barko

Kung sakaling kailangan nating i-extract ang lahat ng mga character, simula sa tiyak, magagamit din natin ang function na ito. Halimbawa,

PUMILI ng pangalan, SUBSTRING(pangalan, 2, LEN(pangalan)) MULA SA Mga Barko

ay magbibigay sa amin ng lahat ng mga character sa mga pangalan ng mga barko, simula sa pangalawang titik sa pangalan. Bigyang-pansin na upang matukoy ang bilang ng mga character na i-extract ginamit ko ang function na LEN(pangalan) na nagbabalik ng isang bilang ng mga character sa pangalan. Malinaw na dahil kailangan ko ang mga character, simula sa pangalawa, ang bilang nito ay magiging mas kaunti kaysa sa buong bilang ng mga character sa pangalan. Ngunit hindi ito nagdudulot ng error, dahil kung lumampas ang isang tinukoy na bilang ng mga character. isang pinahihintulutang numero, ang lahat ng mga character hanggang sa dulo ng isang string ay makukuha. Iyon ang dahilan kung bakit kinukuha ko ito nang may isang reserba na hindi ko sinasadya ang mga kalkulasyon.

REVERSE function

Binabaliktad ng function na ito ang isang string, tulad ng pagbabasa nito mula sa kanan papuntang kaliwa. Iyan ang resulta ng query

SELECT REVERSE("abcdef")

magiging "fedcba". Sa kaso ng kawalan ng RIGHT function sa wika ang query

PUMILI NG KANAN("abcdef",3)

maaaring pantay na mapalitan ng query

SELECT REVERSE(LEFT(REVERSE("abcdef"),3))

Nakikita ko ang tubo ng function na ito sa mga sumusunod. Kailangan nating tukuyin ang isang posisyon hindi ang una, ngunit ang huling paglitaw ng anumang character (o isang pagkakasunud-sunod ng mga character) sa isang string ng character.

Paalalahanan natin ang isang halimbawa, kung saan natin tinutukoy ang posisyon ng unang karakter na "a" sa pangalan ng barkong "California":

SELECT CHARINDEX("a", name) first_a
FROM Ships WHERE name="California"

Ngayon ay tukuyin natin ang posisyon ng huling paglitaw ng character na "a" sa pangalang ito. Ang function

CHARINDEX("a", REVERSE(pangalan))

ay magbibigay-daan sa amin na mahanap ang posisyong ito, ngunit mula sa kanan. Upang makuha ang posisyon ng karakter na ito, ngunit mula sa kaliwa, ito ay sapat na upang magsulat

SELECT LEN(name) + 1 - CHARINDEX("a", REVERSE(name)) first_a
FROM Ships WHERE name="California"

PALITAN function

PALITAN (<string_expression1> , <string_expression2> , <string_expression3>)

Pinapalitan ng function na ito ang string_expression1 lahat ng mga pangyayari ng string_expression2 kasama ang string_expression3. Ang function na ito ay ganap na nakakatulong sa I-UPDATE operator, kung dapat nating baguhin ang nilalaman ng column. Halimbawa, hayaan natin na kailangan nating palitan ang lahat ng mga puwang ng gitling sa mga pangalan ng mga barko.

Pagkatapos ay maaari tayong magsulat
I-UPDATE Mga barko

SET name = REPLACE(pangalan, " ", "-")

(Ang halimbawang ito ay maaari mong gawin sa page na may mga pagsasanay sa DML, kung saan tinatanggap ang mga tanong sa pag-update ng data)

Gayunpaman, mahahanap din ng function na ito ang appliance nito sa mas maraming di-trivial na kaso. Tukuyin natin kung ilang beses ginamit ang letrang "a" sa isang pangalan ng barko. Ang ideya ay medyo madali: palitan natin ang bawat paghahanap ng letra ng alinmang dalawang character, at pagkatapos nito ay kalkulahin natin ang pagkakaiba ng mga haba ng string na nakuha namin at ang source string Kaya,

PUMILI ng pangalan, LEN(PALIT(pangalan, "a", "aa")) - LEN(pangalan) MULA SA Mga Barko

At paano kung kailangan nating matukoy ang bilang ng mga paglitaw ng isang random na pagkakasunud-sunod ng mga character na, sabihin nating, nakukuha natin bilang isang parameter ng isang naka-imbak na pamamaraan? Sa kasong ito, dapat nating dagdagan ang ginamit na algorithm sa itaas ng paghahati sa isang bilang ng mga character sa isang pagkakasunud-sunod:
IDEKLARA ang @str BILANG VARCHAR(100)
SET @str="ma"

PUMILI ng pangalan, (LEN(PALITAN(pangalan, @str, @str+@str)) - LEN(pangalan))/LEN(@str) MULA sa Mga Barko Dito para madoble ang bilang ng mga naghahanap na character, inilapat ang concatenation @str+@str. Gayunpaman para sa epekto na ito maaari naming gamitin ang isa pang function - GUMULI

na inuulit ang unang argumento nang maraming beses gaya ng tinukoy ng pangalawang argumento.

PUMILI ng pangalan, (LEN(REPLACE(name, @str, REPLICATE(@str, 2)))) - LEN(name))/LEN(@str) MULA sa Mga Barko

Iyon ay inuulit namin nang dalawang beses ang substring na nakaimbak sa variable na @str. BAGAY Kung kailangan nating palitan sa isang string hindi isang tiyak na pagkakasunud-sunod ng mga character, ngunit isang tinukoy na bilang ng mga character, simula sa ilang posisyon, mas simple na gamitin ang

function:<character_expression1> , <simulan> , , <character_expression2>)

Pinapalitan ng function na ito ang isang substring na may haba ng haba na nagsisimula sa simulan posisyon sa character_expression1 kasama ang character_expression2.

Ang halimbawa. Baguhin ang pangalan ng isang barko: dugtungan ang "_" (underscore) at isang taon ng paglulunsad pagkatapos ng unang 5 character. Kung wala pang 5 character ang pangalan, dagdagan ito ng mga puwang.

Ang gawaing ito ay maaaring malutas sa maraming iba't ibang mga pag-andar. Susubukan naming gawin ito sa BAGAY function.

Sa unang diskarte, magsusulat tayo (na may piling query):

PUMILI ng pangalan, STUFF(pangalan, 6, LEN(pangalan), "_"+inilunsad) MULA SA Mga Barko

Ginagamit ko ang LEN(pangalan) bilang pangatlong argumento (bilang ng mga character na papalitan), dahil dapat kong palitan ang lahat ng mga character hanggang sa dulo ng string, at iyon ang dahilan kung bakit kinukuha ko ito nang may reserba - ang orihinal na bilang ng mga character sa ang pangalan. Ngunit ang query na ito ay magbabalik pa rin ng isang error maaari tayong gumamit ng isa pang built-in na function - STR:

STR (<float_expression> [ , <haba> [ , <decimal> ] ])

Sa ilalim ng conversion na ito ang round-up ay ginagawa, at a haba tumutukoy sa haba ng resultang string.

Halimbawa,
STR(3.3456, 5, 1) 3.3
STR(3.3456, 5, 2) 3.35
STR(3.3456, 5, 3) 3.346

STR(3.3456, 5, 4) 3.346

Tandaan, na kung nakakuha ng string view ng numero ay mas mababa kaysa sa tinukoy na haba, ang mga nangungunang puwang ay idaragdag. Kung ang resulta ay mas malaki kaysa sa tinukoy na haba, ang fractional na bahagi ay pinuputol (na may round-up); kung sakaling mayroong isang integer na halaga makuha namin ang kaukulang numero ng mga asterisk na "*".

STR(12345,4,0) ****

Sa pamamagitan ng paraan, ang default na haba ay 10 simbolo. Tandaan na ang isang taon ay kinakatawan ng apat na numero, isusulat namin

PUMILI ng pangalan, STUFF(pangalan, 6, LEN(pangalan), "_"+STR(inilunsad, 4)) MULA SA Mga Barko

Halos tama na ang lahat. Ang kaso ay pinagpahinga upang isaalang-alang, kapag ang bilang ng mga simbolo sa pangalan ay mas mababa sa 6, tulad ng sa kasong ito ang function na STUFF ay nagbibigay ng NULL. Well, kailangan nating nasa rack hanggang sa dulo, na konektado sa paggamit ng function na ito sa halimbawang ito, sa paraan ng paglalapat ng isa pang string function. SPACE Idaragdag namin ang mga sumusunod na blangko para sa haba ng pangalan na sadyang higit sa 6. Mayroong espesyal na

function para doon<SPACE(>):

bilang_ng_blangko

PUMILI ng pangalan, STUFF(pangalan + SPACE(6), 6, LEN(pangalan), "_"+STR(inilunsad,4)) MULA SA Mga Barko at RTRIM LTRIM

mga function<character_expression>)

LTRIM(<character_expression>)

gupitin nang naaayon ang mga nangunguna at sumusunod na mga blangko ng expression ng string, na kino-convert bilang default sa VARCHAR uri.

Kailangan nating bumuo ng tulad ng isang string: name_passenger's identifier ng pasahero para sa bawat tala mula sa talahanayan ng Pasahero. Kung magsusulat tayo

PUMILI ng pangalan + "_" + CAST(id_psg AS VARCHAR) MULA SA Pasahero,

makukuha natin ang resulta tulad ng:

Ito ay konektado sa katotohanan na ang pangalan ng hanay ay may uri CHAR(30).

Ang maikling string ay idinagdag kasama ng mga blangko para sa ganitong uri sa tinukoy na dimensyon (mayroon kaming 30 simbolo).

MABABA at ITAAS LTRIM

Ang function na RTIM ay makakatulong sa amin dito:<character_expression>)

PUMILI RTRIM(pangalan) + "_" + CAST(id_psg AS VARCHAR) MULA SA Pasahero<character_expression>)

MABABA(

ITAAS( SOUNDEX at PAGKAKAIBA

i-convert ang lahat ng mga character ng argument nang naaayon sa lower at upper register.<character_expression>)

Ang mga function na ito ay naging kapaki-pakinabang kumpara sa registerdependent strings.<Isang pares ng mga kagiliw-giliw na pag-andar>, <SOUNDEX(>)

PAGKAKAIBA ( character_expression_1 character_expression_2

hayaan kaming matukoy ang magkatulad na tunog ng mga salita. Ang SOUNDEX ay nagbabalik ng isang apat na character na code upang suriin ang pagkakatulad, ngunit ang DIFFERENCE ay wastong sinusuri ang pagkakatulad ng dalawang naghahambing na mga string ng character.

UNICODE function

Dahil hindi sinusuportahan ng mga function na ito ang Cyrillic, tinutukoy kong interesado ako<BOL>)

para sa mga halimbawa ng paggamit nito.

NCHAR function

Sa konklusyon, magdadagdag kami ng ilang mga function at ilang mga halimbawa ng paggamit ng Unicode:<UNICODE (>)

character_expression

ibinabalik ang Unicode value para sa unang character ng input expression.

NCHAR (

integer

nagbabalik ng character na may ibinigay na integer na Unicode value. Ilang halimbawa:

PILIIN ang ASCII("a"), UNICODE("a")

Ibinabalik ang halaga ng ASCII-code at ang Unicode na halaga ng letrang Ruso na "a": 224 at 1072.

PUMILI CHAR(ASCII("a")), CHAR(UNICODE("a"))

Sinusubukan naming bawiin ang isang simbolo sa pamamagitan ng halaga ng code nito. Nakukuha namin ang "a" at NULL. Ang NULL-value ay bumabalik dahil ang 1072 code value ay wala sa karaniwang code table.

PUMILI CHAR(ASCII("a")), NCHAR(UNICODE("a"))

Ngayon ay ayos lang, "a" sa parehong mga kaso. SELECT NCHAR(ASCII("а"))

Mabilis na isara ang Windows (Windows NT/2000/XP) Ang bersyon 3.1 at 3.5 ng Windows NT ay nagpapahintulot sa iyo na isara ang lahat ng mga proseso sa loob ng 20 segundo. Sa Windows NT 3.51 at mas mataas, posibleng matukoy ang agwat kung kailan dapat isara ang system. Upang gawin ito kailangan mong ayusin ang susi

Mula sa aklat na Pagproseso ng Database sa Visual Basic®.NET may-akda McManus Geoffrey P

CHAPTER 3 Introducing SQL Server 2000 Noong nakaraan, maraming programmer ang nagsimulang lumikha ng mga database application gamit ang Visual Basic at isang Microsoft Access database na may Jet engine. Kapag ang database ay lumago sa ilang libong mga talaan o ang mga serbisyo nito ay ginamit ng ilan

Mula sa aklat na Windows Script Host para sa Windows 2000/XP may-akda Popov Andrey Vladimirovich

Mga kinakailangan para sa pag-install ng SQL Server 2000 Upang mag-install ng SQL Server 2000, kailangan mo ng isang computer na may Pentium (o katugmang) processor na may dalas na hindi bababa sa 166 MHz, hard disk space mula 95 hanggang 270 MB (270 MB para sa karaniwang pag-install at 44 MB para sa Desktop Engine), disk drive

Mula sa aklat na Hindi isinusulat ng mga aklat ng Delphi may-akda Grigoriev A. B.

Pag-install ng SQL Server 2000 Pagkatapos pumili ng computer na may kinakailangang configuration, maaari kang magpatuloy sa pag-install. Sa pangkalahatan, ang proseso ng pag-install para sa SQL Server 2000 ay napaka-simple, maliban sa mga sumusunod na tampok: ito ay tumatagal ng medyo mahabang panahon; sa panahon ng proseso ng pag-install, maraming hinihiling para sa una

Mula sa aklat na PHP Reference ng may-akda

Mga Pangunahing Kaalaman sa SQL Server 2000 Kapag na-install at tumatakbo na ang SQL Server, dapat mong kumpletuhin ang mga sumusunod na hakbang bago mo makuha o mai-save ang data: Lumikha ng isa o higit pang mga database. lumikha ng mga talahanayan sa database; lumikha ng mga view at naka-imbak

Mula sa XSLT na libro may-akda Holzner Stephen

Mga function para sa pagtatrabaho sa mga arrays Sa talahanayan. Ang A2.17 ay nagpapakita ng mga function na maaaring magamit upang lumikha ng mga bagong array at makakuha ng impormasyon tungkol sa mga umiiral na Talahanayan A2.17. Mga function para sa pagtatrabaho sa mga array Paglalarawan ng Function Array(arglist) Nagbabalik ng Variant value na

Mula sa aklat na Linux: The Complete Guide may-akda Kolisnichenko Denis Nikolaevich

3.3. Mga subtlety ng pagtatrabaho sa mga string Sa seksyong ito, titingnan natin ang ilang mga subtleties ng pagtatrabaho sa mga string, na nagbibigay-daan sa amin upang mas maunawaan kung anong code ang nabuo ng compiler para sa ilang tila elementarya na pagkilos. Hindi lahat ng mga halimbawang ibinigay dito ay gumagana sa parehong paraan.

Mula sa aklat na The Art of Shell Scripting Language Programming ni Cooper Mendel

Mula sa aklat na The C Language - A Guide for Beginners ni Prata Steven

Mga function ng XPath para sa pagtatrabaho sa mga string Ang mga sumusunod na function ng XPath para sa pagtatrabaho sa mga string ay available sa XSLT: concat(string string1, string string2,...). Ibinabalik ang concatenation (unyon) ng lahat ng mga string na ipinasa dito; naglalaman ng(string string1, string string2). Nagbabalik ng true kung ang unang string ay naglalaman ng pangalawa

Mula sa aklat na Linux at UNIX: shell programming. Gabay ng Developer. ni Tainsley David

23.2.2. Mga function para sa pagtatrabaho sa memorya Ang mga function para sa pagtatrabaho sa memorya ng Glib library ay gumaganap ng parehong mga aksyon tulad ng mga kaukulang function ng C wika Narito ang kanilang mga prototype: gpointer g_malloc(gulong size); g_free(gpointer

Mula sa aklat na Paglalarawan ng wikang PascalABC.NET may-akda Koponan ng RuBoard

Mula sa aklat ng may-akda

13. Mga string ng character at function sa mga string MGA CHARACTER STRING NA NAGSIMULA NG MGA CHARACTER STRING MGA INPUT-OUTPUT STRING NA GAMIT ANG MGA FUNCTION NA GUMAGANA SA MGA STRING COMMAND ARGUMENTS

Mula sa aklat ng may-akda

MGA FUNCTION NA GUMAGANA SA MGA STRING Karamihan sa mga aklatan ng wikang C ay nilagyan ng mga function na gumagana sa mga string. Tingnan natin ang apat na pinaka-kapaki-pakinabang at karaniwan: strlen(), strcat(), strcmp() at strcpy(). Nagamit na namin ang strlen() function, na hinahanap ang haba ng isang string.

Mula sa aklat ng may-akda

Mula sa aklat ng may-akda

Mga gawain sa pagtatrabaho sa mga character at string function Chr(a: byte): char;

Mula sa aklat ng may-akda

Kino-convert ang code sa isang Windows encoding character function ChrUnicode(a: word): char;