Strings

نوع AbstractString هو السوبر نوع لجميع تطبيقات السلاسل في جوليا. السلاسل هي ترميزات لتسلسلات من نقاط الشيفرة Unicode كما تمثلها نوع AbstractChar. تقوم جوليا ببعض الافتراضات حول السلاسل:

• يتم ترميز السلاسل من حيث "وحدات الشيفرة" ذات الحجم الثابت

  • يمكن استخراج وحدات الشيفرة باستخدام codeunit(s, i)
  • أول وحدة شيفرة لها فهرس 1
  • آخر وحدة شيفرة لها فهرس ncodeunits(s)
  • أي فهرس i بحيث 1 ≤ i ≤ ncodeunits(s) هو ضمن الحدود

• يتم فهرسة السلاسل من حيث هذه الوحدات:

  • يتم استخراج الأحرف بواسطة s[i] مع فهرس سلسلة صالح i
  • كل AbstractChar في سلسلة يتم ترميزه بواسطة وحدة أو أكثر من وحدات الشيفرة
  • فقط فهرس أول وحدة شيفرة لـ AbstractChar هو فهرس صالح
  • ترميز AbstractChar مستقل عما يسبقه أو يتبعه
  • ترميزات السلاسل هي ذات تزامن ذاتي – أي أن isvalid(s, i) هو O(1)

بعض دوال السلاسل التي تستخرج وحدات الشيفرة أو الأحرف أو السلاسل الفرعية من السلاسل تعطي خطأ إذا قمت بتمرير فهارس سلسلة غير صالحة أو خارج الحدود. يشمل ذلك codeunit(s, i) و s[i]. الدوال التي تقوم بحساب فهارس السلاسل تتبنى نهجًا أكثر استرخاءً في الفهرسة وتعطيك أقرب فهرس سلسلة صالح عندما تكون ضمن الحدود، أو عندما تكون خارج الحدود، تتصرف كما لو كان هناك عدد لا نهائي من الأحرف padding على كل جانب من السلسلة. عادةً ما يكون طول وحدة الشيفرة لهذه الأحرف padding الخيالية 1 ولكن قد تختار أنواع السلاسل أحجام أحرف "خيالية" مختلفة كما يتناسب مع تطبيقاتها (على سبيل المثال، قد تمرر السلاسل الفرعية حساب الفهارس إلى السلسلة الأساسية التي توفر عرضًا لها). تشمل دوال الفهرسة المسترخية تلك المخصصة لحساب الفهارس: thisind و nextind و prevind. يسمح هذا النموذج بحساب الفهارس للعمل مع الفهارس خارج الحدود كقيم وسيطة طالما أنه لا يتم استخدامها أبدًا لاسترجاع حرف، مما يساعد غالبًا في تجنب الحاجة إلى كتابة كود حول حالات الحافة.

انظر أيضًا codeunit، ncodeunits، thisind، nextind، prevind.

نوع AbstractChar هو النوع الفائق لجميع تطبيقات الأحرف في جوليا. تمثل الحرف نقطة رمز يونيكود، ويمكن تحويلها إلى عدد صحيح عبر دالة codepoint للحصول على القيمة العددية لنقطة الرمز، أو إنشاؤها من نفس العدد الصحيح. تحدد هذه القيم العددية كيفية مقارنة الأحرف باستخدام < و ==، على سبيل المثال. يجب أن تعرف الأنواع الجديدة T <: AbstractChar طريقة codepoint(::T) ومنشئ T(::UInt32)، على الأقل.

قد يكون نوع فرعي معين من AbstractChar قادرًا على تمثيل مجموعة فرعية فقط من يونيكود، وفي هذه الحالة قد يؤدي التحويل من قيمة UInt32 غير مدعومة إلى حدوث خطأ. على العكس، يمثل النوع المدمج Char مجموعة شاملة من يونيكود (من أجل ترميز تدفقات البايت غير الصالحة بدون فقدان)، وفي هذه الحالة يؤدي تحويل قيمة غير يونيكود إلى UInt32 إلى حدوث خطأ. يمكن استخدام دالة isvalid للتحقق من أي نقاط رموز يمكن تمثيلها في نوع AbstractChar معين.

داخليًا، قد يستخدم نوع AbstractChar مجموعة متنوعة من الترميزات. لن يكشف التحويل عبر codepoint(char) عن هذه الترميز لأنه دائمًا ما يعيد القيمة يونيكود للحرف. ينتج print(io, c) لأي c::AbstractChar ترميزًا تحدده io (UTF-8 لجميع أنواع IO المدمجة)، عبر التحويل إلى Char إذا لزم الأمر.

بالمقابل، قد يصدر write(io, c) ترميزًا يعتمد على typeof(c)، ويجب أن يقرأ read(io, typeof(c)) نفس الترميز مثل write. يجب أن توفر الأنواع الجديدة من AbstractChar تنفيذاتها الخاصة لـ write و read.

Char(c::Union{Number,AbstractChar})

Char هو نوع AbstractChar بحجم 32 بت وهو التمثيل الافتراضي للأحرف في جوليا. Char هو النوع المستخدم للأدبيات الحرفية مثل 'x' وهو أيضًا نوع العناصر في String.

من أجل تمثيل تدفقات البايت العشوائية المخزنة في String بدون فقدان، قد يخزن قيمة Char معلومات لا يمكن تحويلها إلى نقطة كود يونيكود — تحويل مثل هذا Char إلى UInt32 سيؤدي إلى حدوث خطأ. يمكن استخدام دالة isvalid(c::Char) للاستعلام عما إذا كان c يمثل حرف يونيكود صالح.

codepoint(c::AbstractChar) -> Integer

إرجاع نقطة الشيفرة Unicode (عدد صحيح غير موقع) المقابلة للحرف c (أو إلقاء استثناء إذا لم يمثل c حرفًا صالحًا). بالنسبة لـ Char، هذه قيمة UInt32، ولكن أنواع AbstractChar التي تمثل فقط مجموعة فرعية من Unicode قد تعيد عدد صحيح بحجم مختلف (مثل UInt8).

length(s::AbstractString) -> Int
length(s::AbstractString, i::Integer, j::Integer) -> Int

إرجاع عدد الأحرف في السلسلة s من الفهارس i إلى j.

يتم حساب ذلك كعدد فهارس وحدات الشيفرة من i إلى j التي هي فهارس أحرف صالحة. مع وجود وسيط سلسلة واحد فقط، يتم حساب عدد الأحرف في السلسلة بأكملها. مع وجود وسائط i و j، يتم حساب عدد الفهارس بين i و j شاملًا التي هي فهارس صالحة في السلسلة s. بالإضافة إلى القيم داخل الحدود، يمكن أن تأخذ i القيمة خارج الحدود ncodeunits(s) + 1 ويمكن أن تأخذ j القيمة خارج الحدود 0.

انظر أيضًا isvalid، ncodeunits، lastindex، thisind، nextind، prevind.

أمثلة

julia> length("jμΛIα")
5

sizeof(str::AbstractString)

حجم، بالبايت، من السلسلة str. يساوي عدد وحدات الشيفرة في str مضروبًا في حجم، بالبايت، لوحدة الشيفرة الواحدة في str.

أمثلة

julia> sizeof("")
0

julia> sizeof("∀")
3

*(s::Union{AbstractString, AbstractChar}, t::Union{AbstractString, AbstractChar}...) -> AbstractString

قم بدمج السلاسل النصية و/أو الأحرف، مما ينتج String أو AnnotatedString (حسب الاقتضاء). هذا يعادل استدعاء دالة string أو annotatedstring على المعطيات. دمج أنواع السلاسل النصية المدمجة دائمًا ينتج قيمة من نوع String ولكن قد تختار أنواع السلاسل النصية الأخرى إرجاع سلسلة من نوع مختلف حسب الاقتضاء.

أمثلة

julia> "Hello " * "world"
"Hello world"

julia> 'j' * "ulia"
"julia"

^(s::Union{AbstractString,AbstractChar}, n::Integer) -> AbstractString

كرر سلسلة أو حرف n مرات. يمكن أيضًا كتابة ذلك كـ repeat(s, n).

انظر أيضًا repeat.

أمثلة

julia> "Test "^3
"Test Test Test "

string(n::Integer; base::Integer = 10, pad::Integer = 1)

قم بتحويل عدد صحيح n إلى سلسلة نصية في base المعطى، مع إمكانية تحديد عدد الأرقام التي يجب أن يتم حشوها إليها.

انظر أيضًا digits, bitstring, count_zeros.

أمثلة

julia> string(5, base = 13, pad = 4)
"0005"

julia> string(-13, base = 5, pad = 4)
"-0023"

string(xs...)

إنشاء سلسلة من أي قيم باستخدام دالة print.

يجب عادةً عدم تعريف string مباشرة. بدلاً من ذلك، قم بتعريف طريقة print(io::IO, x::MyType). إذا كانت string(x) لنوع معين تحتاج إلى أن تكون فعالة للغاية، فقد يكون من المنطقي إضافة طريقة إلى string وتعريف print(io::IO, x::MyType) = print(io, string(x)) لضمان تناسق الدوال.

انظر أيضًا: String, repr, sprint, show.

أمثلة

julia> string("a", 1, true)
"a1true"

repeat(s::AbstractString, r::Integer)

كرر سلسلة r مرات. يمكن كتابة ذلك كـ s^r.

انظر أيضًا ^.

أمثلة

julia> repeat("ha", 3)
"hahaha"

repeat(c::AbstractChar, r::Integer) -> String

كرر حرفًا r مرات. يمكن تحقيق ذلك بشكل مكافئ عن طريق استدعاء c^r.

أمثلة

julia> repeat('A', 3)
"AAA"

