JavaScript: სტრინგებთან მუშაობის მეთოდები. ამოცანები სტრინგებთან მუშაობის ფუნქციებზე JavaScript-ში Jquery ფუნქციები სტრინგებთან მუშაობისთვის

სტრიქონი არის ერთი ან მეტი სიმბოლოს თანმიმდევრობა, რომელიც შეიძლება შეიცავდეს ასოებს, რიცხვებს და სხვა სიმბოლოებს. JavaScript-ში ეს არის უმარტივესი უცვლელი მონაცემთა ტიპი.

სტრიქონები საშუალებას გაძლევთ აჩვენოთ და მანიპულიროთ ტექსტით, ხოლო ტექსტი არის ინფორმაციის ონლაინ კომუნიკაციისა და გადაცემის ძირითადი გზა. ამიტომ, სტრიქონები პროგრამირების ერთ-ერთი მთავარი კონცეფციაა.

ეს გაკვეთილი გასწავლით როგორ შექმნათ და ნახოთ სტრიქონების გამომავალი, დააკავშიროთ სტრიქონები და შეინახოთ ისინი ცვლადებში. თქვენ ასევე გაეცნობით ციტატების, აპოსტროფების და ახალი ხაზების გამოყენების წესებს JavaScript-ში.

სტრიქონის შექმნა და ნახვა

JavaScript-ში სტრიქონის შექმნის სამი გზა არსებობს: ისინი შეიძლება ჩაიწეროს ერთ ბრჭყალებში (‘), ორმაგ ბრჭყალებში (‘) ან უკანა ხაზებში (’). მიუხედავად იმისა, რომ სკრიპტები ზოგჯერ შეიცავს სამივე ტიპის სტრიქონს, მხოლოდ ერთი ტიპის ციტატა უნდა იყოს გამოყენებული ერთი ხაზის ფარგლებში.

ერთ და ორციტირებული სტრიქონები არსებითად ერთი და იგივეა. არ არსებობს კონვენციები ამა თუ იმ ტიპის ციტატების გამოყენებასთან დაკავშირებით, მაგრამ ზოგადად რეკომენდებულია პროგრამის სკრიპტებში ერთი ტიპის თანმიმდევრულად გამოყენება.

"ეს სტრიქონი იყენებს ერთ ბრჭყალებს.";
"ეს სტრიქონი იყენებს ორმაგ ბრჭყალებს.";

სტრიქონის შექმნის მესამე და უახლეს გზას ეწოდება თარგი ლიტერალი. შაბლონის ლიტერალები იწერება უკანა ბრჭყალებში (ასევე ცნობილია როგორც backticks) და მუშაობს ისევე, როგორც ჩვეულებრივი სტრიქონები, რამდენიმე დამატებითი ფუნქციით, რომლებსაც ამ სტატიაში განვიხილავთ.

`ეს სტრიქონი იყენებს backticks-ს.`;

სტრიქონის გამოსავლის სანახავად უმარტივესი გზაა მისი შეყვანა კონსოლში console.log() გამოყენებით.

console.log("ეს არის სტრიქონი კონსოლში.");
ეს არის სტრიქონი კონსოლში.

სტრიქონის მნიშვნელობის მოთხოვნის კიდევ ერთი მარტივი გზაა ბრაუზერის ამომხტარი ფანჯარა, რომლის გამოძახებაც შესაძლებელია alert():

alert ("ეს არის სტრიქონი სიგნალში.");

ეს ხაზი გახსნის შეტყობინებების ფანჯარას ბრაუზერში შემდეგი ტექსტით:

ეს არის სტრიქონი გაფრთხილებაში.

alert() მეთოდი გამოიყენება ნაკლებად ხშირად, რადგან სიგნალები მუდმივად უნდა დაიხუროს.

სტრიქონების შენახვა ცვლადებში

JavaScript-ში ცვლადებს ეწოდება კონტეინერები, რომლებიც ინახავს მნიშვნელობებს var, const ან let საკვანძო სიტყვების გამოყენებით. სტრიქონები შეიძლება მიენიჭოს ცვლადებს.

const newString = "ეს არის სტრიქონი, რომელიც მინიჭებულია ცვლადზე.";

newString ცვლადი ახლა შეიცავს სტრიქონს, რომლის მითითება და ჩვენება შესაძლებელია კონსოლის გამოყენებით.

console.log(newString);
ეს არის სტრიქონი, რომელიც ენიჭება ცვლადს.

ცვლადებისთვის სტრიქონების მინიჭებით, თქვენ არ გჭირდებათ სტრიქონის ხელახლა აკრეფა ყოველ ჯერზე, როდესაც გსურთ მისი გამოტანა, რაც გაადვილებს პროგრამებში სტრინგებთან მუშაობას.

სიმების შეერთება

სტრიქონების შეერთება არის ორი ან მეტი სტრიქონის ერთ ახალ სტრიქონში გაერთიანების პროცესი. შეერთება ხდება + ოპერატორის გამოყენებით. + სიმბოლო ასევე არის მიმატების ოპერატორი მათემატიკური ოპერაციების დროს.

მაგალითად, სცადეთ ორი მოკლე სტრიქონის შეერთება:

"ზღვა" + "ცხენი";
ზღვის ცხენი

შეერთება უერთდება ერთი სტრიქონის დასასრულს მეორე სტრიქონის დასაწყისთან ინტერვალის ჩასმის გარეშე. ხაზებს შორის სივრცე რომ გქონდეთ, ის უნდა დაემატოს პირველი ხაზის ბოლოს.

"ზღვა" + "ცხენი";
ზღვის ცხენი

შეერთება საშუალებას გაძლევთ დააკავშიროთ სტრიქონები და ცვლადები სტრიქონების მნიშვნელობებთან.

const favePoem = "ჩემი საყვარელი ლექსია " + ლექსი + " " + ავტორი ".";

შეერთების შედეგად მიღებული ახალი სტრიქონები შეიძლება გამოყენებულ იქნას პროგრამაში.

ცვლადები შაბლონის ლიტერალებით

შაბლონის ლიტერალების ერთ-ერთი მახასიათებელია სტრიქონში გამონათქვამებისა და ცვლადების ჩართვის შესაძლებლობა. შეერთების ნაცვლად, შეგიძლიათ გამოიყენოთ $() სინტაქსი ცვლადის ჩასართავად.

const პოემა = "ფართო ოკეანე";
const ავტორი = "პაბლო ნერუდა";
const favePoem = `ჩემი საყვარელი ლექსია $(პოემა) $(ავტორი).`;
ჩემი საყვარელი ლექსია პაბლო ნერუდას ფართო ოკეანე.

ეს სინტაქსი საშუალებას გაძლევთ მიიღოთ იგივე შედეგი. შაბლონის ლიტერალები ამარტივებს სტრიქონების შეერთებას.

სიმებიანი ლიტერალები და სიმებიანი მნიშვნელობები

როგორც შენიშნეთ, ყველა სტრიქონი იწერება ბრჭყალებში ან უკანა ბრჭყალებში, მაგრამ გამოტანისას სტრიქონი არ შეიცავს ბრჭყალებს.

"Ზღვის მიღმა";
Ზღვის მიღმა

სტრიქონი ლიტერალი არის სტრიქონი, როგორც ეს ჩანს წყაროს კოდში, ციტატების ჩათვლით. სტრიქონის მნიშვნელობა არის სტრიქონი, რომელიც გამოჩნდება გამოსავალში (ბრჭყალების გარეშე).

ამ მაგალითში, "ზღვის მიღმა" არის სტრიქონი, ხოლო ზღვის მიღმა არის სიმებიანი მნიშვნელობა.

ციტატებისა და აპოსტროფების გადაკვეთა სტრიქონებში

იმის გამო, რომ ბრჭყალები გამოიყენება სტრიქონების აღსანიშნავად, არსებობს სპეციალური წესები სტრიქონებში აპოსტროფებისა და ბრჭყალების გამოყენებისათვის. მაგალითად, JavaScript განმარტავს აპოსტროფს ერთი ციტირებული სტრიქონის შუაში, როგორც დახურვის ერთ ციტატაში და შეეცდება წაიკითხოს დანარჩენი განკუთვნილი სტრიქონი, როგორც კოდი.

განვიხილოთ ეს მაგალითი:

const breakString = "მე"გატეხილი სტრიქონი ვარ";
console.log (brokenString);
უცნობია: მოულოდნელი ჟეტონი (1:24)

იგივე ხდება, თუ თქვენ ცდილობთ გამოიყენოთ ორმაგი ბრჭყალები ორმაგი ციტირებული სტრიქონის შიგნით. თარჯიმანი ვერ შეამჩნევს განსხვავებას.

ასეთი შეცდომების თავიდან ასაცილებლად, შეგიძლიათ გამოიყენოთ:

• სხვადასხვა სიმებიანი სინტაქსი.
• გაქცევის სიმბოლოები.
• თარგი სიტყვასიტყვით.

ალტერნატიული სიმებიანი სინტაქსი

ამ პრობლემის გადასაჭრელად უმარტივესი გზაა სკრიპტში გამოყენებული სინტაქსის საპირისპირო გამოყენება. მაგალითად, ჩადეთ სტრიქონები აპოსტროფებით ორმაგ ბრჭყალებში:

"ჩვენ უსაფრთხოდ ვიყენებთ აპოსტროფს ორმაგ ბრჭყალებში."

ბრჭყალებით სტრიქონები შეიძლება ჩაირთოს ერთ ბრჭყალებში:

"შემდეგ მან თქვა: "გამარჯობა, სამყარო!";

ერთჯერადი და ორმაგი ბრჭყალების კომბინაციით, შეგიძლიათ აკონტროლოთ ციტატებისა და აპოსტროფების ჩვენება სტრიქონებში. თუმცა, ეს გავლენას მოახდენს პროექტის ფაილებში სინტაქსის თანმიმდევრულობაზე, რაც ართულებს მათ შენარჩუნებას.

გაქცევის სიმბოლო \

უკანა ხაზის გამოყენებით JavaScript არ განმარტავს ციტატებს, როგორც დახურვის ციტატებს.

კომბინაცია \' ყოველთვის განიხილება როგორც აპოსტროფი და \" როგორც ორმაგი ბრჭყალები, გამონაკლისის გარეშე.

ეს საშუალებას აძლევს აპოსტროფების გამოყენებას ერთ ციტირებულ სტრიქონებში და ციტატების გამოყენებას ორციტირებულ სტრიქონებში.

"ჩვენ უსაფრთხოდ ვიყენებთ აპოსტროფს ერთ ბრჭყალებში."
"შემდეგ მან თქვა: "გამარჯობა, მსოფლიო!";

ეს მეთოდი ცოტა მოუწესრიგებლად გამოიყურება. მაგრამ აუცილებელია, თუ ერთი და იგივე ხაზი შეიცავს როგორც აპოსტროფს, ასევე ორმაგ ბრჭყალებს.

თარგის ლიტერალები

შაბლონის ლიტერალები განისაზღვრება უკანა ციტატებით, ასე რომ, როგორც ორმაგი ბრჭყალები, ასევე აპოსტროფები შეიძლება უსაფრთხოდ იქნას გამოყენებული ყოველგვარი დამატებითი მანიპულაციის გარეშე.

