Javascript kulinganisha mifuatano miwili. Njia za JavaScript za kufanya kazi na kamba. Pata mhusika katika nafasi fulani katika mfuatano

Unapoandika JavaScript, mara nyingi sana lazima uvinjari Mtandao kutafuta habari kuhusu sintaksia na vigezo vya njia zinazofanya kazi na kamba.

Nimesoma nakala nyingi juu ya kufanya kazi na kamba. Chapisho hili litaonyesha mifano na maelezo mafupi ya njia za kawaida za kufanya kazi na masharti. Nimejaribu kuweka njia za kawaida juu kwa kumbukumbu ya haraka.

Kwa kweli, watengenezaji wengi wenye uzoefu tayari watakuwa wamezoea mbinu nyingi, lakini nadhani hii ni orodha nzuri kwa Kompyuta kuelewa anuwai ya mbinu ambazo zinaweza kusaidia kukamilisha shughuli ngumu kwa njia rahisi.

Inabadilisha kuwa Kamba

Unaweza kubadilisha nambari, usemi wa boolean, au kitu kuwa kamba:

Var myNumber = 24; // 24 var myString = myNumber.toString(); // "24"

Unaweza kuifanya kwa njia sawa na Kamba():

Var myNumber = 24; // 24 var myString = Kamba(myNumber); // "24"

Ikiwa huna uhakika ni thamani gani sio null au isiyofafanuliwa, unaweza kutumia Kamba(), ambayo hurejesha kamba kila wakati, bila kujali aina ya thamani.

Kugawanya kamba katika kamba ndogo

Kugawanya kamba katika safu ya mifuatano unaweza kutumia mbinu split():

Var myString = "kuja,mbali,at,the,koma"; var substringArray = myString.split(","); // ["kuja", "mbali", "katika", "the", "koma"] var arrayLimited = myString.split(",", 3); // ["kuja", "mbali", "saa"]

Kama unavyoona kwenye mstari wa mwisho, parameta ya pili ya kazi ni kikomo kwa idadi ya vitu ambavyo vitakuwa kwenye safu ya mwisho.

Kupata urefu wa kamba

Ili kupata wahusika wangapi kwenye kamba, tunatumia mali urefu:

Var myString = "Wewe" ni mhusika kabisa."; var stringLength = myString.length; // 25

Kutafuta kamba ndogo katika mfuatano

Kuna njia mbili za kutafuta kamba ndogo:

Matumizi indexOf():

Var stringOne = "Johnny Waldo Harrison Waldo"; var wheresWaldo = stringOne.indexOf("Waldo"); // 7

indexOf() Njia huanza kutafuta kamba ndogo kutoka mwanzo wa kamba, na kurudisha nafasi ya mwanzo wa tukio la kwanza la kamba ndogo. Katika kesi hii - nafasi ya 7.

Matumizi lastIndexOf():

Var stringOne = "Johnny Waldo Harrison Waldo"; var wheresWaldo = stringOne.lastIndexOf("Waldo"); // 22

Njia hiyo inarudisha nafasi ya kuanzia ya tukio la mwisho la kamba ndogo kwenye mfuatano.

Njia zote mbili zinarudi -1 ikiwa kamba ndogo haipatikani, na zote mbili huchukua hoja ya hiari ya pili inayoonyesha nafasi katika mfuatano ambapo unataka utafutaji uanze. Kwa hivyo ikiwa hoja ya pili ni "5", indexOf() huanza utafutaji kutoka kwa herufi 5, ikipuuza herufi 0-4, huku lastIndexOf() huanza utafutaji katika herufi 5 na kufanya kazi kinyumenyume, ikipuuza herufi 6 na kuendelea.

Uingizwaji wa kamba ndogo

Ili kuchukua nafasi ya tukio la kamba ndogo katika kamba na kamba nyingine ndogo, unaweza kutumia badilisha ():

Var slugger = "Josh Hamilton"; var betterSlugger = slugger.replace("h Hamilton", "e Bautista"); console.log(betterSlugger); // "Jose Bautista"

Hoja ya kwanza ndio unayotaka kubadilisha na hoja ya pili ni laini mpya. Chaguo za kukokotoa huchukua nafasi ya tukio la kwanza la mfuatano mdogo katika mfuatano.