repr(x; context=nothing)

قم بإنشاء سلسلة من أي قيمة باستخدام دالة show. يجب ألا تضيف طرقًا إلى repr؛ بدلاً من ذلك، قم بتعريف طريقة show.

يمكن تعيين الوسيطة الاختيارية context إلى زوج :key=>value، أو مجموعة من أزواج :key=>value، أو كائن IO أو IOContext الذي تُستخدم سماته لتدفق الإدخال/الإخراج الممرر إلى show.

لاحظ أن repr(x) عادةً ما يكون مشابهًا لكيفية إدخال قيمة x في جوليا. انظر أيضًا repr(MIME("text/plain"), x) لإرجاع نسخة "مُنسقة بشكل جميل" من x مصممة أكثر للاستهلاك البشري، مكافئة لعرض x في REPL.

أمثلة

julia> repr(1)
"1"

julia> repr(zeros(3))
"[0.0, 0.0, 0.0]"

julia> repr(big(1/3))
"0.333333333333333314829616256247390992939472198486328125"

julia> repr(big(1/3), context=:compact => true)
"0.333333"

String(s::AbstractString)

إنشاء String جديد من AbstractString موجود.

SubString(s::AbstractString, i::Integer, j::Integer=lastindex(s))
SubString(s::AbstractString, r::UnitRange{<:Integer})

مثل getindex، ولكن يعيد عرضًا في السلسلة الأصلية s ضمن النطاق i:j أو r على التوالي بدلاً من إنشاء نسخة.

تقوم الماكرو @views بتحويل أي شرائح نصية s[i:j] إلى سلاسل فرعية SubString(s, i, j) في كتلة من الشيفرة.

أمثلة

julia> SubString("abc", 1, 2)
"ab"

julia> SubString("abc", 1:2)
"ab"

julia> SubString("abc", 2)
"bc"

LazyString <: AbstractString

تمثيل كسول لتداخل السلاسل. هذا مفيد عندما يحتاج السلسلة إلى أن تُبنى في سياق حيث يكون إجراء التداخل الفعلي وبناء السلسلة غير ضروري أو غير مرغوب فيه (مثلًا في مسارات الأخطاء للدوال).

تم تصميم هذا النوع ليكون رخيصًا في البناء أثناء وقت التشغيل، محاولًا نقل أكبر قدر ممكن من العمل إلى إما الماكرو أو عمليات الطباعة اللاحقة.

أمثلة

julia> n = 5; str = LazyString("n is ", n)
"n is 5"

انظر أيضًا @lazy_str.

مساعدة موسعة

خصائص الأمان للبرامج المتزامنة

السلسلة الكسولة نفسها لا تقدم أي مشاكل تزامنية حتى لو تم طباعتها في مهام جوليا متعددة. ومع ذلك، إذا كانت طرق print على قيمة مُلتقطة يمكن أن تواجه مشكلة تزامنية عند استدعائها بدون تزامن، فإن طباعة السلسلة الكسولة قد تسبب مشكلة. علاوة على ذلك، قد يتم استدعاء طرق print على القيم الملتقطة عدة مرات، على الرغم من أنه سيتم إرجاع نتيجة واحدة فقط بالضبط.

lazy"str"

قم بإنشاء LazyString باستخدام بناء جملة تداخل السلاسل العادية. لاحظ أن التداخلات يتم تقييمها في وقت إنشاء LazyString، ولكن الطباعة تتأخر حتى الوصول الأول إلى السلسلة.

راجع وثائق LazyString لخصائص الأمان للبرامج المتزامنة.

أمثلة

julia> n = 5; str = lazy"n is $n"
"n is 5"

julia> typeof(str)
LazyString

transcode(T, src)

تحويل بيانات السلسلة بين ترميزات يونيكود. src إما أن تكون String أو Vector{UIntXX} من وحدات كود UTF-XX، حيث XX هو 8 أو 16 أو 32. T تشير إلى ترميز قيمة الإرجاع: String لإرجاع String (مشفرة بـ UTF-8) أو UIntXX لإرجاع Vector{UIntXX} من بيانات UTF-XX. (يمكن أيضًا استخدام الاسم المستعار Cwchar_t كنوع صحيح، لتحويل سلاسل wchar_t* المستخدمة من قبل مكتبات C الخارجية.)

تنجح دالة transcode طالما يمكن تمثيل بيانات الإدخال بشكل معقول في الترميز المستهدف؛ فهي تنجح دائمًا للتحويلات بين ترميزات UTF-XX، حتى بالنسبة لبيانات يونيكود غير الصالحة.

حاليًا، يتم دعم التحويل فقط من/إلى UTF-8.

أمثلة

julia> str = "αβγ"
"αβγ"

julia> transcode(UInt16, str)
3-element Vector{UInt16}:
 0x03b1
 0x03b2
 0x03b3

julia> transcode(String, transcode(UInt16, str))
"αβγ"

unsafe_string(p::Ptr{UInt8}, [length::Integer])

انسخ سلسلة من عنوان سلسلة بأسلوب C (منتهية بـ NUL) مشفرة بتنسيق UTF-8. (يمكن تحرير المؤشر بأمان بعد ذلك.) إذا تم تحديد length (طول البيانات بالبايت)، فلا يتعين أن تكون السلسلة منتهية بـ NUL.

تم تصنيف هذه الوظيفة على أنها "غير آمنة" لأنها ستنهار إذا لم يكن p عنوان ذاكرة صالحًا للبيانات بالطول المطلوب.

ncodeunits(s::AbstractString) -> Int

إرجاع عدد وحدات الشيفرة في سلسلة نصية. يجب أن تلبي الفهارس التي تكون ضمن الحدود للوصول إلى هذه السلسلة الشرط 1 ≤ i ≤ ncodeunits(s). ليست جميع هذه الفهارس صالحة - قد لا تكون بداية حرف، لكنها ستعيد قيمة وحدة شيفرة عند استدعاء codeunit(s,i).

أمثلة

julia> ncodeunits("The Julia Language")
18

julia> ncodeunits("∫eˣ")
6

julia> ncodeunits('∫'), ncodeunits('e'), ncodeunits('ˣ')
(3, 1, 2)

انظر أيضًا codeunit, checkbounds, sizeof, length, lastindex.

codeunit(s::AbstractString) -> Type{<:Union{UInt8, UInt16, UInt32}}

إرجاع نوع وحدة الشيفرة للكائن النصي المعطى. بالنسبة لسلاسل النصوص المشفرة بـ ASCII أو Latin-1 أو UTF-8، سيكون هذا UInt8؛ بالنسبة لـ UCS-2 وUTF-16 سيكون UInt16؛ بالنسبة لـ UTF-32 سيكون UInt32. لا يجب أن يقتصر نوع وحدة الشيفرة على هذه الأنواع الثلاثة، ولكن من الصعب التفكير في تشفيرات نصية مستخدمة على نطاق واسع لا تستخدم واحدة من هذه الوحدات. codeunit(s) هو نفسه typeof(codeunit(s,1)) عندما يكون s سلسلة نصية غير فارغة.

انظر أيضًا ncodeunits.

codeunit(s::AbstractString, i::Integer) -> Union{UInt8, UInt16, UInt32}

ارجع قيمة وحدة الشيفرة في السلسلة s عند الفهرس i. لاحظ أن

codeunit(s, i) :: codeunit(s)

أي أن القيمة المعادة بواسطة codeunit(s, i) هي من النوع المعاد بواسطة codeunit(s).

أمثلة

julia> a = codeunit("Hello", 2)
0x65

julia> typeof(a)
UInt8

انظر أيضًا ncodeunits، checkbounds.

codeunits(s::AbstractString)

احصل على كائن يشبه المتجه يحتوي على وحدات الشيفرة لسلسلة نصية. يُرجع غلاف CodeUnits بشكل افتراضي، ولكن يمكن تعريف codeunits اختياريًا لأنواع السلاسل النصية الجديدة إذا لزم الأمر.

أمثلة

julia> codeunits("Juλia")
6-element Base.CodeUnits{UInt8, String}:
 0x4a
 0x75
 0xce
 0xbb
 0x69
 0x61

ascii(s::AbstractString)

قم بتحويل سلسلة إلى نوع String وتحقق من أنها تحتوي فقط على بيانات ASCII، وإلا سيتم طرح ArgumentError تشير إلى موضع أول بايت غير ASCII.

انظر أيضًا إلى isascii predicate لتصفية أو استبدال الأحرف غير ASCII.

أمثلة

julia> ascii("abcdeγfgh")
ERROR: ArgumentError: invalid ASCII at index 6 in "abcdeγfgh"
Stacktrace:
[...]

julia> ascii("abcdefgh")
"abcdefgh"

Regex(pattern[, flags]) <: AbstractPattern

نوع يمثل تعبيرًا منتظمًا. يمكن استخدام كائنات Regex لمطابقة السلاسل باستخدام match.

يمكن إنشاء كائنات Regex باستخدام ماكرو السلسلة @r_str. عادةً ما يتم استخدام المُنشئ Regex(pattern[, flags]) إذا كان من الضروري إدخال سلسلة pattern. راجع وثائق ماكرو السلسلة للحصول على تفاصيل حول العلامات.

!!! ملاحظة للهروب من المتغيرات المدخلة، استخدم \Q و \E (على سبيل المثال Regex("\\Q$x\\E"))

@r_str -> Regex