`ჩვენ უსაფრთხოდ ვიყენებთ აპოსტროფებს და „ციტატებს“ შაბლონში სიტყვასიტყვით.`;

შაბლონის ლიტერალები არა მხოლოდ თავიდან აიცილებენ შეცდომებს ციტატებისა და აპოსტროფების ჩვენებისას, არამედ ასევე უზრუნველყოფენ ინლაინ გამონათქვამებისა და მრავალხაზოვანი ბლოკების მხარდაჭერას, როგორც ეს განხილულია შემდეგ ნაწილში.

მრავალხაზოვანი ხაზები და ახალი ხაზი

ზოგიერთ სიტუაციაში საჭიროა ახალი ხაზის სიმბოლოს ან ხაზის შეწყვეტის ჩასმა. გაქცევის სიმბოლოები \n ან \r დაგეხმარებათ კოდის გამომავალში ახალი ხაზის ჩასმაში.

const threeLines = "ეს არის სტრიქონი\nრომელიც ვრცელდება\nსამ ხაზზე.";
ეს არის სტრიქონი
რომელიც მოიცავს მთელს
სამი ხაზი.

ეს გაყოფს გამომავალს რამდენიმე ხაზად. თუმცა, თუ კოდში გრძელი სტრიქონებია, მათთან მუშაობა და წაკითხვა რთული იქნება. რამდენიმე სტრიქონზე ერთი სტრიქონის საჩვენებლად გამოიყენეთ შეერთების ოპერატორი.

const threeLines = "ეს არის სტრიქონი\n" +
"ეს ვრცელდება მთელს\n" +
"სამი ხაზი.";

თქვენ ასევე შეგიძლიათ გაქცევა ახალი ხაზიდან escape სიმბოლოს გამოყენებით.

const threeLines = "ეს არის სტრიქონი\n\
რომელიც ვრცელდება მთელს\n\
სამი ხაზი.";

შენიშვნა: ეს მეთოდი არ არის რეკომენდებული, რადგან შესაძლოა ზოგიერთ ბრაუზერში პრობლემები გამოიწვიოს.

იმისათვის, რომ თქვენი კოდი წაკითხული იყოს, გამოიყენეთ შაბლონის ლიტერალები. ეს გამორიცხავს სიმბოლოების შეერთებას და გაქცევას.

const threeLines = `ეს არის სტრიქონი
რომელიც მოიცავს მთელს
სამი ხაზი.`;
ეს არის სტრიქონი
რომელიც მოიცავს მთელს
სამი ხაზი.

იმის გამო, რომ სხვადასხვა კოდის ბაზამ შეიძლება გამოიყენოს სხვადასხვა სტანდარტები, მნიშვნელოვანია იცოდეთ ყველა გზა ახალ ხაზზე გატეხვისა და მრავალხაზოვანი სტრიქონების შესაქმნელად.

დასკვნა

ახლა თქვენ იცით JavaScript-ში სტრიქონებთან მუშაობის ძირითადი პრინციპები, შეგიძლიათ შექმნათ სტრიქონები და შაბლონი ლიტერალები, შეასრულოთ შეერთება და გადაკვეთა და ცვლადებისთვის სტრიქონების მინიჭება.

ტეგები:

როცა javascript-ში ვწერ, ხშირად მიწევს საძიებო სისტემებს მივმართო, რათა განვმარტო სტრინგებთან მომუშავე მეთოდების სინტაქსი (და რიგი, არგუმენტების განსაზღვრა).

ამ სტატიაში შევეცდები მოგცეთ სტრიქონებთან დაკავშირებული ყველაზე გავრცელებული javascript მეთოდების მაგალითები და აღწერა. მოხერხებულობისთვის ყველაზე პოპულარული მეთოდები განთავსებულია სტატიის ზედა ნაწილში.

კონვერტაცია სიმებიანი

თქვენ შეგიძლიათ გადაიყვანოთ რიცხვი, ლოგიკური ან ობიექტი სტრიქონად.

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

თქვენ ასევე შეგიძლიათ განახორციელოთ მსგავსი მანიპულირება string() ფუნქციის გამოყენებით.

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

ნიკოლას ზაკასი ამბობს: "თუ არ ხართ დარწმუნებული მნიშვნელობის შესახებ (null ან undefined), გამოიყენეთ String() ფუნქცია, რადგან ის აბრუნებს სტრიქონს ცვლადის ტიპის მიუხედავად."

განუსაზღვრელინიშნავს, რომ ცვლადს არ ენიჭება რაიმე მნიშვნელობა, ა null, - რომ მას ენიჭება ცარიელი მნიშვნელობა (შეიძლება ვთქვათ, რომ null განისაზღვრება როგორც ცარიელი ობიექტი).

დაყავით სტრიქონი ქვესტრიქონებად

სტრიქონის ქვესტრიქონების მასივში გასაყოფად შეგიძლიათ გამოიყენოთ split() მეთოდი:

Var myString = "Coming,Apart,at,the,მძიმით"; var substringArray = myString.split(","); // ["მოდის", "გარდა", "at", "the", "მძიმით"] var arrayLimited = myString.split(",", 3); // ["მოდის", "ცალკე", "ზე"]

როგორც ბოლო ხაზი გვთავაზობს, მეორე არჩევითი არგუმენტის მნიშვნელობა განსაზღვრავს ელემენტების რაოდენობას დაბრუნებულ მასივში.

მიიღეთ სიმების სიგრძე

სიგრძის თვისების გამოყენებით შეგიძლიათ იპოვოთ უნიკოდის სიმბოლოების რაოდენობა სტრიქონში:

Var myString = "შენ საკმაოდ პერსონაჟი ხარ."; var stringLength = myString.length; // 25

განსაზღვრეთ ქვესტრიქონი სტრიქონში

თქვენი გეგმის მისაღწევად ორი გზა არსებობს:

გამოიყენეთ indexOf():

Var stringOne = "ჯონი უოლდო ჰარისონ უოლდო"; var wheresWaldo = stringOne.indexOf("Waldo"); // 7

indexOf() მეთოდი ეძებს ქვესტრინგს (პირველი არგუმენტი გავიდა) სტრიქონში (სტრიქონის დასაწყისიდან) და აბრუნებს პირველი სიმბოლოს პოზიციას, საიდანაც ქვესტრიქონი დაიწყო სტრიქონში გამოჩენა.

გამოიყენეთ lastIndexOf():

Var stringOne = "ჯონი უოლდო ჰარისონ უოლდო"; var wheresWaldo = stringOne.lastIndexOf("Waldo"); // 22

lastIndexOf() მეთოდი ყველაფერს ერთნაირად აკეთებს, გარდა იმისა, რომ ის ეძებს ბოლო ქვესტრინგს, რომელიც გვხვდება სტრიქონში.

თუ ქვესტრიქონი ვერ მოიძებნა, ორივე მეთოდი აბრუნებს -1-ს. მეორე არჩევითი არგუმენტი განსაზღვრავს პოზიციას სტრიქონში, სადაც გსურთ ძიების დაწყება. ასე რომ, თუ indexOf() მეთოდის მეორე არგუმენტი არის 5, მაშინ ძიება დაიწყება მე-5 სიმბოლოდან და 0-4 სიმბოლოები იგნორირებული იქნება. lastIndexOf()-ისთვის, ასევე თუ მეორე არგუმენტი არის 5, ძიება დაიწყება საპირისპირო მიმართულებით, მე-6 და ზემოთ სიმბოლოების იგნორირება.

როგორ შევცვალოთ სტრიქონის ნაწილი

სტრიქონის ნაწილის (ან თუნდაც მთლიანად) შესაცვლელად, გამოიყენეთ replace() მეთოდი.

Var slugger = "ჯოშ ჰემილტონი"; var betterSlugger = slugger.replace("h Hamilton", "e Bautista"); console.log (betterSlugger); // "ხოზე ბაუტისტა"

პირველი არგუმენტი შეიცავს ქვესტრიქონის ნაწილს, რომელიც უნდა შეიცვალოს; მეორე არგუმენტი არის სტრიქონი, რომელიც დაიკავებს ჩანაცვლებული ქვესტრიქონის ადგილს. ქვესტრიქონის მხოლოდ პირველი ინსტანცია შეიცვლება.

ქვესტრიქონის ყველა შემთხვევის ჩასანაცვლებლად გამოიყენეთ რეგულარული გამოხატულება "g" დროშით.

Var myString = "ის ყიდის საავტომობილო ჭურვებს მანქანის ნაპირზე"; var newString = myString.replace(/automotive/g, "sea"); console.log(newString); // "ის ყიდის ზღვის ჭურვებს ზღვის ნაპირზე"

მეორე არგუმენტი შეიძლება შეიცავდეს ქვესტრინგს ან ფუნქციას, რომელიც უნდა შეიცვალოს.

იპოვნეთ პერსონაჟი მოცემულ პოზიციაზე

იმის გასარკვევად, თუ რომელი სიმბოლოა მოცემულ პოზიციაზე, შეგიძლიათ გამოიყენოთ charAt() მეთოდი:

Var myString = "ბუმბულის ჩიტები"; var whatsAtSeven = myString.charAt(7); // "ვ"

როგორც ხშირად ხდება Javascript-ში, პირველი პოზიცია იწყება 0-დან და არა 1-დან.

ალტერნატიულად, შეგიძლიათ გამოიყენოთ charCodeAt() მეთოდი, მაგრამ თავად სიმბოლოს ნაცვლად მიიღებთ მის კოდს.

Var myString = "ბუმბულის ჩიტები"; var whatsAtSeven = myString.charCodeAt(7); // "102" var whatsAtEleven = myString.charCodeAt(11); // "70"

გაითვალისწინეთ, რომ დიდი ასოს კოდი (პოზიცია 11) განსხვავდება იმავე ასოს პატარა ასოს კოდისგან (პოზიცია 7).

სტრიქონების შეერთება ჯავასკრიპტში

უმეტესწილად, თქვენ გამოიყენებთ (+) ოპერატორს სტრიქონების შესაერთებლად. მაგრამ თქვენ ასევე შეგიძლიათ დააკავშიროთ სტრიქონები concat() მეთოდის გამოყენებით.

Var stringOne = "Knibb High Football"; var stringTwo = stringOne.concat("წესები."); // "Knibb High Football წესები"

მრავალი სტრიქონი შეიძლება გადაეცეს concat()-ს და შედეგად მიღებული სტრიქონი გამოჩნდება იმ თანმიმდევრობით, რომლითაც ისინი დაემატა concat() მეთოდს.

Var stringOne = "Knibb"; var stringTwo = "მაღალი"; var stringThree = "ფეხბურთი"; var stringFour = "წესები."; var finalString = stringOne.concat(stringTwo, stringThree, stringFour); console.log(finalString); // „კნიბის მაღალი ფეხბურთის წესები“.

სტრიქონის ნაწილი (ქვესტრიქონის ამოღება Javascript-ში)

არსებობს სამი განსხვავებული გზა ახალი სტრიქონის შესაქმნელად ქვესტრიქონის ნაწილის „გაყვანით“ არსებული სტრიქონიდან.

slice() გამოყენებით:

Var stringOne = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.slice(5, 10); // "ფღიჯ"

substring()-ის გამოყენებით:

Var stringOne = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.substring(5, 10); // "ფღიჯ"