Ili kuchukua nafasi ya matukio yote, unahitaji kutumia usemi wa kawaida na bendera ya kimataifa:

Var myString = "Anauza makombora ya magari kwenye ufuo wa magari"; var newString = myString.replace(/automotive/g, "bahari"); console.log(newString); // "Anauza makombora kwenye ufuo wa bahari"

Hoja ya pili inaweza kujumuisha kiolezo maalum au kazi. Unaweza kusoma zaidi.

Pata mhusika katika nafasi fulani katika mfuatano

Tunaweza kupata ishara kwa kutumia kazi charAt():

Var myString = "Ndege wa Unyoya"; var whatsAtSeven = myString.charAt(7); // "f"

Kama kawaida katika JavaScript, nafasi ya kwanza kwenye kamba huanza saa 0, sio 1.

Kama kazi mbadala unaweza kutumia charCodeAt() kazi, ambayo ni msimbo wa tabia.

Var myString = "Ndege wa Unyoya"; var whatsAtSeven = myString.charCodeAt(7); // "102" var whatsAtEleven = myString.charCodeAt(11); // "70"

Kumbuka kwamba msimbo wa herufi "F" (nafasi 11) ni tofauti na herufi "f" (nafasi 7).

Kamba za Kuunganisha

Katika hali nyingi, unaweza kutumia opereta "+" kuunganisha mifuatano. Lakini unaweza pia kutumia njia concat():

Var stringOne = "Knibb High football"; var stringTwo = stringOne.concat("sheria."); // "Sheria za soka za Knibb High"

Kwa njia hii tunaweza kuchanganya mistari mingi kuwa moja kwa mpangilio ambao imeandikwa:

Var stringOne = "Knibb"; var stringTwo = "Juu"; var stringThree = "mpira wa miguu"; var stringFour = "sheria."; var finalString = stringOne.concat(stringTwo, stringThree, stringFour); console.log(finalString); // "Sheria za soka za juu za Knibb."

Uchimbaji wa kamba ndogo

Kuna njia 3 za kupata kamba kutoka kwa sehemu ya kamba nyingine:

Kutumia kipande():

Var stringOne = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.slice (5, 10); // "fghij"

Kutumia kamba ndogo():

Var stringOne = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.substring (5, 10); // "fghij"

Katika vitendaji vyote viwili, kigezo cha kwanza ni herufi ambayo kamba ndogo huanza (kuanzia nafasi ya 0) na hoja ya pili (ya hiari) ni nafasi ya mhusika ambapo kamba ndogo inarudishwa. Mfano (5, 10) hurejesha kamba kati ya nafasi 5 na 9.

Kutumia substr():

Var stringOne = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.substr (5, 10); // "fghijklmno"

Hoja ya kwanza ni nafasi ya mhusika ambapo mstari mpya huanza na hoja ya pili ni idadi ya wahusika kutoka nafasi ya kuanzia ya mstari mpya. Wale. (5, 10) hurejesha herufi 10, kuanzia nafasi ya 5.

Badilisha mfuatano kuwa herufi kubwa au ndogo.

Kuna njia 4 za kutafsiri. 2 za kwanza hubadilisha kamba kuwa herufi kubwa:

Var stringOne = "Ongea, siwezi" kukusikia."; var stringTwo = stringOne.toLocaleUpperCase(); // "SEMEA, SIWEZI" KUKUSIKIA" var stringThree = stringOne.toUpperCase(); // "SEMEA, SIWEZI" KUKUSIKIA

Nyingine 2 hubadilisha kamba kuwa herufi ndogo:

Var stringOne = "SI LAZIMA" Upige Mlio"; var stringTwo = stringOne.toLocaleLowerCase(); // "huna budi kupiga kelele" var stringThree = stringOne.toLowerCase(); // "sio lazima kupiga kelele"

Ni bora kutumia njia za "locale", kwa sababu ... katika maeneo tofauti, kwa mfano, nchini Uturuki, onyesho la rejista haifanyi kazi kama tulivyozoea na kwa hivyo matokeo yanaweza kuwa yale tuliyotaka. Ikiwa unatumia njia za "locale", basi hakutakuwa na matatizo hayo.

Ulinganishaji wa Muundo

Kufanana kwa muundo kwenye kamba kunaweza kufanywa kwa kutumia njia 2, ambazo hufanya kazi tofauti.