قم بإنشاء تعبير عادي، مثل r"^[a-z]*$"، بدون التداخل وفك الهروب (باستثناء علامة الاقتباس " التي يجب أن تظل مهروسة). يقبل التعبير العادي أيضًا واحدًا أو أكثر من العلامات، المدرجة بعد الاقتباس النهائي، لتغيير سلوكه:

• i يمكّن المطابقة غير الحساسة لحالة الأحرف
• m يعامل الرموز ^ و $ كأنها تطابق بداية ونهاية الأسطر الفردية، بدلاً من السلسلة الكاملة.
• s يسمح لمعدل . بمطابقة الأسطر الجديدة.
• x يمكّن "وضع المسافات الحرة": يتم تجاهل المسافات البيضاء بين رموز التعبير العادي باستثناء عندما تكون مهروسة بـ \، و # في التعبير العادي يتم التعامل معها على أنها تبدأ تعليقًا (يتم تجاهله حتى نهاية السطر).
• a يمكّن وضع ASCII (يوقف وضع UTF و UCP). بشكل افتراضي، تطابق \B، \b، \D، \d، \S، \s، \W، \w، إلخ، بناءً على خصائص الأحرف Unicode. مع هذه الخيار، تطابق هذه التسلسلات فقط الأحرف ASCII. يشمل ذلك أيضًا \u، الذي سيصدر قيمة الحرف المحددة مباشرة كبايت واحد، وليس محاولة ترميزها إلى UTF-8. من المهم أن يسمح هذا الخيار بالمطابقة ضد سلاسل UTF-8 غير الصالحة، من خلال التعامل مع كل من المطابق والهدف كبايتات بسيطة (كما لو كانت بايتات ISO/IEC 8859-1 / Latin-1) بدلاً من ترميزات الأحرف. في هذه الحالة، غالبًا ما يتم دمج هذا الخيار مع s. يمكن تحسين هذا الخيار بشكل أكبر عن طريق بدء النمط بـ (UCP) أو (UTF).

انظر Regex إذا كانت هناك حاجة للتداخل.

أمثلة

julia> match(r"a+.*b+.*?d$"ism, "Goodbye,\nOh, angry,\nBad world\n")
RegexMatch("angry,\nBad world")

هذا التعبير العادي لديه أول ثلاث علامات مفعلة.

SubstitutionString(substr) <: AbstractString

يخزن السلسلة المعطاة substr كـ SubstitutionString، لاستخدامها في استبدالات التعبيرات العادية. يتم إنشاؤها بشكل شائع باستخدام الماكرو @s_str.

أمثلة

julia> SubstitutionString("Hello \\g<name>, it's \\1")
s"Hello \g<name>, it's \1"

julia> subst = s"Hello \g<name>, it's \1"
s"Hello \g<name>, it's \1"

julia> typeof(subst)
SubstitutionString{String}

@s_str -> SubstitutionString

قم بإنشاء سلسلة استبدال، تُستخدم لاستبدالات التعبيرات العادية. داخل السلسلة، تشير التسلسلات بالشكل \N إلى مجموعة الالتقاط N في التعبير العادي، و \g<groupname> تشير إلى مجموعة الالتقاط المسماة بالاسم groupname.

أمثلة

julia> msg = "#Hello# from Julia";

julia> replace(msg, r"#(.+)# from (?<from>\w+)" => s"FROM: \g<from>; MESSAGE: \1")
"FROM: Julia; MESSAGE: Hello"

@raw_str -> String

أنشئ سلسلة نصية خام بدون استبدال أو فك تشفير. الاستثناء هو أنه يجب الهروب من علامات الاقتباس. تقوم الشرطات العكسية بهروب كل من علامات الاقتباس والشرطات العكسية الأخرى، ولكن فقط عندما تسبق سلسلة من الشرطات العكسية حرف اقتباس. وبالتالي، فإن 2n من الشرطات العكسية متبوعة باقتباس ترمز إلى n من الشرطات العكسية ونهاية النص، بينما 2n+1 من الشرطات العكسية متبوعة باقتباس ترمز إلى n من الشرطات العكسية متبوعة بحرف اقتباس.

أمثلة

julia> println(raw"\ $x")
\ $x

julia> println(raw"\"")
"

julia> println(raw"\\\"")
\"

julia> println(raw"\\x \\\"")
\\x \"

@b_str

إنشاء متجه بايت غير قابل للتغيير (UInt8) باستخدام بناء جملة السلسلة.

أمثلة

julia> v = b"12\x01\x02"
4-element Base.CodeUnits{UInt8, String}:
 0x31
 0x32
 0x01
 0x02

julia> v[2]
0x32

@html_str -> Docs.HTML

إنشاء كائن HTML من سلسلة حرفية.

أمثلة

julia> html"Julia"
HTML{String}("Julia")

@text_str -> Docs.Text

إنشاء كائن Text من سلسلة حرفية.

أمثلة

julia> text"Julia"
Julia

isvalid(value) -> Bool

ارجع true إذا كانت القيمة المعطاة صالحة لنوعها، والذي يمكن أن يكون حاليًا إما AbstractChar أو String أو SubString{String}.

أمثلة

julia> isvalid(Char(0xd800))
false

julia> isvalid(SubString(String(UInt8[0xfe,0x80,0x80,0x80,0x80,0x80]),1,2))
false

julia> isvalid(Char(0xd799))
true

isvalid(T, value) -> Bool

ارجع true إذا كانت القيمة المعطاة صالحة لهذا النوع. الأنواع الحالية يمكن أن تكون إما AbstractChar أو String. القيم لـ AbstractChar يمكن أن تكون من نوع AbstractChar أو UInt32. القيم لـ String يمكن أن تكون من ذلك النوع، SubString{String}، Vector{UInt8}، أو مصفوفة فرعية متجاورة منها.

أمثلة

julia> isvalid(Char, 0xd800)
false

julia> isvalid(String, SubString("thisisvalid",1,5))
true

julia> isvalid(Char, 0xd799)
true

isvalid(s::AbstractString, i::Integer) -> Bool

دالة تشير إلى ما إذا كان الفهرس المعطى هو بداية ترميز حرف في s أم لا. إذا كانت isvalid(s, i) صحيحة، فإن s[i] ستعيد الحرف الذي يبدأ ترميزه عند ذلك الفهرس، وإذا كانت خاطئة، فإن s[i] ستثير خطأ فهرس غير صالح أو خطأ حدودي اعتمادًا على ما إذا كان i ضمن الحدود. لكي تكون isvalid(s, i) دالة O(1)، يجب أن يكون ترميز s ذاتي التزامن. هذه فرضية أساسية لدعم السلاسل العامة في جوليا.

انظر أيضًا getindex، iterate، thisind، nextind، prevind، length.

أمثلة

julia> str = "αβγdef";

julia> isvalid(str, 1)
true

julia> str[1]
'α': Unicode U+03B1 (الفئة Ll: حرف، صغير)

julia> isvalid(str, 2)
false

julia> str[2]
ERROR: StringIndexError: invalid index [2], valid nearby indices [1]=>'α', [3]=>'β'
Stacktrace:
[...]

match(r::Regex, s::AbstractString[, idx::Integer[, addopts]])

ابحث عن أول تطابق للتعبير العادي r في s وأعد كائن RegexMatch يحتوي على التطابق، أو لا شيء إذا فشل التطابق. يمكن استرداد السلسلة الفرعية المتطابقة عن طريق الوصول إلى m.match ويمكن استرداد التسلسلات الملتقطة عن طريق الوصول إلى m.captures تشير الوسيطة الاختيارية idx إلى فهرس يجب أن تبدأ منه عملية البحث.

أمثلة

julia> rx = r"a(.)a"
r"a(.)a"

julia> m = match(rx, "cabac")
RegexMatch("aba", 1="b")

julia> m.captures
1-element Vector{Union{Nothing, SubString{String}}}:
 "b"

julia> m.match
"aba"

julia> match(rx, "cabac", 3) === nothing
true

eachmatch(r::Regex, s::AbstractString; overlap::Bool=false)

ابحث عن جميع المطابقات للتعبير العادي r في s وأعد مُكرِّرًا للمطابقات. إذا كان overlap هو true، يُسمح بتداخل التسلسلات المطابقة في الفهارس في السلسلة الأصلية، وإلا يجب أن تكون من نطاقات أحرف متميزة.

أمثلة

julia> rx = r"a.a"
r"a.a"

julia> m = eachmatch(rx, "a1a2a3a")
Base.RegexMatchIterator{String}(r"a.a", "a1a2a3a", false)

julia> collect(m)
2-element Vector{RegexMatch}:
 RegexMatch("a1a")
 RegexMatch("a3a")

julia> collect(eachmatch(rx, "a1a2a3a", overlap = true))
3-element Vector{RegexMatch}:
 RegexMatch("a1a")
 RegexMatch("a2a")
 RegexMatch("a3a")

RegexMatch <: AbstractMatch

نوع يمثل تطابقًا واحدًا لـ Regex تم العثور عليه في سلسلة نصية. يتم إنشاؤه عادةً من دالة match.

يخزن حقل match الجزء الفرعي من السلسلة المطابقة بالكامل. يخزن حقل captures الأجزاء الفرعية لكل مجموعة التقاط، مفهرسة حسب الرقم. لفهرسة بواسطة اسم مجموعة الالتقاط، يجب فهرسة كائن المطابقة بالكامل بدلاً من ذلك، كما هو موضح في الأمثلة. يتم تخزين موقع بداية المطابقة في حقل offset. يخزن حقل offsets مواقع بداية كل مجموعة التقاط، مع 0 تشير إلى مجموعة لم يتم التقاطها.

يمكن استخدام هذا النوع كحلقة تكرارية على مجموعات الالتقاط لـ Regex، مما ينتج عنه الأجزاء الفرعية الملتقطة في كل مجموعة. بسبب ذلك، يمكن تفكيك التقاطات المطابقة. إذا لم يتم التقاط مجموعة، سيتم إرجاع nothing بدلاً من جزء فرعي.

تم تعريف طرق تقبل كائن RegexMatch لـ iterate، length، eltype، keys، haskey، و getindex، حيث تكون المفاتيح هي أسماء أو أرقام مجموعة الالتقاط. راجع keys لمزيد من المعلومات.

أمثلة

julia> m = match(r"(?<hour>\d+):(?<minute>\d+)(am|pm)?", "11:30 in the morning")
RegexMatch("11:30", hour="11", minute="30", 3=nothing)

julia> m.match
"11:30"

julia> m.captures
3-element Vector{Union{Nothing, SubString{String}}}:
 "11"
 "30"
 nothing


julia> m["minute"]
"30"

julia> hr, min, ampm = m; # تفكيك مجموعات الالتقاط بواسطة التكرار

julia> hr
"11"

keys(m::RegexMatch) -> Vector

إرجاع متجه من المفاتيح لجميع مجموعات الالتقاط من التعبير العادي الأساسي. يتم تضمين المفتاح حتى إذا فشلت مجموعة الالتقاط في المطابقة. أي أن idx سيكون في قيمة الإرجاع حتى إذا كان m[idx] == nothing.

ستكون لمجموعات الالتقاط غير المسماة مفاتيح عددية تتوافق مع فهرسها. بينما ستكون لمجموعات الالتقاط المسماة مفاتيح نصية.

أمثلة

julia> keys(match(r"(?<hour>\d+):(?<minute>\d+)(am|pm)?", "11:30"))
3-element Vector{Any}:
  "hour"
  "minute"
 3

isless(a::AbstractString, b::AbstractString) -> Bool

اختبر ما إذا كانت السلسلة a تأتي قبل السلسلة b في الترتيب الأبجدي (تقنيًا، في الترتيب المعجمي حسب نقاط الشيفرة Unicode).

أمثلة

julia> isless("a", "b")
true

julia> isless("β", "α")
false

julia> isless("a", "a")
false

==(a::AbstractString, b::AbstractString) -> Bool

اختبر ما إذا كانت سلسلتان متساويتين حرفًا بحرف (تقنيًا، نقطة رمز Unicode بنقطة رمز Unicode). إذا كانت أي من السلسلتين AnnotatedString يجب أن تتطابق خصائص السلسلة أيضًا.

أمثلة

julia> "abc" == "abc"
true

julia> "abc" == "αβγ"
false

cmp(a::AbstractString, b::AbstractString) -> Int

قارن بين سلسلتين. أعد 0 إذا كانت السلسلتان لهما نفس الطول وكان الحرف في كل فهرس هو نفسه في كلا السلسلتين. أعد -1 إذا كانت a بادئة لـ b، أو إذا كانت a تأتي قبل b في الترتيب الأبجدي. أعد 1 إذا كانت b بادئة لـ a، أو إذا كانت b تأتي قبل a في الترتيب الأبجدي (تقنيًا، الترتيب المعجمي حسب نقاط الشيفرة Unicode).

أمثلة

julia> cmp("abc", "abc")
0

julia> cmp("ab", "abc")
-1

julia> cmp("abc", "ab")
1

julia> cmp("ab", "ac")
-1

julia> cmp("ac", "ab")
1

julia> cmp("α", "a")
1

julia> cmp("b", "β")
-1

lpad(s, n::Integer, p::Union{AbstractChar,AbstractString}=' ') -> String

حوّل s إلى سلسلة وأضف الحشو على اليسار باستخدام p لجعلها بطول n حرفًا (في textwidth). إذا كانت s بالفعل بطول n حرفًا، يتم إرجاع سلسلة متساوية. يتم الحشو بالمسافات بشكل افتراضي.

أمثلة

julia> lpad("March", 10)
"     March"

rpad(s, n::Integer, p::Union{AbstractChar,AbstractString}=' ') -> String

قم بتحويل s إلى سلسلة وأضف الحشو على اليمين باستخدام p لجعلها بطول n حرفًا (في textwidth). إذا كانت s بالفعل بطول n حرفًا، يتم إرجاع سلسلة متساوية. يتم الحشو بالمسافات بشكل افتراضي.

أمثلة

julia> rpad("March", 20)
"March               "

findfirst(pattern::AbstractString, string::AbstractString)
findfirst(pattern::AbstractPattern, string::String)

ابحث عن أول ظهور لـ pattern في string. يعادل findnext(pattern, string, firstindex(s)).

أمثلة

julia> findfirst("z", "Hello to the world") # لا يُرجع شيئًا، ولكن لا يُطبع في REPL

julia> findfirst("Julia", "JuliaLang")
1:5

findnext(pattern::AbstractString, string::AbstractString, start::Integer)
findnext(pattern::AbstractPattern, string::String, start::Integer)

ابحث عن occurrence التالية لـ pattern في string بدءًا من الموضع start. يمكن أن يكون pattern إما سلسلة نصية، أو تعبيرًا منتظمًا، وفي هذه الحالة يجب أن يكون string من نوع String.

قيمة الإرجاع هي نطاق من الفهارس حيث يتم العثور على تسلسل المطابقة، بحيث s[findnext(x, s, i)] == x:

findnext("substring", string, i) == start:stop بحيث string[start:stop] == "substring" و i <= start، أو nothing إذا لم يتم المطابقة.

أمثلة

julia> findnext("z", "Hello to the world", 1) === nothing
true

julia> findnext("o", "Hello to the world", 6)
8:8

julia> findnext("Lang", "JuliaLang", 2)
6:9

findnext(ch::AbstractChar, string::AbstractString, start::Integer)

ابحث عن occurrence التالية للحرف ch في string بدءًا من الموضع start.

أمثلة

julia> findnext('z', "Hello to the world", 1) === nothing
true

julia> findnext('o', "Hello to the world", 6)
8

findlast(pattern::AbstractString, string::AbstractString)

ابحث عن آخر ظهور لـ pattern في string. يعادل findprev(pattern, string, lastindex(string)).

أمثلة

julia> findlast("o", "Hello to the world")
15:15

julia> findfirst("Julia", "JuliaLang")
1:5

findlast(ch::AbstractChar, string::AbstractString)

ابحث عن آخر ظهور للحرف ch في string.

أمثلة

julia> findlast('p', "happy")
4

julia> findlast('z', "happy") === nothing
true

findprev(pattern::AbstractString, string::AbstractString, start::Integer)

ابحث عن الظهور السابق لـ pattern في string بدءًا من الموضع start.

قيمة الإرجاع هي نطاق من الفهارس حيث يتم العثور على تسلسل المطابقة، بحيث s[findprev(x, s, i)] == x:

findprev("substring", string, i) == start:stop بحيث string[start:stop] == "substring" و stop <= i، أو nothing إذا لم يتم المطابقة.

أمثلة

julia> findprev("z", "Hello to the world", 18) === nothing
true

julia> findprev("o", "Hello to the world", 18)
15:15

julia> findprev("Julia", "JuliaLang", 6)
1:5

occursin(needle::Union{AbstractString,AbstractPattern,AbstractChar}, haystack::AbstractString)

حدد ما إذا كان الوسيط الأول هو سلسلة فرعية من الوسيط الثاني. إذا كان needle تعبيرًا منتظمًا، تحقق مما إذا كان haystack يحتوي على تطابق.

أمثلة

julia> occursin("Julia", "JuliaLang is pretty cool!")
true

julia> occursin('a', "JuliaLang is pretty cool!")
true

julia> occursin(r"a.a", "aba")
true

julia> occursin(r"a.a", "abba")
false

انظر أيضًا contains.

occursin(haystack)

أنشئ دالة تتحقق مما إذا كان وسيطها موجودًا في haystack، أي دالة تعادل needle -> occursin(needle, haystack).

الدالة المعادة من النوع Base.Fix2{typeof(occursin)}.

أمثلة

julia> search_f = occursin("JuliaLang is a programming language");

julia> search_f("JuliaLang")
true

julia> search_f("Python")
false

reverse(s::AbstractString) -> AbstractString

يعكس سلسلة نصية. تقنيًا، تقوم هذه الدالة بعكس نقاط الشيفرة في سلسلة نصية، وفائدتها الرئيسية هي معالجة السلاسل النصية بترتيب عكسي، خاصةً للبحث باستخدام التعبيرات العادية العكسية. انظر أيضًا reverseind لتحويل الفهارس في s إلى فهارس في reverse(s) والعكس، وgraphemes من الوحدة Unicode للعمل على "الحروف" المرئية للمستخدم (الحروف الرسومية) بدلاً من نقاط الشيفرة. انظر أيضًا Iterators.reverse للتكرار بترتيب عكسي دون إنشاء نسخة. يجب على أنواع السلاسل النصية المخصصة تنفيذ دالة reverse بأنفسهم ويجب أن تعيد عادةً سلسلة نصية بنفس النوع والترميز. إذا أعادوا سلسلة نصية بترميز مختلف، يجب عليهم أيضًا تجاوز reverseind لهذا النوع من السلاسل النصية لتلبية s[reverseind(s,i)] == reverse(s)[i].

أمثلة

julia> reverse("JuliaLang")
"gnaLailuJ"

!!! ملاحظة قد يتم عرض الأمثلة أدناه بشكل مختلف على أنظمة مختلفة. تشير التعليقات إلى كيفية عرضها

يمكن أن تؤدي الحروف المركبة إلى نتائج مفاجئة:

julia> reverse("ax̂e") # القبعة فوق x في المدخل، وفوق e في المخرج
"êxa"

julia> using Unicode

julia> join(reverse(collect(graphemes("ax̂e")))) # يعكس الحروف الرسومية؛ القبعة فوق x في كل من المدخل والمخرج
"ex̂a"

replace([io::IO], s::AbstractString, pat=>r, [pat2=>r2, ...]; [count::Integer])

ابحث عن النمط المعطى pat في s، واستبدل كل ظهور بـ r. إذا تم توفير count، استبدل في أقصى حد count من الظهورات. قد يكون pat حرفًا واحدًا، أو متجهًا أو مجموعة من الأحرف، أو سلسلة، أو تعبيرًا منتظمًا. إذا كان r دالة، يتم استبدال كل ظهور بـ r(s) حيث s هو السلسلة الفرعية المطابقة (عندما يكون pat هو AbstractPattern أو AbstractString) أو الحرف (عندما يكون pat هو AbstractChar أو مجموعة من AbstractChar). إذا كان pat تعبيرًا منتظمًا و r هو SubstitutionString، فإن مراجع مجموعة الالتقاط في r يتم استبدالها بالنص المطابق المقابل. لإزالة حالات pat من string، قم بتعيين r إلى String فارغ ("").

قيمة الإرجاع هي سلسلة جديدة بعد الاستبدالات. إذا تم توفير وسيط io::IO، يتم كتابة السلسلة المحولة بدلاً من ذلك إلى io (مع إرجاع io). (على سبيل المثال، يمكن استخدام ذلك بالتزامن مع IOBuffer لإعادة استخدام مصفوفة ذاكرة مؤهلة مسبقًا في المكان).

يمكن تحديد أنماط متعددة، وسيتم تطبيقها من اليسار إلى اليمين في وقت واحد، لذا سيتم تطبيق نمط واحد فقط على أي حرف، ولن يتم تطبيق الأنماط إلا على النص المدخل، وليس على الاستبدالات.

أمثلة

julia> replace("Python is a programming language.", "Python" => "Julia")
"Julia is a programming language."

julia> replace("The quick foxes run quickly.", "quick" => "slow", count=1)
"The slow foxes run quickly."

julia> replace("The quick foxes run quickly.", "quick" => "", count=1)
"The  foxes run quickly."

julia> replace("The quick foxes run quickly.", r"fox(es)?" => s"bus\1")
"The quick buses run quickly."

julia> replace("abcabc", "a" => "b", "b" => "c", r".+" => "a")
"bca"

eachsplit(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
eachsplit(str::AbstractString; limit::Integer=0, keepempty::Bool=false)

قسّم str على حدوثات الفاصل (الفواصل) dlm وأرجع مُكرّرًا على السلاسل الفرعية. يمكن أن يكون dlm أي من التنسيقات المسموح بها من قبل findnext كأول حجة (أي كـ سلسلة، تعبير منتظم أو دالة)، أو كحرف واحد أو مجموعة من الحروف.

إذا تم حذف dlm، فإنه يت default إلى isspace.

تكون الوسائط الاختيارية كما يلي:

• limit: الحجم الأقصى للنتيجة. limit=0 تعني عدم وجود حد أقصى (افتراضي)
• keepempty: ما إذا كان يجب الاحتفاظ بالحقول الفارغة في النتيجة. الافتراضي هو false بدون حجة dlm، و true مع حجة dlm.

انظر أيضًا split.

أمثلة

julia> a = "Ma.rch"
"Ma.rch"

julia> b = eachsplit(a, ".")
Base.SplitIterator{String, String}("Ma.rch", ".", 0, true)

julia> collect(b)
2-element Vector{SubString{String}}:
 "Ma"
 "rch"

eachrsplit(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
eachrsplit(str::AbstractString; limit::Integer=0, keepempty::Bool=false)

إرجاع مُكرِّر على SubStrings من str، يتم إنتاجه عند تقسيمه على الفاصل (الفواصل) dlm، ويتم إرجاعه بترتيب عكسي (من اليمين إلى اليسار). يمكن أن يكون dlm أي من التنسيقات المسموح بها من قبل findprev كأول حجة (أي سلسلة، حرف واحد أو دالة)، أو مجموعة من الأحرف.

إذا تم حذف dlm، فإنه يت default إلى isspace، و keepempty يت default إلى false.

تكون الوسائط الاختيارية كما يلي:

• إذا كان limit > 0، فإن المُكرِّر سيقسم على الأكثر limit - 1 مرات قبل إرجاع بقية السلسلة دون تقسيم. limit < 1 يعني عدم وجود حد للتقسيمات (افتراضي).
• keepempty: ما إذا كان يجب إرجاع الحقول الفارغة عند التكرار. الافتراضي هو false بدون حجة dlm، و true مع حجة dlm.

لاحظ أنه على عكس split، rsplit و eachsplit، هذه الدالة تتكرر على السلاسل الفرعية من اليمين إلى اليسار كما تحدث في الإدخال.

انظر أيضًا eachsplit، rsplit.

أمثلة

julia> a = "Ma.r.ch";

julia> collect(eachrsplit(a, ".")) == ["ch", "r", "Ma"]
true

julia> collect(eachrsplit(a, "."; limit=2)) == ["ch", "Ma.r"]
true

split(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
split(str::AbstractString; limit::Integer=0, keepempty::Bool=false)

قسّم str إلى مصفوفة من السلاسل الفرعية عند حدوث الفاصل (الفواصل) dlm. يمكن أن يكون dlm أي من التنسيقات المسموح بها من قبل findnext كأول وسيط (أي كـ سلسلة، تعبير منتظم أو دالة)، أو كحرف واحد أو مجموعة من الحروف.

إذا تم حذف dlm، فإنه يت default إلى isspace.

الوسائط الاختيارية هي:

• limit: الحجم الأقصى للنتيجة. limit=0 تعني عدم وجود حد أقصى (افتراضي)
• keepempty: ما إذا كان يجب الاحتفاظ بالحقول الفارغة في النتيجة. الافتراضي هو false بدون وسيط dlm، و true مع وسيط dlm.

انظر أيضًا rsplit، eachsplit.

أمثلة

julia> a = "Ma.rch"
"Ma.rch"

julia> split(a, ".")
2-element Vector{SubString{String}}:
 "Ma"
 "rch"

rsplit(s::AbstractString; limit::Integer=0, keepempty::Bool=false)
rsplit(s::AbstractString, chars; limit::Integer=0, keepempty::Bool=true)

مشابه لـ split، ولكن بدءًا من نهاية السلسلة.

أمثلة

julia> a = "M.a.r.c.h"
"M.a.r.c.h"

julia> rsplit(a, ".")
5-element Vector{SubString{String}}:
 "M"
 "a"
 "r"
 "c"
 "h"

julia> rsplit(a, "."; limit=1)
1-element Vector{SubString{String}}:
 "M.a.r.c.h"

julia> rsplit(a, "."; limit=2)
2-element Vector{SubString{String}}:
 "M.a.r.c"
 "h"

strip([pred=isspace,] str::AbstractString) -> SubString
strip(str::AbstractString, chars) -> SubString

قم بإزالة الأحرف الزائدة من البداية والنهاية من str، إما تلك المحددة بواسطة chars أو تلك التي تعيد الدالة pred القيمة true.

السلوك الافتراضي هو إزالة المسافات البيضاء والفواصل الزائدة من البداية والنهاية: انظر isspace للحصول على تفاصيل دقيقة.

الحجة الاختيارية chars تحدد أي الأحرف يجب إزالتها: يمكن أن تكون حرفًا واحدًا، أو متجهًا، أو مجموعة من الأحرف.

انظر أيضًا lstrip و rstrip.

أمثلة

julia> strip("{3, 5}\n", ['{', '}', '\n'])
"3, 5"

lstrip([pred=isspace,] str::AbstractString) -> SubString
lstrip(str::AbstractString, chars) -> SubString

قم بإزالة الأحرف الزائدة من str، إما تلك المحددة بواسطة chars أو تلك التي تعيد الدالة pred القيمة true.

السلوك الافتراضي هو إزالة الفراغات الزائدة والفواصل: انظر isspace للحصول على تفاصيل دقيقة.

تحدد الوسيطة الاختيارية chars الأحرف التي يجب إزالتها: يمكن أن تكون حرفًا واحدًا، أو متجهًا أو مجموعة من الأحرف.

انظر أيضًا strip و rstrip.

أمثلة

julia> a = lpad("March", 20)
"               March"

julia> lstrip(a)
"March"

rstrip([pred=isspace,] str::AbstractString) -> SubString
rstrip(str::AbstractString, chars) -> SubString

قم بإزالة الأحرف الزائدة من str، إما تلك المحددة بواسطة chars أو تلك التي تعيد الدالة pred القيمة true.

السلوك الافتراضي هو إزالة الفراغات الزائدة والفواصل: انظر isspace للحصول على تفاصيل دقيقة.

الحجة الاختيارية chars تحدد الأحرف التي يجب إزالتها: يمكن أن تكون حرفًا واحدًا، أو متجهًا أو مجموعة من الأحرف.

انظر أيضًا strip و lstrip.

أمثلة

julia> a = rpad("March", 20)
"March               "

julia> rstrip(a)
"March"

startswith(s::AbstractString, prefix::Union{AbstractString,Base.Chars})

ارجع true إذا كانت s تبدأ بـ prefix، والتي يمكن أن تكون سلسلة، أو حرف، أو مجموعة/مصفوفة/مجموعة من الحروف. إذا كانت prefix مجموعة/مصفوفة/مجموعة من الحروف، اختبر ما إذا كان الحرف الأول من s ينتمي إلى تلك المجموعة.

انظر أيضًا endswith، contains.

أمثلة

julia> startswith("JuliaLang", "Julia")
true

startswith(io::IO, prefix::Union{AbstractString,Base.Chars})

تحقق مما إذا كان كائن IO يبدأ بمقدمة، والتي يمكن أن تكون إما سلسلة، أو حرف، أو مجموعة/مصفوفة/مجموعة من الحروف. انظر أيضًا peek.

startswith(prefix)

أنشئ دالة تتحقق مما إذا كان وسيطها يبدأ بـ prefix، أي دالة تعادل y -> startswith(y, prefix).

الدالة المعادة هي من النوع Base.Fix2{typeof(startswith)}، والتي يمكن استخدامها لتنفيذ طرق متخصصة.

أمثلة

julia> startswith("Julia")("JuliaLang")
true

julia> startswith("Julia")("Ends with Julia")
false

startswith(s::AbstractString, prefix::Regex)

ارجع true إذا كانت s تبدأ بنمط التعبير العادي، prefix.

!!! ملاحظة startswith لا يقوم بتجميع التثبيت في التعبير العادي، بل يمرر التثبيت كـ match_option إلى PCRE. إذا كان وقت التجميع موزعًا، فإن occursin(r"^...", s) أسرع من startswith(s, r"...").

انظر أيضًا occursin و endswith.

!!! توافق "جوليا 1.2" هذه الطريقة تتطلب على الأقل جوليا 1.2.

أمثلة

julia> startswith("JuliaLang", r"Julia|Romeo")
true

endswith(s::AbstractString, suffix::Union{AbstractString,Base.Chars})

ارجع true إذا كانت s تنتهي بـ suffix، والتي يمكن أن تكون سلسلة، أو حرف، أو مجموعة/مصفوفة من الحروف. إذا كانت suffix مجموعة/مصفوفة من الحروف، تحقق مما إذا كان آخر حرف من s ينتمي إلى تلك المجموعة.

انظر أيضًا startswith، contains.

أمثلة

julia> endswith("Sunday", "day")
true

endswith(suffix)

أنشئ دالة تتحقق مما إذا كانت حجتها تنتهي بـ suffix، أي دالة تعادل y -> endswith(y, suffix).

الدالة المعادة هي من النوع Base.Fix2{typeof(endswith)}، والتي يمكن استخدامها لتنفيذ طرق متخصصة.

أمثلة

julia> endswith("Julia")("Ends with Julia")
true

julia> endswith("Julia")("JuliaLang")
false

endswith(s::AbstractString, suffix::Regex)

ارجع true إذا كانت s تنتهي بنمط التعبير العادي، suffix.

!!! ملاحظة endswith لا يقوم بتجميع التثبيت في التعبير العادي، بل يمرر التثبيت كـ match_option إلى PCRE. إذا كان وقت التجميع موزعًا، فإن occursin(r"...$", s) أسرع من endswith(s, r"...").

انظر أيضًا occursin و startswith.

!!! توافق "جوليا 1.2" هذه الطريقة تتطلب على الأقل جوليا 1.2.

أمثلة

julia> endswith("JuliaLang", r"Lang|Roberts")
true

contains(haystack::AbstractString, needle)

Return true if haystack contains needle. This is the same as occursin(needle, haystack), but is provided for consistency with startswith(haystack, needle) and endswith(haystack, needle).

See also occursin, in, issubset.

أمثلة

julia> contains("JuliaLang is pretty cool!", "Julia")
true

julia> contains("JuliaLang is pretty cool!", 'a')
true

julia> contains("aba", r"a.a")
true

julia> contains("abba", r"a.a")
false

contains(needle)

أنشئ دالة تتحقق مما إذا كان وسيطها يحتوي على needle، أي دالة تعادل haystack -> contains(haystack, needle).

الدالة المعادة هي من النوع Base.Fix2{typeof(contains)}، والتي يمكن استخدامها لتنفيذ طرق متخصصة.

first(s::AbstractString, n::Integer)

احصل على سلسلة تتكون من أول n حرف من s.

أمثلة

julia> first("∀ϵ≠0: ϵ²>0", 0)
""

julia> first("∀ϵ≠0: ϵ²>0", 1)
"∀"

julia> first("∀ϵ≠0: ϵ²>0", 3)
"∀ϵ≠"

last(s::AbstractString, n::Integer)

احصل على سلسلة تتكون من آخر n حرف من s.

أمثلة

julia> last("∀ϵ≠0: ϵ²>0", 0)
""

julia> last("∀ϵ≠0: ϵ²>0", 1)
"0"

julia> last("∀ϵ≠0: ϵ²>0", 3)
"²>0"

uppercase(c::AbstractChar)

قم بتحويل c إلى أحرف كبيرة.

انظر أيضًا lowercase، titlecase.

أمثلة

julia> uppercase('a')
'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase)

julia> uppercase('ê')
'Ê': Unicode U+00CA (category Lu: Letter, uppercase)

uppercase(s::AbstractString)

إرجاع s مع تحويل جميع الأحرف إلى أحرف كبيرة.

انظر أيضًا lowercase, titlecase, uppercasefirst.

أمثلة

julia> uppercase("Julia")
"JULIA"

lowercase(c::AbstractChar)

قم بتحويل c إلى أحرف صغيرة.

انظر أيضًا uppercase، titlecase.

أمثلة

julia> lowercase('A')
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> lowercase('Ö')
'ö': Unicode U+00F6 (category Ll: Letter, lowercase)

lowercase(s::AbstractString)

إرجاع s مع تحويل جميع الأحرف إلى أحرف صغيرة.

انظر أيضًا uppercase، titlecase، lowercasefirst.

أمثلة

julia> lowercase("STRINGS AND THINGS")
"strings and things"

titlecase(c::AbstractChar)

قم بتحويل c إلى حالة العنوان. قد يختلف هذا عن الحالة العليا للأزواج، قارن المثال أدناه.

انظر أيضًا uppercase، lowercase.

أمثلة

julia> titlecase('a')
'A': ASCII/Unicode U+0041 (الفئة Lu: حرف، حالة عليا)

julia> titlecase('dž')
'Dž': Unicode U+01C5 (الفئة Lt: حرف، حالة عنوان)

julia> uppercase('dž')
'DŽ': Unicode U+01C4 (الفئة Lu: حرف، حالة عليا)

titlecase(s::AbstractString; [wordsep::Function], strict::Bool=true) -> String

قم بتحويل الحرف الأول من كل كلمة في s إلى حرف كبير؛ إذا كان strict صحيحًا، يتم تحويل كل حرف آخر إلى حرف صغير، وإلا تُترك كما هي. بشكل افتراضي، تُعتبر جميع الأحرف غير الحروف التي تبدأ جرافيم جديدة كفواصل كلمات؛ يمكن تمرير دالة ككلمة رئيسية wordsep لتحديد أي الأحرف يجب اعتبارها كفواصل كلمات. انظر أيضًا uppercasefirst لتحويل الحرف الأول فقط في s إلى حرف كبير.

انظر أيضًا uppercase، lowercase، uppercasefirst.

أمثلة

julia> titlecase("the JULIA programming language")
"The Julia Programming Language"

julia> titlecase("ISS - international space station", strict=false)
"ISS - International Space Station"

julia> titlecase("a-a b-b", wordsep = c->c==' ')
"A-a B-b"

uppercasefirst(s::AbstractString) -> String

إرجاع s مع تحويل الحرف الأول إلى حرف كبير (تقنيًا "حالة العنوان" لـ Unicode). انظر أيضًا titlecase لتكبير الحرف الأول من كل كلمة في s.

انظر أيضًا lowercasefirst، uppercase، lowercase، titlecase.

أمثلة

julia> uppercasefirst("python")
"Python"

lowercasefirst(s::AbstractString)

إرجاع s مع تحويل الحرف الأول إلى حرف صغير.

انظر أيضًا uppercasefirst, uppercase, lowercase, titlecase.

أمثلة

julia> lowercasefirst("Julia")
"julia"

join([io::IO,] iterator [, delim [, last]])

اجمع أي iterator في سلسلة واحدة، مع إدراج الفاصل المحدد (إن وجد) بين العناصر المتجاورة. إذا تم إعطاء last، فسيتم استخدامه بدلاً من delim بين العنصرين الأخيرين. يتم تحويل كل عنصر من iterator إلى سلسلة عبر print(io::IOBuffer, x). إذا تم إعطاء io، فسيتم كتابة النتيجة إلى io بدلاً من إرجاعها كسلسلة String.

أمثلة

julia> join(["apples", "bananas", "pineapples"], ", ", " and ")
"apples, bananas and pineapples"

julia> join([1,2,3,4,5])
"12345"

chop(s::AbstractString; head::Integer = 0, tail::Integer = 1)

قم بإزالة أول head وآخر tail من الأحرف من s. تستدعي الدالة chop(s) لإزالة آخر حرف من s. إذا تم طلب إزالة المزيد من الأحرف مما هو موجود في length(s)، فسيتم إرجاع سلسلة فارغة.

انظر أيضًا chomp، startswith، first.

أمثلة

julia> a = "March"
"March"

julia> chop(a)
"Marc"

julia> chop(a, head = 1, tail = 2)
"ar"

julia> chop(a, head = 5, tail = 5)
""

chopprefix(s::AbstractString, prefix::Union{AbstractString,Regex}) -> SubString

قم بإزالة البادئة prefix من s. إذا لم يبدأ s بـ prefix، يتم إرجاع سلسلة تساوي s.

انظر أيضًا chopsuffix.

أمثلة

julia> chopprefix("Hamburger", "Ham")
"burger"

julia> chopprefix("Hamburger", "hotdog")
"Hamburger"

chopsuffix(s::AbstractString, suffix::Union{AbstractString,Regex}) -> SubString

قم بإزالة اللاحقة suffix من s. إذا لم ينتهِ s بـ suffix، يتم إرجاع سلسلة تساوي s.

انظر أيضًا chopprefix.

أمثلة

julia> chopsuffix("Hamburger", "er")
"Hamburg"

julia> chopsuffix("Hamburger", "hotdog")
"Hamburger"

chomp(s::AbstractString) -> SubString

إزالة سطر جديد واحد في نهاية سلسلة.

انظر أيضًا chop.

أمثلة

julia> chomp("Hello\n")
"Hello"

thisind(s::AbstractString, i::Integer) -> Int

إذا كان i ضمن حدود s، أعد الفهرس لبداية الحرف الذي ينتمي إليه وحدة ترميز i. بعبارة أخرى، إذا كان i هو بداية حرف، أعد i؛ إذا لم يكن i هو بداية حرف، ارجع إلى بداية حرف وأعد ذلك الفهرس. إذا كان i يساوي 0 أو ncodeunits(s)+1، أعد i. في جميع الحالات الأخرى، ألقِ استثناء BoundsError.

أمثلة

julia> thisind("α", 0)
0

julia> thisind("α", 1)
1

julia> thisind("α", 2)
1

julia> thisind("α", 3)
3

julia> thisind("α", 4)
ERROR: BoundsError: attempt to access 2-codeunit String at index [4]
[...]

julia> thisind("α", -1)
ERROR: BoundsError: attempt to access 2-codeunit String at index [-1]
[...]

nextind(str::AbstractString, i::Integer, n::Integer=1) -> Int

• حالة n == 1

  إذا كان i ضمن الحدود في s، ارجع فهرس بداية الحرف الذي يبدأ ترميزه بعد الفهرس i. بعبارة أخرى، إذا كان i هو بداية حرف، ارجع بداية الحرف التالي؛ إذا لم يكن i هو بداية حرف، انتقل للأمام حتى بداية حرف وارجع ذلك الفهرس. إذا كان i يساوي 0، ارجع 1. إذا كان i ضمن الحدود ولكنه أكبر أو يساوي lastindex(str)، ارجع ncodeunits(str)+1. خلاف ذلك، ارمِ BoundsError.

• حالة n > 1

  يتصرف كما لو تم تطبيق n مرات nextind لـ n==1. الاختلاف الوحيد هو أنه إذا كان n كبيرًا جدًا بحيث إن تطبيق nextind سيصل إلى ncodeunits(str)+1، فإن كل تكرار متبقي يزيد القيمة المرجعة بمقدار 1. هذا يعني أنه في هذه الحالة يمكن أن ترجع nextind قيمة أكبر من ncodeunits(str)+1.

• حالة n == 0

  ارجع i فقط إذا كان i فهرسًا صالحًا في s أو يساوي 0. خلاف ذلك، يتم رمي StringIndexError أو BoundsError.

أمثلة

julia> nextind("α", 0)
1

julia> nextind("α", 1)
3

julia> nextind("α", 3)
ERROR: BoundsError: attempt to access 2-codeunit String at index [3]
[...]

julia> nextind("α", 0, 2)
3

julia> nextind("α", 1, 2)
4

prevind(str::AbstractString, i::Integer, n::Integer=1) -> Int

• حالة n == 1

  إذا كان i ضمن الحدود في s، ارجع فهرس بداية الحرف الذي يبدأ ترميزه قبل الفهرس i. بعبارة أخرى، إذا كان i هو بداية حرف، ارجع بداية الحرف السابق؛ إذا لم يكن i هو بداية حرف، ارجع حتى بداية حرف وارجع ذلك الفهرس. إذا كان i يساوي 1، ارجع 0. إذا كان i يساوي ncodeunits(str)+1، ارجع lastindex(str). خلاف ذلك، ألقِ BoundsError.

• حالة n > 1

  يتصرف كما لو تم تطبيق n مرات prevind لـ n==1. الاختلاف الوحيد هو أنه إذا كان n كبيرًا جدًا بحيث إن تطبيق prevind سيصل إلى 0، فإن كل تكرار متبقي يقلل القيمة المرجعة بمقدار 1. هذا يعني أنه في هذه الحالة يمكن أن تعيد prevind قيمة سالبة.

• حالة n == 0

  ارجع i فقط إذا كان i فهرسًا صالحًا في str أو يساوي ncodeunits(str)+1. خلاف ذلك، يتم إلقاء StringIndexError أو BoundsError.

أمثلة

julia> prevind("α", 3)
1

julia> prevind("α", 1)
0

julia> prevind("α", 0)
ERROR: BoundsError: attempt to access 2-codeunit String at index [0]
[...]

julia> prevind("α", 2, 2)
0

julia> prevind("α", 2, 3)
-1

textwidth(c)

أعطِ عدد الأعمدة اللازمة لطباعة حرف.

أمثلة

julia> textwidth('α')
1

julia> textwidth('⛵')
2

textwidth(s::AbstractString)

احصل على عدد الأعمدة اللازمة لطباعة سلسلة نصية.

أمثلة

julia> textwidth("March")
5

isascii(c::Union{AbstractChar,AbstractString}) -> Bool

اختبر ما إذا كان الحرف ينتمي إلى مجموعة أحرف ASCII، أو ما إذا كان هذا صحيحًا لجميع عناصر سلسلة.

أمثلة

julia> isascii('a')
true

julia> isascii('α')
false

julia> isascii("abc")
true

julia> isascii("αβγ")
false

على سبيل المثال، يمكن استخدام isascii كدالة شرطية لـ filter أو replace لإزالة أو استبدال الأحرف غير ASCII، على التوالي:

julia> filter(isascii, "abcdeγfgh") # تجاهل الأحرف غير ASCII
"abcdefgh"

julia> replace("abcdeγfgh", !isascii=>' ') # استبدال الأحرف غير ASCII بمسافات
"abcde fgh"

isascii(cu::AbstractVector{CU}) where {CU <: Integer} -> Bool

اختبر ما إذا كانت جميع القيم في المتجه تنتمي إلى مجموعة أحرف ASCII (0x00 إلى 0x7f). هذه الوظيفة مصممة لتستخدم من قبل تطبيقات السلاسل الأخرى التي تحتاج إلى فحص ASCII سريع.

iscntrl(c::AbstractChar) -> Bool

يختبر ما إذا كان الحرف هو حرف تحكم. أحرف التحكم هي الأحرف غير القابلة للطباعة من مجموعة اللاتينية-1 من يونيكود.

أمثلة

julia> iscntrl('\x01')
true

julia> iscntrl('a')
false

isdigit(c::AbstractChar) -> Bool

يختبر ما إذا كان الحرف رقمًا عشريًا (0-9).

انظر أيضًا: isletter.

أمثلة

julia> isdigit('❤')
false

julia> isdigit('9')
true

julia> isdigit('α')
false

isletter(c::AbstractChar) -> Bool

اختبر ما إذا كان الحرف حرفًا. يتم تصنيف الحرف كحرف إذا كان ينتمي إلى فئة Unicode العامة Letter، أي حرف يبدأ رمز فئته بـ 'L'.

انظر أيضًا: isdigit.

أمثلة

julia> isletter('❤')
false

julia> isletter('α')
true

julia> isletter('9')
false

islowercase(c::AbstractChar) -> Bool

يختبر ما إذا كان الحرف حرفًا صغيرًا (وفقًا لمعيار Unicode الخاص بخصائص Lowercase المشتقة).

انظر أيضًا isuppercase.

أمثلة

julia> islowercase('α')
true

julia> islowercase('Γ')
false

julia> islowercase('❤')
false

isnumeric(c::AbstractChar) -> Bool

يختبر ما إذا كان الحرف عدديًا. يتم تصنيف الحرف على أنه عددي إذا كان ينتمي إلى الفئة العامة ليوحد Unicode رقم، أي حرف يبدأ رمز فئته بـ 'N'.

لاحظ أن هذه الفئة الواسعة تشمل أحرفًا مثل ¾ و ௰. استخدم isdigit للتحقق مما إذا كان الحرف رقمًا عشريًا بين 0 و 9.

أمثلة

julia> isnumeric('௰')
true

julia> isnumeric('9')
true

julia> isnumeric('α')
false

julia> isnumeric('❤')
false

isprint(c::AbstractChar) -> Bool

يختبر ما إذا كان الحرف قابل للطباعة، بما في ذلك المسافات، ولكن ليس حرف تحكم.

أمثلة

julia> isprint('\x01')
false

julia> isprint('A')
true

ispunct(c::AbstractChar) -> Bool

يختبر ما إذا كان الحرف ينتمي إلى فئة Unicode العامة "علامة الترقيم"، أي حرف يبدأ رمز فئته بـ 'P'.

أمثلة

julia> ispunct('α')
false

julia> ispunct('/')
true

julia> ispunct(';')
true

isspace(c::AbstractChar) -> Bool

يختبر ما إذا كان الحرف هو أي حرف فراغ. يشمل الأحرف ASCII '\t'، '\n'، '\v'، '\f'، '\r'، و ' '، وحرف Latin-1 U+0085، والأحرف في فئة Unicode Zs.

أمثلة

julia> isspace('\n')
true

julia> isspace('\r')
true

julia> isspace(' ')
true

julia> isspace('\x20')
true

isuppercase(c::AbstractChar) -> Bool

يختبر ما إذا كان الحرف حرفًا كبيرًا (وفقًا لخاصية Uppercase المشتقة من معيار Unicode).

انظر أيضًا islowercase.

أمثلة

julia> isuppercase('γ')
false

julia> isuppercase('Γ')
true

julia> isuppercase('❤')
false

isxdigit(c::AbstractChar) -> Bool

اختبر ما إذا كان الحرف رقمًا سداسيًا عشريًا صالحًا. لاحظ أن هذا لا يشمل x (كما في البادئة القياسية 0x).

أمثلة

julia> isxdigit('a')
true

julia> isxdigit('x')
false

escape_string(str::AbstractString[, esc]; keep = ())::AbstractString
escape_string(io, str::AbstractString[, esc]; keep = ())::Nothing

الهروب العام لتسلسلات الهروب التقليدية في C وUnicode. الشكل الأول يُرجع السلسلة الهاربة، بينما الشكل الثاني يطبع النتيجة إلى io.

تُهرب الشرطات الخلفية (\) باستخدام شرطة خلفية مزدوجة ("\\"). تُهرب الأحرف غير القابلة للطباعة إما باستخدام رموز الهروب القياسية في C، "\0" لـ NUL (إذا كانت غير غامضة)، أو نقطة كود Unicode ("\u" بادئة) أو سداسي عشري ("\x" بادئة).

تحدد الوسيطة الاختيارية esc أي أحرف إضافية يجب أيضًا هروبها عن طريق إضافة شرطة خلفية (" تُهرب أيضًا بشكل افتراضي في الشكل الأول).

تحدد الوسيطة keep مجموعة من الأحرف التي يجب الاحتفاظ بها كما هي. لاحظ أن esc له أولوية هنا.

انظر أيضًا unescape_string للعملية العكسية.

أمثلة

julia> escape_string("aaa\nbbb")
"aaa\\nbbb"

julia> escape_string("aaa\nbbb"; keep = '\n')
"aaa\nbbb"

julia> escape_string("\xfe\xff") # utf-8 غير صالح
"\\xfe\\xff"

julia> escape_string(string('\u2135','\0')) # غير غامض
"ℵ\\0"

julia> escape_string(string('\u2135','\0','0')) # \0 سيكون غامضًا
"ℵ\\x000"

escape_raw_string(s::AbstractString, delim='"') -> AbstractString
escape_raw_string(io, s::AbstractString, delim='"')

قم بتهريب سلسلة بالطريقة المستخدمة لتحليل الحروف السلسلية الخام. لكل حرف اقتباس مزدوج (") في سلسلة الإدخال s (أو delim إذا تم تحديده)، تقوم هذه الدالة بعد عدد n من أحرف الشرط المسبق (\)، ثم تزيد عدد الشرط المسبق من n إلى 2n+1 (حتى بالنسبة لـ n = 0). كما أنها تضاعف تسلسل الشرط المسبق في نهاية السلسلة.

تستخدم هذه الاتفاقية في تهريب السلاسل في السلاسل الخام وغيرها من الحروف السلسلية غير القياسية. (كما أنها تحدث لتكون اتفاقية التهريب المتوقعة من قبل وقت تشغيل مترجم Microsoft C/C++ عندما يقوم بتحليل سلسلة سطر الأوامر إلى مصفوفة argv[]).

انظر أيضًا escape_string.

unescape_string(str::AbstractString, keep = ())::AbstractString
unescape_string(io, s::AbstractString, keep = ())::Nothing

فك التشفير العام لتسلسلات الهروب التقليدية في C و Unicode. الشكل الأول يُرجع السلسلة المشفرة، بينما الشكل الثاني يطبع النتيجة إلى io. يُحدد الوسيط keep مجموعة من الأحرف التي (بالإضافة إلى الشرطات الخلفية) يجب الاحتفاظ بها كما هي.

تُعترف بتسلسلات الهروب التالية:

• شرطة خلفية مشفرة (\\)
• اقتباس مزدوج مشفر (\")
• تسلسلات الهروب القياسية في C (\a, \b, \t, \n, \v, \f, \r, \e)
• نقاط كود Unicode BMP (\u مع 1-4 أرقام سداسية عشرية تالية)
• جميع نقاط كود Unicode (\U مع 1-8 أرقام سداسية عشرية تالية؛ القيمة القصوى = 0010ffff)
• بايتات سداسية عشرية (\x مع 1-2 أرقام سداسية عشرية تالية)
• بايتات ثمانية (\ مع 1-3 أرقام ثمانية تالية)

انظر أيضًا escape_string.

أمثلة

julia> unescape_string("aaa\\nbbb") # تسلسل هروب C
"aaa\nbbb"

julia> unescape_string("\\u03c0") # unicode
"π"

julia> unescape_string("\\101") # ثماني
"A"

julia> unescape_string("aaa \\g \\n", ['g']) # باستخدام وسيط `keep`
"aaa \\g \n"

AnnotatedString{S <: AbstractString} <: AbstractString

سلسلة نصية مع بيانات وصفية، في شكل مناطق مشروحة.

بشكل أكثر تحديدًا، هذه عبارة عن غلاف بسيط حول أي AbstractString يسمح لمناطق من السلسلة المغلفة بأن تكون مشروحة بقيم معنونة.

                           C
                    ┌──────┸─────────┐
  "هذه سلسلة نصية مشروحة كمثال"
  └──┰────────┼─────┘         │
     A        └─────┰─────────┘
                    B

يمثل الرسم البياني أعلاه AnnotatedString حيث تم شرح ثلاث نطاقات (موسومة بـ A و B و C). تحتوي كل ملاحظة على تسمية (Symbol) وقيمة (Any). يتم الاحتفاظ بهذه المعلومات الثلاث كـ @NamedTuple{region::UnitRange{Int64}, label::Symbol, value}.

لا تحتاج التسميات إلى أن تكون فريدة، يمكن أن يحمل نفس النطاق عدة ملاحظات بنفس التسمية.

يجب أن تحافظ الشيفرة المكتوبة لـ AnnotatedStrings بشكل عام على الخصائص التالية:

• أي الأحرف يتم تطبيق ملاحظة عليها
• ترتيب تطبيق الملاحظات على كل حرف

يمكن إدخال دلالات إضافية من خلال الاستخدامات المحددة لـ AnnotatedStrings.

نتيجة لهذه القواعد هي أن الملاحظات المتجاورة، الموضوعة بشكل متتالي، مع تسميات وقيم متطابقة تعادل ملاحظة واحدة تمتد عبر النطاق المدمج.

انظر أيضًا AnnotatedChar، annotatedstring، annotations، و annotate!.

المنشئات

AnnotatedString(s::S<:AbstractString) -> AnnotatedString{S}
AnnotatedString(s::S<:AbstractString, annotations::Vector{@NamedTuple{region::UnitRange{Int64}, label::Symbol, value}})

يمكن أيضًا إنشاء AnnotatedString باستخدام annotatedstring، الذي يعمل مثل string ولكنه يحتفظ بأي ملاحظات موجودة في المعطيات.

أمثلة

julia> AnnotatedString("هذه سلسلة نصية مشروحة كمثال",
                    [(1:18, :A => 1), (12:28, :B => 2), (18:35, :C => 3)])
"هذه سلسلة نصية مشروحة كمثال"

AnnotatedChar{S <: AbstractChar} <: AbstractChar

حرف مع تعليقات.

بشكل أكثر تحديدًا، هذه عبارة عن غلاف بسيط حول أي AbstractChar، والذي يحمل قائمة من التعليقات المسماة بشكل عشوائي (@NamedTuple{label::Symbol, value}) مع الحرف المغلف.

انظر أيضًا: AnnotatedString، annotatedstring، annotations، و annotate!.

المنشئات

AnnotatedChar(s::S) -> AnnotatedChar{S}
AnnotatedChar(s::S, annotations::Vector{@NamedTuple{label::Symbol, value}})

أمثلة

julia> AnnotatedChar('j', :label => 1)
'j': ASCII/Unicode U+006A (category Ll: Letter, lowercase)

annotatedstring(values...)

أنشئ AnnotatedString من أي عدد من values باستخدام تمثيلهم المطبوع print.

هذا يعمل مثل string، ولكنه يعتني بالحفاظ على أي تعليقات توضيحية موجودة (في شكل AnnotatedString أو AnnotatedChar قيم).

انظر أيضًا AnnotatedString و AnnotatedChar.

أمثلة

julia> annotatedstring("now a AnnotatedString")
"now a AnnotatedString"

julia> annotatedstring(AnnotatedString("annotated", [(1:9, :label => 1)]), ", and unannotated")
"annotated, and unannotated"

annotations(str::Union{AnnotatedString, SubString{AnnotatedString}},
            [position::Union{Integer, UnitRange}]) ->
    Vector{@NamedTuple{region::UnitRange{Int64}, label::Symbol, value}}

احصل على جميع التعليقات التي تنطبق على str. إذا تم توفير position، فسيتم إرجاع التعليقات التي تتداخل فقط مع position.

تُقدم التعليقات مع المناطق التي تنطبق عليها، في شكل متجه من أزواج المنطقة–التعليق.

وفقًا للمعاني الموثقة في AnnotatedString، يتطابق ترتيب التعليقات المعادة مع الترتيب الذي تم تطبيقها به.

انظر أيضًا: annotate!.

annotations(chr::AnnotatedChar) -> Vector{@NamedTuple{label::Symbol, value}}

احصل على جميع التعليقات التوضيحية لـ chr، في شكل متجه من أزواج التعليقات التوضيحية.

annotate!(str::AnnotatedString, [range::UnitRange{Int}], label::Symbol, value)
annotate!(str::SubString{AnnotatedString}, [range::UnitRange{Int}], label::Symbol, value)

قم بتعليق نطاق من str (أو السلسلة الكاملة) بقيمة معنونة (label => value). لإزالة تعليقات label الموجودة، استخدم قيمة nothing.

ترتيب تطبيق التعليقات على str له معنى دلالي، كما هو موضح في AnnotatedString.

annotate!(char::AnnotatedChar, label::Symbol, value::Any)

قم بتعليق char مع الزوج label => value.