ორივე (slice() და substring()) მეთოდებისთვის, პირველი არგუმენტი არის სიმბოლოს პოზიცია, რომლითაც იწყება სტრიქონი (ითვლის 0-დან), მეორე არგუმენტი არის სიმბოლოს პოზიცია, რომელზეც მთავრდება ქვესტრიქონი, და მეორე არგუმენტში მითითებული სიმბოლო არ შედის დაბრუნებულ ქვესტრინგში.

substr()-ის გამოყენებით:

Var stringOne = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.substr(5, 10); // "ფღიიკლმნო"

substr მეთოდისთვის, პირველი არგუმენტი ასევე განსაზღვრავს სიმბოლოს პოზიციას, საიდანაც იწყება ქვესტრიქონი. მეორე არგუმენტი არჩევითია. მაგრამ ამავდროულად, მეორე არგუმენტი განსაზღვრავს სიმბოლოების რაოდენობას, რომლებიც უნდა იყოს ჩართული ქვესტრინგში, დაწყებული იმ პოზიციიდან, რომელიც უკვე განვსაზღვრეთ პირველ არგუმენტში. ეს ტექნიკა კარგად არის ილუსტრირებული ზემოთ მოცემულ მაგალითში.

სტრიქონის გარდაქმნა ქვედა ან ზედ რეზერვში Javascript-ში

არსებობს ოთხი მეთოდი საჭირო კონვერტაციის განსახორციელებლად. ორი სტრიქონის სიმბოლოების დიდ რეზერვში გადასაყვანად.

Var stringOne = "ელაპარაკე, მე არ მესმის."; var stringTwo = stringOne.toLocaleUpperCase(); // "SPEAK UP, I CAN"T HEAR YOU" var stringThree = stringOne.toUpperCase(); // "ელაპარაკე, მე არ მესმის შენი"

და ორი სტრიქონის მცირე რეზერვში გადასაყვანად:

Var stringOne = "არ უნდა იყვირო"; var stringTwo = stringOne.toLocaleLowerCase(); // "არ უნდა იყვირო" var stringThree = stringOne.toLowerCase(); // "არ უნდა იყვირო"

ზოგადად, არ არსებობს განსხვავება ლოკალურ მეთოდსა და არალოკალურ მეთოდს შორის, თუმცა, „ზოგიერთი ენისთვის, როგორიცაა თურქული, რომლის სიმბოლოების რეზერვი არ შეესაბამება დადგენილ Unicode შემთხვევას, არალოკალური მეთოდის გამოყენების შედეგები შეიძლება იყავი განსხვავებული." ამიტომ, დაიცავით შემდეგი წესი: „თუ არ იცით ენა, რომელზედაც კოდი გაიშვება, უფრო უსაფრთხოა ლოკალური მეთოდების გამოყენება“.

შაბლონის შესატყვისი javascript-ში

თქვენ შეგიძლიათ შეამოწმოთ ნიმუშის არსებობა სტრიქონში 2 მეთოდის გამოყენებით.

match() მეთოდი გამოიძახება სიმებიანი ობიექტზე, რომელიც გადასცემს რეგულარულ გამოხატვას, როგორც არგუმენტს match() მეთოდს.

Var myString = "რამდენი ხის შეიძლება ხის ჩაკმა ჩაკიდო"; var myPattern = /.ood/; var myResult = myString.match(myPattern); // ["ხის"] var patternLocation = myResult.index; // 9 var originalString = myResult.input // "How much wood could a wood chack chuck"

და exec() მეთოდი გამოძახებულია RegExp ობიექტზე, გადასცემს სტრიქონს არგუმენტად:

Var myString = "რამდენი ხის შეიძლება ხის ჩაკმა ჩაკიდო"; var myPattern = /.huck/; var myResult = myPattern.exec(myString); // ["ჩაკი"] var patternLocation = myResult.index; // 27 var originalString = myResult.input // "რამდენი ხის შეუძლია ხის ჩაკიდოს"

ორივე მეთოდი აბრუნებს პირველ დამთხვევას. თუ შესატყვისები არ არის ნაპოვნი, NULL დაბრუნდება. თუ რეგულარულ გამონათქვამს აქვს "g" დროშა, შედეგი იქნება მასივი, რომელიც შეიცავს ყველა შესატყვისს.

ასევე შეგიძლიათ გამოიყენოთ search() მეთოდი, რომელიც არგუმენტად იღებს რეგულარულ გამონათქვამს და აბრუნებს პირველი შესატყვისი ნიმუშის საწყის პოზიციას.

Var myString = "დავარაუდოთ"; var patternLocation = myString.search(/ume/); // 3

თუ შესატყვისები არ არის ნაპოვნი, მეთოდი დაბრუნდება -1.

ორი სტრიქონის შედარება შემდგომი დახარისხებისთვის

ლოკალში დალაგების თანმიმდევრობის საფუძველზე ორი სტრიქონის შესადარებლად, შეგიძლიათ გამოიყენოთ localeCompare მეთოდი. localeCompare მეთოდი აბრუნებს სამ შესაძლო მნიშვნელობას.

MyString = "ქათამი"; var myStringTwo = "კვერცხი"; var whichCameFirst = myString.localeCompare(myStringTwo); // -1 (Chrome-ის გარდა, რომელიც აბრუნებს -2) whichCameFirst = myString.localeCompare("chicken"); // 0 whichCameFirst = myString.localeCompare("apple"); // 1 (Chrome აბრუნებს 2)

როგორც ზემოთ ნაჩვენებია, უარყოფითი მნიშვნელობა დაბრუნდება, თუ თავდაპირველი სტრიქონი დალაგებულია სტრიქონის არგუმენტამდე, თუ სიმებიანი არგუმენტი დალაგებულია ორიგინალური სტრიქონის შემდეგ, დაბრუნდება +1. თუ null დაბრუნდა, ორი სტრიქონი ექვივალენტურია.

JavaScript-ში ქვესტრიქონების არჩევის რამდენიმე გზა არსებობს, მათ შორის ქვესტრიქონი (), substr(), ნაჭერი ()და ფუნქციები regexp.

JavaScript 1.0 და 1.1-ში, ქვესტრიქონი ()არსებობს, როგორც ერთადერთი მარტივი გზა უფრო დიდი სტრიქონის ნაწილის შესარჩევად. მაგალითად, ხაზის შესარჩევად დაჭერასაწყისი გამოხატულება, გამოყენება "გამოხატვა".substring(2,7). ფუნქციის პირველი პარამეტრი არის სიმბოლოების ინდექსი, რომლითაც იწყება შერჩევა, ხოლო მეორე პარამეტრი არის სიმბოლოების ინდექსი, რომლითაც სრულდება შერჩევა (არ მოიცავს): ქვესტრიქონი (2,7)მოიცავს 2, 3, 4, 5 და 6 ინდექსებს.

JavaScript 1.2-ში ფუნქციონირებს substr(), ნაჭერი ()და regexpასევე შეიძლება გამოყენებულ იქნას სიმების გასაყოფად.

Substr()იქცევა ისევე, როგორც სუბსტრ Pearl ენა, სადაც პირველი პარამეტრი მიუთითებს სიმბოლოების ინდექსზე, რომლითაც იწყება შერჩევა, ხოლო მეორე პარამეტრი განსაზღვრავს ქვესტრიქონის სიგრძეს. იგივე დავალების შესასრულებლად, როგორც წინა მაგალითში, თქვენ უნდა გამოიყენოთ "გამოხატვა".substr(2,5). გახსოვდეთ, 2 არის საწყისი წერტილი, ხოლო 5 არის მიღებული ქვესტრიქონის სიგრძე.

სიმებზე გამოყენებისას, ნაჭერი ()იქცევა ფუნქციის მსგავსად ქვესტრიქონი (). თუმცა, ის ბევრად უფრო ძლიერია, შეუძლია ნებისმიერი ტიპის მასივთან მუშაობა და არა მხოლოდ სტრიქონებთან. ნაჭერი ()ასევე იყენებს უარყოფით ოფსეტებს სასურველ პოზიციაზე წვდომისთვის, ხაზის ბოლოდან. "გამოხატვა".slice(2,-3)დააბრუნებს მეორე სიმბოლოსა და მესამე სიმბოლოს შორის აღმოჩენილ ქვესტრიქონს ბოლოდან, დააბრუნებს ისევ დააჭირეთ.

ბოლო და ყველაზე უნივერსალური მეთოდი ქვესტრინგებთან მუშაობისთვის არის JavaScript 1.2-ში რეგულარული გამოხატვის ფუნქციების მეშვეობით მუშაობა. კიდევ ერთხელ, ყურადღება მიაქციეთ იმავე მაგალითს, ქვესტრინგს "დაჭერა"მიღებული სიმისგან "გამოხატვა":

Write("გამოხატვა".match(/press/));

ჩაშენებული ობიექტი სიმებიანი

Საგანი სიმებიანიეს არის პრიმიტიული სტრიქონის მნიშვნელობის ობიექტის განხორციელება. მისი კონსტრუქტორი ასე გამოიყურება:

ახალი სტრიქონი ( მნიშვნელობა?)

Აქ მნიშვნელობანებისმიერი სიმებიანი გამოხატულება, რომელიც განსაზღვრავს ობიექტის პრიმიტიულ მნიშვნელობას. თუ არ არის მითითებული, ობიექტის პრიმიტიული მნიშვნელობა არის "" .

String ობიექტის თვისებები:

კონსტრუქტორიკონსტრუქტორი, რომელმაც შექმნა ობიექტი. სიმბოლოების რაოდენობა სტრიქონზე. პროტოტიპიმითითება ობიექტის კლასის პროტოტიპზე.

სტანდარტული სიმებიანი ობიექტის მეთოდები

აბრუნებს სიმბოლოს მოცემულ პოზიციაზე სტრიქონში. აბრუნებს სიმბოლოს კოდს, რომელიც მდებარეობს სტრიქონში მოცემულ პოზიციაზე. აბრუნებს სტრიქონების შეერთებას. ქმნის სტრიქონს უნიკოდის კოდებით განსაზღვრული სიმბოლოებიდან. აბრუნებს მითითებული ქვესტრიქონის პირველი გაჩენის პოზიციას. აბრუნებს მითითებული ქვესტრინგის ბოლო გამოჩენის პოზიციას. ადარებს ორ სტრიქონს ოპერაციული სისტემის ენაზე დაყრდნობით. შეესაბამება სტრიქონს ჩვეულებრივ გამოსახულებას. შეესაბამება სტრიქონს ჩვეულებრივ გამოსახულებას და ცვლის ნაპოვნი ქვესტრიქონს ახალი ქვესტრიქონით. შეესაბამება სტრიქონს რეგულარულ გამოსახულებას. იბრუნებს სტრიქონის ნაწილს და აბრუნებს ახალ სტრიქონს. ყოფს სტრიქონს ქვესტრიქონების მასივში. აბრუნებს პოზიციისა და სიგრძის მიხედვით მოცემულ ქვესტრიქონს. აბრუნებს საწყისი და საბოლოო პოზიციებით მითითებულ ქვესტრინგს. ოპერაციული სისტემის ენის გათვალისწინებით გარდაქმნის სტრიქონის ყველა ასოს პატარა რეზერვში. ოპერაციული სისტემის ენაზე დაყრდნობით სტრიქონის ყველა ასოს გარდაქმნის დიდზე. გარდაქმნის სტრიქონში არსებულ ყველა ასოს მცირე რეესტრში. გარდაქმნის ობიექტს სტრიქონად. გარდაქმნის სტრიქონში არსებულ ყველა ასოს დიდ რეესტრში. აბრუნებს ობიექტის პრიმიტიულ მნიშვნელობას.