Njia mechi() inatumika kwa kamba na inachukua usemi wa kawaida kama parameta:

Var myString = "Ni kiasi gani cha kuni kinachoweza kusukuma kuni"; var myPattern = /.ood/; var myResult = myString.match(myPattern); // ["mbao"] var patternLocation = myResult.index; // 9 var originalString = myResult.input // "Ni kiasi gani cha kuni kinaweza kupasua kuni"

Njia kutekeleza () inatumika kwa kitu cha kawaida cha kujieleza na inachukua kamba kama parameta:

Var myString = "Ni kiasi gani cha kuni kinachoweza kusukuma kuni"; var myPattern = /.huck/; var myResult = myPattern.exec(myString); // ["chuck"] var patternLocation = myResult.index; // 27 var originalString = myResult.input // "Ni kiasi gani cha kuni kinaweza kupasua kuni"

Katika njia zote mbili, mechi ya kwanza tu inarudishwa. Ikiwa hakuna mechi, inarudi null.

Unaweza pia kutumia mbinu tafuta () ambayo huchukua usemi wa kawaida na kurudisha nafasi ya mechi ya kwanza katika muundo:

Var myString = "Asume"; var patternLocation = myString.search(/ume/); // 3

Kama hakukuwa na mechi," -1 «.

Kulinganisha mifuatano miwili ya kupanga

Unaweza kulinganisha mifuatano 2 ili kubaini ni ipi inayokuja kwanza katika alfabeti. Ili kufanya hivyo, tutatumia njia localeCompare() ambayo inarudisha maadili 3 yanayowezekana:

Var myString = "kuku"; var myStringTwo = "yai"; var whichCameFirst = myString.localeCompare(myStringTwo); // -1 (Chrome inarudi -2) whichCameFirst = myString.localeCompare("kuku"); // 0 whichCameFirst = myString.localeCompare("apple"); // 1 (Chrome inarudi 2)

Kama inavyoonyeshwa hapo juu, nambari hasi inarudishwa ikiwa hoja ya kamba inakuja baada ya mfuatano wa asili. Nambari chanya ikiwa hoja ya mfuatano inakuja kabla ya mfuatano wa asili. Ikirudishwa 0 - ina maana mistari ni sawa.

Kuangalia thamani ya kurudi ni bora kutumia ikiwa (matokeo< 0), чем if (result === -1). Последнее не будет работать в Chrome.

Asante kwa umakini wako, natumai umejifunza mambo mengi mapya na ya kuvutia!

Mwandishi wa makala: Alex. Kategoria:
Tarehe ya kuchapishwa: 03/19/2013

Nitawaonya mara moja, ndiyo, makala ni sahihi kidogo, kuwakaribisha kwa maoni, kuna ufafanuzi mzuri huko).

Siku njema.

Kuna waendeshaji wawili sawa katika JavaScript: == na ===. Ikiwa hujui tofauti zao, hii inaweza kusababisha makosa mengi. Kwa hivyo niliamua kufungua mada hii. Ni tofauti gani hasa kati ya == na ===, jinsi wanavyofanya kazi, kwa nini hii hutokea, na jinsi ya kuepuka makosa.

Opereta == inalinganisha kwa usawa, lakini === inalinganisha kwa utambulisho. Faida ya === operator ni kwamba haitoi maadili mawili kwa aina moja. Hii ndiyo sababu ni kawaida kutumika.

Abc == haijafafanuliwa; // kweli ikiwa abc = haijafafanuliwa | null abc === haijafafanuliwa; // kweli - ikiwa tu abc = haijafafanuliwa!
abc == uongo; // kweli ikiwa abc = uongo | 0 | "" | abc === uongo; // kweli ikiwa tu abc = uongo!
Baada ya yote, kuchanganya uwongo na 0 (au "", au ) sio wazo nzuri.

Bila shaka:
5 === 5; // kweli kweli === kweli; // kweli "abc" === "abc"; // kweli

Na sasa mfano wa kuvutia.
5 == 5; // kweli 5 === 5; // Nambari mpya ya kweli(5) == 5; // Nambari mpya ya kweli(5) === 5; // uongo!

Kwa nini hii inatokea? Ndio, nambari yoyote ni kitu cha darasa la Nambari. Lakini unaweza kuwakilisha nambari kama nambari - kwa kila mara. Inatangazwa mara moja na daima inafanana na yenyewe. Lakini wakati huo huo, wakati wa kutangaza kitu kipya cha darasa la Nambari, ni sawa na thamani, lakini sio sawa (kwa kuwa haya ni vitu viwili tofauti kabisa vya darasa la Nambari).

Safu/Vitu

Lakini kwa safu na vitu, waendeshaji wote wawili hufanya kazi kwa njia ile ile, kulinganisha kwa kitambulisho:
var a = (); a == (); // uongo a === (); // uongo a == a; // kweli a === a; // kweli

Ili kulinganisha safu na vitu, unaweza kuandika kazi maalum:
kazi isEq(a, b)( if(a == b) inarudi kweli; kwa(var i in a)( if(!isEq(a[i], b[i])) rudisha sivyo; ) kwa(var i) katika b)( if(!isEq(a[i], b[i])) rudisha sivyo; ) rudisha kweli; )
Uzembe kidogo, mizunguko miwili, na karibu hasOwnProperty sahau; Naam, hiyo itafanya.

Hii<-

Kuna mtego mmoja zaidi. Huu ni uhamishaji kwa hii.
(kazi())( hii == 5; // kweli hii === 5; // uongo )).piga simu(5);

Huu ndio wakati. Inastahili kusahau juu yake.

Jumla...

Kweli, sasa hebu tufikirie kuwa tunaandika muundo wetu wa juu, kwa kutumia opereta === badala ya == kwa sababu ni nzuri zaidi, na mtu hupata mende kadhaa nasi.
func(Nambari mpya(5)); (kazi())( func(hii); )).piga simu(5);

Je, mifano kama hiyo inaonekana kuwa haiwezi kutumika? Tafadhali!

JQuery:
$.kila(, function())( func(hii); ));

Kweli, au nilitaka kupanua nambari.
var Tano = Nambari mpya(5); Tano.a = 2; // alitaka kupanua, lakini 5 tu haina kupanua // hapa sisi kutumia kwa namna fulani ... func(Five);

Hiyo ndiyo yote, natumaini itakuwa na manufaa kwa mtu. Asante kwa umakini wako.

Operesheni za waendeshaji kulinganisha zinaweza kuwa nambari au nambari za nambari. Mifuatano hulinganishwa kulingana na mpangilio wa kawaida wa leksikografia unapotumia Unicode.

JavaScript inaruhusu ulinganisho madhubuti na ulinganisho na utumaji wa aina. Kwa kulinganisha kali, operesheni zote mbili lazima ziwe za aina moja na:

Mistari miwili ni sawa kabisa ikiwa ina mlolongo sawa wa wahusika
Nambari mbili ni sawa ikiwa ni sawa katika maana ya kawaida ya neno. +0 ni sawa kabisa na -0.
NaN sio sawa na chochote, pamoja na NaN
Operesheni mbili za boolean ni sawa kabisa ikiwa zote ni za kweli au za uwongo
Uendeshaji wa vitu viwili ni sawa kabisa ikiwa ni marejeleo ya kitu kimoja cha kawaida
Null na Undefined ni sawa == lakini sio sawa kabisa ===

Jedwali lifuatalo linaelezea waendeshaji kulinganisha:

Opereta	Maelezo	Mifano ambayo inarudi kuwa kweli wakati var1=3, var2=4
Sawa na (==)	Ikiwa operesheni mbili sio aina moja, javascript hubadilisha aina na kulinganisha madhubuti. Ikiwa operesheni yoyote ni nambari au thamani ya boolean, basi operesheni zinabadilishwa kuwa nambari; ikiwa operand yoyote ni kamba, ya pili inabadilishwa kuwa kamba	3 == var1 "3" == var1 3 == "3"
Sio sawa (!=)	Hurejesha kweli ikiwa uendeshaji si sawa. Ikiwa uendeshaji ni wa aina tofauti, javascript hubadilisha.	var1 != 4 var1 != "5"
Sawa kabisa (===)	Hurejesha kweli ikiwa uendeshaji ni sawa kabisa (tazama hapo juu), bila ubadilishaji wa aina.
Sio sawa kabisa (!==)	Hurejesha kweli ikiwa uendeshaji si sawa kabisa (tazama hapo juu) au ni za aina tofauti.	var2 !== 3 3 !== "3"
Zaidi (>)	Hurejesha kweli ikiwa operesheni ya kushoto ni kubwa kuliko operesheni ya kulia.
Kubwa kuliko au sawa na (>=)	Hurejesha kweli ikiwa operesheni ya kushoto ni kubwa kuliko au sawa na operesheni ya kulia.	var2 >= var1 var1 >= 3
Chini (<)	Hurejesha kweli ikiwa uendeshaji wa kushoto ni chini ya uendeshaji wa kulia.
Chini au sawa (<=)	Hurejesha kweli ikiwa uendeshaji wa kushoto ni chini ya au sawa na uendeshaji wa kulia.	var1<= var2 var2<= 5