String ობიექტის არასტანდარტული მეთოდები

ქმნის HTML სანიშნეს ( …). ახვევს სტრიქონს ტეგებში …. ახვევს სტრიქონს ტეგებში …. ახვევს სტრიქონს ტეგებში …. ახვევს სტრიქონს ტეგებში …. ახვევს სტრიქონს ტეგებში …. ახვევს სტრიქონს ტეგებში …. ახვევს სტრიქონს ტეგებში …. ქმნის HTML ჰიპერბმულს (). ახვევს სტრიქონს ტეგებში …. ახვევს სტრიქონს ტეგებში …. ახვევს სტრიქონს ტეგებში . ახვევს სტრიქონს ტეგებში .

სიგრძის თვისება

Სინტაქსი : საგანი.სიგრძე ატრიბუტები: (DontEnum, DontDelete, ReadOnly)

ქონების ღირებულება სიგრძეარის სიმბოლოების რაოდენობა ხაზში. ცარიელი სტრიქონისთვის ეს მნიშვნელობა არის ნული.

წამყვანი მეთოდი

Სინტაქსი : საგანი.წამყვანი( სახელი) არგუმენტები: სახელი შედეგი: სიმებიანი მნიშვნელობა

მეთოდი წამყვანი ობიექტი, ჩასმულია ტეგებში …. არ არის შემოწმებული, რომ ორიგინალური სტრიქონი უკვე იყო ჩასმული ამ ტეგებში. ეს მეთოდი გამოიყენება document.write და document.writeln მეთოდებთან ერთად, რათა შეიქმნას სანიშნე HTML დოკუმენტში მითითებული მითითებით. სახელი. მაგალითად, ოპერატორი document.write("My text".anchor("Bookmark")) არის ოპერატორის document.write(" ჩემი ტექსტი") .

დიდი მეთოდი

Სინტაქსი : საგანი.დიდი() შედეგი: სიმებიანი მნიშვნელობა

მეთოდი დიდიაბრუნებს სტრიქონს, რომელიც შედგება ობიექტი, ჩასმულია ტეგებში …. არ არის შემოწმებული, რომ ორიგინალური სტრიქონი უკვე იყო ჩასმული ამ ტეგებში. ეს მეთოდი გამოიყენება document.write და document.writeln მეთოდებთან ერთად ტექსტის დიდი შრიფტით საჩვენებლად. მაგალითად, განცხადება document.write("My text".big()) აჩვენებს სტრიქონს My text ბრაუზერის ეკრანზე.

დახამხამების მეთოდი

Სინტაქსი : საგანი.თვალის დახამხამება() შედეგი: სიმებიანი მნიშვნელობა

მეთოდი თვალის დახამხამებააბრუნებს სტრიქონს, რომელიც შედგება პრიმიტიული სტრიქონის მნიშვნელობისგან ობიექტი, ჩასმულია ტეგებში …. არ არის შემოწმებული, რომ ორიგინალური სტრიქონი უკვე იყო ჩასმული ამ ტეგებში. ეს მეთოდი გამოიყენება document.write და document.writeln მეთოდებთან ერთად ტექსტის მოციმციმე შრიფტით საჩვენებლად. ეს ტეგები არ არის HTML სტანდარტის ნაწილი და მხარდაჭერილია მხოლოდ Netscape და WebTV ბრაუზერებით. მაგალითად, განცხადება document.write("ჩემი ტექსტი".blink()) აჩვენებს სტრიქონს My text ბრაუზერის ეკრანზე.

თამამი მეთოდი

Სინტაქსი : საგანი.bold() შედეგი: სიმებიანი მნიშვნელობა

მეთოდი გაბედულიაბრუნებს სტრიქონს, რომელიც შედგება პრიმიტიული სტრიქონის მნიშვნელობისგან ობიექტი, ჩასმულია ტეგებში …. არ არის შემოწმებული, რომ ორიგინალური სტრიქონი უკვე იყო ჩასმული ამ ტეგებში. ეს მეთოდი გამოიყენება document.write და document.writeln მეთოდებთან ერთად ტექსტის თამამი შრიფტით საჩვენებლად. მაგალითად, ოპერატორი document.write("ჩემი ტექსტი".bold()) აჩვენებს ხაზს ჩემი ტექსტი .

charAt მეთოდი

Სინტაქსი : საგანი.charAt( პოზიცია) არგუმენტები: პოზიციანებისმიერი რიცხვითი გამოხატულება შედეგი: სიმებიანი მნიშვნელობა

მეთოდი charAtაბრუნებს მოცემულში მდებარე სიმბოლოსგან შემდგარ სტრიქონს პოზიციებიპრიმიტიული სიმებიანი მნიშვნელობა ობიექტი. ხაზოვანი სიმბოლოების პოზიციები დანომრილია ნულიდან საგანი. -1.

თუ პოზიცია ამ დიაპაზონის მიღმაა, ცარიელი სტრიქონი ბრუნდება. მაგალითად, განცხადება document.write("String".charAt(0)) დაბეჭდავს სიმბოლოს C ბრაუზერის ეკრანზე.