Kutumia Viendeshaji Kulinganisha

Waendeshaji wa kawaida wa usawa (== na !=) hulinganisha operesheni mbili bila kuzingatia aina zao. Usawa madhubuti (=== na !==) hulinganisha uendeshaji wa aina moja. Tumia usawa kamili ikiwa waendeshaji lazima ziwe na aina na thamani sawa. Vinginevyo, tumia waendeshaji wa usawa wa kawaida, ambao hukuruhusu kupima usawa wa kazi hata ikiwa ni za aina tofauti.

Wakati wa kubadilisha aina, JavaScript inabadilisha String , Number , Boolean na Object kama ifuatavyo:

Wakati wa kulinganisha nambari na kamba, kamba inabadilishwa kuwa thamani ya nambari. Katika kesi hii, JavaScript inapata thamani ya nambari kutoka kwa kamba halisi: "123" == 123 .
Ikiwa moja ya oparesheni ni boolean, basi inabadilishwa kuwa 1 ikiwa ni kweli na hadi +0 ikiwa ni ya uwongo.
Ikiwa kitu kinalinganishwa na nambari au mfuatano, JavaScript hujaribu kupata thamani inayolingana ya kitu hicho. Inabadilisha kitu kuwa thamani ya awali, mfuatano, au nambari kwa kutumia njia za valueOf na toString. Ikiwa kitu hakiwezi kubadilishwa, hitilafu ya wakati wa kukimbia hutolewa.

Ninapoandika katika javascript, mara nyingi hunilazimu kugeukia injini za utaftaji ili kufafanua syntax ya njia (na mpangilio, ufafanuzi wa hoja) zinazofanya kazi na kamba.

Katika makala hii nitajaribu kutoa mifano na maelezo ya mbinu za kawaida za javascript zinazohusiana na masharti. Njia maarufu zaidi ziko juu ya kifungu kwa urahisi.

Badilisha kuwa kamba

Unaweza kubadilisha nambari, boolean, au kitu kuwa mfuatano.

Var myNumber = 24; // 24 var myString = myNumber.toString(); // "24"

Unaweza pia kufanya udanganyifu sawa kwa kutumia string() kazi.

Var myNumber = 24; // 24 var myString = Kamba(myNumber); // "24"

Nicholas Zakas anasema: "Ikiwa huna uhakika juu ya thamani (basi au isiyofafanuliwa), basi tumia kazi ya String(), kwani inarudisha kamba bila kujali aina ya kutofautisha."

isiyofafanuliwa inamaanisha kuwa kutofautisha hakupewi dhamana yoyote, a null, - kwamba imepewa dhamana tupu (tunaweza kusema kwamba null inafafanuliwa kama kitu tupu).

Gawanya mfuatano katika mifuatano midogo

Kugawanya kamba katika safu ndogo unaweza kutumia split() njia:

Var myString = "kuja,mbali,at,the,koma"; var substringArray = myString.split(","); // ["kuja", "mbali", "katika", "the", "koma"] var arrayLimited = myString.split(",", 3); // ["kuja", "mbali", "saa"]

Kama mstari wa mwisho unavyopendekeza, thamani ya hoja ya pili ya hiari huamua idadi ya vipengele katika safu iliyorejeshwa.

Pata urefu wa kamba

Kutumia mali ya urefu unaweza kupata idadi ya herufi za Unicode kwenye kamba:

Var myString = "Wewe" ni mhusika kabisa."; var stringLength = myString.length; // 25

Bainisha mfuatano mdogo katika mfuatano

Kuna njia mbili za kufikia mpango wako:

Tumia indexOf() :

Var stringOne = "Johnny Waldo Harrison Waldo"; var wheresWaldo = stringOne.indexOf("Waldo"); // 7

Njia ya indexOf() hutafuta mfuatano mdogo (hoja ya kwanza iliyopitishwa) katika mfuatano (kutoka mwanzo wa mfuatano) na kurudisha nafasi ya herufi ya kwanza ambapo kamba ndogo ilianza kutokea kwenye mfuatano huo.

Tumia lastIndexOf() :

Var stringOne = "Johnny Waldo Harrison Waldo"; var wheresWaldo = stringOne.lastIndexOf("Waldo"); // 22

Njia ya lastIndexOf() hufanya kila kitu sawa, isipokuwa kwamba inatafuta kamba ndogo ya mwisho ambayo hutokea kwenye kamba.

Ikiwa kamba ndogo haipatikani, njia zote mbili zinarudi -1. Hoja ya pili ya hiari inabainisha nafasi katika mfuatano ambapo unataka kuanza utafutaji. Kwa hivyo, ikiwa hoja ya pili kwa njia ya indexOf() ni 5, basi utaftaji utaanza kutoka kwa herufi ya 5, na herufi 0-4 zitapuuzwa. Kwa lastIndexOf() , pia ikiwa hoja ya pili ni 5, utaftaji utaanza kwa mwelekeo tofauti, na herufi 6 na zaidi zikipuuzwa.

Jinsi ya kubadilisha sehemu ya kamba

Ili kubadilisha sehemu (au hata yote) ya kamba, tumia njia ya replace().

Var slugger = "Josh Hamilton"; var betterSlugger = slugger.replace("h Hamilton", "e Bautista"); console.log(betterSlugger); // "Jose Bautista"

Hoja ya kwanza ina sehemu ya kamba ndogo ambayo inapaswa kubadilishwa; hoja ya pili ni kamba ambayo itachukua nafasi ya kamba ndogo kubadilishwa. Tukio la kwanza la mfuatano mdogo ndilo litakalobadilishwa.

Ili kuchukua nafasi ya matukio yote ya kamba ndogo, tumia usemi wa kawaida na alama ya "g".

Var myString = "Anauza makombora ya magari kwenye ufuo wa magari"; var newString = myString.replace(/automotive/g, "bahari"); console.log(newString); // "Anauza makombora kwenye ufuo wa bahari"

Hoja ya pili inaweza kujumuisha kamba ndogo au chaguo za kukokotoa zitakazobadilishwa.

Tafuta mhusika katika nafasi fulani

Ili kujua ni mhusika gani aliye katika nafasi fulani, unaweza kutumia charAt() njia:

Var myString = "Ndege wa Unyoya"; var whatsAtSeven = myString.charAt(7); // "f"

Kama kawaida katika javascript, nafasi ya kwanza huanza kutoka 0, sio 1.

Vinginevyo, unaweza kutumia charCodeAt() njia, lakini badala ya mhusika yenyewe, utapokea msimbo wake.

Var myString = "Ndege wa Unyoya"; var whatsAtSeven = myString.charCodeAt(7); // "102" var whatsAtEleven = myString.charCodeAt(11); // "70"

Kumbuka kwamba msimbo wa herufi kubwa (nafasi 11) ni tofauti na msimbo wa herufi sawa katika herufi ndogo (nafasi 7).

Muunganisho wa kamba katika javascript

Kwa sehemu kubwa, utatumia opereta (+) kubatilisha masharti. Lakini unaweza pia kubatilisha kamba kwa kutumia njia ya concat().

Var stringOne = "Knibb High football"; var stringTwo = stringOne.concat("sheria."); // "Sheria za soka za Knibb High"

Mifuatano mingi inaweza kupitishwa kwa concat(), na mfuatano unaotokana utaonekana kwa mpangilio ambao uliongezwa kwa mbinu ya concat().

Sehemu ya kamba (toa kamba ndogo katika javascript)

Kuna njia tatu tofauti za kuunda kamba mpya kwa "kuvuta" sehemu ya kamba ndogo kutoka kwa kamba iliyopo.

Kutumia slice() :

Var stringOne = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.slice (5, 10); // "fghij"

Kwa kutumia substring() :

Var stringOne = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.substring (5, 10); // "fghij"