Სინტაქსი : საგანი charCodeAt მეთოდი პოზიცია) არგუმენტები: პოზიციანებისმიერი რიცხვითი გამოხატულება შედეგი.charCodeAt(

მეთოდი charAt: რიცხვითი მნიშვნელობა პოზიციებიპრიმიტიული სიმებიანი მნიშვნელობა ობიექტიაბრუნებს მოცემულში მდებარე სიმბოლოს Unicode კოდის ტოლ რიცხვს საგანი. ხაზოვანი სიმბოლოების პოზიციები დანომრილია ნულიდან . -1.თუ პოზიცია ამ დიაპაზონის მიღმაა, ის ბრუნდება

NaN

Სინტაქსი : საგანი. მაგალითად, ოპერატორი document.write("String".charCodeAt(0).toString(16)) გამოაჩენს რუსული ასო "C"-ის თექვსმეტობით კოდს ბრაუზერის ეკრანზე: 421. კონკატის მეთოდი, .კონკატი(, …, ხაზი 0) არგუმენტები: კონკატის მეთოდი, .კონკატი(, …, ხაზი 0ხაზი 1 შედეგი: სიმებიანი მნიშვნელობა

მეთოდი stringNნებისმიერი სიმებიანი გამონათქვამები

საგანი + კონკატის მეთოდი + .კონკატი( + … + ხაზი 0

კონკატ

აბრუნებს ახალ სტრიქონს, რომელიც არის ორიგინალური სტრიქონისა და მეთოდის არგუმენტების შეერთება. ეს მეთოდი ოპერაციის ტოლფასია

Სინტაქსი : საგანიმაგალითად, ოპერატორი document.write("Frost and sun.".concat("მშვენიერი დღე.")) აჩვენებს ხაზს Frost and sun ბრაუზერის ეკრანზე. მშვენიერი დღეა. შედეგი: სიმებიანი მნიშვნელობა

მეთოდი ფიქსირებული მეთოდიაბრუნებს სტრიქონს, რომელიც შედგება პრიმიტიული სტრიქონის მნიშვნელობისგან ობიექტი, ჩასმულია ტეგებში …. არ არის შემოწმებული, რომ ორიგინალური სტრიქონი უკვე იყო ჩასმული ამ ტეგებში. ეს მეთოდი გამოიყენება document.write და document.writeln მეთოდებთან ერთად ტექსტის ტელეტიპის შრიფტით საჩვენებლად. მაგალითად, განცხადება document.write("My text".fixed()) აჩვენებს სტრიქონს My text ბრაუზერის ეკრანზე.

შრიფტის ფერის მეთოდი

Სინტაქსი : საგანი.fontcolor(ფერი) არგუმენტები: ფერისიმებიანი გამოხატულება შედეგი: სიმებიანი მნიშვნელობა

მეთოდი შრიფტის ფერიაბრუნებს სტრიქონს, რომელიც შედგება პრიმიტიული სტრიქონის მნიშვნელობისგან ობიექტი, ჩასმულია ტეგებში ფერი>…. არ არის შემოწმებული, რომ ორიგინალური სტრიქონი უკვე იყო ჩასმული ამ ტეგებში. ეს მეთოდი გამოიყენება document.write და document.writeln მეთოდებთან ერთად ტექსტის მითითებულ ფერში საჩვენებლად. მაგალითად, განცხადება document.write("My text".fontcolor("red")) აჩვენებს სტრიქონს My text ბრაუზერის ეკრანზე.

შრიფტის ზომის მეთოდი

Სინტაქსი : საგანი.შრიფტის ზომა( ზომა) არგუმენტები: ზომარიცხვითი გამოხატულება შედეგი: სიმებიანი მნიშვნელობა

მეთოდი შრიფტის ზომააბრუნებს სტრიქონს, რომელიც შედგება პრიმიტიული სტრიქონის მნიშვნელობისგან ობიექტი, ჩასმულია ტეგებში …. არ არის შემოწმებული, რომ ორიგინალური სტრიქონი უკვე იყო ჩასმული ამ ტეგებში. ეს მეთოდი გამოიყენება document.write და document.writeln მეთოდებთან ერთად ტექსტის განსაზღვრული შრიფტის ზომით საჩვენებლად. მაგალითად, განცხადება document.write("My text".fontsize(5)) აჩვენებს სტრიქონს My text ბრაუზერის ეკრანზე.

CharCode მეთოდიდან

Სინტაქსი : String.fromCharCode( კოდი 1, კოდი2, …, კოდიN) არგუმენტები: კოდი 1, კოდი2, …, კოდიNრიცხვითი გამონათქვამები შედეგი: სიმებიანი მნიშვნელობა

მეთოდი CharCode-დანქმნის ახალ სტრიქონს (მაგრამ არა სტრიქონის ობიექტს), რომელიც წარმოადგენს უნიკოდის სიმბოლოების კოდებთან შეერთებას კოდი 1, კოდი2, …, კოდიN.

ეს არის ობიექტის სტატიკური მეთოდი სიმებიანი, ასე რომ თქვენ არ გჭირდებათ კონკრეტულად შექმნათ სიმებიანი ობიექტი მასზე წვდომისთვის. მაგალითი:

Var s = String.fromCharCode(65, 66, 67); // s უდრის "ABC"

მეთოდის ინდექსი

Სინტაქსი : საგანი.indexOf( ქვესტრიქონი[,დაწყება]?) არგუმენტები: ქვესტრიქონინებისმიერი სიმებიანი გამოხატულება დაწყებანებისმიერი რიცხვითი გამოხატულება შედეგი.charCodeAt(

მეთოდი indexOfუბრუნდება პირველ პოზიციას ქვესტრიქონებიპრიმიტიული სტრიქონის მნიშვნელობაში ობიექტი. საგანი დაწყება დაწყება დაწყება დაწყებამეტი ვიდრე საგანი საგანი

ჩხრეკა ტარდება მარცხნიდან მარჯვნივ. წინააღმდეგ შემთხვევაში, ეს მეთოდი მეთოდის იდენტურია. შემდეგი მაგალითი ითვლის სტრიქონში ქვესტრიქონის ნიმუშის შემთხვევების რაოდენობას.

ფუნქცია მოხდეს(str, ნიმუში) ( var pos = str.indexOf(pattern); for (var count = 0; pos != -1; count++) pos = str.indexOf(pattern, pos + pattern.length); დაბრუნების რაოდენობა )

დახრის მეთოდი

Სინტაქსი : საგანი.italics() შედეგი: სიმებიანი მნიშვნელობა

მეთოდი დახრილიაბრუნებს სტრიქონს, რომელიც შედგება პრიმიტიული სტრიქონის მნიშვნელობისგან ობიექტი, ჩასმულია ტეგებში …. არ არის შემოწმებული, რომ ორიგინალური სტრიქონი უკვე იყო ჩასმული ამ ტეგებში. ეს მეთოდი გამოიყენება document.write და document.writeln მეთოდებთან ერთად ტექსტის დახრილი შრიფტით საჩვენებლად. მაგალითად, ოპერატორი document.write("ჩემი ტექსტი".italics()) აჩვენებს ხაზს ჩემი ტექსტი .

lastIndexOf მეთოდი

Სინტაქსი : საგანი.lastIndexOf( ქვესტრიქონი[,დაწყება]?) არგუმენტები: ქვესტრიქონინებისმიერი სიმებიანი გამოხატულება დაწყებანებისმიერი რიცხვითი გამოხატულება შედეგი.charCodeAt(

მეთოდი ბოლო ინდექსიაბრუნებს ბოლო პოზიციას ქვესტრიქონებიპრიმიტიული სტრიქონის მნიშვნელობაში ობიექტი საგანი. -1. დაწყებათუ მოყვანილია არჩევითი არგუმენტი დაწყება; თუ არა, მაშინ 0 პოზიციიდან, ანუ ხაზის პირველი სიმბოლოდან. თუ დაწყებაუარყოფითი, მაშინ იგი აღებულია ნულის ტოლი; თუ დაწყებამეტი ვიდრე საგანი. -1, მაშინ მიღებულია თანაბარი საგანი. -1.

თუ ობიექტი არ შეიცავს ამ ქვესტრინგს, მაშინ დაბრუნდება მნიშვნელობა -1.

ჩხრეკა ტარდება მარჯვნიდან მარცხნივ. წინააღმდეგ შემთხვევაში, ეს მეთოდი მეთოდის იდენტურია. მაგალითი:

Var n = "თეთრი ვეშაპი".lastIndexOf("ვეშაპი"); // n უდრის 6-ს

Სინტაქსი : საგანიბმული მეთოდი .ბმული() არგუმენტები: .ბმული(ური შედეგი: სიმებიანი მნიშვნელობა

მეთოდი ნებისმიერი სიმებიანი გამოხატულებააბრუნებს სტრიქონს, რომელიც შედგება პრიმიტიული სტრიქონის მნიშვნელობისგან ობიექტიბმული, ჩასმულია ური ტეგებში .ბმული("> . არ არის შემოწმებული, იყო თუ არა წყაროს სტრიქონი უკვე ჩასმული ამ ტეგებში. ეს მეთოდი გამოიყენება document.write და document.writeln მეთოდებთან ერთად ჰიპერბმულის შესაქმნელად HTML დოკუმენტში მითითებული მითითებით.

. მაგალითად, განცხადება document.write("ჩემი ტექსტი".link("#Bookmark")) ექვივალენტურია განაცხადის document.write("ჩემი ტექსტი") .

Სინტაქსი : საგანი localeCompare მეთოდი .კონკატი() არგუმენტები: .კონკატი(ური შედეგი.localeCompare(

: ნომერი

მეთოდი მხარდაჭერალოკალური შედარება ობიექტიადარებს ორ სტრიქონს ოპერაციული სისტემის ეროვნული პარამეტრების გათვალისწინებით. ის აბრუნებს -1 თუ პრიმიტიულ მნიშვნელობას ნაკლებიხაზები 1 ნაკლები, +1 თუ მეტია

და 0, თუ ეს მნიშვნელობები იგივეა.

Სინტაქსი : საგანიმატჩის მეთოდი . მატჩი () არგუმენტები: . მატჩი ( შედეგირეგვირ

მეთოდი : სიმების მასივი . მატჩი ( ობიექტიმატჩი null. მატჩის შედეგი არის ნაპოვნი ქვესტრიქონების მასივი ან

• თუ მატჩები არ არის. სადაც: . მატჩი (თუ . მატჩი (.არ შეიცავს გლობალური ძიების ვარიანტს, შემდეგ მეთოდი შესრულებულია(საგანიაღმასრულებელი . მატჩი () და მისი შედეგი ბრუნდება. შედეგად მიღებული მასივი შეიცავს ელემენტში ნაპოვნი ქვესტრიქონს ინდექსით 0, ხოლო დანარჩენი ელემენტები შეიცავს ქვეგამოსახულებების შესაბამის ქვესტრიქონებს.
• თუ მატჩები არ არის. სადაც: . მატჩი (, ჩასმული ფრჩხილებში. . მატჩი (.არ შეიცავს გლობალური ძიების ვარიანტს, შემდეგ მეთოდი შესრულებულია(საგანიშეიცავს გლობალური ძიების ვარიანტს, შემდეგ მეთოდს . მატჩი (.) შესრულებულია მანამ, სანამ შესატყვისები მოიძებნება. თუ n არის ნაპოვნი შესატყვისების რაოდენობა, მაშინ შედეგი არის n ელემენტის მასივი, რომელიც შეიცავს ნაპოვნი ქვესტრიქონებს. საკუთრებაბოლო ინდექსი

მინიჭებული აქვს პოზიციის ნომერი წყაროს სტრიქონში, რომელიც მიუთითებს პირველ სიმბოლოზე ბოლო ნაპოვნი მატჩის შემდეგ, ან 0, თუ შესატყვისები არ იქნა ნაპოვნი. . მატჩი (.არ შეიცავს გლობალური ძიების ვარიანტს, შემდეგ მეთოდი შესრულებულიაუნდა გვახსოვდეს, რომ მეთოდი . მატჩი (ცვლის ობიექტის თვისებებს

. მაგალითები:

Სინტაქსი : საგანიჩანაცვლების მეთოდი . მატჩი (,.ჩანაცვლება() საგანიჩანაცვლების მეთოდი . მატჩი (,ხაზი) არგუმენტები: . მატჩი (ფუნქცია ხაზირეგულარული გამოხატვის სიმებიანი სტრიქონის გამოხატულება შედეგიფუნქციის სახელი ან ფუნქციის დეკლარაცია

მეთოდი : ახალი ხაზიჩანაცვლება . მატჩი (შეესაბამება რეგულარულ გამოხატვას ობიექტიპრიმიტიული სიმებიანი მნიშვნელობით . მატჩი (და ცვლის ნაპოვნი ქვესტრიქონებს სხვა ქვესტრიქონებით. შედეგი არის ახალი სტრიქონი, რომელიც არის ორიგინალური სტრიქონის ასლი გაკეთებული ჩანაცვლებით. ჩანაცვლების მეთოდი განისაზღვრება გლობალური ძიების ვარიანტით

თუ მატჩები არ არის. სადაც: . მატჩი (არ შეიცავს გლობალური ძიების ოფციას, მაშინ ძიება შესრულებულია პირველი ქვესტრინგისთვის, რომელიც ემთხვევა . მატჩი (და ის შეიცვალა. თუ . მატჩი (შეიცავს გლობალური ძიების ვარიანტს, შემდეგ ყველა ქვესტრიქონი ემთხვევა . მატჩი (, და ისინი შეიცვალა.

.ჩანაცვლება(, შემდეგ ყოველი ნაპოვნი ქვესტრიქონი იცვლება მისით. ამ შემთხვევაში, ხაზი შეიძლება შეიცავდეს შემდეგ ობიექტის თვისებებს RegExp, როგორიცაა $1 , , $9 , lastMatch , lastParen , leftContext და rightContext . მაგალითად, ოპერატორი document.write("გემრიელი ვაშლი, წვნიანი ვაშლი.".replace(/apples/g, "მსხალი")) ბრაუზერის ეკრანზე აჩვენებს ხაზს Delicious pears, juicy pears.

თუ მეორე არგუმენტი არის ხაზი, შემდეგ ნაპოვნი თითოეული ქვესტრიქონი იცვლება ამ ფუნქციის გამოძახებით. ფუნქციას აქვს შემდეგი არგუმენტები. პირველი არგუმენტი არის ნაპოვნი ქვესტრიქონი, რასაც მოჰყვება არგუმენტები, რომლებიც შეესაბამება ყველა ქვეგამოთქმას . მატჩი (, ფრჩხილებში ჩასმული, ბოლო არგუმენტი არის ნაპოვნი ქვესტრიქონის პოზიცია წყაროს სტრიქონში, რომელიც ითვლის ნულიდან, ხოლო ბოლო არგუმენტი არის თავად წყაროს სტრიქონი. შემდეგი მაგალითი გვიჩვენებს, თუ როგორ გამოიყენოთ მეთოდი : ახალი ხაზიშეგიძლიათ დაწეროთ ფუნქცია ფარენჰეიტის ცელსიუსზე გადასაყვანად. მოცემული სცენარი

ფუნქცია myfunc($0,$1) ( return (($1-32) * 5 / 9) + "C"; ) ფუნქცია f2c(x) ( var s = String(x); return s.replace(/(\d+( \.\d*)?)F\b/, myfunc ) document.write(f2c("212F"));

გამოაჩენს ხაზს 100C ბრაუზერის ეკრანზე.

გთხოვთ გაითვალისწინოთ, რომ ეს მეთოდი ცვლის ობიექტის თვისებებს . მატჩი (.

შეცვალეთ მაგალითი

ჩაანაცვლეთ ქვესტრიქონის ყველა შემთხვევა სტრიქონში

ხშირად ხდება, რომ თქვენ უნდა შეცვალოთ ერთი სტრიქონის ყველა შემთხვევა მეორე სტრიქონით:

Var str = "foobarfoobar"; str=str.replace(/foo/g,"xxx"); // შედეგი იქნება str = "xxxbarxxxbar";

ძებნის მეთოდი

Სინტაქსი : საგანი.ძებნა( . მატჩი () არგუმენტები: . მატჩი (ნებისმიერი რეგულარული გამოხატულება შედეგი: რიცხვითი გამოხატულება

მეთოდი ძებნაჩანაცვლება . მატჩი (შეესაბამება რეგულარულ გამოხატვას ობიექტი. მატჩის შედეგი არის ნაპოვნი პირველი ქვესტრიქონის პოზიცია, რომელიც ითვლის ნულიდან, ან -1, თუ შესატყვისები არ არის. ამავე დროს, გლობალური ძიების ვარიანტი . მატჩი (იგნორირებულია და თვისებები . მატჩი (არ შეცვალო.

მაგალითები:

Სინტაქსი : საგანინაჭრის მეთოდი დაწყება [,.ნაჭერი(]?) არგუმენტები: დაწყებადა .ნაჭერი(დასასრული შედეგიფუნქციის სახელი ან ფუნქციის დეკლარაცია

მეთოდი ნებისმიერი რიცხვითი გამონათქვამები ობიექტინაჭერი დაწყება, პოზიციიდან .ნაჭერი(თანამდებობაზე .ნაჭერი( დაწყება, მის გარეშე. თუ

და ორიგინალური ხაზის ბოლომდე. საგანიხაზოვანი სიმბოლოების პოზიციები დანომრილია ნულიდან დაწყება საგანი. +დაწყება. -1. .ნაჭერი(თუ ღირებულება საგანი. +.ნაჭერი(. თუ ღირებულება

უარყოფითი, შემდეგ ის იცვლება

. სხვა სიტყვებით რომ ვთქვათ, უარყოფითი არგუმენტები განიხილება, როგორც ოფსეტები სტრიქონის ბოლოდან.

Სინტაქსი : საგანი.პატარა() შედეგი: სიმებიანი მნიშვნელობა

მეთოდი პატარააბრუნებს სტრიქონს, რომელიც შედგება პრიმიტიული სტრიქონის მნიშვნელობისგან ობიექტი, ჩასმულია ტეგებში …. არ არის შემოწმებული, რომ ორიგინალური სტრიქონი უკვე იყო ჩასმული ამ ტეგებში. ეს მეთოდი გამოიყენება document.write და document.writeln მეთოდებთან ერთად ტექსტის მცირე შრიფტით საჩვენებლად. მაგალითად, განცხადება document.write("ჩემი ტექსტი".small()) აჩვენებს სტრიქონს My text ბრაუზერის ეკრანზე.

გაყოფის მეთოდი

Სინტაქსი : საგანი.გაყოფა( გამსაზღვრელი [,ნომერი]?) არგუმენტები: გამსაზღვრელისტრიქონი ან რეგულარული გამოხატულება ნომერირიცხვითი გამოხატულება შედეგი: სიმებიანი მასივი (ობიექტი მასივი)

მეთოდი გაყოფაარღვევს პრიმიტიულ მნიშვნელობას ობიექტიქვესტრიქონების მასივში და აბრუნებს მას. ქვესტრიქონებად დაყოფა ხდება შემდეგნაირად. წყაროს სტრიქონი სკანირებულია მარცხნიდან მარჯვნივ გამსაზღვრელი. როგორც კი ის მოიძებნება, ქვესტრიქონი წინა დელიმიტერის ბოლოდან (ან სტრიქონის დასაწყისიდან, თუ ეს დელიმიტერის პირველი შემთხვევაა) აღმოჩენის დასაწყისამდე ემატება ქვესტრიქონების მასივს. ამრიგად, თავად გამყოფი არ ჩანს ქვესტრიქონის ტექსტში.

არჩევითი არგუმენტი ნომერიგანსაზღვრავს მიღებული მასივის მაქსიმალურ შესაძლო ზომას. თუ მითითებულია, მაშინ შერჩევის შემდეგ ნომრებიქვესტრინგის მეთოდი გადის მაშინაც კი, თუ ორიგინალური სტრიქონის სკანირება არ დასრულებულა.

გამსაზღვრელიშეიძლება მითითებული იყოს როგორც სტრიქონი ან როგორც რეგულარული გამოხატულება. არის რამდენიმე შემთხვევა, რომელიც განსაკუთრებულ განხილვას მოითხოვს:

შემდეგი მაგალითი იყენებს რეგულარულ გამონათქვამს HTML ტეგების განმსაზღვრელად დასაზუსტებლად. ოპერატორი

ბრაუზერის ეკრანზე გამოჩნდება ხაზი ტექსტი, თამამი და დახრილი.

დარტყმის მეთოდი

Სინტაქსი : საგანი.strike() შედეგი: სიმებიანი მნიშვნელობა

მეთოდი გაფიცვააბრუნებს სტრიქონს, რომელიც შედგება პრიმიტიული სტრიქონის მნიშვნელობისგან ობიექტი, ჩასმულია ტეგებში …. არ არის შემოწმებული, რომ ორიგინალური სტრიქონი უკვე იყო ჩასმული ამ ტეგებში. ეს მეთოდი გამოიყენება document.write და document.writeln მეთოდებთან ერთად ტექსტის საჩვენებელი შრიფტით. მაგალითად, განცხადება document.write("ჩემი ტექსტი".strike()) აჩვენებს სტრიქონს My text ბრაუზერის ეკრანზე.

ქვე მეთოდი

Სინტაქსი : საგანი.sub() შედეგი: სიმებიანი მნიშვნელობა

მეთოდი ქვეაბრუნებს სტრიქონს, რომელიც შედგება პრიმიტიული სტრიქონის მნიშვნელობისგან ობიექტი, ჩასმულია ტეგებში . არ არის შემოწმებული, რომ ორიგინალური სტრიქონი უკვე იყო ჩასმული ამ ტეგებში. ეს მეთოდი გამოიყენება document.write და document.writeln მეთოდებთან ერთად ტექსტის ხელმოწერის სახით საჩვენებლად. მაგალითად, განცხადება document.write("ჩემი ტექსტი".sub()) აჩვენებს სტრიქონს My text ბრაუზერის ეკრანზე.

სუბსტრ მეთოდი

Სინტაქსი : საგანი.substr( პოზიცია [,სიგრძე]?) არგუმენტები: პოზიციადა სიგრძერიცხვითი გამონათქვამები შედეგი: სიმებიანი მნიშვნელობა

მეთოდი სუბსტრაბრუნებს სტრიქონის პრიმიტიული მნიშვნელობის ქვესტრიქონს ობიექტიამით დაწყებული პოზიციებიდა შეიცავს სიგრძეპერსონაჟები. თუ სიგრძეარ არის მითითებული, მაშინ ქვესტრიქონი ბრუნდება მოცემულიდან დაწყებული პოზიციებიდა ორიგინალური ხაზის ბოლომდე. თუ სიგრძეარის უარყოფითი ან ნულოვანი, ცარიელი სტრიქონი ბრუნდება.

და ორიგინალური ხაზის ბოლომდე. საგანი. -1. პოზიციათუ საგანიმეტი ან ტოლი პოზიციაარის უარყოფითი, შემდეგ იგი ინტერპრეტირებულია, როგორც ოფსეტური ხაზის ბოლოდან, ანუ ის იცვლება საგანი.+პოზიცია.

შენიშვნა. თუ პოზიციაარის უარყოფითი, Internet Explorer შეცდომით ცვლის მას 0-ით, ამიტომ თავსებადობის მიზეზების გამო ეს ოფცია არ უნდა იქნას გამოყენებული.

Var src = "abcdef"; var s1 = src.substr(1, 3); // "bcd" var s2 = src.substr(1); // "bcdef" var s3 = src.substr(-1); // "f", მაგრამ MSIE-ში: "abcdef"

ქვესტრიქონის მეთოდი

Სინტაქსი : საგანი.ქვესტრიქონი( დაწყება [,.ნაჭერი(]) არგუმენტები: დაწყებადა .ნაჭერი(რიცხვითი გამონათქვამები შედეგი: სიმებიანი მნიშვნელობა

მეთოდი ქვესტრიქონიაბრუნებს სტრიქონის პრიმიტიული მნიშვნელობის ქვესტრიქონს ობიექტინაჭერი დაწყება, პოზიციიდან .ნაჭერი(თანამდებობაზე .ნაჭერი(არ არის მითითებული, შემდეგ ბრუნდება ქვესტრიქონი, დაწყებული პოზიციიდან დაწყება, მის გარეშე. თუ

და ორიგინალური ხაზის ბოლომდე. საგანი. -1. . -1.უარყოფითი არგუმენტები ან თანაბარი დაწყებაიცვლება ნულით; თუ არგუმენტი აღემატება თავდაპირველი სტრიქონის სიგრძეს, მაშინ ის იცვლება მისით. თუ მეტიდასასრული დაწყება, შემდეგ ადგილებს იცვლიან. თუ უდრისდასასრული

, შემდეგ ცარიელი სტრიქონი ბრუნდება.

შედეგი არის სტრიქონის მნიშვნელობა და არა სტრიქონის ობიექტი. მაგალითები:

Var src = "abcdef"; var s1 = src.substring(1, 3); // "bc" var s2 = src.substring(1, -1); // "a" var s3 = src.substring(-1, 1); // "ა"

Სინტაქსი : საგანისუპის მეთოდი შედეგი: სიმებიანი მნიშვნელობა

მეთოდი .sup()აბრუნებს სტრიქონს, რომელიც შედგება პრიმიტიული სტრიქონის მნიშვნელობისგან ობიექტი, ჩასმულია ტეგებში სუპ

. არ არის შემოწმებული, რომ ორიგინალური სტრიქონი უკვე იყო ჩასმული ამ ტეგებში. ეს მეთოდი გამოიყენება document.write და document.writeln მეთოდებთან ერთად ტექსტის ზედამხედველობის სახით გამოსაჩენად. მაგალითად, განცხადება document.write("ჩემი ტექსტი".sup()) აჩვენებს სტრიქონს My text ბრაუზერის ეკრანზე.

Სინტაქსი : საგანი toLocaleLowerCase მეთოდი შედეგი.toLocaleLowerCase()

: ნომერი: ახალი ხაზი

მეთოდი : Internet Explorer მხარდაჭერილია 5.5 ვერსიიდან. Netscape Navigator არ არის მხარდაჭერილი. LocaleLowerCase-ზე

აბრუნებს ახალ სტრიქონს, რომელშიც ორიგინალური სტრიქონის ყველა ასო ჩანაცვლებულია პატარა ასოებით, ოპერაციული სისტემის ლოკალური პარამეტრების გათვალისწინებით. ორიგინალური სტრიქონის დარჩენილი სიმბოლოები არ შეცვლილა. ორიგინალური სტრიქონი იგივე რჩება. როგორც წესი, ეს მეთოდი აბრუნებს იგივე შედეგს, როგორც ; განსხვავება შესაძლებელია მხოლოდ იმ შემთხვევაში, თუ ენის დაშიფვრა ეწინააღმდეგება უნიკოდის წესებს დიდი ასოებით გადაყვანისთვის.

Სინტაქსი : საგანი toLocaleUpperCase მეთოდი შედეგი.toLocaleLowerCase()

: ნომერი: ახალი ხაზი

მეთოდი .toLocaleUpperCase() LocaleUpperCase

აბრუნებს ახალ სტრიქონს, რომელშიც ორიგინალური სტრიქონის ყველა ასო ჩანაცვლებულია დიდი ასოებით, ოპერაციული სისტემის ლოკალური პარამეტრების გათვალისწინებით. ორიგინალური სტრიქონის დარჩენილი სიმბოლოები არ შეცვლილა. ორიგინალური სტრიქონი იგივე რჩება. როგორც წესი, ეს მეთოდი აბრუნებს იგივე შედეგს, როგორც ; განსხვავება შესაძლებელია მხოლოდ იმ შემთხვევაში, თუ ენის კოდირება ეწინააღმდეგება უნიკოდის წესებს მცირე ასოების დიდ ასოებად გადაქცევისთვის.

Სინტაქსი : საგანი To LowerCase მეთოდი შედეგიფუნქციის სახელი ან ფუნქციის დეკლარაცია

მეთოდი .toLowerCase()აბრუნებს ახალ სტრიქონს თავდაპირველი სტრიქონის ყველა ასოებით შეცვლილი პატარა ასოებით. ორიგინალური სტრიქონის დარჩენილი სიმბოლოები არ შეცვლილა. ორიგინალური სტრიქონი იგივე რჩება. მაგალითად, განცხადება document.write("String object".toLowerCase()) დაბეჭდავს სტრიქონის ობიექტის სტრიქონს ბრაუზერის ეკრანზე.

მოგესალმებით ყველას, ვინც საფუძვლიანად გადაწყვიტა ისწავლოს პროტოტიპზე ორიენტირებული ენა. ბოლო დროს გითხარით , და დღეს ჩვენ გავაანალიზებთ JavaScript სტრიქონებს. ვინაიდან ამ ენაში ტექსტის ყველა ელემენტი არის სტრიქონები (არ არსებობს სიმბოლოების ცალკე ფორმატი), შეგიძლიათ გამოიცნოთ, რომ ეს განყოფილება მნიშვნელოვან ნაწილს იკავებს js სინტაქსის შესწავლაში.

სწორედ ამიტომ, ამ პუბლიკაციაში გეტყვით, თუ როგორ იქმნება სტრიქონის ელემენტები, რა მეთოდები და თვისებებია მათთვის გათვალისწინებული, როგორ ხდება სტრიქონების სწორად გადაქცევა, მაგალითად, რიცხვად გადაქცევა, როგორ შეგიძლიათ ამოიღოთ სასურველი ქვესტრიქონი და მრავალი სხვა. ამას გარდა, დავამაგრებ პროგრამის კოდის მაგალითებს. ახლა კი საქმეს გადავიდეთ!

სიმებიანი ცვლადის სინტაქსი

js ენაში ყველა ცვლადი დეკლარირებულია var საკვანძო სიტყვის გამოყენებით, შემდეგ კი, პარამეტრების ფორმატიდან გამომდინარე, განისაზღვრება დეკლარირებული ცვლადის ტიპი. როგორც გახსოვთ JavaScript-დან, ძლიერი აკრეფა არ არის. სწორედ ამიტომ არის ეს სიტუაცია კოდექსში.

ცვლადების ინიციალიზაციისას, მნიშვნელობები შეიძლება ჩამოყალიბდეს ორმაგად, ერთჯერადად და 2015 წლიდან, დახრილი ერთეული ბრჭყალებით. ქვემოთ მე მიმაგრებული მაქვს სტრიქონების გამოცხადების თითოეული მეთოდის მაგალითები.

მინდა განსაკუთრებული ყურადღება მივაქციო მესამე მეთოდს. მას აქვს მთელი რიგი უპირატესობები.

მისი დახმარებით თქვენ შეგიძლიათ მარტივად განახორციელოთ ხაზის გაწყვეტა და ის ასე გამოიყურება:

გაფრთხილება (რამდენიმე

მე გადავდივარ

და მესამე მეთოდი საშუალებას გაძლევთ გამოიყენოთ $(…) კონსტრუქცია. ეს ინსტრუმენტი საჭიროა ინტერპოლაციის ჩასართავად. არ ინერვიულო, ახლა მე გეტყვი რა არის.

$(…)-ის წყალობით თქვენ შეგიძლიათ არა მხოლოდ ცვლადი მნიშვნელობების ჩასმა სტრიქონებში, არამედ მათთან ერთად განახორციელოთ არითმეტიკული და ლოგიკური ოპერაციები, გამოძახების მეთოდები, ფუნქციები და ა.შ. ამ ყველაფერს ერთი ტერმინი - ინტერპოლაცია ჰქვია. შეამოწმეთ ამ მიდგომის განხორციელების მაგალითი.

1 2 3

var კალამი = 3; var ფანქარი = 1; alert(`$(კალამი) + $(ფანქარი*5) = $(კალამი + ფანქარი)`);

var კალამი = 3; var ფანქარი = 1; alert(`$(კალამი) + $(ფანქარი*5) = $(კალამი + ფანქარი)`);

შედეგად, გამოთქმა "3 + 1*5 = 8" გამოჩნდება ეკრანზე.

რაც შეეხება სტრიქონების გამოცხადების პირველ ორ გზას, მათში განსხვავება არ არის.

მოდით ვისაუბროთ ცოტა განსაკუთრებულ პერსონაჟებზე

პროგრამირების ბევრ ენას აქვს სპეციალური სიმბოლოები, რომლებიც ხელს უწყობენ ტექსტის მანიპულირებას სტრიქონებში. მათ შორის ყველაზე ცნობილია ხაზის შესვენება (\n).

ყველა მსგავსი ინსტრუმენტი თავდაპირველად იწყება უკანა ხაზით (\) და მას მოსდევს ინგლისური ანბანის ასოები.

ქვემოთ მე მივამაგრე პატარა ცხრილი, რომელშიც ჩამოთვლილია რამდენიმე სპეციალური სიმბოლო.

ჩვენ ვაგროვებთ მეთოდებისა და თვისებების მძიმე არსენალს

ენის შემქმნელებმა მოგვაწოდეს მრავალი მეთოდი და თვისება სტრინგებთან მუშაობის გასამარტივებლად და ოპტიმიზაციისთვის. გასულ წელს ახალი სტანდარტის გამოშვებით, სახელწოდებით ES-2015, ეს სია ახალი ინსტრუმენტებით შეივსო.

სიგრძე

დავიწყებ ყველაზე პოპულარული თვისებით, რომელიც გვეხმარება სიმებიანი ცვლადების მნიშვნელობების სიგრძის დადგენაში. ეს სიგრძე. იგი გამოიყენება ამ გზით:

var string = "Unicorns";

alert(string.length);

პასუხი აჩვენებს რიცხვს 9. ეს თვისება ასევე შეიძლება გამოყენებულ იქნას თავად მნიშვნელობებზე:

„უნიკორნები“.სიგრძე;

შედეგი არ შეიცვლება.

charAt()

ეს მეთოდი საშუალებას გაძლევთ ამოიღოთ კონკრეტული სიმბოლო ტექსტიდან. შეგახსენებთ, რომ ნუმერაცია იწყება ნულიდან, ამიტომ სტრიქონიდან პირველი სიმბოლოს ამოსაღებად, თქვენ უნდა დაწეროთ შემდეგი ბრძანებები:

var string = "Unicorns";

alert(string.charAt(0));.

თუმცა, შედეგად მიღებული შედეგი არ იქნება სიმბოლოს ტიპი;

საწყისი toLowerCase () to Uppercase ()

ეს მეთოდები აკონტროლებს პერსონაჟების შემთხვევას. კოდის „შინაარსი“ დაწერისას.

toUpperCase ()მთელი სიტყვა ნაჩვენები იქნება დიდი ასოებით.

საპირისპირო ეფექტისთვის, თქვენ უნდა გამოიყენოთ "შინაარსი". toLowerCase().

indexOf()

პოპულარული და აუცილებელი ინსტრუმენტი ქვესტრიქონების საძიებლად. არგუმენტად, თქვენ უნდა შეიყვანოთ სიტყვა ან ფრაზა, რომლის პოვნაც გსურთ და მეთოდი აბრუნებს ნაპოვნი ელემენტის პოზიციას. თუ მოძიებული ტექსტი ვერ მოიძებნა, „-1“ დაუბრუნდება მომხმარებელს.

1 2 3 4

var text = "ყვავილების ძიების ორგანიზება!"; alert(text.indexOf("ფერი")); //19 alert(text.indexOf(" ")); //12 alert(text.lastIndexOf(" ")); //18

var text = "ყვავილების ძიების ორგანიზება!"; alert(text.indexOf("ფერი")); //19 alert(text.indexOf(" ")); //12 alert(text.lastIndexOf(" ")); //18

გაითვალისწინეთ, რომ lastIndexOf() აკეთებს იგივეს, მხოლოდ ის ეძებს წინადადების ბოლოდან.

ქვესტრინგის მოპოვება

ამ მოქმედებისთვის js-ში სამი დაახლოებით იდენტური მეთოდი შეიქმნა.

ჯერ შევხედოთ მას ქვესტრიქონი (დაწყება, დასასრული)და ნაჭერი (დაწყება, დასასრული). ისინი ერთნაირად მუშაობენ. პირველი არგუმენტი განსაზღვრავს საწყის პოზიციას, საიდანაც დაიწყება მოპოვება, ხოლო მეორე პასუხისმგებელია საბოლოო გაჩერებაზე. ორივე მეთოდით, სტრიქონი ამოღებულია სიმბოლოს გარეშე, რომელიც მდებარეობს ბოლო პოზიციაზე.

var text = "ატმოსფერო"; alert(text.substring(4)); // გამოჩნდება "სფერული" გაფრთხილება(text.substring(2, 5)); //აჩვენეთ "mos" alert(text.slice(2, 5)); //აჩვენეთ "mos"

ახლა გადავხედოთ მესამე მეთოდს, რომელსაც ე.წ substr(). ის ასევე უნდა შეიცავდეს 2 არგუმენტს: დაწყებადა სიგრძე.

პირველი განსაზღვრავს საწყის პოზიციას, ხოლო მეორე განსაზღვრავს ამოსაღები სიმბოლოების რაოდენობას. ამ სამ ინსტრუმენტს შორის განსხვავებების დასადგენად, მე გამოვიყენე წინა მაგალითი.

var text = "ატმოსფერო";

alert(text.substr(2, 5)); //აჩვენეთ "mosfe"

ქვესტრიქონების აღების ჩამოთვლილი საშუალებების გამოყენებით, შეგიძლიათ წაშალოთ არასაჭირო სიმბოლოები ახალი ხაზის ელემენტებიდან, რომლებთანაც შემდეგ მუშაობს პროგრამა.

პასუხი ()

ეს მეთოდი ხელს უწყობს ტექსტში სიმბოლოების და ქვესტრიქონების შეცვლას. ის ასევე შეიძლება გამოყენებულ იქნას გლობალური ჩანაცვლების განსახორციელებლად, მაგრამ ამისათვის თქვენ უნდა შეიყვანოთ რეგულარული გამონათქვამები.

ეს მაგალითი ჩაანაცვლებს ქვესტრიქონს მხოლოდ პირველ სიტყვაში.

var text = "ატმოსფეროს ატმოსფერო"; var newText = text.replace("Atmo","Strato") alert(newText) // შედეგი: სტრატოსფეროს ატმოსფერო

და ამ პროგრამული უზრუნველყოფის დანერგვაში, რეგულარული გამოხატვის დროშის "g" გამო, შესრულდება გლობალური ჩანაცვლება.

var text = "ატმოსფეროს ატმოსფერო"; var newText = text.replace(/Atmo/g,"Strato") alert(newText) // შედეგი: სტრატოსფერო სტრატოსფერო

მოდით გავაკეთოთ კონვერტაცია

JavaScript უზრუნველყოფს მხოლოდ სამი ტიპის ობიექტის ტიპის კონვერტაციას:

1. რიცხვითი;
2. სიმებიანი;
3. ლოგიკური.

მიმდინარე პუბლიკაციაში ვისაუბრებ 2 მათგანზე, ვინაიდან მათ შესახებ ცოდნა უფრო მეტადაა საჭირო სიმებთან მუშაობისთვის.

რიცხვითი კონვერტაცია

ელემენტის მნიშვნელობის ციფრულ ფორმაში მკაფიოდ გადასაყვანად, შეგიძლიათ გამოიყენოთ ნომერი (მნიშვნელობა).

ასევე არის უფრო მოკლე გამოთქმა: +"999".

var a = ნომერი ("999");

სიმებიანი კონვერტაცია

შესრულებულია ფუნქციით გაფრთხილება, ასევე აშკარა ზარი სტრიქონი (ტექსტი).

გამარჯობა! ამ გაკვეთილზე ჩვენ განვიხილავთ, თუ როგორ შეგიძლიათ შექმნათ სტრიქონი და ფუნქციები JavaScript-ში სტრიქონებთან მუშაობისთვის. პრინციპში, JavaScript-ში ნებისმიერი ტექსტური ცვლადი არის სტრიქონი, რადგან JavaScript არ არის მკაცრად აკრეფილი პროგრამირების ენა (წაიკითხეთ მონაცემთა ტიპების შესახებ). ასევე სტრინგებთან მუშაობისთვის გამოიყენება String კლასი:

Var name1 = "ტომი";

ამიტომ გამოიყენეთ String კონსტრუქტორი:

Var name1 = new String ("Tommy");

პირველ მეთოდს ძირითადად იყენებენ, ალბათ იმიტომ, რომ ის უფრო მოკლეა.

სტრიქონებთან მუშაობის String კლასს აქვს თვისებებისა და ფუნქციების საკმაოდ დიდი ნაკრები, რომლითაც შეგიძლიათ განახორციელოთ სხვადასხვა მანიპულაციები სიმებით.

სიმების სიგრძე

სიგრძე თვისება საშუალებას გაძლევთ დააყენოთ სტრიქონის სიგრძე. ეს ქონება აბრუნებს რიცხვს:

Var hello1 = "გამარჯობა სამყარო"; document.write("ხაზში "" + hello + "" " + hello1.length + " სიმბოლოები");

ძიება სტრიქონში

სტრიქონში გარკვეული ქვესტრიქონის საპოვნელად გამოიყენება ფუნქციები indexOf() (აბრუნებს ქვესტრიქონის პირველი გაჩენის ინდექსს) და lastIndexOf() (აბრუნებს ქვესტრიქონის ბოლო გაჩენის ინდექსს). ეს ფუნქციები იღებს ორ არგუმენტს:

• ქვესტრიქონი, რომელიც რეალურად უნდა მოიძებნოს
• არასავალდებულო არგუმენტი, რომელიც განსაზღვრავს რომელი სიმბოლოდან უნდა მოძებნოს ქვესტრიქონი სტრიქონში

ორივე ეს ფუნქცია აბრუნებს რიცხვს, რომელიც არის სიმბოლოს ინდექსი, რომლითაც იწყება ქვესტრიქონი სტრიქონში. თუ ქვესტრიქონი ვერ მოიძებნა, რიცხვი -1 დაბრუნდება. ამიტომ, ეს ფუნქციები გამოიყენება ლოგიკურ ოპერატორებში, რადგან, როგორც წესი, თქვენ უბრალოდ უნდა შეამოწმოთ სტრიქონი შეიცავს თუ არა ქვესტრინგს, მაშინ ამ შემთხვევაში ამ ფუნქციების შედეგი შედარებულია -1-თან.

Var str1 = "გამარჯობა ვასია!"; var podstr = "პეტია"; if(str.indexOf(podstr) == -1)( document.write("ქვესტრიქონი ვერ მოიძებნა."); ) else (document.write("ქვესტრიქონი ნაპოვნია"); )

მაგალითში გამოჩნდება შეტყობინება "ქვესტრიქონი ვერ მოიძებნა", რადგან სტრიქონი "პიტერი" არ შეიცავს სტრიქონში "გამარჯობა ვასია!".

ფუნქციები მოიცავს, startsWith, endsWith

უფრო თანამედროვე მეთოდი str.includes(substr, pos) აბრუნებს true თუ string str შეიცავს ქვესტრიქონს substr, ან false თუ არა.

ეს არის სწორი არჩევანი, თუ ჩვენ უნდა შევამოწმოთ არის თუ არა მატჩი, მაგრამ პოზიცია არ არის საჭირო:

Alert("ვიჯეტი ID-ით". მოიცავს ("ვიჯეტი")); // true alert("Hello". მოიცავს ("Bye")); // ცრუ

არასავალდებულო მეორე არგუმენტი str.includes-ისთვის საშუალებას გაძლევთ დაიწყოთ ძებნა კონკრეტულ პოზიციაზე:

Alert ("Midget". მოიცავს ("id")); // true alert("Midget". მოიცავს ("id", 3)); // false, ძიება დაიწყო მე-3 პოზიციიდან

str.startsWith და str.endsWith მეთოდები ამოწმებს, შესაბამისად, იწყება თუ არა სტრიქონი კონკრეტული სტრიქონით:

Alert("ვიჯეტი". startsWith("Wid")); // true, "Wid" - "ვიჯეტის" გაფრთხილების დასაწყისი ("ვიჯეტი".endsWith("get")); // true, "get" - დამთავრებული "ვიჯეტი"

ქვესტრიქონის შერჩევა

სტრიქონიდან ქვესტრინგის ამოსაჭრელად გამოიყენება ისეთი ფუნქციები, როგორიცაა substr() და substring().

substring() ფუნქცია იღებს 2 არგუმენტს:

• პერსონაჟის საწყისი პოზიცია ხაზში, საიდანაც ხაზი ამოიჭრება
• ბოლო პოზიცია, რომელზეც სიმები უნდა იყოს მოჭრილი

var hello1 = "გამარჯობა სამყარო. ნახვამდის სამყარო"; var world1 = hello1.substring(7, 10); //მე-7-დან მე-10 ინდექსის დოკუმენტი.write(world1); //სამყარო

substr() ფუნქცია ასევე იღებს ქვესტრიქონის საწყისი ინდექსს, როგორც პირველ პარამეტრს, ხოლო ქვესტრიქონის სიგრძეს, როგორც მე-2 პარამეტრს:

Var hello1 = "გამარჯობა სამყარო. ნახვამდის სამყარო"; var bye1 = hello1.substr(12, 2); დოკუმენტი.წერე(bye1);// ადრე

და თუ მე-2 პარამეტრი არ არის მითითებული, მაშინ ხაზი ბოლომდე შეიკვეცება:

Var hello1 = "გამარჯობა სამყარო. ნახვამდის სამყარო"; var bye1 = hello1.substr(12); document.write(bye1); //მშვიდობით მშვიდობა

წერილის საქმის კონტროლი

ასოების რეგისტრის შესაცვლელად, ანუ ყველა ასო პატარა ან დიდი რომ იყოს, გამოიყენეთ ფუნქციები toLowerCase() (სიმბოლოების მცირე რეზერვში გადასაყვანად, ანუ ყველა ასო იქნება პატარა) და toUpperCase() (სიმბოლოების გადასაყვანად. დიდი, ანუ ყველა ასო დიდი იქნება).

Var hello1 = "გამარჯობა ჯიმ"; document.write(hello1.toLowerCase() + "
"); //გამარჯობა ჯიმ document.write(hello1.toUpperCase() + "
"); //გამარჯობა ჯიმ

სიმბოლოს მიღება მისი ინდექსით

იმისათვის, რომ ვიპოვოთ კონკრეტული სიმბოლო სტრიქონში მისი ინდექსით, გამოიყენება charAt() და charCodeAt() ფუნქციები. ორივე ეს ფუნქცია არგუმენტად იღებს სიმბოლოების ინდექსს:

Var hello1 = "გამარჯობა ჯიმ"; document.write(hello1.charAt(3) + "
"); //document.write(hello1.charCodeAt(3) +"
"); //1080

მაგრამ მხოლოდ იმ შემთხვევაში, თუ charAt() ფუნქცია დააბრუნებს სიმბოლოს თავისი მუშაობის შედეგად, მაშინ charCodeAt() ფუნქცია დააბრუნებს ამ სიმბოლოს რიცხვით Unicode კოდს.

სივრცეების ამოღება

სტრიქონში სივრცეების მოსაშორებლად გამოიყენეთ trim() ფუნქცია:

Var hello1 = "გამარჯობა ჯიმ"; var beforeLen = hello1.length; hello1 = hello1.trim(); var afterLen = hello1.length; document.write("სტრიქონის სიგრძე: " + beforeLen + "
"); //15 document.write("სტრიქონის სიგრძე შემდეგ: " + afterLen + "
"); //10

სტრიქონების შეერთება

concat() ფუნქცია საშუალებას გაძლევთ დააკავშიროთ 2 სტრიქონი:

Var hello1 = "გამარჯობა"; var world1 = "ვასია"; hello1 = hello1.concat(world1); დოკუმენტი.წერე(გამარჯობა); //გამარჯობა, ვასია

ქვესტრიქონის ჩანაცვლება

ჩანაცვლება() ფუნქცია საშუალებას გაძლევთ შეცვალოთ ერთი ქვესტრიქონი მეორეთი:

Var hello1 = "დილა მშვიდობისა"; hello1 = hello1.replace("დღე", "საღამო"); დოკუმენტი.წერე(გამარჯობა1); //Საღამო მშვიდობისა

ფუნქციის პირველი არგუმენტი მიუთითებს რომელი ქვესტრიქონი უნდა შეიცვალოს, ხოლო მე-2 არგუმენტი მიუთითებს რომელი ქვესტრიქონით უნდა შეიცვალოს.

სტრიქონის გაყოფა მასივში

split() ფუნქცია საშუალებას გაძლევთ დაყოთ სტრიქონი ქვესტრიქონების მასივში კონკრეტული გამიჯვნის გამოყენებით. შეგიძლიათ გამოიყენოთ სტრიქონი, რომელიც გადაეცემა მეთოდს:

ვარ მესი = „დღეს მშვენიერი ამინდი იყო“; var stringArr = mes.split(" "); for(var str1 stringArr-ში) document.write(stringArr + "
");

სიმებიანი შედარება

ასევე, სტრიქონების შედარებისას მხედველობაში უნდა იქნას მიღებული ასოების შემთხვევა. დიდი ასო პატარა ასოზე მცირეა, ასო e კი ზოგადად ანბანის მიღმაა.

ᲓᲐᲕᲐᲚᲔᲑᲔᲑᲘ

ბოლო ასოს რეგისტრის შეცვლა სტრიქონში

დაწერეთ ფუნქცია lastLetterStr(str), რომელიც შეცვლის ბოლო ასოს რეგისტრს და გახდის მას დიდს.

სპამის შემოწმება

დაწერეთ ფუნქცია provSpam(str), რომელიც შეამოწმებს სტრიქონს ქვესტრინგების არსებობაზე: „სპამი“, „სექსი“, „xxx“. და დააბრუნეთ true, თუ არსებობს ქვესტრიქონის მონაცემები და false სხვაგვარად.

იპოვეთ ნომერი

დაწერეთ ფუნქცია extrNum(str), რომელიც იღებს რიცხვს სტრიქონიდან, თუ სტრიქონი შეიცავს რიცხვს და რიცხვის ფუნქცია უნდა დაბრუნდეს. მაგალითად, არის ხაზი "120 UAH", რომელიც უნდა დაბრუნდეს 120 ხაზიდან.

ამის გასაძლიერებლად უყურეთ ვიდეოს JavaScript-ში სტრიქონებთან მუშაობის შესახებ.