Kwa njia zote mbili (kipande() na substring()), hoja ya kwanza ni nafasi ya mhusika ambapo kamba ndogo huanza (kuhesabu kutoka 0), hoja ya pili ni nafasi ya mhusika ambapo kamba ndogo inaisha, na herufi iliyoteuliwa katika hoja ya pili haijajumuishwa kwenye kamba ndogo iliyorejeshwa.

Kutumia substr() :

Var stringOne = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.substr (5, 10); // "fghijklmno"

Kwa njia ya substr, hoja ya kwanza pia inabainisha nafasi ya mhusika ambapo kamba ndogo huanza. Hoja ya pili ni ya hiari. Lakini wakati huo huo, hoja ya pili inabainisha idadi ya wahusika ambao wanapaswa kujumuishwa katika mstari mdogo, kuanzia nafasi ambayo tayari tumefafanua katika hoja ya kwanza. Mbinu hii imeonyeshwa vizuri katika mfano hapo juu.

Kubadilisha mfuatano kuwa herufi ndogo au kubwa katika javascript

Kuna njia nne za kufanya mabadiliko muhimu. Mbili kubadilisha herufi za kamba hadi herufi kubwa.

Var stringOne = "Ongea, siwezi" kukusikia."; var stringTwo = stringOne.toLocaleUpperCase(); // "SEMEA, SIWEZI" KUKUSIKIA" var stringThree = stringOne.toUpperCase(); // "SEMEA, SIWEZI" KUKUSIKIA

Na mbili kubadilisha kamba kuwa herufi ndogo:

Var stringOne = "SI LAZIMA" Upige Mlio"; var stringTwo = stringOne.toLocaleLowerCase(); // "huna budi kupiga kelele" var stringThree = stringOne.toLowerCase(); // "sio lazima kupiga kelele"

Kwa ujumla, hakuna tofauti kati ya njia ya eneo na njia isiyo ya kienyeji, hata hivyo, "kwa lugha zingine, kama vile Kituruki, ambazo tabia yake haifuati kisa cha Unicode, matokeo ya kutumia njia isiyo ya kienyeji yanaweza. kuwa tofauti." Kwa hiyo, fuata kanuni ifuatayo: "ikiwa hujui lugha ambayo msimbo utafanya kazi, ni salama kutumia mbinu za eneo."

Ulinganishaji wa muundo katika javascript

Unaweza kuangalia uwepo wa muundo katika kamba kwa kutumia njia 2.

Njia ya match() inaitwa kwa kitu cha kamba, kupitisha usemi wa kawaida kama hoja kwa njia ya match().

Na exec() njia inaitwa kwenye kitu cha RegExp, kupitisha kamba kama hoja:

Njia zote mbili zinarudisha tukio la kwanza linalolingana. Ikiwa hakuna zinazolingana zitapatikana, NULL itarejeshwa. Ikiwa usemi wa kawaida una alama ya "g", matokeo yatakuwa safu iliyo na mechi zote.

Unaweza pia kutumia search() mbinu, ambayo huchukua usemi wa kawaida kama hoja na kurudisha nafasi ya kuanzia ya muundo wa kwanza unaolingana.

Var myString = "Asume"; var patternLocation = myString.search(/ume/); // 3

Ikiwa hakuna mechi zinazopatikana, njia itarudi -1.

Kulinganisha mifuatano miwili ya kupanga baadaye

Ili kulinganisha mifuatano miwili kulingana na mpangilio wa mpangilio wa eneo, unaweza kutumia mbinu ya localeCompare. Mbinu ya localeCompare inarudisha thamani tatu zinazowezekana.

MyString = "kuku"; var myStringTwo = "yai"; var whichCameFirst = myString.localeCompare(myStringTwo); // -1 (isipokuwa Chrome, ambayo inarudi -2) whichCameFirst = myString.localeCompare("kuku"); // 0 whichCameFirst = myString.localeCompare("apple"); // 1 (Chrome inarudi 2)

Kama inavyoonyeshwa hapo juu, thamani hasi itarejeshwa ikiwa mfuatano wa asili utapangwa kabla ya hoja ya mfuatano; ikiwa hoja ya mfuatano itapangwa baada ya mfuatano wa asili, +1 itarejeshwa. Ikiwa null itarejeshwa, mifuatano miwili ni sawa.