View source for प्रोग्रामिंग भाषाओं की तुलना (स्ट्रिंग फ़ंक्शंस)

{{redirect|स्ट्रिंग फ़ंक्शन|फॉर्मल लैंग्वेज सिद्धांत में स्ट्रिंग फ़ंक्शंस|स्ट्रिंग ऑपरेशन}}
{{further|प्रोग्रामिंग लैंग्वेजो की तुलना}}

{{ProgLangCompare}}
स्ट्रिंग फ़ंक्शन का उपयोग कंप्यूटर [[प्रोग्रामिंग भाषा|प्रोग्रामिंग]] [[लैंग्वेजो]] में [[स्ट्रिंग (कंप्यूटर विज्ञान)]] में अदला बदली करने या स्ट्रिंग के बारे में जानकारी या क्वेरी करने के लियें दोनों में उपयोग किया जाता है।

इस प्रकार अधिकांश प्रोग्रामिंग लैंग्वेजो में स्ट्रिंग [[ डेटा प्रकार |डेटा प्रकार]] में कुछ स्ट्रिंग फ़ंक्शन होते है, चूंकि स्ट्रिंग को सीधे संभालने के लिए प्रत्येक लैंग्वेज के भीतर अन्य निम्न-स्तरीय विधि भी होती है। जो ऑब्जेक्ट-ओरिएंटेड लैंग्वेजो में स्ट्रिंग फ़ंक्शंस को अधिकांशतः स्ट्रिंग ऑब्जेक्ट के गुणों और विधियों के रूप में कार्यान्वित करती है और जबकि कार्यात्मक और सूची-आधारित लैंग्वेजो में एक स्ट्रिंग को एक सूची करैक्टर कोड के रूप में दर्शाया जाता है और इसलिए सभी सूची अदला- बदली प्रक्रियाओं को स्ट्रिंग फ़ंक्शन के रूप में माना जा सकता है। चूंकि ऐसी लैंग्वेजो में स्पष्ट स्ट्रिंग-विशिष्ट फ़ंक्शंस के सबसेट को भी प्रयुक्त कर सकती हैं।

फ़ंक्शन के लिए जो स्ट्रिंग्स में अदला- बदली करता है, आधुनिक ऑब्जेक्ट-ओरिएंटेड लैंग्वेज, जैसे C # और [[जावा (प्रोग्रामिंग भाषा)|जावा प्रोग्रामिंग लैंग्वेज]] में अपरिवर्तनीय स्ट्रिंग्स होती हैं और एक कॉपी को नई आवंटित गतिशील मेमोरी में रीटर्न करती है, जबकि अन्य, जैसे C [[सी (प्रोग्रामिंग भाषा)|प्रोग्रामिंग लैंग्वेज]] मूल स्ट्रिंग में अदला- बदली करता है, जब तक कि प्रोग्रामर डेटा को एक नई स्ट्रिंग में कॉपी नहीं करता है। उदाहरण के लिए नीचे कॉनकीटेनेशन में दर्शाया गया है।

इस प्रकार स्ट्रिंग फ़ंक्शन का सबसे मौलिक उदाहरण<code>length(string)</code> फ़ंक्शन है। यह फ़ंक्शन स्ट्रिंग की लंबाई को शाब्दिक रूप से रीटर्न करता है ।

:. e.g. <code>length("hello world")</code> would return 11.

अन्य लैंग्वेजो में समान या बिल्कुल समान सिंटेक्स या पैरामीटर परिणाम वाले स्ट्रिंग फ़ंक्शन होते हैं। उदाहरण के लिए, कई लैंग्वेजो में लंबाई फ़ंक्शन को सामान्यतः लेन (स्ट्रिंग) के रूप में दर्शाया जाता है। इस प्रकार सामान्य कार्यों की नीचे दी गई सूची का उद्देश्य इस कन्फ्यूश़न को सीमित करने में मदद करता है।

==सामान्य स्ट्रिंग फ़ंक्शंस (बहु लैंग्वेज संदर्भ)==
{{unreferenced section|date=July 2013}}
कई लैंग्वेजो में सामान्य रूप से उपयोग किए जाने वाले विभिन्न नामों सहित स्ट्रिंग फ़ंक्शंस नीचे सूचीबद्ध हैं। सामान्य फ़ंक्शंस की नीचे दी गई सूची का उद्देश्य प्रोग्रामर्स को किसी लैंग्वेज में समकक्ष फ़ंक्शन ढूंढने में मदद करता है। ध्यान दें, स्ट्रिंग संयोजन और [[नियमित अभिव्यक्ति|नियमित एक्सप्रेशन]] को भिन्न -भिन्न पृष्ठों में प्रबंधित किया जाता है। [[उद्धरण चिह्न]] गुइलमेट्स में कथन (“… ») वैकल्पिक हैं।
===CharAt===

{| class="wikitable"
|- style="background:#fffeed;"
! परिभाषा 
| <code>charAt(string,integer)</code> returns character.
|-
! विवरण 
| स्ट्रिंग में इंडेक्स पर करैक्टर रीटर्न करता है।
|-
! एक्विवलेंट 
| लंबाई 1 करैक्टर की सबस्ट्रिंग दिखाया गया है 
|}
{| class="wikitable sortable"
|- style="text-align:left;"
! प्रारूप !! लैंग्वेज !! आधार इंडेक्स 
|-
| <code>''string''[''i'']</code>
|[[ALGOL 68]], [[APL (programming language)|APL]], [[Julia (programming language)|Julia]], [[Pascal (programming language)|Pascal]], [[Object Pascal]] ([[Delphi (programming language)|Delphi]]), [[Seed7]]
|1
|-
| <code>''string''[''i'']</code>
|[[C (programming language)|C]], [[C++]], [[C Sharp (programming language)|C#]], [[Cobra (programming language)|Cobra]], [[D (programming language)|D]], [[FreeBASIC]], [[Go (programming language)|Go]], [[Python (programming language)|Python]],<ref name="at1"/> [[PHP]], [[Ruby (programming language)|Ruby]],<ref name="at1"/> [[Windows PowerShell]], [[JavaScript]], [[APL (programming language)|APL]]
|0
|-
| <code>''string''{''i''}</code>
|[[PHP]] (deprecated in 5.3)
|0
|-
| <code>''string''(''i'')</code>
|[[Ada (programming language)|Ada]]
|≥1
|-
| <code>Mid(''string'',i,1)</code>
|[[Visual Basic (classic)|VB]]
|1
|-
| <code>MID$(''string'',i,1)</code>
|[[BASIC]]
|1
|-
| <code>''string''.Chars(''i'')</code>
|[[Visual Basic .NET|VB.NET]]
|0
|-
| <code>''string''(''i'':''i'')</code>
|[[Fortran]]
|1
|-
| <code>''string''.charAt(''i'')</code>
|[[Java (programming language)|Java]], [[JavaScript]]
|0
|-
| <code>''string''.[''i'']</code>
|[[OCaml]], [[F Sharp (programming language)|F#]]
|0
|-
| <code>''string''.chars().nth(''i'')</code>
|[[Rust (programming language)|Rust]]<ref>In Rust, the [https://doc.rust-lang.org/std/primitive.str.html#method.chars <code>str::chars</code>] method iterates over code points and the [https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.nth <code>std::iter::Iterator::nth</code>] method on iterators returns the zero-indexed nth value from the iterator, or [[option type|<code>None</code>]].</ref>
|0
|-
| <code>''string''[''i'',''1'']</code>
|[[Pick Basic]]
|1
|-
| <code>String.sub (''string'', ''i'')</code>
|[[Standard ML]]
|0
|-
| <code>''string'' !! ''i''</code>
|[[Haskell (programming language)|Haskell]]
|0
|-
| <code>(string-ref ''string'' ''i'')</code>
|[[Scheme (programming language)|Scheme]]
|0
|-
| <code>(char ''string'' ''i'')</code>
|[[Common Lisp]]
|0
|-
| <code>(elt ''string'' ''i'')</code>
|[[ISLISP]]
|0
|-
| <code>(get ''string'' ''i'')</code>
|[[Clojure]]
|0
|-
| <code>substr(''string'', ''i'', 1)</code>
|[[Perl 5]]<ref name="at1"/>
|0
|-
| <code>substr(''string'', ''i'', 1)</code> <br /> <code>string.substr(''i'', 1)</code>
|[[Raku (programming language)|Raku]]<ref name="at2"/>
|0
|-
| <code>substr(''string'', ''i'', 1)</code>
|[[PL/I]]
|1
|-
| <code>''string''.at(''i'')</code>
|[[C++]] (STL) (w/ bounds checking)
|0
|-
| <code>lists:nth(''i'', ''string'')</code>
|[[Erlang (programming language)|Erlang]]
|1
|-
| <code>[''string'' characterAtIndex:''i'']</code>
|[[Objective-C]] (<code>NSString *</code> only)
|0
|-
| <code>string.sub(''string'', ''i'', ''i'') <br /> (''string''):sub(''i'', ''i'')</code>
|[[Lua (programming language)|Lua]]<ref name="at1"/>
|1
|-
| <code>''string'' at: ''i''</code>
|[[Smalltalk]] (w/ bounds checking)
|1
|-
| <code>string index ''string i''</code>
|[[Tcl]]
|0
|-
| <code>StringTake[''string'', {''i''}]</code>
|[[Mathematica]], [[Wolfram Language]]<ref name="at1"/>
|1
|-
| <code>''string''@''i''</code>
|[[Eiffel (programming language)|Eiffel]]
|1
|-
| <code>''string'' (''i'':1)</code>
| [[COBOL]]
|1
|-
| <code>${''string_param'':''i'':1}</code>
| [[Bash (Unix shell)|Bash]]
|0
|-
| <code>''i''⌷''string''</code>
| [[APL (programming language)|APL]]
|0 or 1
|}
<syntaxhighlight lang="c">
{ Example in Pascal }
var 
  MyStr: string = 'Hello, World';
  MyChar: Char;
begin
  MyChar := MyStr[2];          // 'e'
</syntaxhighlight><syntaxhighlight lang="c">
# Example in ALGOL 68 #
"Hello, World"[2];             // 'e'
</syntaxhighlight><syntaxhighlight lang="c">
// Example in C
#include <stdio.h>             // for printf
char MyStr[] = "Hello, World";
printf("%c", *(MyStr+1));      // 'e'
printf("%c", *(MyStr+7));      // 'W'
printf("%c", MyStr[11]);       // 'd'
printf("%s", MyStr);           // 'Hello, World'
printf("%s", "Hello(2), World(2)"); // 'Hello(2), World(2)'
</syntaxhighlight><syntaxhighlight lang="c">
// Example in C++
#include <iostream>            // for "cout"
#include <string.h>            // for "string" data type
using namespace std;
char MyStr1[] = "Hello(1), World(1)";
string MyStr2 = "Hello(2), World(2)";
cout << "Hello(3), World(3)";  // 'Hello(3), World(3)'
cout << MyStr2[6];             // '2'
cout << MyStr1.substr (5, 3);  // '(1)'
</syntaxhighlight><syntaxhighlight lang="c">
// Example in C#
"Hello, World"[2];             // 'l'
</syntaxhighlight><syntaxhighlight lang="c">
# Example in Perl 5
substr("Hello, World", 1, 1);  # 'e'
</syntaxhighlight><syntaxhighlight lang="c">
# Examples in Python
"Hello, World"[2]              #  'l'
"Hello, World"[-3]             #  'r'
</syntaxhighlight><syntaxhighlight lang="c">
# Example in Raku
"Hello, World".substr(1, 1);   # 'e'

</syntaxhighlight><syntaxhighlight lang="c">
' Example in Visual Basic
Mid("Hello, World",2,1)
</syntaxhighlight><syntaxhighlight lang="c++-objdumb">
 Example in Visual Basic .NET
"Hello, World".Chars(2)    '  "l"c
</syntaxhighlight>
<syntaxhighlight lang="c++-objdumb">
" Example in Smalltalk "
'Hello, World' at: 2.        "$e"
</syntaxhighlight><syntaxhighlight lang="c-objdump">
//Example in Rust
"Hello, World".chars().nth(2);   // Some('l')
</syntaxhighlight>

===तुलना करें (इन्टिजर परिणाम)===
{| class="wikitable"
|- style="background:#fffeed;"
! परिभाषा 
| <code>compare(string<sub>1</sub>,string<sub>2</sub>)</code> returns integer.
|-
! विवरण 
| दो स्ट्रिंग की एक दूसरे से तुलना करते है। यदि वे समतुल्य होती है, तो शून्य लौटाया जाता है। अन्यथा, इनमें से अधिकांश रूटीन एक धनात्मक या ऋणात्मक परिणाम लौटाते है और इस प्रकार चाहे स्ट्रिंग 1 शब्दावली की दृष्टि से स्ट्रिंग 2 की तुलना में क्रमशः अधिक या कम होती है, इस प्रकार एक्सेप्शन स्कीम और रेक्स रूटीन जो पहले बेमेल के इंडेक्स को लौटाते हैं और स्मॉलटॉक जो तुलना कोड का उत्तर देते हुए बताते हैं कि रिसीवर स्ट्रिंग पैरामीटर के सापेक्ष कैसे सॉर्ट करता है।
|}
{| class="wikitable sortable"
|- style="text-align:left;"
! प्रारूप !! लैंग्वेज 
|-
| <code>IF ''string<sub>1</sub>''<''string<sub>2</sub>'' THEN -1 ELSE ABS (''string<sub>1</sub>''>''string<sub>2</sub>'') FI</code>
|[[ALGOL 68]]
|-
| <code>cmp(''string<sub>1</sub>'', ''string<sub>2</sub>'')</code>
|[[Python 2]]
|-
| <code>(''string<sub>1</sub>'' > ''string<sub>2</sub>'') - (''string<sub>1</sub>'' < ''string<sub>2</sub>'')</code>
|[[Python (programming language)|Python]]
|-
| <code>[[strcmp]](''string<sub>1</sub>'', ''string<sub>2</sub>'')</code>
|[[C (programming language)|C]], [[PHP]]
|-
| <code>std.string.cmp(''string<sub>1</sub>'', ''string<sub>2</sub>'')</code>
|[[D (programming language)|D]]
|-
| <code>StrComp(''string<sub>1</sub>'', ''string<sub>2</sub>'')</code>
|[[Visual Basic (classic)|VB]], [[Object Pascal]] ([[Delphi (programming language)|Delphi]])
|-
| <code>''string<sub>1</sub>'' cmp ''string<sub>2</sub>''</code>
|[[Perl]], [[Raku (programming language)|Raku]]
|-
| <code>''string<sub>1</sub>'' compare: ''string<sub>2</sub>''</code>
|[[Smalltalk]] ([[Squeak]], [[Pharo]])
|-
| <code>''string<sub>1</sub>'' <=> ''string<sub>2</sub>''</code>
|[[Ruby (programming language)|Ruby]], [[C++]] (STL, [[C++20]])<ref>In C++, the overloaded [https://en.cppreference.com/w/cpp/language/operator_comparison#Three-way%20comparison <code>operator<=></code>] method on a [https://en.cppreference.com/w/cpp/string/basic_string string] returns a [https://en.cppreference.com/w/cpp/utility/compare/strong_ordering <code>std::strong_ordering</code>] object (otherwise <code>std::weak_ordering</code>): <code>less</code>, <code>equal</code> (same as <code>equivalent</code>), or <code>greater</code>.</ref>
|-
| <code>''string<sub>1</sub>''.compare(''string<sub>2</sub>'')</code>
|[[C++]] (STL), [[Swift (programming language)|Swift]] (Foundation)
|-
| <code>compare(''string<sub>1</sub>'', ''string<sub>2</sub>'')</code>
|[[Rexx]], [[Seed7]]
|-
| <code>CompareStr(''string<sub>1</sub>'', ''string<sub>2</sub>'')</code>
|[[Pascal (programming language)|Pascal]], [[Object Pascal]] ([[Delphi (programming language)|Delphi]])
|-
| <code>''string<sub>1</sub>''.compareTo(''string<sub>2</sub>'')</code>
|[[Cobra (programming language)|Cobra]], [[Java (programming language)|Java]]
|-
| <code>''string<sub>1</sub>''.CompareTo(''string<sub>2</sub>'')</code>
|[[Visual Basic .Net|VB .NET]], [[C Sharp (programming language)|C#]], [[F Sharp (programming language)|F#]]
|-
| <code>(compare ''string<sub>1</sub>'' ''string<sub>2</sub>'')</code>
|[[Clojure]]
|-
| <code>(string= ''string<sub>1</sub>'' ''string<sub>2</sub>'')</code>
|[[Common Lisp]]
|-
| <code>(string-compare ''string<sub>1</sub>'' ''string<sub>2</sub>'' ''p<'' ''p='' ''p>'')</code>
|[[Scheme (programming language)|Scheme]] (SRFI 13)
|-
| <code>(string= ''string<sub>1</sub>'' ''string<sub>2</sub>'')</code>
|[[ISLISP]]
|-
| <code>compare ''string<sub>1</sub>'' ''string<sub>2</sub>''</code>
|[[OCaml]]
|-
| <code>String.compare (''string<sub>1</sub>'', ''string<sub>2</sub>'')</code>
|[[Standard ML]]<ref>returns LESS, EQUAL, or GREATER</ref>
|-
| <code>compare ''string<sub>1</sub>'' ''string<sub>2</sub>''</code>
|[[Haskell (programming language)|Haskell]]<ref>returns LT, EQ, or GT</ref>
|-
| <code>[string]::Compare(''string<sub>1</sub>'', ''string<sub>2</sub>'')</code>
|[[Windows PowerShell]]
|-
| <code>[''string<sub>1</sub>'' compare:''string<sub>2</sub>'']</code>
|[[Objective-C]] (<code>NSString *</code> only)
|-
| <code>LLT(''string<sub>1</sub>'',''string<sub>2</sub>'') <br/> LLE(''string<sub>1</sub>'',''string<sub>2</sub>'') <br/> LGT(''string<sub>1</sub>'',''string<sub>2</sub>'') <br/> LGE(''string<sub>1</sub>'',''string<sub>2</sub>'') </code>
|[[Fortran]]<ref>returns <code>.TRUE.</code> or <code>.FALSE.</code>.  These functions are based on the ASCII collating sequence.</ref>
|-
| <code>''string<sub>1</sub>''.localeCompare(''string<sub>2</sub>'')</code>
|[[JavaScript]]
|-
| <code>bytes.Compare([]byte(''string<sub>1</sub>''), []byte(''string<sub>2</sub>''))</code>
|[[Go (programming language)|Go]]
|-
| <code>string compare ?-nocase? ?-length int? ''string<sub>1</sub>'' ''string<sub>2</sub>''</code>
|[[Tcl]]
|-
| <code>compare(''string<sub>1</sub>'',''string<sub>2</sub>'',''count'')</code>
|[[PL/I]]<ref name="lower1">IBM extension.</ref>
|-
| <code>''string<sub>1</sub>''.cmp(''string<sub>2</sub>'')</code>
| [[Rust (programming language)|Rust]]<ref>In Rust, the [https://doc.rust-lang.org/std/cmp/trait.Ord.html#tymethod.cmp <code>Ord::cmp</code>] method on a [https://doc.rust-lang.org/std/primitive.str.html#impl-Ord string] returns an [https://doc.rust-lang.org/std/cmp/enum.Ordering.html <code>Ordering</code>]: <code>Less</code>, <code>Equal</code>, or <code>Greater</code>.</ref>
|}

<syntaxhighlight lang="perl">
# Example in Perl 5
"hello" cmp "world";       # returns -1
</syntaxhighlight>

<syntaxhighlight lang="python">
# Example in Python
cmp("hello", "world")      # returns -1
</syntaxhighlight>
# <syntaxhighlight lang="c#">
# Examples in Raku
"hello" cmp "world";       # returns Less
"world" cmp "hello";       # returns More
"hello" cmp "hello";       # returns Same
</syntaxhighlight>
<syntaxhighlight lang="c">
/** Example in Rexx */ 
compare("hello", "world")  /* returns index of mismatch: 1 */
</syntaxhighlight><syntaxhighlight lang="c">
; Example in Scheme
(use-modules (srfi srfi-13))
; returns index of mismatch: 0
(string-compare "hello" "world" values values values)
</syntaxhighlight>

===तुलना करें (रिलेशनल ऑपरेटर आधारित, बूलियन परिणाम)===
{| class="wikitable"
|- style="background:#fffeed;"
! परिभाषा 
| <code>string<sub>1</sub> OP string<sub>2</sub></code> OR <code>(compare string<sub>1</sub> string<sub>2</sub>)</code> returns Boolean.
|-
! विवरण 
| लेक्सिकोग्राफ़िक रूप से एक रिलेशनल ऑपरेटर या फ़ंक्शन का उपयोग करके दो स्ट्रिंग्स की तुलना करता है। बूलियन परिणाम रीटर्न करता है 
|}
{| class="wikitable sortable"
|- style="text-align:left;"
! प्रारूप !! लैंग्वेज 
|-
| <code>''string<sub>1</sub>'' OP ''string<sub>2</sub>''</code>, where <code>OP</code> can be any of <code>=, <>, <, >, <=</code> and <code>>=</code>
|[[Pascal (programming language)|Pascal]], [[Object Pascal]] ([[Delphi (programming language)|Delphi]]), [[OCaml]], [[Seed7]], [[Standard ML]], [[BASIC]], [[Visual Basic (classic)|VB]], [[Visual Basic .NET|VB .NET]], [[F Sharp (programming language)|F#]]
|-
| <code>''string<sub>1</sub>'' OP ''string<sub>2</sub>''</code>, where <code>OP</code> can be any of <code>=, /=, ≠, <, >, <=, ≤</code> and <code>≥</code>; Also: <code>EQ, NE, LT, LE, GE</code> and <code>GT</code>
|[[ALGOL 68]]
|-
| <code>(stringOP? ''string<sub>1</sub>'' ''string<sub>2</sub>'')</code>, where <code>OP</code> can be any of <code>=, -ci=, <, -ci<, >, -ci>, <=, -ci<=, >=</code> and <code>-ci>=</code> (operators starting with '<code>-ci</code>' are case-insensitive)
|[[Scheme (programming language)|Scheme]]
|-
| <code>(stringOP ''string<sub>1</sub>'' ''string<sub>2</sub>'')</code>, where <code>OP</code> can be any of <code>=, -ci=, <>, -ci<>, <, -ci<, >, -ci>, <=, -ci<=, >=</code> and <code>-ci>=</code> (operators starting with '<code>-ci</code>' are case-insensitive)
|[[Scheme (programming language)|Scheme]] (SRFI 13)
|-
| <code>(stringOP ''string<sub>1</sub>'' ''string<sub>2</sub>'')</code>, where <code>OP</code> can be any of <code>=, -equal, /=, -not-equal, <, -lessp, >, -greaterp, <=, -not-greaterp, >=</code> and <code>-not-lessp</code> (the verbal operators are case-insensitive) 
|[[Common Lisp]]
|-
| <code>(stringOP ''string<sub>1</sub>'' ''string<sub>2</sub>'')</code>, where <code>OP</code> can be any of <code>=, /=, <, >, <=,</code> and <code>>=</code>
|[[ISLISP]]
|-
| <code>''string<sub>1</sub>'' OP ''string<sub>2</sub>''</code>, where <code>OP</code> can be any of <code>=, \=, <, >, <=</code> and <code>>=</code>
|[[Rexx]]
|-
| <code>''string<sub>1</sub>'' OP ''string<sub>2</sub>''</code>, where <code>OP</code> can be any of <code>=, ¬=, <, >, <=, >=, ¬<</code> and <code>¬></code>
|[[PL/I]]
|-
| <code>''string<sub>1</sub>'' OP ''string<sub>2</sub>''</code>, where <code>OP</code> can be any of <code>=, /=, <, >, <=</code> and <code>>=</code>
|[[Ada (programming language)|Ada]]
|-
| <code>''string<sub>1</sub>'' OP ''string<sub>2</sub>''</code>, where <code>OP</code> can be any of <code>==, /=, <, >, =<</code> and <code>>=</code>
|[[Erlang (programming language)|Erlang]]
|-
| <code>''string<sub>1</sub>'' OP ''string<sub>2</sub>''</code>, where <code>OP</code> can be any of <code>==, /=, <, >, <=</code> and <code>>=</code>
|[[Haskell (programming language)|Haskell]]
|-
| <code>''string<sub>1</sub>'' OP ''string<sub>2</sub>''</code>, where <code>OP</code> can be any of <code>''eq'', ''ne'', ''lt'', ''gt'', ''le''</code> and <code>''ge''</code>
|[[Perl]], [[Raku (programming language)|Raku]]
|-
| <code>''string<sub>1</sub>'' OP ''string<sub>2</sub>''</code>, where <code>OP</code> can be any of <code>==, !=, <, >, <=</code> and <code>>=</code>
|[[C++]] (STL), [[C Sharp (programming language)|C#]], [[D (programming language)|D]], [[Go (programming language)|Go]], [[JavaScript]], [[Python (programming language)|Python]], [[PHP]], [[Ruby (programming language)|Ruby]], [[Rust (programming language)|Rust]],<ref name="Rust compare">In Rust, the operators <code>==</code> and <code>!=</code> and the methods <code>eq</code>, <code>ne</code> are implemented by the [https://doc.rust-lang.org/std/primitive.str.html#impl-PartialEq%3Cstr%3E <code>PartialEq</code>] trait, and the operators <code><</code>, <code>></code>, <code><=</code>, <code>>=</code> and the methods <code>lt</code>, <code>gt</code>, <code>le</code>, <code>ge</code> are implemented by the [https://doc.rust-lang.org/std/primitive.str.html#impl-PartialOrd%3Cstr%3E <code>PartialOrd</code>] trait.</ref> [[Swift (programming language)|Swift]]
|-
| <code>''string<sub>1</sub>'' OP ''string<sub>2</sub>''</code>, where <code>OP</code> can be any of <code>-eq, -ceq, -ne, -cne, -lt, -clt, -gt, -cgt, -le, -cle, -ge,</code> and <code>-cge</code> (operators starting with '<code>c</code>' are case-sensitive)
|[[Windows PowerShell]]
|-
| <code>''string<sub>1</sub>'' OP ''string<sub>2</sub>''</code>, where <code>OP</code> can be any of <code>==, ~=, <, >, <=</code> and <code>>=</code>
|[[Lua (programming language)|Lua]]
|-
| <code>''string<sub>1</sub>'' OP ''string<sub>2</sub>''</code>, where <code>OP</code> can be any of <code>=, ~=, <, >, <=</code> and <code>>=</code>
|[[Smalltalk]]
|-
| <code>''string<sub>1</sub>'' OP ''string<sub>2</sub>''</code>, where <code>OP</code> can be any of <code>==, /=, <, >, <=</code> and <code>>=; Also: .EQ., .NE., .LT., .LE., .GT.</code> and <code>.GE.</code>
|[[Fortran]].<ref>The operators use the compiler's default collating sequence.</ref>
|-
| <code>''string<sub>1</sub>'' OP ''string<sub>2</sub>''</code> where <code>OP</code> can be any of <code>=, <>, <, >, <=, >=</code> as well as worded एक्विवलेंट s
| [[COBOL]]
|-
| <code>''string<sub>1</sub>'' OP ''string<sub>2</sub>''</code> where <code>OP</code> can be any of <code>==, <>, <, >, <=</code> and <code>>=</code>
| [[Cobra (programming language)|Cobra]]
|-
| <code>''string<sub>1</sub>'' OP ''string<sub>2</sub>''</code> is available in the syntax, but means comparison of the pointers pointing to the strings, not of the string contents. Use the Compare (integer result) function.
| [[C (programming language)|C]], [[Java (programming language)|Java]]
|-
| <code>''string<sub>1</sub>''.METHOD(''string<sub>2</sub>'')</code> where <code>METHOD</code> is any of <code>eq</code>, <code>ne</code>, <code>gt</code>, <code>lt</code>, <code>ge</code>, <code>le</code>
| [[Rust (programming language)|Rust]]<ref name="Rust compare" />
|}

<syntaxhighlight lang="erlang">
% Example in Erlang
"hello" > "world".            % returns false
</syntaxhighlight>
# <syntaxhighlight lang="c">
# Example in Raku
"art" gt "painting";           # returns False
"art" lt "painting";           # returns True
</syntaxhighlight>
 
<syntaxhighlight lang="c">
# Example in Windows PowerShell
"hello" -gt "world"           # returns false
</syntaxhighlight>
 
<syntaxhighlight lang="c">
;; Example in Common Lisp
(string> "art" "painting")      ; returns nil
(string< "art" "painting")      ; returns non nil
</syntaxhighlight>
===कौन्कैटनेशन ===
{{see also|कौन्कैटनेशन }}

{| class="wikitable"
|- style="background:#fffeed;"
! परिभाषा 
| <code>concatenate(string<sub>1</sub>,string<sub>2</sub>)</code> returns string.
|-
! विवरण 
| दो स्ट्रिंग को एक दूसरे से जोड़ता है, इस प्रकार यह संयुक्त स्ट्रिंग को रीटर्न करता है । ध्यान दें कि सी जैसी कुछ लैंग्वेजो में परिवर्तनशील स्ट्रिंग हैं, इसलिए वास्तव में दूसरी स्ट्रिंग को पहली स्ट्रिंग में जोड़ा जाता है और उत्परिवर्तित स्ट्रिंग वापस आ जाती है।
|}

{| class="wikitable sortable"
|- style="text-align:left;"
! प्रारूप !! लैंग्वेज 
|-
| <code>''string<sub>1</sub>'' & ''string<sub>2</sub>''</code>
|[[Ada (programming language)|Ada]], [[FreeBASIC]], [[Seed7]], [[BASIC]], [[Visual Basic (classic)|VB]], [[Visual Basic .NET|VB .NET]], [[COBOL]] (between literals only)
|-
| <code> [[strcat]](''string<sub>1</sub>'', ''string<sub>2</sub>'')</code>
| [[C (programming language)|C]], [[C++]] (<code>[[character (computing)|char]] [[Pointer (computer programming)|*]]</code> only)<ref>modifies ''<code>string<sub>1</sub></code>'', which must have enough space to store the result</ref>
|-
| <code>''string<sub>1</sub>'' . ''string<sub>2</sub>''</code>
|[[Perl]], [[PHP]]
|-
| <code>''string<sub>1</sub>'' + ''string<sub>2</sub>''</code>
|[[ALGOL 68]], [[C++]] (STL), [[C Sharp (programming language)|C#]], [[Cobra (programming language)|Cobra]], [[FreeBASIC]], [[Go (programming language)|Go]], [[Pascal (programming language)|Pascal]], [[Object Pascal]] ([[Delphi (programming language)|Delphi]]), [[Java (programming language)|Java]], [[JavaScript]], [[Windows PowerShell]], [[Python (programming language)|Python]], [[Ruby (programming language)|Ruby]], [[Rust (programming language)|Rust]],<ref>In Rust, the <code>+</code> operator is implemented by the [https://doc.rust-lang.org/stable/std/string/struct.String.html#impl-Add%3C%26%27_%20str%3E <code>Add</code>] trait.</ref> [[F Sharp (programming language)|F#]], [[Swift (programming language)|Swift]], [[Turing (programming language)|Turing]], [[Visual Basic (classic)|VB]]
|-
| <code>''string<sub>1</sub>'' ~ ''string<sub>2</sub>''</code>
|[[D (programming language)|D]], [[Raku (programming language)|Raku]]
|-
| <code>(string-append ''string<sub>1</sub>'' ''string<sub>2</sub>'')</code>
|[[Scheme (programming language)|Scheme]], [[ISLISP]]
|-
| <code>(concatenate 'string ''string<sub>1</sub>'' ''string<sub>2</sub>'')</code>
|[[Common Lisp]]
|-
| <code>(str ''string<sub>1</sub>'' ''string<sub>2</sub>'')</code>
|[[Clojure]]
|-
| <code>''string<sub>1</sub>'' <nowiki>||</nowiki> ''string<sub>2</sub>''</code>
|[[Rexx]], [[SQL]], [[PL/I]]
|-
| <code>''string<sub>1</sub>'' // ''string<sub>2</sub>''</code>
|[[Fortran]]
|-
| <code>''string<sub>1</sub>'' ++ ''string<sub>2</sub>''</code>
|[[Erlang (programming language)|Erlang]], [[Haskell (programming language)|Haskell]]
|-
| <code>''string<sub>1</sub>'' ^ ''string<sub>2</sub>''</code>
|[[OCaml]], [[Standard ML]], [[F Sharp (programming language)|F#]]
|-
| <code>[''string<sub>1</sub>'' stringByAppendingString:''string<sub>2</sub>'']</code>
|[[Objective-C]] (<code>NSString *</code> only)
|-
| <code>''string<sub>1</sub>'' .. ''string<sub>2</sub>''</code>
|[[Lua (programming language)|Lua]]
|-
| <code>''string<sub>1</sub>'' , ''string<sub>2</sub>''</code>
|[[Smalltalk]], [[APL (programming language)|APL]]
|-
| <code>''string<sub>1</sub>'' ''string<sub>2</sub>''</code>
|[[SNOBOL]]
|-
| <code>''string<sub>1</sub>string<sub>2</sub>''</code>
|[[Bash (Unix shell)|Bash]]
|-
| <code>''string<sub>1</sub>'' <> ''string<sub>2</sub>''</code>
|[[Mathematica]]
|-
|concat ''string<sub>1</sub> string<sub>2</sub>''
|[[Tcl]]
|}

<syntaxhighlight lang="pascal">
{ Example in Pascal }
'abc' + 'def';      // returns "abcdef"
</syntaxhighlight>

<syntaxhighlight lang="csharp">
// Example in C#
"abc" + "def";      // returns "abcdef"
</syntaxhighlight>

<syntaxhighlight lang="vbnet">
' Example in Visual Basic
"abc" & "def"       '  returns "abcdef"
"abc" + "def"       '  returns "abcdef"
"abc" & Null        '  returns "abc"
"abc" + Null        '  returns Null
</syntaxhighlight>

<syntaxhighlight lang="d">
// Example in D
"abc" ~ "def";      // returns "abcdef"
</syntaxhighlight>

<syntaxhighlight lang="lisp">
;; Example in common lisp
(concatenate 'string "abc " "def " "ghi")  ; returns "abc def ghi"
</syntaxhighlight>

<syntaxhighlight lang="perl">
# Example in Perl 5
"abc" . "def";      # returns "abcdef"
"Perl " . 5;        # returns "Perl 5"
</syntaxhighlight>
 
<syntaxhighlight lang="c">
# Example in Raku
"abc" ~ "def";      # returns "abcdef"
"Perl " ~ 6;        # returns "Perl 6"
</syntaxhighlight>

===कॉन्टैन===

{| class="wikitable"
|- style="background:#fffeed;"
! परिभाषा 
| <code>contains(''string'',''substring'')</code> returns boolean
|-
! विवरण 
| यह रीटर्न करता है कि स्ट्रिंग में सबस्ट्रिंग के रूप में सबस्ट्रिंग है या नहीं। यह फाइंड का उपयोग करने और फिर यह पता लगाने के बराबर है कि इसके परिणामस्वरूप फाइंड अनुभाग के तीसरे कॉलम में सूचीबद्ध विफलता की स्थिति नहीं आती है। चूंकि, कुछ लैंग्वेजो में इस परीक्षण को व्यक्त करने का एक सरल तरीका है।
|-
! संबंधित
| [[#Find|फाइंड]] 
|}
{| class="wikitable sortable"
|- style="text-align:left;"
! प्रारूप !! लैंग्वेज 
|-
| <code>''string_in_string''(''string'', '''loc int''', ''substring'')</code>
| [[ALGOL 68]]
|-
| <code>''ContainsStr''(''string'', ''substring'')</code>
| [[Object Pascal]] ([[Delphi (programming language)|Delphi]])
|-
| <code>strstr(''string'', ''substring'') != NULL</code>
| [[C (programming language)|C]], [[C++]] (<code>char *</code> only)
|-
| <code>''string''.Contains(''substring'')</code>
| [[C Sharp (programming language)|C#]], [[Visual Basic .NET|VB .NET]], [[Windows PowerShell]], [[F Sharp (programming language)|F#]]
|-
| <code>''string''.contains(''substring'')</code>
| [[Cobra (programming language)|Cobra]], [[Java (programming language)|Java]] (1.5+), [[Raku (programming language)|Raku]], [[Rust (programming language)|Rust]],<ref>See the [https://doc.rust-lang.org/stable/std/primitive.str.html#method.contains <code>str::contains</code>] method.</ref> [[C++]] ([[C++23]])<ref>See the [https://en.cppreference.com/w/cpp/string/basic_string/contains <code>std::basic_string::contains</code>] method.</ref>
|-
| <code>''string''.indexOf(''substring'') &gt;= 0</code>
|[[JavaScript]]
|-
| <code>strpos(''string'', ''substring'') !== false</code>
|[[PHP]]
|-
| <code>str_contains(''string'', ''substring'')</code>
|[[PHP]] (8+)
|-
| <code>pos(''string'', ''substring'') &lt;&gt; 0</code>
|[[Seed7]]
|-
| <code>''substring'' in ''string''</code>
|[[Cobra (programming language)|Cobra]], [[Python (programming language)|Python]] (2.3+)
|-
| <code>string.find(''string'', ''substring'') ~= nil</code>
|[[Lua (programming language)|Lua]]
|-
| <code>''string''.include?(''substring'')</code>
|[[Ruby (programming language)|Ruby]]
|-
| <code>Data.List.isInfixOf ''substring'' ''string''</code>
|[[Haskell (programming language)|Haskell]] (GHC 6.6+)
|-
| <code>''string'' includesSubstring: ''substring''</code>
|[[Smalltalk]] ([[Squeak]], [[Pharo]], [[Smalltalk/X]])
|-
| <code>String.isSubstring ''substring'' ''string''</code>
|[[Standard ML]]
|-
| <code>(search ''substring'' ''string'')</code>
|[[Common Lisp]]
|-
| <code>(not (null (string-index ''substring'' ''string'')))</code>
|[[ISLISP]]
|-
| <code>(substring? ''substring'' ''string'')</code>
|[[Clojure]]
|-
| <code>! StringFreeQ[''string'', ''substring'']</code>
|[[Mathematica]]
|-
| <code>index(''string'', ''substring'', ''startpos'')>0</code>
|[[Fortran, PL/I]]<ref name="contain1">''startpos'' is IBM extension.</ref>
|-
| <code>index(''string'', ''substring'', ''occurrence'')>0</code>
|[[Pick Basic]]
|-
| <code>strings.Contains(''string'', ''substring'')</code>
| [[Go (programming language)|Go]]
|-
| <code>''string''.find(''substring'') != string::npos</code>
| [[C++]]
|-
| <code>[''string'' containsString:''substring'']</code>
|[[Objective-C]] (<code>NSString *</code> only, iOS 8+/OS X 10.10+)
|-
| <code>''string''.rangeOfString(''substring'') != nil</code>
|[[Swift (programming language)|Swift]] (Foundation)
|-
| <code>∨/''substring''⍷''string''</code>
|[[APL (programming language)|APL]]
|}
 
<syntaxhighlight lang="c">
¢ Example in ALGOL 68 ¢
string in string("e", loc int, "Hello mate");      ¢ returns true ¢
string in string("z", loc int, "word");            ¢ returns false ¢
</syntaxhighlight><syntaxhighlight lang="csharp">
// Example In C#
"Hello mate".Contains("e");      // returns true
"word".Contains("z");            // returns false
</syntaxhighlight>

<syntaxhighlight lang="python">
#  Example in Python
"e" in "Hello mate"              #  returns true
"z" in "word"                    #  returns false
</syntaxhighlight>
#
<syntaxhighlight lang="c">
#  Example in Raku
"Good morning!".contains('z')    #  returns False
"¡Buenos días!".contains('í');   #  returns True
</syntaxhighlight><syntaxhighlight lang="c">
"  Example in Smalltalk "
'Hello mate' includesSubstring: 'e'  " returns true "
'word' includesSubstring: 'z'        " returns false "

</syntaxhighlight>

===इक्वलिटी ===
परीक्षण करते है कि क्या दो स्ट्रिंग बराबर हैं। #Compare और #Compare में जैसे दिखाया गया है। ध्यान दें कि इन्टिजर परिणाम के साथ सामान्य तुलना के माध्यम से इक्वलिटी जांच करना न केवल प्रोग्रामर के लिए भ्रमित करने वाला है, अपितु इस प्रकार यह बहुत अधिक महंगा ऑपरेशन है; इस प्रकार "सी-स्ट्रिंग्स" का उपयोग करते समय यह विशेष रूप से सच है।


{| class="wikitable sortable"
|- style="text-align:left;"
! प्रारूप !! लैंग्वेज 
|-
| <code>''string<sub>1</sub>'' == ''string<sub>2</sub>''</code>
|[[Python (programming language)|Python]], [[C++]] (STL), [[C Sharp (programming language)|C#]], [[Cobra (programming language)|Cobra]], [[Go (programming language)|Go]], [[JavaScript]] (similarity), [[PHP]] (similarity), [[Ruby (programming language)|Ruby]], [[Rust (programming language)|Rust]],<ref name="Rust compare" /> [[Erlang (programming language)|Erlang]], [[Haskell (programming language)|Haskell]], [[Lua (programming language)|Lua]], [[D (programming language)|D]], [[Mathematica]], [[Swift (programming language)|Swift]]
|-
| <code>''string<sub>1</sub>'' === ''string<sub>2</sub>''</code>
|[[JavaScript]], [[PHP]]
|-
| <code>''string<sub>1</sub>'' == ''string<sub>2</sub>'' or <br/> ''string<sub>1</sub>'' .EQ. ''string<sub>2</sub>''</code>
|[[Fortran]]
|-
| <code>strcmp(''string<sub>1</sub>'', ''string<sub>2</sub>'') == 0</code>
|[[C (programming language)|C]]
|-
| <code>(string=? ''string<sub>1</sub>'' ''string<sub>2</sub>'')</code>
|[[Scheme (programming language)|Scheme]]
|-
| <code>(string= ''string<sub>1</sub>'' ''string<sub>2</sub>'')</code>
|[[Common Lisp]], [[ISLISP]]
|-
| <code>''string<sub>1</sub>'' = ''string<sub>2</sub>''</code>
|[[ALGOL 68]], [[Ada (programming language)|Ada]], [[Object Pascal]] ([[Delphi (programming language)|Delphi]]), [[OCaml]], [[Pascal (programming language)|Pascal]], [[Rexx]], [[Seed7]], [[Standard ML]], [[BASIC]], [[Visual Basic (classic)|VB]], [[Visual Basic .NET|VB .NET]], [[F Sharp (programming language)|F#]], [[Smalltalk]], [[PL/I]], [[COBOL]]
|-
| <code>test ''string<sub>1</sub>'' = ''string<sub>2</sub>'', or <br />[ ''string<sub>1</sub>'' = ''string<sub>2</sub>'' ]</code>
|[[Bourne Shell]]
|-
| <code>''string<sub>1</sub>'' eq ''string<sub>2</sub>''</code>
|[[Perl]], [[Raku (programming language)|Raku]]
|-
| <code>''string<sub>1</sub>''.equals(''string<sub>2</sub>'')</code>
|[[Cobra (programming language)|Cobra]], [[Java (programming language)|Java]]
|-
| <code>''string<sub>1</sub>''.Equals(''string<sub>2</sub>'')</code>
|[[C Sharp (programming language)|C#]]
|-
| <code>''string<sub>1</sub>'' -eq ''string<sub>2</sub>'', or <br />[string]::Equals(''string<sub>1</sub>'', ''string<sub>2</sub>'')</code>
|[[Windows PowerShell]]
|-
| <code>[''string<sub>1</sub>'' isEqualToString:''string<sub>2</sub>''], or <br />[''string<sub>1</sub>'' isEqual:''string<sub>2</sub>'']</code>
|[[Objective-C]] (<code>NSString *</code> only)
|-
| <code>''string<sub>1</sub>'' ≡ ''string<sub>2</sub>''</code>
|[[APL (programming language)|APL]]
|-
| <code>''string<sub>1</sub>''.eq(''string<sub>2</sub>'')</code>
|[[Rust (programming language)|Rust]]<ref name="Rust compare" />
|}

<syntaxhighlight lang="csharp">
// Example in C#
"hello" == "world"           // returns false
</syntaxhighlight>

<syntaxhighlight lang="vbnet">
' Example in Visual Basic
"hello" = "world"            '  returns false
</syntaxhighlight>

<syntaxhighlight lang="perl">
# Examples in Perl 5
'hello' eq 'world'           # returns 0
'hello' eq 'hello'           # returns 1
</syntaxhighlight>
 
<syntaxhighlight lang="c">
# Examples in Raku
'hello' eq 'world'           # returns False
'hello' eq 'hello'           # returns True
</syntaxhighlight><syntaxhighlight lang="c">
# Example in Windows PowerShell
"hello" -eq "world"          #  returns false
</syntaxhighlight><syntaxhighlight lang="c">
⍝ Example in APL
'hello' ≡ 'world'          ⍝  returns 0
</syntaxhighlight>


===फाइंड===

{| class="wikitable"
|- style="background:#fffeed;"
! परिभाषा 
| <code>find(''string'',''substring'')</code> returns integer
|-
! विवरण 
| स्ट्रिंग में सबस्ट्रिंग की पहली घटना की शुरुआत की स्थिति रीटर्न करता है । यदि सबस्ट्रिंग नहीं मिलती है तो इनमें से अधिकतर रूटीन एक अमान्य इंडेक्स वैल्यू -1 लौटाते हैं जहां इंडेक्स 0 पर आधारित होते हैं 0 जहां वे 1 पर आधारित होते हैं या कुछ मान को बूलियन फाल्स के रूप में व्याख्या किया जाता है।
|-
! संबंधित 
| instrrev
|}
{| class="wikitable sortable"
|- style="text-align:left;"
! प्रारूप !! लैंग्वेज !! इफ नॉट फाउंड 
|-
| <code>string in string(substring, pos, ''string[startpos:]'')</code>
|[[ALGOL 68]]
|returns BOOL: TRUE or FALSE, and position in REF INT pos.
|-
| <code>InStr(«''startpos'',»''string'',''substring'')</code>
|[[Visual Basic (classic)|VB]] (positions start at 1)
|returns 0
|-
| <code>INSTR$(''string'',''substring'')</code>
|[[BASIC]] (positions start at 1)
|returns 0
|-
| <code>index(''string'',''substring'')</code>
|[[AWK]]
|returns 0
|-
| <code>index(''string'',''substring''«,''startpos''»)</code>
|[[Perl 5]]
|returns −1
|-
| <code>index(''string'',''substring''«,''startpos''»)</code> <br /> <code>''string''.index(''substring'',«,''startpos''»)</code>
|[[Raku (programming language)|Raku]]
|returns Nil
|-
| <code>instr(«''startpos'',»''string'',''substring'')</code>
|[[FreeBASIC]]
|returns 0
|-
| <code>strpos(''string'',''substring''«,''startpos''»)</code>
|[[PHP]]
|returns FALSE
|-
| <code>locate(''string'', ''substring'')</code>
|[[Ingres (database)|Ingres]]
|returns string length + 1
|-
| <code>strstr(''string'', ''substring'')</code>
|[[C (programming language)|C]], [[C++]] (<code>[[character (computing)|char]] [[Pointer (computer programming)|*]]</code> only, returns pointer to first character)
|returns NULL
|-
| <code>std.string.indexOf(''string'', ''substring'')</code>
|[[D (programming language)|D]]
|returns −1
|-
| <code>pos(''string'', ''substring''«, ''startpos''»)</code>
|[[Seed7]]
|returns 0
|-
| <code>strings.Index(''string'', ''substring'')</code>
|[[Go (programming language)|Go]]
|returns −1
|-
| <code>pos(''substring'', ''string'')</code>
|[[Pascal (programming language)|Pascal]], [[Object Pascal]] ([[Delphi (programming language)|Delphi]])
|returns 0
|-
| <code>pos(''substring'', ''string''«,''startpos''»)</code>
|[[Rexx]]
|returns 0
|-
| <code>''string''.find(''substring''«,''startpos''»)</code>
|[[C++]] (STL)
|returns std::string::npos
|-
| <code>''string''.find(''substring''«,''startpos''«,''endpos''»»)</code>
|rowspan=2|[[Python (programming language)|Python]]
|returns −1
|-
| <code>''string''.index(''substring''«,''startpos''«,''endpos''»»)</code>
|raises ValueError
|-
| <code>''string''.index(''substring''«,''startpos''»)</code>
|[[Ruby (programming language)|Ruby]]
|returns nil
|-
| <code>''string''.indexOf(''substring''«,''startpos''»)</code>
|[[Java (programming language)|Java]], [[JavaScript]]
|returns −1
|-
| <code>''string''.IndexOf(''substring''«,''startpos''«, ''charcount''»»)</code>
|[[Visual Basic .NET|VB .NET]], [[C Sharp (programming language)|C#]], [[Windows PowerShell]], [[F Sharp (programming language)|F#]]
|returns −1
|-
| <code>string:str(''string'', ''substring'')</code>
|[[Erlang (programming language)|Erlang]]
|returns 0
|-
| <code>(string-contains ''string'' ''substring'')</code>
|[[Scheme (programming language)|Scheme]] (SRFI 13)
|returns #f
|-
| <code>(search ''substring'' ''string'')</code>
|[[Common Lisp]]
|returns NIL
|-
| <code>(string-index ''substring'' ''string'')</code>
|[[ISLISP]]
|returns <code>nil</code>
|-
| <code>List.findIndex (List.isPrefixOf ''substring'') (List.tails ''string'')</code>
|[[Haskell (programming language)|Haskell]] (returns Just ''index'')
|returns Nothing
|-
| <code>Str.search_forward (Str.regexp_string ''substring'') ''string'' 0</code>
|[[OCaml]]
|raises Not_found
|-
| <code>Substring.size (#1 (Substring.position ''substring'' (Substring.full ''string'')))</code>
|[[Standard ML]]
|returns string length
|-
| <code>[''string'' rangeOfString:''substring''].location</code>
|[[Objective-C]] (<code>NSString *</code> only)
|returns NSNotFound
|-
| <code>string.find(''string'', ''substring'') <br /> (''string''):find(''substring'')</code>
|[[Lua (programming language)|Lua]]
|returns nil
|-
| <code>''string'' indexOfSubCollection: ''substring'' startingAt: ''startpos'' ifAbsent: ''aBlock'' <br /> ''string'' findString: ''substring'' startingAt: ''startpos'' </code>
|[[Smalltalk]] ([[Squeak]], [[Pharo]])
|evaluate aBlock which is a block closure (or any object understanding value) <br /> returns 0
|-
| <code>startpos = INDEX(''string'', ''substring'' «,''back''» «, ''kind''»)</code>
|[[Fortran]]
|returns 0 if substring is not in string; returns LEN(string)+1 if substring is empty
|-
| <code>POSITION(''substring'' IN ''string'')</code>
|[[SQL]]
|returns 0 (positions start at 1)
|-
| <code>index(''string'', ''substring'', ''startpos'' )</code>
|[[PL/I]]<ref name="contain1" />
|returns 0 (positions start at 1)
|-
| <code>index(''string'', ''substring'', ''occurrence'' )</code>
|[[Pick Basic]]
|returns 0 if occurrence of substring is not in string; (positions start at 1)
|-
| <code>''string''.indexOf(''substring''«,''startpos''«, ''charcount''»»)</code>
|[[Cobra (programming language)|Cobra]]
|returns −1
|-
| <code>string first ''substring string startpos''</code>
|[[Tcl]]
|returns −1
|-
| <code>(''substring''⍷''string'')⍳1</code>
|[[APL (programming language)|APL]]
|returns 1 + the last position in ''string''
|-
| <code>''string''.find(''substring'')</code>
|[[Rust (programming language)|Rust]]<ref name="Rust find">See the [https://doc.rust-lang.org/stable/std/primitive.str.html#method.find <code>str::find</code>] method.</ref>
|returns [[Option type|<code>None</code>]]
|}
उदाहरण
* सामान्य लिस्प
*: <syntaxhighlight lang="lisp">
(search "e" "Hello mate")             ;  returns 1
(search "z" "word")                   ;  returns NIL
</syntaxhighlight>
* C#
*: <syntaxhighlight lang="csharp">
"Hello mate".IndexOf("e");            // returns 1
"Hello mate".IndexOf("e", 4);         // returns 9
"word".IndexOf("z");                  // returns -1
</syntaxhighlight>
* राकु
*: <syntaxhighlight lang="raku">
"Hello, there!".index('e')           # returns 1
"Hello, there!".index('z')           # returns Nil
</syntaxhighlight>
* स्कीम
*: <syntaxhighlight lang="scheme">
(use-modules (srfi srfi-13))
(string-contains "Hello mate" "e")    ;  returns 1
(string-contains "word" "z")          ;  returns #f
</syntaxhighlight>
* विसुअल बेसिक 
*: <syntaxhighlight lang="vbnet">
' Examples in 
InStr("Hello mate", "e")              '  returns 2
InStr(5, "Hello mate", "e")           '  returns 10
InStr("word", "z")                    '  returns 0
</syntaxhighlight>
* स्माल टॉक 
*: <syntaxhighlight lang="smalltalk">
'Hello mate' indexOfSubCollection:'ate'  "returns 8"
</syntaxhighlight>
*: <syntaxhighlight lang="smalltalk">
'Hello mate' indexOfSubCollection:'late' "returns 0"
</syntaxhighlight>
*: <syntaxhighlight lang="smalltalk">
I'Hello mate' 
    indexOfSubCollection:'late'
    ifAbsent:[ 99 ]                      "returns 99"
</syntaxhighlight>
*: <syntaxhighlight lang="smalltalk">
'Hello mate' 
    indexOfSubCollection:'late'
    ifAbsent:[ self error ]              "raises an exception"
</syntaxhighlight>

===फाइंड करैक्टर ===

{| class="wikitable"
|- style="background:#fffeed;"
! परिभाषा 
| <code>find_character(''string'',''char'')</code> returns integer
|-
! विवरण 
| स्ट्रिंग में कैरेक्टर चार की पहली घटना की शुरुआत की स्थिति रीटर्न करता है । यदि करैक्टर नहीं मिलता है तो इनमें से अधिकांश रूटीन एक अमान्य सूचकांक मान -1 लौटाते हैं जहां सूचकांक 0-आधारित होते हैं, 0 जहां वे 1-आधारित होते हैं या कुछ मूल्य बूलियन गलत के रूप में व्याख्या किए जाते हैं। इसे एक करैक्टर की स्ट्रिंग के साथ फाइंड के एक विशेष स्थिति के रूप में पूरा किया जाता है लेकिन कई लैंग्वेजो में केवल एक करैक्टर का पता लगाना आसान या अधिक कुशल हो सकता है। इस प्रकार साथ ही कई लैंग्वेजो में अक्षर और स्ट्रिंग भिन्न -भिन्न प्रकार के होते हैं इसलिए ऐसा फ़ंक्शन रखना सुविधाजनक है।
|-
| संबंधित 
| फाइंड 
|}
{| class="wikitable sortable"
|- style="text-align:left;"
! प्रारूप !! लैंग्वेज !! इफ नॉट फाउंड 
|-
| <code>char in string(char, pos, ''string[startpos:]'')</code>
|[[ALGOL 68]]
|returns {{mono|BOOL}}: {{mono|TRUE}} or {{mono|FALSE}}, and position in {{mono|REF INT pos}}.
|-
| <code>instr(''string'', any ''char''«,''startpos''»)</code> (char, can contain more them one char, in which case the position of the first appearance of any of them is returned.)
|[[FreeBASIC]]
|returns 0
|-
| <code>strchr(''string'',''char'')</code>
|[[C (programming language)|C]], [[C++]] (<code>[[character (computing)|char]] [[Pointer (computer programming)|*]]</code> only, returns pointer to character)
|returns {{mono|NULL}}
|-
| <code>std.string.find(''string'', ''dchar'')</code>
|[[D (programming language)|D]]
|returns −1
|-
| <code>''string''.find(''char''«,''startpos''»)</code>
|[[C++]] (STL)
|returns {{mono|std::string::npos}}
|-
| <code>pos(''string'', ''char''«, ''startpos''»)</code>
|[[Seed7]]
|returns 0
|-
| <code>strings.IndexRune(''string'',''char'')</code>
|[[Go (programming language)|Go]]
|returns −1
|-
| <code>''string''.indexOf(''char''«,''startpos''»)</code>
|[[Java (programming language)|Java]], [[JavaScript]]
|returns −1
|-
| <code>''string''.IndexOf(''char''«,''startpos''«, ''charcount''»»)</code>
|[[Visual Basic .NET|VB .NET]], [[C Sharp (programming language)|C#]], [[Windows PowerShell]], [[F Sharp (programming language)|F#]]
|returns −1
|-
| <code>(position ''char'' ''string'')</code>
|[[Common Lisp]]
|returns {{mono|NIL}}
|-
| <code>(char-index ''char'' ''string'')</code>
|[[ISLISP]]
|returns {{mono|nil}}
|-
| <code>List.elemIndex ''char'' ''string''</code>
|[[Haskell (programming language)|Haskell]] (returns <code>Just ''index''</code>)
|returns {{mono|Nothing}}
|-
| <code>String.index ''string'' ''char''</code>
|[[OCaml]]
|raises {{mono|Not_found}}
|-
| <code>position = SCAN (''string'', ''set'' «, ''back''» «, ''kind''») or <br/> position = VERIFY (''string'', ''set'' «, ''back''» «, ''kind''»){{ref|Fortran find|[a]}}</code>
|[[Fortran]]
|returns zero
|-
| <code>''string'' indexOf: ''char'' ifAbsent: aBlock <br> ''string'' indexOf: ''char'' <br> ''string'' includes: ''char''</code>
|[[Smalltalk]]
|evaluate <code>aBlock</code> which is a <code>BlockClosure</code> (or any object understanding value) <br> returns 0 <br> returns <code>true</code> or <code>false</code>
|-
| <code>index(''string'', ''char'', ''startpos'' )</code>
|[[PL/I]]<ref name="fc1">''<code>startpos</code>'' is IBM extension.</ref>
|returns 0 (positions start at 1)
|-
|<code>''string''.index(?''char'')</code>
|[[Ruby (programming language)|Ruby]]
|returns {{mono|nil}}
|-
|<code>strpos(''string'',''char'',''startpos'')</code>
|[[PHP]]
|returns {{mono|false}}
|-
| <code>''string''.indexOf(''char''«,''startpos''«, ''charcount''»»)</code>
|[[Cobra (programming language)|Cobra]]
|returns −1
|-
| <code>''string''⍳''char''</code>
|[[APL (programming language)|APL]]
|returns 1 + the last position in ''string''
|-
| <code>''string''.find(''substring'')</code>
|[[Rust (programming language)|Rust]]<ref name="Rust find" />
|returns [[Option type|{{mono|None}}]]
|}

<syntaxhighlight lang="csharp">
// Examples in C#
"Hello mate".IndexOf('e');              // returns 1
"word".IndexOf('z')                     // returns -1
</syntaxhighlight>

<syntaxhighlight lang="lisp">
; Examples in Common Lisp
(position #\e "Hello mate")             ;  returns 1
(position #\z "word")                   ;  returns NIL
</syntaxhighlight>
<!-- endsection -->
{{note|Fortran find|a}} करैक्टर के एक सेट को देखते हुए, SCAN किये गए पहले करैक्टर की स्थिति रीटर्न करता है ,<ref>{{cite web|url=http://fortranwiki.org/fortran/show/scan |title=फोरट्रान विकी में स्कैन करें|publisher=Fortranwiki.org |date=2009-04-30 |access-date=2013-08-18}}</ref> जबकि VERIFY पहले करैक्टर की स्थिति रीटर्न करता है जो सेट से संबंधित नहीं है।<ref>{{cite web|url=http://fortranwiki.org/fortran/show/verify |title=फोरट्रान विकी में सत्यापित करें|publisher=Fortranwiki.org |date=2012-05-03 |access-date=2013-08-18}}</ref>


===फॉर्मेट ===
{{See also|प्रिंटफ फॉर्मेट स्ट्रिंग}}
<!-- startsection -->
{| class="wikitable"
|- style="background:#fffeed;"
! परिभाषा 
| <code>format(''formatstring'', ''items'')</code> returns string
|-
! विवरण 
| एक या अधिक आइटम का स्वरूपित स्ट्रिंग प्रतिनिधित्व रीटर्न करता है।
|}
{| class="wikitable sortable"
|- style="text-align:left;"
! प्रारूप 
! लैंग्वेज 
! प्रारूप string syntax
|-
| <code>associate(''file'', ''string''); [[putf]](''file'', ''$प्रारूप string$'', ''items'')</code>
|[[ALGOL 68]]
|ALGOL
|-
| <code>प्रारूप (''item'', ''प्रारूप string'')</code>
|[[Visual Basic (classic)|VB]]
| <code></code>
|-
| <code>[[sprintf]](''प्रारूप string'', ''items'')</code>
|[[Perl]], [[PHP]], [[Raku (programming language)|Raku]], [[Ruby (programming language)|Ruby]]
|C
|-
| <code>item.fmt(''प्रारूप string'')</code>
|[[Raku (programming language)|Raku]]
|C
|-
| <code>io_lib:प्रारूप (''प्रारूप string'', ''items'')</code>
|[[Erlang (programming language)|Erlang]]
| <code></code>
|-
| <code>[[sprintf]](''outputstring'', ''प्रारूप string'', ''items'')</code>
|[[C (programming language)|C]]
|C
|-
| <code>std::प्रारूप (''प्रारूप string'', ''items'')</code>
| [[C++]] ([[C++20]])
|Python
|-
| <code>std.string.प्रारूप (''प्रारूप string'', ''items'')</code>
|[[D (programming language)|D]]
|C
|-
| <code>प्रारूप (''प्रारूप string'', ''items'')</code>
|[[Object Pascal]] ([[Delphi (programming language)|Delphi]])
| <code></code>
|-
| <code>fmt.Sprintf(''प्रारूप string'', ''items'')</code>
|[[Go (programming language)|Go]]
|C
|-
| <code>[[printf (Unix)|printf]] ''प्रारूप string'' ''items''</code>
|[[Unix]]
|C
|-
| <code>''प्रारूप string'' % (''items'')</code>
|[[Python (programming language)|Python]], [[Ruby (programming language)|Ruby]]
|C
|-
| <code>''प्रारूप string''.प्रारूप (''items'')</code>
|[[Python scripting language|Python]]
|.NET
|-
|<code>f''प्रारूप string''</code>
|[[Python 3]]
|-
| <code>Printf.sprintf ''प्रारूप string''</code><ref>''<code>formatstring</code>'' must be a fixed literal at compile time for it to have the correct type.</ref><code> ''items''</code>
| [[OCaml]], [[F Sharp (programming language)|F#]]
|C
|-
| <code>Text.Printf.printf ''प्रारूप string'' ''items''</code>
|[[Haskell (programming language)|Haskell]] (GHC)
|C
|-
| <code>''प्रारूप string'' printf: ''items''</code>
|[[Smalltalk]]
|C
|-
| <code>String.प्रारूप (''प्रारूप string'', ''items'')</code>
|[[Java (programming language)|Java]]
|C
|-
| <code>String.प्रारूप (''प्रारूप string'', ''items'')</code>
|[[Visual Basic .NET|VB .NET]], [[C Sharp (programming language)|C#]], [[F Sharp (programming language)|F#]]
|.NET
|-
| <code>(प्रारूप ''प्रारूप string'' ''items'')</code>
|[[Scheme (programming language)|Scheme]] (SRFI 28)
|Lisp
|-
| <code>([[Format (Common Lisp)|प्रारूप]] nil ''प्रारूप string'' ''items'')</code>
|[[Common Lisp]]
|Lisp
|-
| <code>(प्रारूप ''प्रारूप string'' ''items'')</code>
|[[Clojure]]
|Lisp
|-
| <code>''प्रारूप string'' -f ''items''</code>
|[[Windows PowerShell]]
|.NET
|-
| <code>[NSString stringWithप्रारूप :''प्रारूप string'', ''items'']</code>
|[[Objective-C]] (<code>NSString *</code> only)
|C
|-
| <code>String(प्रारूप :''प्रारूप string'', ''items'')</code>
|[[Swift (programming language)|Swift]] (Foundation)
|C
|-
| <code>string.प्रारूप (''प्रारूप string'', ''items'') <br /> (''प्रारूप string''):प्रारूप (''items'')</code>
|[[Lua (programming language)|Lua]]
|C
|-
| <code>WRITE (''outputstring'', ''प्रारूप string'') ''items''</code>
|[[Fortran]]
|Fortran
|-
| <code>put string(''string'') edit(''items'')(''प्रारूप'' )</code>
|[[PL/I]]
|PL/I (similar to Fortran)
|-
| <code>String.प्रारूप (''प्रारूप string'', ''items'')</code>
|[[Cobra (programming language)|Cobra]]
|.NET
|-
| <code>प्रारूप ''प्रारूप string items''</code>
|[[Tcl]]
|C
|-
| <code>''प्रारूप numbers'' ⍕ ''items''</code> or <code>''प्रारूप string'' ⎕FMT ''items''</code>
|[[APL (programming language)|APL]]
|APL
|-
| <code>प्रारूप !(''प्रारूप string'', ''items'')</code>
| [[Rust (programming language)|Rust]]<ref>See [https://doc.rust-lang.org/stable/std/macro.format.html <code>std::format</code>], which is imported by the Rust [https://doc.rust-lang.org/stable/std/prelude/index.html prelude] so that it can be used under the name <code>format</code>.</ref>
| Python
|}

<syntaxhighlight lang="csharp">
// Example in C#
String.Format("My {0} costs {1:C2}", "pen", 19.99); // returns "My pen costs $19.99"
</syntaxhighlight>

<syntaxhighlight lang="delphi">
// Example in Object Pascal (Delphi)
Format('My %s costs $%2f', ['pen', 19.99]);         // returns "My pen costs $19.99"
</syntaxhighlight>

<syntaxhighlight lang="java">
// Example in Java
String.format("My %s costs $%2f", "pen", 19.99);    // returns "My pen costs $19.99"
</syntaxhighlight><syntaxhighlight lang="c">
# Examples in Raku
sprintf "My %s costs \$%.2f", "pen", 19.99;          # returns "My pen costs $19.99"
1.fmt("%04d");                                       # returns "0001"
</syntaxhighlight>
; <syntaxhighlight lang="c">
# Example in Python
"My %s costs $%.2f" % ("pen", 19.99);                #  returns "My pen costs $19.99"
"My {0} costs ${1:.2f}".format("pen", 19.99);        #  returns "My pen costs $19.99"
</syntaxhighlight>
; <syntaxhighlight lang="c">
#Example in Python 3.6+
pen = "pen"
f"My {pen} costs {19.99}"                                          #returns "My pen costs 19.99"
</syntaxhighlight>
; <syntaxhighlight lang="c">
/* example in PL/I */
put string(some_string) edit('My ', 'pen', ' costs', 19.99)(a,a,a,p'$$$V.99')
/* returns "My pen costs $19.99" */
</syntaxhighlight>

===इन इक्वलिटी ===
यदि दो स्ट्रिंग बराबर नहीं हैं तो टेस्ट करते है। इस प्रकार #Equality में दिखाया गया है
{| class="wikitable sortable"
|- style="text-align:left;"
! प्रारूप !! लैंग्वेज 
|-
| <code>''string<sub>1</sub>'' '''ne''' ''string<sub>2</sub>'', or ''string<sub>1</sub>'' NE ''string<sub>2</sub>''</code>
|[[ALGOL 68]] – note: the operator "'''ne'''" is literally in '''bold''' type-font.
|-
| <code>''string<sub>1</sub>'' /= ''string<sub>2</sub>''</code>
|[[ALGOL 68]], [[Ada (programming language)|Ada]], [[Erlang (programming language)|Erlang]], [[Fortran]], [[Haskell (programming language)|Haskell]] 
|-
| <code>''string<sub>1</sub>'' <> ''string<sub>2</sub>''</code>
|[[BASIC]], [[Visual Basic (classic)|VB]], [[Visual Basic .NET|VB .NET]], [[Pascal (programming language)|Pascal]], [[Object Pascal]] ([[Delphi (programming language)|Delphi]]), [[OCaml]], [[PHP]], [[Seed7]], [[Standard ML]], [[F Sharp (programming language)|F#]], [[COBOL]], [[Cobra (programming language)|Cobra]], [[Python 2]] (deprecated)
|-
| <code>''string<sub>1</sub>'' # ''string<sub>2</sub>''</code>
|[[BASIC]] (some implementations)
|-
| <code>''string<sub>1</sub>'' ne ''string<sub>2</sub>''</code>
|[[Perl]], [[Raku (programming language)|Raku]] 
|-
| <code>(string<> ''string<sub>1</sub>'' ''string<sub>2</sub>'')</code>
|[[Scheme (programming language)|Scheme]] (SRFI 13)
|-
| <code>(string/= ''string<sub>1</sub>'' ''string<sub>2</sub>'')</code>
|[[Common Lisp]] 
|-
| <code>(string/= ''string<sub>1</sub>'' ''string<sub>2</sub>'')</code>
|[[ISLISP]] 
|-
| <code>(not= ''string<sub>1</sub>'' ''string<sub>2</sub>'')</code>
|[[Clojure]] 
|-
| <code>''string<sub>1</sub>'' != ''string<sub>2</sub>''</code>
|[[C++]] (STL), [[C Sharp (programming language)|C#]], [[Go (programming language)|Go]], [[JavaScript]] (not similar), [[PHP]] (not similar), [[Python (programming language)|Python]], [[Ruby (programming language)|Ruby]], [[Rust (programming language)|Rust]],<ref name="Rust compare" /> [[Swift (programming language)|Swift]], [[D (programming language)|D]], [[Mathematica]]
|-
| <code>''string<sub>1</sub>'' !== ''string<sub>2</sub>''</code>
|[[JavaScript]], [[PHP]] 
|-
| <code>''string<sub>1</sub>'' \= ''string<sub>2</sub>''</code>
|[[Rexx]] 
|-
| <code>''string<sub>1</sub>'' ¬= ''string<sub>2</sub>''</code>
|[[PL/I]] 
|-
| <code>test ''string<sub>1</sub>'' != ''string<sub>2</sub>'', or <br />[ ''string<sub>1</sub>'' != ''string<sub>2</sub>'' ]</code>
|[[Bourne Shell]]
|-
| <code>''string<sub>1</sub>'' -ne ''string<sub>2</sub>'', or <br />-not [string]::Equals(''string<sub>1</sub>'', ''string<sub>2</sub>'')</code>
|[[Windows PowerShell]]
|-
| <code>''string<sub>1</sub>'' ~= ''string<sub>2</sub>''</code>
|[[Lua (programming language)|Lua]], [[Smalltalk]]
|-
| <code>''string<sub>1</sub>'' ≢ ''string<sub>2</sub>''</code>
|[[APL (programming language)|APL]]
|-
| <code>''string<sub>1</sub>''.ne(''string<sub>2</sub>'')</code>
| [[Rust (programming language)|Rust]]<ref name="Rust compare" />
|}

<syntaxhighlight lang="csharp">
// Example in C#
"hello" != "world"    // returns true
</syntaxhighlight>

<syntaxhighlight lang="vbnet">
' Example in Visual Basic
"hello" <> "world"    '  returns true
</syntaxhighlight>

<syntaxhighlight lang="clojure">
;; Example in Clojure
(not= "hello" "world")  ; ⇒ true
</syntaxhighlight>

<syntaxhighlight lang="perl">
# Example in Perl 5
'hello' ne 'world'      # returns 1
</syntaxhighlight><syntaxhighlight lang="c">
# Example in Raku
'hello' ne 'world'      # returns True

</syntaxhighlight>
  
<syntaxhighlight lang="c">
# Example in Windows PowerShell
"hello" -ne "world"   #  returns true
</syntaxhighlight>

===इंडेक्स ===
देखें #Find

===इंडेक्स ऑफ़ ===
देखें #Find

===इंस्ट्र===
देखें #Find

===इंस्ट्रेव===
#देखें #rfind 

===जॉइन ===
{| class="wikitable"
|- style="background:#fffeed;"
! परिभाषा 
| <code> join(''separator'', ''list_of_strings'')</code> returns a list of strings joined with a separator
|-
! विवरण 
| प्रत्येक सबस्ट्रिंग के बीच सेपरेटर स्ट्रिंग के साथ, स्ट्रिंग की सूची को एक नई स्ट्रिंग में जोड़ता है। विभाजन के विपरीत होता है 
|-
| संबंधित 
| sprintf
|}
{| class="wikitable sortable"
|- style="text-align:left;"
! प्रारूप !! लैंग्वेज 
|-
| <code>std.string.join(''array_of_strings'', ''separator'')</code>
|[[D (programming language)|D]]
|-
| <code>string:join(''list_of_strings'', ''separator'')</code>
|[[Erlang (programming language)|Erlang]]
|-
| <code>join(''separator'', ''list_of_strings'')</code>
|[[Perl]], [[PHP]], [[Raku (programming language)|Raku]]
|-
| <code>implode(''separator'', ''array_of_strings'')</code>
|[[PHP]]
|-
| <code>''separator''.join(''sequence_of_strings'')</code>
|[[Python (programming language)|Python]], [[Swift (programming language)|Swift]] 1.x
|-
| <code>''array_of_strings''.join(''separator'')</code>
|[[Ruby (programming language)|Ruby]], [[JavaScript]], [[Raku (programming language)|Raku]], [[Rust (programming language)|Rust]]<ref>See the [https://doc.rust-lang.org/stable/std/primitive.slice.html#method.join <code>slice::join</code>] method.</ref>
|-
| <code>(string-join ''array_of_strings'' ''separator'')</code>
|[[Scheme (programming language)|Scheme]] (SRFI 13)
|-
| <code>([[Format (Common Lisp)|प्रारूप]] nil "~{~a~^''separator''~}" ''array_of_strings'')</code>
|[[Common Lisp]]
|-
| <code>(clojure.string/join ''separator'' ''list_of_strings'')<br/>(apply str (interpose ''separator'' ''list_of_strings''))</code>
|[[Clojure]]
|-
| <code>strings.Join(''array_of_strings'', ''separator'')</code>
|[[Go (programming language)|Go]]
|-
| <code>join(''array_of_strings'', ''separator'')</code>
|[[Seed7]]
|-
| <code>String.concat ''separator'' ''list_of_strings''</code>
|[[OCaml]]
|-
| <code>String.concatWith ''separator'' ''list_of_strings''</code>
|[[Standard ML]]
|-
| <code>Data.List.intercalate ''separator'' ''list_of_strings''</code>
|[[Haskell (programming language)|Haskell]] (GHC 6.8+)
|-
| <code>Join(''array_of_strings'', ''separator'')</code>
|[[Visual Basic (classic)|VB]]
|-
| <code>String.Join(''separator'', ''array_of_strings'')</code>
|[[Visual Basic .NET|VB .NET]], [[C Sharp (programming language)|C#]], [[F Sharp (programming language)|F#]]
|-
| <code>String.join(''separator'', ''array_of_strings'')</code>
|[[Java (programming language)|Java]] 8+
|-
| <code>&{$OFS=''$separator''; "''$array_of_strings''"}, or <br />''array_of_strings'' -join ''separator''</code>
|[[Windows PowerShell]]
|-
| <code>[''array_of_strings'' componentsJoinedByString:''separator'']</code>
|[[Objective-C]] (<code>NSString *</code> only)
|-
| <code>table.concat(''table_of_strings'', ''separator'')</code>
|[[Lua (programming language)|Lua]] 
|-
| <code><nowiki>{|String streamContents: [ :stream |</nowiki> ''collectionOfAnything'' asStringOn: stream delimiter: ''separator'' <nowiki>]</nowiki> <br/>''collectionOfAnything'' joinUsing: ''separator''</code>
|[[Smalltalk]] ([[Squeak]], [[Pharo]])
|-
| <code>''array_of_strings''.join(''separator''«, ''final_separator''»)</code>
|[[Cobra (programming language)|Cobra]]
|-
| <code>''sequence_of_strings''.joinWithSeparator(''separator'')</code>
|[[Swift (programming language)|Swift]] 2.x
|-
| <code>1↓∊''separator'',¨''list_of_strings''</code>
|[[APL (programming language)|APL]]
|}

<syntaxhighlight lang="csharp">
// Example in C#
String.Join("-", {"a", "b", "c"})  // "a-b-c"
</syntaxhighlight>

<syntaxhighlight lang="smalltalk">
" Example in Smalltalk "
#('a' 'b' 'c') joinUsing: '-'      " 'a-b-c' "
</syntaxhighlight>

<syntaxhighlight lang="perl">
# Example in Perl 5
join( '-', ('a', 'b', 'c'));       # 'a-b-c'
</syntaxhighlight><syntaxhighlight lang="c">
# Example in Raku
<a b c>.join('-');       # 'a-b-c'
</syntaxhighlight><syntaxhighlight lang="c">
# Example in Python
"-".join(["a", "b", "c"])          #  'a-b-c'
</syntaxhighlight><syntaxhighlight lang="c">
# Example in Ruby
["a", "b", "c"].join("-")          #  'a-b-c'
</syntaxhighlight><syntaxhighlight lang="c">
; Example in Scheme
(use-modules (srfi srfi-13))
(string-join '("a" "b" "c") "-")   ;  "a-b-c"
</syntaxhighlight>

===lastindexof===
#rfind देखें

===बाएं===
{| class="wikitable"
|- style="background:#fffeed;"
! परिभाषा 
| <code>left(''string'',''n'')</code> returns string
|-
! विवरण 
| स्ट्रिंग का बायां n भाग रीटर्न करता है। यदि n स्ट्रिंग की लंबाई से अधिक है तो अधिकांश कार्यान्वयन संपूर्ण स्ट्रिंग एक्सेप्शन रीटर्न करता है, इसे उदाहरण के रूप में दिखाया गया है। इस प्रकार ध्यान दें कि UTF-8, UTF-16 या Shift-JIS जैसे परिवर्तनीय लंबाई एन्कोडिंग के लिए इनवेलिड स्ट्रिंग्स से बचने के लिए अंत में स्ट्रिंग स्थिति को हटाना आवश्यक होता है।
|}
{| class="wikitable sortable"
|- style="text-align:left;"
! फॉर्मेट !! लैंग्वेज 
|-
|<code>string (string'First .. string'First + ''n'' - 1)</code>
|[[Ada (programming language)|Ada]]
|-
| <code>substr(''string'', 0, ''n'')</code>
|[[AWK]] (changes string), [[Perl]], [[PHP]], [[Raku (programming language)|Raku]]
|-
| <code>LEFT$(''string'',''n'')</code>
|[[BASIC]], [[Visual Basic (classic)|VB]]
|-
| <code>left(''string'',''n'')</code>
||[[Visual Basic (classic)|VB]], [[FreeBASIC]], [[Ingres (database)|Ingres]], [[Pick Basic]]
|-
| <code>strncpy(''string2'', ''string'', ''n'')</code>
|[[C (programming language)|C standard library]]
|-
| <code>''string''.substr(0,''n'')</code>
|[[C++]] (STL), [[Raku (programming language)|Raku]]
|-
| <code>[''string'' substringToIndex:''n'']</code>
|[[Objective-C]] (<code>NSString *</code> only)
|-
| <code>(apply str (take ''n'' ''string''))</code>
|[[Clojure]]
|-
| <code>''string''[0 .. ''n'']</code>
|[[D (programming language)|D]]<ref>if n is larger than the length of the string, then in Debug mode ArrayRangeException is thrown, in Release mode, the behaviour is [[unspecified behavior|unspecified]].</ref>
|-
| <code>string:substr(''string'', ''start'', ''length'')</code>
|[[Erlang (programming language)|Erlang]]
|-
| <code>(subseq ''string'' 0 ''n'')</code>
|[[Common Lisp]]
|-
| <code>''string''[:''n'']</code>
|[[Cobra (programming language)|Cobra]], [[Go (programming language)|Go]], [[Python (programming language)|Python]]
|-
| <code>left(''string'',''n'' «,''padchar''»)</code>
|[[Rexx]], [[Erlang (programming language)|Erlang]]
|-
| <code>''string''[0, ''n''] <br /> ''string''[0..''n'' - 1]</code>
|[[Ruby (programming language)|Ruby]]
|-
| <code>''string''[1, ''n'']</code>
|[[Pick Basic]]
|-
| <code>''string''[ .. ''n'']</code>
|[[Seed7]]
|-
| <code>''string''.Substring(0,''n'')</code>
|[[Visual Basic .NET|VB .NET]], [[C Sharp (programming language)|C#]], [[Windows PowerShell]], [[F Sharp (programming language)|F#]]
|-
| <code>leftstr(''string'', ''n'')</code>
|[[Pascal (programming language)|Pascal]], [[Object Pascal]] ([[Delphi (programming language)|Delphi]])
|-
|<code>''copy'' (''string'',1,''n'')</code>
|[[Turbo Pascal]]
|-
| <code>''string''.substring(0,''n'')</code>
|[[Java (programming language)|Java]],<ref>if n is larger than the length of the string, Java will throw an IndexOutOfBoundsException</ref> [[JavaScript]] 
|-
| <code>(string-take ''string'' ''n'')</code>
|[[Scheme (programming language)|Scheme]] (SRFI 13)
|-
| <code>take ''n'' ''string''</code>
|[[Haskell (programming language)|Haskell]]
|-
| <code>String.extract (''string'', ''n'', NONE)</code>
|[[Standard ML]]
|-
| <code>String.sub ''string'' 0 ''n''</code>
|[[OCaml]]<ref name="ReferenceA">if n is larger than length of string, raises Invalid_argument</ref>
|-
| <code>''string''.[..''n'']</code>
|[[F Sharp (programming language)|F#]]
|-
| <code>string.sub(''string'', 1, ''n'') <br /> (''string''):sub(1, ''n'')</code>
|[[Lua (programming language)|Lua]]
|-
| <code>''string'' first: ''n''</code>
|[[Smalltalk]] ([[Squeak]], [[Pharo]])
|-
| <code>''string''(:''n'')</code>
|[[Fortran]]
|-
| <code>StringTake[''string'', ''n'']</code>
|[[Mathematica]]<ref name="ReferenceB">if n is larger than length of string, throw the message "StringTake::take:"</ref>
|-
|<code>''string'' («FUNCTION» LENGTH(''string'') - ''n'':''n'')</code>
|[[COBOL]]
|-
|<code>''string''.substring(0, ''n'')</code>
|[[Cobra (programming language)|Cobra]]
|-
|<code>''n''↑''string''.</code>
|[[APL (programming language)|APL]]
|-
| <code>''string''[0..n]</code><br><code>''string''[..n]</code><br><code>''string''.get(0..n)</code><br><code>''string''.get(..n)</code>
| [[Rust (programming language)|Rust]]<ref name="Rust indexing">In Rust, strings are indexed in terms of byte offsets and there is a runtime panic if the index is out of bounds or if it would result in invalid [[UTF-8]]. A <code>&str</code> (string reference) can be [https://doc.rust-lang.org/stable/std/primitive.str.html#impl-Index%3CI%3E indexed] by various types of ranges, including [https://doc.rust-lang.org/stable/std/slice/trait.SliceIndex.html#impl-SliceIndex%3Cstr%3E <code>Range</code>] (<code>0..n</code>), [https://doc.rust-lang.org/stable/std/slice/trait.SliceIndex.html#impl-SliceIndex%3Cstr%3E-1 <code>RangeFrom</code>] (<code>n..</code>), and [https://doc.rust-lang.org/stable/std/slice/trait.SliceIndex.html#impl-SliceIndex%3Cstr%3E-4 <code>RangeTo</code>] (<code>..n</code>) because they all implement the [https://doc.rust-lang.org/stable/std/slice/trait.SliceIndex.html <code>SliceIndex</code>] trait with <code>str</code> being the type being indexed.

The [https://doc.rust-lang.org/stable/std/primitive.str.html#method.get <code>str::get</code>] method is the non-panicking way to index. It returns [[option type|<code>None</code>]] in the cases in which indexing would panic.</ref>
|}
<syntaxhighlight lang="c++-objdumb">
# Example in Raku
"Hello, there!".substr(0, 6);  # returns "Hello,"
</syntaxhighlight><syntaxhighlight lang="c">
/* Examples in Rexx */
left("abcde", 3)         /* returns "abc"      */
left("abcde", 8)         /* returns "abcde   " */
left("abcde", 8, "*")    /* returns "abcde***" */
</syntaxhighlight><syntaxhighlight lang="c">
; Examples in Scheme
(use-modules (srfi srfi-13))
(string-take "abcde", 3) ;  returns "abc" 
(string-take "abcde", 8) ;  error

</syntaxhighlight><syntaxhighlight lang="c">
' Examples in Visual Basic
Left("sandroguidi", 3)   '  returns "san" 
Left("sandroguidi", 100) '  returns "sandroguidi"
</syntaxhighlight>

===लेन===
##length देखें




===लंबाई===
{| class="wikitable"
|- style="background:#fffeed;"
! परिभाषा 
| <code>length(''string'')</code> returns an integer number
|-
! विवरण 
| शून्य टर्मिनेटर या स्ट्रिंग की किसी अन्य आंतरिक संरचनात्मक जानकारी की गणना न करते हुए स्ट्रिंग की लंबाई रीटर्न करता है। इस प्रकार एक खाली स्ट्रिंग 0 की लंबाई रीटर्न करती है।
|}
{| class="wikitable sortable"
|- style="text-align:left;"
! फॉर्मेट !! Returns !! लैंग्वेज 
|-
|<code>string'Length</code>
| <code></code>
|[[Ada (programming language)|Ada]]
|-
|<code>UPB string</code>
| <code></code>
|[[ALGOL 68]]
|-
|<code>echo "${#''string_param''}"</code>
| <code></code>
|[[Bash (Unix shell)|Bash]]
|-
| <code>length(''string'')</code>
| <code></code>
|[[Ingres (database)|Ingres]], [[Perl 5]], [[Pascal (programming language)|Pascal]], [[Object Pascal]] ([[Delphi (programming language)|Delphi]]), [[Rexx]], [[Seed7]], [[SQL]], [[PL/I]]
|-
| <code>len(''string'')</code>
| <code></code>
|[[BASIC]], [[FreeBASIC]], [[Python (programming language)|Python]], [[Go (programming language)|Go]], [[Pick Basic]]
|-
| <code>length(''string''), string:len(''string'')</code>
| <code></code>
|[[Erlang (programming language)|Erlang]]
|-
| <code>Len(''string'')</code>
| <code></code>
|[[Visual Basic (classic)|VB]], [[Pick Basic]]
|-
| <code>''string''.Length</code>
|Number of [[UTF-16]] [[code unit]]s
|[[Visual Basic .NET|VB .NET]], [[C Sharp (programming language)|C#]], [[Windows PowerShell]], [[F Sharp (programming language)|F#]]
|-
| <code>chars(''string'')</code> <br /> <code>''string''.chars</code>
|Number of graphemes (NFG)
|[[Raku (programming language)|Raku]]
|-
| <code>codes(''string'')</code> <br /> <code>''string''.codes</code>
|Number of Unicode code points
|[[Raku (programming language)|Raku]]
|-
| <code>''string''.size OR ''string''.length</code>
|Number of bytes<ref>Ruby lacks Unicode support</ref>
|[[Ruby (programming language)|Ruby]]
|-
| <code>[[strlen]](''string'')</code>
|Number of bytes
|[[C (programming language)|C]], [[PHP]]
|-
| <code>''string''.length()</code>
| <code></code>
|[[C++]] (STL)
|-
| <code>''string''.length</code>
| <code></code>
|[[Cobra (programming language)|Cobra]], [[D (programming language)|D]], [[JavaScript]]
|-
| <code>''string''.length()</code>
|Number of [[UTF-16]] [[code unit]]s
|[[Java (programming language)|Java]]
|-
| <code>(string-length ''string'')</code>
| <code></code>
|[[Scheme (programming language)|Scheme]]
|-
| <code>(length ''string'')</code>
| <code></code>
|[[Common Lisp]], [[ISLISP]]
|-
| <code>(count ''string'')</code>
| <code></code>
|[[Clojure]]
|-
| <code>String.length ''string''</code>
| <code></code>
|[[OCaml]]
|-
| <code>size ''string''</code>
| <code></code>
|[[Standard ML]]
|-
| <code>length ''string''</code>
|Number of Unicode code points
|[[Haskell (programming language)|Haskell]]
|-
| <code>''string''.length</code>
| Number of [[UTF-16]] code units
|[[Objective-C]] (<code>NSString *</code> only)
|-
| <code>''string''.characters.count</code>
| Number of characters
|[[Swift (programming language)|Swift]] (2.x)
|-
| <code>count(''string'')</code>
| Number of characters
|[[Swift (programming language)|Swift]] (1.2)
|-
| <code>countElements(''string'')</code>
| Number of characters
|[[Swift (programming language)|Swift]] (1.0–1.1)
|-
| <code>string.len(''string'') <br /> (''string''):len() <br /> #''string''</code>
| <code></code>
|[[Lua (programming language)|Lua]]
|-
| <code>''string'' size</code>
| <code></code>
|[[Smalltalk]]
|-
| <code>LEN(''string''), or LEN_TRIM(''string'')</code>
| <code></code>
|[[Fortran]]
|-
| <code>StringLength[''string'']</code>
| <code></code>
|[[Mathematica]]
|-
|<code>«FUNCTION» LENGTH(''string'')</code> or
<code>«FUNCTION» BYTE-LENGTH(''string'')</code>
| number of characters and number of bytes, respectively
| [[COBOL]]
|-
|<code>string length ''string''</code>
|a decimal string giving the number of characters
|[[Tcl]]
|-
|<code>≢ ''string''</code>
|
|[[APL (programming language)|APL]]
|-
| <code>''string''.len()</code>
| Number of bytes
| [[Rust (programming language)|Rust]]<ref>See the [https://doc.rust-lang.org/stable/std/primitive.str.html#method.len <code>str::len</code>] method.</ref>
|-
| <code>''string''.chars().count()</code>
| Number of Unicode code points
| [[Rust (programming language)|Rust]]<ref>In Rust, the [https://doc.rust-lang.org/std/primitive.str.html#method.chars <code>str::chars</code>] method iterates over code points and the [https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.count <code>std::iter::Iterator::count</code>] method on iterators consumes the iterator and returns the total number of elements in the iterator.</ref>
|}

<syntaxhighlight lang="csharp">
// Examples in C#
"hello".Length;      // returns 5
"".Length;           // returns 0
</syntaxhighlight>

<syntaxhighlight lang="erlang">
# Examples in Erlang
string:len("hello"). %  returns 5
string:len("").      %  returns 0
</syntaxhighlight>

<syntaxhighlight lang="perl">
# Examples in Perl 5
length("hello");     #  returns 5
length("");          #  returns 0
</syntaxhighlight><syntaxhighlight lang="c">
# Examples in Raku
"🏳️‍🌈".chars; chars "🏳️‍🌈";      # both return 1
"🏳️‍🌈".codes; codes "🏳️‍🌈";      # both return 4
"".chars; chars "";          # both return 0
"".codes; codes "";          # both return 0

</syntaxhighlight><syntaxhighlight lang="c">
' Examples in Visual Basic
Len("hello")         '  returns 5
Len("")              '  returns 0
</syntaxhighlight><syntaxhighlight lang="c">
//Examples in Objective-C
[@"hello" Length]   //returns 5
[@"" Length]   //returns 0

</syntaxhighlight><syntaxhighlight lang="c">
-- Examples in Lua
("hello"):len() -- returns 5
#"" -- returns 0
</syntaxhighlight>

===लोकेट===

देखें #Find
===लोअरकेस===

{| class="wikitable"
|- style="background:#fffeed;"
! परिभाषा 
| <code>lowercase(''string'')</code> returns string
|-
! विवरण 
| लोअरकेस में स्ट्रिंग रीटर्न करता है। 
|}
{| class="wikitable sortable"
|- style="text-align:left;"
! फॉर्मेट !! लैंग्वेज 
|-
| <code>LCase(''string'') </code>
|[[Visual Basic (classic)|VB]]
|-
| <code>lcase(''string'') </code>
|[[FreeBASIC]]
|-
| <code>lc(''string'')</code>
|[[Perl]], [[Raku (programming language)|Raku]]
|-
| <code>''string''.lc</code>
|[[Raku (programming language)|Raku]]
|-
|<code>tolower(''char'')</code>
|[[C (programming language)|C]]<ref>operates on one character</ref>
|-
| <code>std.string.toLower(''string'') </code>
|[[D (programming language)|D]]
|-
| <code>transform(''string''.begin(), ''string''.end(), ''result''.begin(), ::tolower)</code><ref name="cpptransform">The <code>transform</code> function exists in the <code>std::</code> namespace. You must include the <code><algorithm></code> header file to use it. The <code>tolower</code> and <code>toupper</code> functions are in the global namespace, obtained by the <code><ctype.h></code> header file. The <code>std::tolower</code> and <code>std::toupper</code> names are overloaded and cannot be passed to <code>std::transform</code> without a cast to resolve a function overloading ambiguity, e.g. <code>std::transform(''string''.begin(), ''string''.end(), ''result''.begin(), (int (*)(int))std::tolower);</code></ref>
| [[C++]]<ref><code>[[std::string]]</code> only, result is stored in string ''<code>result</code>'' which is at least as long as ''<code>string</code>'', and may or may not be ''<code>string</code>'' itself</ref>
|-
| <code>lowercase(''string'')</code>
|[[Object Pascal]] ([[Delphi (programming language)|Delphi]])
|-
| <code>strtolower(''string'')</code>
|[[PHP]]
|-
| <code>lower(''string'')</code>
|[[Seed7]]
|-
|<code>${''string_param'',,}</code>
|[[Bash (Unix shell)|Bash]]
|-
|<code>[[echo (command)|echo]] "string" <nowiki>|</nowiki> [[tr (program)|tr]] 'A-Z' 'a-z'</code>
|[[Unix]]
|-
| <code>''string''.lower()</code>
|[[Python (programming language)|Python]]
|-
| <code>downcase(''string'')</code>
|[[Pick Basic]]
|-
| <code>''string''.downcase</code>
|[[Ruby (programming language)|Ruby]]<ref name="ReferenceC">only ASCII characters as Ruby lacks Unicode support</ref>
|-
| <code>strings.ToLower(''string'')</code>
|[[Go (programming language)|Go]]
|-
| <code>(string-downcase ''string'')</code>
|[[Scheme (programming language)|Scheme]] (R6RS), [[Common Lisp]]
|-
| <code>(lower-case ''string'')</code>
|[[Clojure]]
|-
| <code>String.lowercase ''string''</code>
|[[OCaml]]
|-
| <code>String.map Char.toLower ''string''</code>
|[[Standard ML]]
|-
| <code>map Char.toLower ''string''</code>
|[[Haskell (programming language)|Haskell]]
|-
| <code>''string''.toLowerCase()</code>
|[[Java (programming language)|Java]], [[JavaScript]]
|-
| <code>to_lower(''string'')</code>
|[[Erlang (programming language)|Erlang]]
|-
| <code>''string''.ToLower()</code>
|[[Visual Basic .NET|VB .NET]], [[C Sharp (programming language)|C#]], [[Windows PowerShell]], [[F Sharp (programming language)|F#]]
|-
| <code>''string''.lowercaseString</code>
|[[Objective-C]] (<code>NSString *</code> only), [[Swift (programming language)|Swift]] (Foundation)
|-
| <code>string.lower(''string'') <br /> (''string''):lower()</code>
|[[Lua (programming language)|Lua]]
|-
| <code>''string'' asLowercase</code>
|[[Smalltalk]]
|-
| <code>LOWER(''string'')</code>
|[[SQL]]
|-
| <code>lowercase(''string'')</code>
|[[PL/I]]<ref name="lower1" />
|-
| <code>ToLowerCase[''string'']</code>
|[[Mathematica]]
|-
| <code>«FUNCTION» LOWER-CASE(''string'')</code>
|[[COBOL]]
|-
| <code>''string''.toLower</code>
|[[Cobra (programming language)|Cobra]]
|-
| <code>string tolower ''string''</code>
|[[Tcl]]
|-
| <code>''string''.to_lowercase()</code>
| [[Rust (programming language)|Rust]]<ref>See the [https://doc.rust-lang.org/stable/std/primitive.str.html#method.to_lowercase <code>str::to_lowercase</code>] method.</ref>
|}

<syntaxhighlight lang="csharp">
// Example in C#
"Wiki means fast?".ToLower();        // "wiki means fast?" 
</syntaxhighlight>

<syntaxhighlight lang="scheme">
; Example in Scheme
(use-modules (srfi srfi-13))
(string-downcase "Wiki means fast?") ;  "wiki means fast?"
</syntaxhighlight>

<syntaxhighlight lang="c">
/* Example in C */
#include <ctype.h>
#include <stdio.h>
int main(void) {
    char string[] = "Wiki means fast?";
    int i;
    for (i = 0; i < sizeof(string) - 1; ++i) {
        /* transform characters in place, one by one */ 
        string[i] = tolower(string[i]);
    }
    puts(string);                       /* "wiki means fast?" */
    return 0;
}
</syntaxhighlight><syntaxhighlight lang="c">
# Example in Raku
"Wiki means fast?".lc;             # "wiki means fast?"

</syntaxhighlight>


===मिड===
##substring देखें<br />

===विभाजन===
{| class="wikitable"
|- style="background:#fffeed;"
! परिभाषा 
| <string>.partition(''separator'') returns the sub-string before the separator; the separator; then the sub-string after the separator.
|-
! विवरण 
| दी गई स्ट्रिंग को सेपरेटर द्वारा विभाजित करता है और तीन सबस्ट्रिंग रीटर्न करता है, जो मिलकर मूल बनाते हैं। 
|}
{| class="wikitable sortable"
|- style="text-align:left;"
! फॉर्मेट !! लैंग्वेज !! टिप्पणियाँ
|-
| <code>''string''.partition(''separator'')</code>
|[[Python (programming language)|Python]], [[Ruby (programming language)|Ruby]](1.9+)
|
|-
| <code>lists:partition(''pred'', ''string'')</code>
|[[Erlang (programming language)|Erlang]]
|
|-
| <code>split /(''separator'')/, ''string'', 2</code>
|[[Perl 5]]
|
|-
| <code>split ''separator'', ''string'', 2</code> <br /> <code>''string''.split( ''separator'', 2 )</code>
|[[Raku (programming language)|Raku]]
|Separator does not have to be a regular expression
|}

<syntaxhighlight lang="python">
# Examples in Python
"Spam eggs spam spam and ham".partition('spam')   # ('Spam eggs ', 'spam', ' spam and ham')
"Spam eggs spam spam and ham".partition('X')      # ('Spam eggs spam spam and ham', "", "")
</syntaxhighlight>

<syntaxhighlight lang="perl">
# Examples in Perl 5 / Raku
split /(spam)/, 'Spam eggs spam spam and ham' ,2;   # ('Spam eggs ', 'spam', ' spam and ham');
split /(X)/, 'Spam eggs spam spam and ham' ,2;      # ('Spam eggs spam spam and ham');
</syntaxhighlight>

===रिप्लेस ===
{| class="wikitable"
|- style="background:#fffeed;"
! परिभाषा 
| <code>replace(''string'', ''find'', ''replace'')</code> returns string
|-
! विवरण 
| प्रतिस्थापित करने के लिए खोज अकरन्स के साथ एक स्ट्रिंग रीटर्न करता है।
|}
{| class="wikitable sortable"
|- style="text-align:left;"
! फॉर्मेट !! लैंग्वेज 
|-
| <code>changestr(''find'', ''string'', ''replace'')</code>
|[[Rexx]]
|-
| <code>std.string.replace(''string'', ''find'', ''replace'')</code>
|[[D (programming language)|D]]
|-
| <code>Replace(''string'', ''find'', ''replace'')</code>
|[[Visual Basic (classic)|VB]]
|-
| <code>replace(''string'', ''find'', ''replace'')</code>
|[[Seed7]]
|-
| <code>change(''string'', ''find'', ''replace'')</code>
|[[Pick Basic]]
|-
| <code>''string''.Replace(''find'', ''replace'')</code>
| [[C Sharp (programming language)|C#]], [[F Sharp (programming language)|F#]], [[Visual Basic .NET|VB .NET]]
|-
| <code>str_replace(''find'', ''replace'', ''string'')</code>
|[[PHP]]
|-
| <code>re:replace(''string'', ''find'', ''replace'', «{return, list}»)</code>
|[[Erlang (programming language)|Erlang]]
|-
| <code>''string''.replace(''find'', ''replace'')</code>
|[[Cobra (programming language)|Cobra]], [[Java (programming language)|Java]] (1.5+), [[Python (programming language)|Python]], [[Rust (programming language)|Rust]]<ref>See the [https://doc.rust-lang.org/stable/std/primitive.str.html#method.replace <code>str::replace</code>] method.</ref>
|-
| <code>''string''.replaceAll(''find_regex'', ''replace'')<ref name="regex" /></code>
|[[Java (programming language)|Java]]
|-
| <code>''string''.gsub(''find'', ''replace'')</code>
|[[Ruby (programming language)|Ruby]]
|-
| <code>''string'' =~ s/''find_regex''/''replace''/g<ref name="regex">The "find" string in this construct is interpreted as a [[regular expression]]. Certain characters have special meaning in regular expressions. If you want to find a string literally, you need to quote the special characters.</ref></code>
|[[Perl 5]]
|-
| <code>''string''.subst(''find'', ''replace'', :g)</code>
|[[Raku (programming language)|Raku]]
|-
| <code>''string''.replace(''find'', ''replace'', "g") <ref>third parameter is non-standard</ref> or<br /> ''string''.replace(/''find_regex''/g, ''replace'')<ref name="regex" /></code>
|[[JavaScript]]
|-
| <code>[[echo (command)|echo]] "''string''" <nowiki>|</nowiki> [[sed]] 's/''find_regex''/''replace''/g'<ref name="regex" /></code>
|[[Unix]]
|-
| <code>${''string_param''//''find_pattern''/''replace''}</code>
|[[Bash (Unix shell)|Bash]]
|-
| <code>''string''.replace(''find'', ''replace''), or<br />''string'' -replace ''find_regex'', ''replace''<ref name="regex" /></code>
|[[Windows PowerShell]]
|-
| <code>Str.global_replace (Str.regexp_string ''find'') ''replace'' ''string''</code>
|[[OCaml]]
|-
| <code>[''string'' stringByReplacingOccurrencesOfString:''find'' withString:''replace'']</code>
|[[Objective-C]] (<code>NSString *</code> only)
|-
| <code>''string''.stringByReplacingOccurrencesOfString(''find'', withString:''replace'')</code>
|[[Swift (programming language)|Swift]] (Foundation)
|-
| <code>string.gsub(''string'', ''find'', ''replace'') <br /> (''string''):gsub(''find'', ''replace'')</code>
|[[Lua (programming language)|Lua]]
|-
| <code>''string'' copyReplaceAll: ''find'' with: ''replace''</code>
|[[Smalltalk]] ([[Squeak]], [[Pharo]])
|-
| <code>string map {''find'' ''replace''} ''string''</code>
|[[Tcl (programming language)|Tcl]]
|-
| <code>StringReplace[''string'', ''find'' -> ''replace'']</code>
|[[Mathematica]]
|-
| <code>strings.Replace(''string'', ''find'', ''replace'', -1)</code>
| [[Go (programming language)|Go]]
|-
| <code>INSPECT ''string'' REPLACING ALL/LEADING/FIRST ''find'' BY ''replace''</code>
| [[COBOL]]
|-
| <code>''find_regex'' ⎕R ''replace_regex'' ⊢ ''string''</code>
| [[APL (programming language)|APL]]
|}

<syntaxhighlight lang="csharp">
// Examples in C#
"effffff".Replace("f", "jump");     // returns "ejumpjumpjumpjumpjumpjump"
"blah".Replace("z", "y");           // returns "blah"
</syntaxhighlight>

<syntaxhighlight lang="java">
// Examples in Java
"effffff".replace("f", "jump");     // returns "ejumpjumpjumpjumpjumpjump"
"effffff".replaceAll("f*", "jump"); // returns "ejump"
</syntaxhighlight><syntaxhighlight lang="c">
// Examples in Raku
"effffff".subst("f", "jump", :g);    # returns "ejumpjumpjumpjumpjumpjump"
"blah".subst("z", "y", :g);          # returns "blah"

</syntaxhighlight><syntaxhighlight lang="c">
' Examples in Visual Basic
Replace("effffff", "f", "jump")     '  returns "ejumpjumpjumpjumpjumpjump"
Replace("blah", "z", "y")           '  returns "blah"

</syntaxhighlight><syntaxhighlight lang="c">
# Examples in Windows PowerShell
"effffff" -replace "f", "jump"      #  returns "ejumpjumpjumpjumpjumpjump"
"effffff" -replace "f*", "jump"     #  returns "ejump"

</syntaxhighlight>

===रिवर्स===
{| class="wikitable"
|- style="background:#fffeed;"
! परिभाषा 
| <code>reverse(''string'')</code>
|-
! विवरण 
| स्ट्रिंग में करैक्टर के क्रम को रिवर्स कर देता है।
|}
{| class="wikitable sortable"
|- style="text-align:left;"
! फॉर्मेट !! लैंग्वेज 
|-
| <code>reverse ''string''</code>
|[[Perl 5]], [[Haskell (programming language)|Haskell]]
|-
| <code>flip ''string''</code> <br /> <code>''string''.flip</code>
|[[Raku (programming language)|Raku]]<!-- reverses graphemes -->
|-
| <code>lists:reverse(''string'')</code>
|[[Erlang (programming language)|Erlang]]
|-
| <code>strrev(''string'')</code>
|[[PHP]]
|-
| <code>''string''[::-1]</code>
|[[Python (programming language)|Python]]
|-
| <code>(string-reverse ''string'')</code>
|[[Scheme (programming language)|Scheme]] (SRFI 13)
|-
| <code>(reverse ''string'')</code>
|[[Common Lisp]]
|-
| <code>''string''.reverse</code>
|[[Ruby (programming language)|Ruby]], [[D (programming language)|D]] (modifies string)
|-
| <code>new StringBuilder(''string'').reverse().toString()</code>
|[[Java (programming language)|Java]]
|-
| <code>std::reverse(''string''.begin(), ''string''.end());</code>
|[[C++]] (<code>[[std::string]]</code> only, modifies string)
|-
| <code>StrReverse(''string'')</code>
|[[Visual Basic (classic)|VB]]
|-
| <code>''string''.Reverse()</code>
|[[Visual Basic .NET|VB .NET]], [[C Sharp (programming language)|C#]]
|-
| <code>implode (rev (explode ''string''))</code>
|[[Standard ML]]
|-
| <code>''string''.split("").reverse().join("")</code>
|[[JavaScript]]
|-
| <code>string.reverse(''string'') <br /> (''string''):reverse()</code>
|[[Lua (programming language)|Lua]]
|-
| <code>''string'' reverse</code>
|[[Smalltalk]]
|-
| <code>StringReverse[''string'']</code>
|[[Mathematica]]
|-
|<code>reverse(''string'')</code>
|[[PL/I]]
|-
|<code>«FUNCTION» REVERSE(''string'')</code>
|[[COBOL]]
|-
|<code>''string''.toCharArray.toList.reversed.join()</code>
|[[Cobra (programming language)|Cobra]]
|-
| <code>String(''string''.characters.reverse())</code>
|[[Swift (programming language)|Swift]] (2.x)
|-
| <code>String(reverse(''string''))</code>
|[[Swift (programming language)|Swift]] (1.2)
|-
| <code>string reverse ''string''</code>
|[[Tcl]]
|-
| <code>⌽''string''</code>
|[[APL (programming language)|APL]]
|-
| <code>''string''.chars().rev().collect::<String>()</code>
| [[Rust (programming language)|Rust]]<ref>In Rust, the [https://doc.rust-lang.org/std/primitive.str.html#method.chars <code>str::chars</code>] method iterates over code points, the [https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.rev <code>std::iter::Iterator::rev</code>] method on reversible iterators ([https://doc.rust-lang.org/stable/std/iter/trait.DoubleEndedIterator.html <code>std::iter::DoubleEndedIterator</code>]) creates a reversed iterator, and the [https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.collect <code>std::iter::Iterator::collect</code>] method consumes the iterator and creates a collection (which here is specified as a [https://doc.rust-lang.org/stable/std/string/struct.String.html <code>String</code>] with the [[turbofish]] syntax) from the iterator's elements.</ref>
|-
| <code>echo ''string'' <nowiki>|</nowiki> rev</code>
| [[Unix]]
|}

<syntaxhighlight lang="smalltalk">
" Example in Smalltalk "
'hello' reversed             " returns 'olleh' "
</syntaxhighlight>

<syntaxhighlight lang="perl">
# Example in Perl 5
reverse "hello"              # returns "olleh"
</syntaxhighlight><syntaxhighlight lang="c">
# Example in Raku
"hello".flip                 # returns "olleh"
</syntaxhighlight><syntaxhighlight lang="c">
# Example in Python
"hello"[::-1]                # returns "olleh"
</syntaxhighlight><syntaxhighlight lang="c">
; Example in Scheme
(use-modules (srfi srfi-13))
(string-reverse "hello")     ; returns "olleh"
</syntaxhighlight>

===rफाइंड  ===

{| class="wikitable"
|- style="background:#fffeed;"
! परिभाषा 
| <code>rfind(''string'',''substring'')</code> returns integer
|-
! विवरण 
| स्ट्रिंग में सबस्ट्रिंग की अंतिम घटना की शुरुआत की स्थिति रीटर्न करता है। यदि सबस्ट्रिंग नहीं मिलती है, तो इनमें से अधिकतर रूटीन अकरन्स इंडेक्स मान -1 रीटर्न करते है जहां इंडेक्स 0-आधारित होते हैं, 0 जहां वे 1-आधारित होते हैं या कुछ मान बूलियन इंटरप्रेट के रूप में व्याख्या करता है।
|-
| संबंधित 
| instr
|}
{| class="wikitable sortable"
|- style="text-align:left;"
! फॉर्मेट !! लैंग्वेज !! इफ नॉट फाउंड 
|-
| <code>InStrRev(«''startpos'',» ''string'',''substring'')</code>
|[[Visual Basic (classic)|VB]]
|returns 0
|-
| <code>instrrev(«''startpos'',» ''string'',''substring'')</code>
|[[FreeBASIC]]
|returns 0
|-
| <code>rindex(''string'',''substring''«,''startpos''»)</code>
|[[Perl 5]]
|returns −1
|-
| <code>rindex(''string'',''substring''«,''startpos''»)</code> <br /> <code>''string''.rindex(''substring''«,''startpos''»)</code>
|[[Raku (programming language)|Raku]]
|returns {{mono|Nil}}
|-
| <code>strrpos(''string'',''substring''«,''startpos''»)</code>
|[[PHP]]
|returns {{mono|FALSE}}
|-
| <code>''string''.rfind(''substring''«,''startpos''»)</code>
|[[C++]] (STL)
|returns {{mono|std::string::npos}}
|-
| <code>std.string.rfind(''string'', ''substring'')</code>
|[[D (programming language)|D]]
|returns −1
|-
| <code>''string''.rfind(''substring''«,''startpos''«, ''endpos''»»)</code>
|rowspan=2|[[Python (programming language)|Python]]
|returns −1
|-
|<code>''string''.rindex(''substring''«,''startpos''«, ''endpos''»»)</code>
|raises {{mono|ValueError}}
|-
|<code>rpos(''string'', ''substring''«,''startpos''»)</code>
|[[Seed7]]
|returns 0
|-
|<code>''string''.rindex(''substring''«,''startpos''»)</code>
|[[Ruby (programming language)|Ruby]]
|returns {{mono|nil}}
|-
| <code>strings.LastIndex(''string'', ''substring'')</code>
|[[Go (programming language)|Go]]
|returns −1
|-
| <code>''string''.lastIndexOf(''substring''«,''startpos''»)</code>
|[[Java (programming language)|Java]], [[JavaScript]]
|returns −1
|-
| <code>''string''.LastIndexOf(''substring''«,''startpos''«, ''charcount''»»)</code>
|[[Visual Basic .NET|VB .NET]], [[C Sharp (programming language)|C#]], [[Windows PowerShell]], [[F Sharp (programming language)|F#]]
|returns −1
|-
| <code>(search ''substring'' ''string'' :from-end t)</code>
|[[Common Lisp]]
|returns {{mono|NIL}}
|-
| <code>[''string'' rangeOfString:''substring'' options:NSBackwardsSearch].location</code>
|[[Objective-C]] (<code>NSString *</code> only)
|returns {{mono|NSNotFound}}
|-
| <code>Str.search_backward (Str.regexp_string ''substring'') ''string'' (Str.length ''string'' - 1)</code>
|[[OCaml]]
|raises {{mono|Not_found}}
|-
| <code>string.match(''string'', '.*()'..''substring'') <br /> ''string'':match('.*()'..''substring'')</code>
|[[Lua (programming language)|Lua]]
|returns {{mono|nil}}
|-
| <code>Ada.Strings.Unbounded.Index(Source => ''string'', Pattern => ''substring'', <br /> Going => Ada.Strings.Backward)</code>
|[[Ada (programming language)|Ada]]
|returns 0
|-
|<code>''string''.lastIndexOf(''substring''«,''startpos''«, ''charcount''»»)</code>
|[[Cobra (programming language)|Cobra]]
|returns −1
|-
|<code>''string'' lastIndexOfString:''substring''</code>
|[[Smalltalk]]
|returns 0
|-
|<code>string last ''substring string startpos''</code>
|[[Tcl]]
|returns −1
|-
|<code>(⌽<\⌽''substring''⍷'string')⍳1</code>
|[[APL (programming language)|APL]]
|returns −1
|-
| <code>''string''.rfind(''substring'')</code>
| [[Rust (programming language)|Rust]]<ref>See the [https://doc.rust-lang.org/stable/std/primitive.str.html#method.rfind <code>str::rfind</code>] method.</ref>
| returns [[Option type|{{mono|None}}]]
|}

<syntaxhighlight lang="lisp">
; Examples in Common Lisp
(search "e" "Hello mate" :from-end t)     ;  returns 9
(search "z" "word" :from-end t)           ;  returns NIL
</syntaxhighlight>

<syntaxhighlight lang="csharp">
// Examples in C#
"Hello mate".LastIndexOf("e");           // returns 9
"Hello mate".LastIndexOf("e", 4);        // returns 1
"word".LastIndexOf("z");                 // returns -1
</syntaxhighlight>

<syntaxhighlight lang="perl">
# Examples in Perl 5
rindex("Hello mate", "e");               # returns 9
rindex("Hello mate", "e", 4);            # returns 1
rindex("word", "z");                     # returns -1
</syntaxhighlight><syntaxhighlight lang="c">
# Examples in Raku
"Hello mate".rindex("e");                # returns 9
"Hello mate".rindex("e", 4);             # returns 1
"word".rindex('z');                      # returns Nil
</syntaxhighlight><syntaxhighlight lang="c">
' Examples in Visual Basic
InStrRev("Hello mate", "e")              '  returns 10
InStrRev(5, "Hello mate", "e")           '  returns 2
InStrRev("word", "z")                    '  returns 0
</syntaxhighlight>


===सही===
{| class="wikitable"
|- style="background:#fffeed;"
! परिभाषा 
| <code>right(''string'',''n'')</code> returns string
|-
! विवरण 
| स्ट्रिंग का दायाँ n भाग रीटर्न करता है। यदि n स्ट्रिंग की लंबाई से अधिक है तो अधिकांश कार्यान्वयन संपूर्ण स्ट्रिंग एक्सेप्शन रीटर्न करते है, उदाहरण में दिखाया गया है
|}
{| class="wikitable sortable"
|- style="text-align:left;"
! फॉर्मेट !! लैंग्वेज 
|-
|<code>string (string'Last - ''n'' + 1 .. string'Last)</code>
|[[Ada (programming language)|Ada]]
|-
| <code>Right(''string'',''n'')</code>
|[[Visual Basic (classic)|VB]]
|-
| <code>RIGHT$(''string'',''n'')</code>
|[[BASIC]]
|-
| <code>right(''string'',''n'')</code>
|[[FreeBASIC]], [[Ingres (database)|Ingres]], [[Pick Basic]]
|-
| <code>strcpy(''string2'', ''string''+''n'')</code> (n must not be greater than the length of ''string'')
|[[C (programming language)|C]]
|-
| <code>''string''.Substring(''string''.Length()-''n'')</code>
|[[C Sharp (programming language)|C#]]
|-
| <code>''string''[len(''string'')-''n'':]</code>
|[[Go (programming language)|Go]]
|-
| <code>''string''.substring(''string''.length()-''n'')</code>
|[[Java (programming language)|Java]]
|-
| <code>''string''.slice(-''n'')</code>
|[[JavaScript]]<ref>{{cite web|url=https://es5.github.com/#x15.5.4.13 |title=Annotated ES5 |publisher=Es5.github.com |access-date=2013-08-18}}</ref>
|-
| <code>right(''string'',''n'' «,''padchar''»)</code>
|[[Rexx]], [[Erlang (programming language)|Erlang]]
|-
| <code>substr(''string'',-''n'')</code>
|[[Perl 5]], [[PHP]]
|-
| <code>substr(''string'',*-''n'')</code> <br /> <code>''string''.substr(*-''n'')</code>
|[[Raku (programming language)|Raku]]
|-
| <code>''string''[-''n'':]</code>
|[[Cobra (programming language)|Cobra]], [[Python (programming language)|Python]]
|-
| <code>${''string_param'': -''n''}</code> (note the space after the colon)
|[[Bash (Unix shell)|Bash]]
|-
| <code>''string''[''n'']</code>
|[[Pick Basic]]
|-
| <code>(string-take-right ''string'' ''n'')</code>
|[[Scheme (programming language)|Scheme]] (SRFI 13)
|-
| <code>''string''[-''n''..-1]</code>
|[[Ruby (programming language)|Ruby]]
|-
| <code>''string''[$-''n'' .. $]</code>
|[[D (programming language)|D]]<ref>if n is larger than length of string, then in Debug mode ArrayRangeException is thrown, and unspecified behaviour in Release mode</ref>
|-
| <code>String.sub ''string'' (String.length ''string'' - ''n'') ''n''</code>
|[[OCaml]]<ref name="ReferenceA"/>
|-
| <code>string.sub(''string'', -''n'') <br /> (''string''):sub(-''n'')</code>
|[[Lua (programming language)|Lua]]
|-
| <code>''string'' last: ''n''</code>
|[[Smalltalk]] ([[Squeak]], [[Pharo]])
|-
| <code>StringTake[''string'', -''n'']</code>
|[[Mathematica]]<ref name="ReferenceB"/>
|-
| <code>''string'' (1:''n'')</code>
| [[COBOL]]
|-
|<code>''¯n''↑''string''.</code>
|[[APL (programming language)|APL]]
|-
| <code>''string''[n..]</code><br><code>''string''.get(n..)</code>
| [[Rust (programming language)|Rust]]<ref name="Rust indexing" />
|}

<syntaxhighlight lang="java">
// Examples in Java; extract rightmost 4 characters
String str = "CarDoor";
str.substring(str.length()-4); // returns 'Door'
</syntaxhighlight><syntaxhighlight lang="c">
# Examples in Raku
"abcde".substr(*-3);          # returns "cde"
"abcde".substr(*-8);          # 'out of range' error

</syntaxhighlight><syntaxhighlight lang="c">
/* Examples in Rexx */
right("abcde", 3)              /* returns "cde"      */
right("abcde", 8)              /* returns "   abcde" */
right("abcde", 8, "*")         /* returns "***abcde" */
</syntaxhighlight><syntaxhighlight lang="c">
; Examples in Scheme
(use-modules (srfi srfi-13))
(string-take-right "abcde", 3) ;  returns "cde" 
(string-take-right "abcde", 8) ;  error

</syntaxhighlight><syntaxhighlight lang="c">
' Examples in Visual Basic
Right("sandroguidi", 3)        '  returns "idi" 
Right("sandroguidi", 100)      '  returns "sandroguidi"

</syntaxhighlight>

===rपार्टीशन===
{| class="wikitable"
|- style="background:#fffeed;"
! परिभाषा 
| <string>.rpartition(सेपरेटर) स्ट्रिंग के भीतर दाएं से बाएं तक विभाजक की खोज करता है, फिर विभाजक से पहले उप-स्ट्रिंग को विभाजक और फिर विभाजक के बाद उप-स्ट्रिंग रीटर्न करता है।
|-
! विवरण 
| दी गई स्ट्रिंग को सबसे दाएँ सेपरेटर द्वारा विभाजित करता है और तीन सबस्ट्रिंग रीटर्न करता है। जो मिलकर मूल बनाते हैं। 
|}
{| class="wikitable sortable"
|- style="text-align:left;"
! फॉर्मेट !! लैंग्वेज 
|-
| <code>''string''.rpartition(''separator'')</code>
|[[Python (programming language)|Python]], [[Ruby (programming language)|Ruby]]
|}

<syntaxhighlight lang="python">
# Examples in Python
"Spam eggs spam spam and ham".rpartition('spam')  ### ('Spam eggs spam ', 'spam', ' and ham')
"Spam eggs spam spam and ham".rpartition('X')     ### ("", "", 'Spam eggs spam spam and ham')
</syntaxhighlight>

===स्लाइस===
##substring देखें<br />
===स्पलिट===
{| class="wikitable"
|- style="background:#fffeed;"
! परिभाषा 
| <स्ट्रिंग>.स्प्लिट स्पलिट सीमा सेपरेटर पर एक स्ट्रिंग को विभाजित करती है, वैकल्पिक रूप से केवल सीमित संख्या में सबस्ट्रिंग तक होती है
|-
! विवरण 
| दी गई स्ट्रिंग को सेपरेटर द्वारा स्वयं एक स्ट्रिंग की अकरन्स से विभाजित करता है और सबस्ट्रिंग की एक सूची या ऐरे रीटर्न करता है। यदि सीमा दी गई है, तो सीमा -1 स्पलिट को पढ़ने के बाद, शेष स्ट्रिंग को अंतिम उपस्ट्रिंग में बनाया जाता है और इस प्रकार भले ही इसमें कोई सेपरेटर होता है। योजना और एरलांग कार्यान्वयन समान हैं लेकिन कई मायनों में भिन्न हैं। जावास्क्रिप्ट इस मायने में भी भिन्न है कि यह कट करता है, यह शेष स्ट्रिंग को अंतिम तत्व के रूप में नहीं डालता है। उदाहरण यहां देखें. कोबरा कार्यान्वयन रिक्त स्थान पर सम्मलित होने के विपरीत डिफ़ॉल्ट होता है। 
|}
{| class="wikitable sortable"
|- style="text-align:left;"
! फॉर्मेट !! लैंग्वेज 
|-
| <code>split(/''separator''/, ''string''«, ''limit''»)</code>
|[[Perl 5]]
|-
| <code>split(''separator'', ''string''«, ''limit''»)</code> <br /> <code>''string''.split(''separator'', «''limit''»)</code>
|[[Raku (programming language)|Raku]]
|-
| <code>explode(''separator'', ''string''«, ''limit''»)</code>
|[[PHP]]
|-
| <code>''string''.split(''separator''«, ''limit''-1»)</code>
|[[Python (programming language)|Python]]
|-
| <code>''string''.split(''separator''«, ''limit''»)</code>
|[[JavaScript]], [[Java (programming language)|Java]], [[Ruby (programming language)|Ruby]]
|-
| <code>string:tokens(''string'', ''sepchars'')</code>
|[[Erlang (programming language)|Erlang]]
|-
| <code>strings.Split(''string'', ''separator'')<br />strings.SplitN(''string'', ''separator'', ''limit'')</code>
|[[Go (programming language)|Go]]
|-
| <code>(string-tokenize ''string''« ''charset''« ''start''« ''end''»»»)</code>
|[[Scheme (programming language)|Scheme]] (SRFI 13)
|-
| <code>Split(''string'', ''sepchars''«, ''limit''»)</code>
|[[Visual Basic (classic)|VB]]
|-
| <code>''string''.Split(''sepchars''«, ''limit''«, ''options''»»)</code>
|[[Visual Basic .NET|VB .NET]], [[C Sharp (programming language)|C#]], [[F Sharp (programming language)|F#]]
|-
| <code>''string'' -split ''separator''«, ''limit''«, ''options''»»</code>
|[[Windows PowerShell]]
|-
| <code>Str.split (Str.regexp_string ''separator'') ''string''</code>
|[[OCaml]]
|-
| <code>std.string.split(''string'', ''separator'')</code>
|[[D (programming language)|D]]
|-
| <code>[''string'' componentsSeparatedByString:''separator'']</code>
|[[Objective-C]] (<code>NSString *</code> only)
|-
| <code>''string''.componentsSeparatedByString(''separator'')</code>
|[[Swift (programming language)|Swift]] (Foundation)
|-
|<code>TStringList.Delimiter, TStringList.DelimitedText</code>
|[[Object Pascal]]
|-
| <code>StringSplit[''string'', ''separator''«, ''limit''»]</code>
|[[Mathematica]]
|-
| <code>''string''.split«(''sepchars''«, ''limit''«, ''options''»»)»</code>
|[[Cobra (programming language)|Cobra]]
|-
|<code>split ''string separator''</code>
|[[Tcl]]
|-
| <code>(''separator''≠''string'')⊂''string''</code> or <code>''separator''(≠⊆⊢)''string''</code> in APL2 and Dyalog APL 16.0 respectively
|[[APL (programming language)|APL]]
|-
| <code>''string''.split(''separator'')</code>
<code>''string''.split(''limit'', ''separator'')</code>
| [[Rust (programming language)|Rust]]<ref>See the [https://doc.rust-lang.org/stable/std/primitive.str.html#method.split <code>str::split</code>] and [https://doc.rust-lang.org/stable/std/primitive.str.html#method.rsplit <code>str::rsplit</code>] methods.</ref>
|}

<syntaxhighlight lang="csharp">
// Example in C#
"abc,defgh,ijk".Split(',');                 // {"abc", "defgh", "ijk"}
"abc,defgh;ijk".Split(',', ';');            // {"abc", "defgh", "ijk"}
</syntaxhighlight>

<syntaxhighlight lang="erlang">
% Example in Erlang
string:tokens("abc;defgh;ijk", ";").        %  ["abc", "defgh", "ijk"]
</syntaxhighlight>

<syntaxhighlight lang="java">
// Examples in Java
"abc,defgh,ijk".split(",");                 // {"abc", "defgh", "ijk"}
"abc,defgh;ijk".split(",|;");               // {"abc", "defgh", "ijk"}
</syntaxhighlight>

<syntaxhighlight lang="pascal">
{ Example in Pascal }
var
  lStrings: TStringList;
  lStr: string;
begin
  lStrings := TStringList.Create;
  lStrings.Delimiter := ',';
  lStrings.DelimitedText := 'abc,defgh,ijk';
  lStr := lStrings.Strings[0]; // 'abc'
  lStr := lStrings.Strings[1]; // 'defgh'
  lStr := lStrings.Strings[2]; // 'ijk'
end;
</syntaxhighlight>

<syntaxhighlight lang="perl">
# Examples in Perl 5
split(/spam/, 'Spam eggs spam spam and ham'); # ('Spam eggs ', ' ', ' and ham')
split(/X/, 'Spam eggs spam spam and ham');    # ('Spam eggs spam spam and ham')
</syntaxhighlight><syntaxhighlight lang="c">
# Examples in Raku
'Spam eggs spam spam and ham'.split(/spam/);  # (Spam eggs     and ham)
split(/X/, 'Spam eggs spam spam and ham');    # (Spam eggs spam spam and ham)
</syntaxhighlight>


===स्प्रिंटफ़===
##Format देखें

===स्ट्रिप ===
##trim देखें<br />
===स्टर्कम्प ===
##Compare (integer result) देखें

===सबस्ट्रिंग===
{{hatnote|See [[#substring|CharAt]] for base of startpos/endpos.}}

{| class="wikitable"
|- style="background:#fffeed;"
! परिभाषा 
| <code>substring(''string'', ''startpos'', ''endpos'')</code> returns string <br /> <code>substr(''string'', ''startpos'', ''numChars'')</code> returns string
|- 
! विवरण 
| स्टार्टपोज़ और एंडपोज़ पर शुरू होने या लंबाई संख्या वाले स्टार्टपोज़ पर शुरू होने के बीच स्ट्रिंग का एक सबस्ट्रिंग रीटर्न करता है। यदि प्रारंभिक बिंदु से परे numChars करैक्टर से कम हैं तो परिणामी स्ट्रिंग को छोटा कर दिया जाता है। एंडपोज़ सबस्ट्रिंग में अंतिम करैक्टर के बाद इंडेक्स का प्रतिनिधित्व करता है। ध्यान दें कि [[UTF-8]], [[UTF-16]] या [[Shift-JIS]] जैसे परिवर्तनीय लंबाई एन्कोडिंग के लिए इनवेलिड स्ट्रिंग्स से बचने के लिए अंत में स्ट्रिंग स्थिति को हटाना आवश्यक होता है।
|}
{| class="wikitable sortable"
|- style="text-align:left;"
! फॉर्मेट !! लैंग्वेज 
|-
|<code>string[''startpos'':''endpos'']</code>
|[[ALGOL 68]] (changes आधार इंडेक्स )
|-
|<code>string (''startpos'' .. ''endpos'')</code>
|[[Ada (programming language)|Ada]] (changes आधार इंडेक्स )
|-
| <code>Mid(''string'', ''startpos'', ''numChars'')</code>
|[[Visual Basic (classic)|VB]]
|-
| <code>mid(''string'', ''startpos'', ''numChars'')</code>
|[[FreeBASIC]]
|-
| <code>''string''[''startpos''+(⍳''numChars'')-~⎕IO]</code>
|[[APL (programming language)|APL]]
|-
| <code>MID$(''string'', ''startpos'', ''numChars'')</code>
|[[BASIC]]
|-
| <code>substr(''string'', ''startpos'', ''numChars'')</code>
|[[AWK]] (changes string), [[Perl 5]],<ref name="substr2"/><ref name="substr4"/> [[PHP]]<ref name="substr2"/><ref name="substr4"/>
|-
| <code>substr(''string'', ''startpos'', ''numChars'')</code> <br /> <code>''string''.substr(''startpos'', ''numChars'')</code>
|[[Raku (programming language)|Raku]]<ref name="substr5"/><ref name="substr6"/>
|-
| <code>substr(''string'', ''startpos'' «,''numChars'', ''padChar''»)</code>
|[[Rexx]]
|-
| <code>''string''[''startpos'':''endpos'']</code>
|[[Cobra (programming language)|Cobra]], [[Python (programming language)|Python]],<ref name="substr2"/><ref name="substr3"/> [[Go (programming language)|Go]]
|-
| <code>''string''[''startpos'', ''numChars'']</code>
|[[Pick Basic]]
|-
| <code>''string''[''startpos'', ''numChars''] <br /> ''string''[''startpos'' .. ''endpos''-1] <br /> ''string''[''startpos'' ... ''endpos'']</code>
|[[Ruby (programming language)|Ruby]]<ref name="substr2"/><ref name="substr3"/>
|-
| <code>''string''[''startpos'' .. ''endpos''] <br /> ''string''[''startpos'' len ''numChars'']</code>
|[[Seed7]]
|-
| <code>''string''.slice(''startpos''«, ''endpos''»)</code>
|[[JavaScript]]<ref name="substr2"/><ref name="substr3"/>
|-
| <code>''string''.substr(''startpos''«, ''numChars''»)</code>
|[[C++]] (STL), [[JavaScript]]
|-
| <code>''string''.Substring(''startpos'', ''numChars'')</code>
|[[Visual Basic .NET|VB .NET]], [[C Sharp (programming language)|C#]], [[Windows PowerShell]], [[F Sharp (programming language)|F#]]
|-
| <code>''string''.substring(''startpos''«, ''endpos''»)</code>
|[[Java (programming language)|Java]], [[JavaScript]]
|-
| <code>copy(''string'', ''startpos'', ''numChars'')</code>
|[[Object Pascal]] ([[Delphi (programming language)|Delphi]])
|-
| <code>(substring ''string'' ''startpos'' ''endpos'')</code>
|[[Scheme (programming language)|Scheme]]
|-
| <code>(subseq ''string'' ''startpos'' ''endpos'')</code>
|[[Common Lisp]]
|-
| <code>(subseq ''string'' ''startpos'' ''endpos'')</code>
|[[ISLISP]]
|-
| <code>String.sub ''string'' ''startpos'' ''numChars''</code>
|[[OCaml]]
|-
| <code>substring (''string'', ''startpos'', ''numChars'')</code>
|[[Standard ML]]
|-
| <code>string:sub_string(''string'', ''startpos'', ''endpos'')<br />string:substr(''string'', ''startpos'', ''numChars'')</code>
|[[Erlang (programming language)|Erlang]]
|-
| <code>strncpy(''result'', ''string'' + ''startpos'', ''numChars'');</code>
|[[C (programming language)|C]]
|-
| <code>''string''[''startpos'' .. ''endpos''+1]</code>
|[[D (programming language)|D]]
|-
| <code>take ''numChars'' $ drop ''startpos'' ''string''</code>
|[[Haskell (programming language)|Haskell]]
|-
| <code>[''string'' substringWithRange:NSMakeRange(''startpos'', ''numChars'')]</code>
|[[Objective-C]] (<code>NSString *</code> only)
|-
| <code>''string''.[''startpos''..''endpos'']</code>
|[[F Sharp (programming language)|F#]]
|-
| <code>string.sub(''string'', ''startpos'', ''endpos'') <br /> (''string''):sub(''startpos'', ''endpos'')</code>
|[[Lua (programming language)|Lua]]<ref name="substr2"/><ref name="substr3"/>
|-
| <code>''string'' copyFrom: ''startpos'' to: ''endpos''</code>
|[[Smalltalk]]
|-
| <code>''string''(''startpos'':''endpos'')</code>
|[[Fortran]]
|-
| <code>SUBSTRING(''string'' FROM ''startpos'' «FOR ''numChars''»)</code>
|[[SQL]]
|-
| <code>StringTake[''string'', {''startpos'', ''endpos''}]</code>
|[[Mathematica]]<ref name="substr2"/><ref name="substr3"/>
|-
| <code>''string'' (''startpos'':''numChars'')</code>
| [[COBOL]]
|-
| <code>${''string_param'':''startpos'':''numChars''}</code>
| [[Bash (Unix shell)|Bash]]
|-
|string range ''string startpos endpos''
|[[Tcl]]
|-
| <code>''string''[''startpos''..''endpos'']</code><br><code>''string''.get(''startpos''..''endpos'')</code>
| [[Rust (programming language)|Rust]]<ref name="Rust indexing" />
|}

<syntaxhighlight lang="csharp">
// Examples in C#
"abc".Substring(1, 1):      // returns "b"
"abc".Substring(1, 2);      // returns "bc"
"abc".Substring(1, 6);      // error
</syntaxhighlight>

<syntaxhighlight lang="lisp">
;; Examples in Common Lisp
(subseq "abc" 1 2)          ; returns "b"
(subseq "abc" 2)            ; returns "c"
</syntaxhighlight>

<syntaxhighlight lang="erlang">
% Examples in Erlang
string:substr("abc", 2, 1). %  returns "b"
string:substr("abc", 2).    %  returns "bc"
</syntaxhighlight>

<syntaxhighlight lang="perl">
# Examples in Perl 5
substr("abc", 1, 1);       #  returns "b"
substr("abc", 1);          #  returns "bc"
</syntaxhighlight><syntaxhighlight lang="c">
# Examples in Raku
"abc".substr(1, 1);        #  returns "b"
"abc".substr(1);           #  returns "bc"

</syntaxhighlight><syntaxhighlight lang="c">
# Examples in Python
"abc"[1:2]                 #  returns "b"
"abc"[1:3]                 #  returns "bc"
</syntaxhighlight><syntaxhighlight lang="c">
/* Examples in Rexx */
substr("abc", 2, 1)         /* returns "b"      */
substr("abc", 2)            /* returns "bc"     */
substr("abc", 2, 6)         /* returns "bc    " */
substr("abc", 2, 6, "*")    /* returns "bc****" */
</syntaxhighlight>

===अपरकेस===
{| class="wikitable"
|- style="background:#fffeed;"
! परिभाषा 
| <code>uppercase(''string'')</code> returns string
|-
! विवरण 
| अपरकेस में स्ट्रिंग रीटर्न करता है। 
|}
{| class="wikitable sortable"
|- style="text-align:left;"
! फॉर्मेट !! लैंग्वेज 
|-
| <code>UCase(''string'') </code>
|[[Visual Basic (classic)|VB]]
|-
| <code>ucase(''string'') </code>
|[[FreeBASIC]]
|-
| <code>toupper(''string'') </code>
|[[AWK]] (changes string)
|-
| <code>uc(''string'')</code>
|[[Perl]], [[Raku (programming language)|Raku]]
|-
| <code>''string''.uc</code>
|[[Raku (programming language)|Raku]]
|-
|<code>toupper(''char'')</code>
|[[C (programming language)|C]] (operates on one character)
|-
|<code>for(size_t i = 0, len = strlen(''string''); i&lt; len; i++) ''string''[i] = toupper(''string''[i]);</code><br/><code>for (char *c = ''string''; *c != '\0'; c++) *c = toupper(*c);</code>
|[[C (programming language)|C]] (string / char array)
|-
| <code>std.string.toUpper(''string'')</code>
|[[D (programming language)|D]]
|-
| <code>transform(''string''.begin(), ''string''.end(), ''result''.begin(), toupper)<ref name="cpptransform" /></code>
| [[C++]]<ref><code>[[std::string]]</code> only, result is stored in string ''result'' which is at least as long as ''string'', and may or may not be ''string'' itself</ref>
|-
| <code>uppercase(''string'')</code>
|[[Object Pascal]] ([[Delphi (programming language)|Delphi]])
|-
|<code>upcase(''char'')</code>
|[[Object Pascal]] ([[Delphi (programming language)|Delphi]]) (operates on one character)
|-
| <code>strtoupper(''string'')</code>
|[[PHP]]
|-
| <code>upper(''string'')</code>
|[[Seed7]]
|-
|<code>${''string_param''^^}</code> (mnemonic: ^ is pointing up)
|[[Bash (Unix shell)|Bash]]
|-
|<code>[[echo (command)|echo]] "string" <nowiki>|</nowiki> [[tr (program)|tr]] 'a-z' 'A-Z' </code>
|[[Unix]]
|-
| <code>translate(''string'')</code>, or<br/>
<code>UPPER variables</code>, or<br/>
<code>PARSE UPPER VAR SrcVar DstVar</code>
|[[Rexx]]
|-
| <code>''string''.upper()</code>
|[[Python (programming language)|Python]]
|-
| <code>upcase(''string'')</code>
|[[Pick Basic]]
|-
| <code>''string''.upcase</code>
|[[Ruby (programming language)|Ruby]]<ref name="ReferenceC"/>
|-
| <code>strings.ToUpper(''string'')</code>
|[[Go (programming language)|Go]]
|-
| <code>(string-upcase ''string'')</code>
|[[Scheme (programming language)|Scheme]], [[Common Lisp]]
|-
| <code>String.uppercase ''string''</code>
|[[OCaml]]
|-
| <code>String.map Char.toUpper ''string''</code>
|[[Standard ML]]
|-
| <code>map Char.toUpper ''string''</code>
|[[Haskell (programming language)|Haskell]]
|-
| <code>''string''.toUpperCase()</code>
|[[Java (programming language)|Java]], [[JavaScript]]
|-
| <code>to_upper(''string'')</code>
|[[Erlang (programming language)|Erlang]]
|-
| <code>''string''.ToUpper()</code>
|[[Visual Basic .NET|VB .NET]], [[C Sharp (programming language)|C#]], [[Windows PowerShell]], [[F Sharp (programming language)|F#]]
|-
| <code>''string''.uppercaseString</code>
|[[Objective-C]] (<code>NSString *</code> only), [[Swift (programming language)|Swift]] (Foundation)
|-
| <code>string.upper(''string'') <br /> (''string''):upper()</code>
|[[Lua (programming language)|Lua]]
|-
| <code>''string'' asUppercase</code>
|[[Smalltalk]]
|-
| <code>UPPER(''string'')</code>
|[[SQL]]
|-
| <code>ToUpperCase[''string'']</code>
|[[Mathematica]]
|-
| <code>«FUNCTION» UPPER-CASE(''string'')</code>
|[[COBOL]]
|-
| <code>''string''.toUpper</code>
|[[Cobra (programming language)|Cobra]]
|-
| <code>string toupper ''string''</code>
| [[Tcl]]
|-
| <code>''string''.to_uppercase()</code>
| [[Rust (programming language)|Rust]]<ref>In Rust, the [https://doc.rust-lang.org/stable/std/primitive.str.html#method.to_uppercase <code>str::to_uppercase</code>] method returns a newly allocated [https://doc.rust-lang.org/stable/std/string/struct.String.html <code>String</code>] with any lowercase characters changed to uppercase ones following the Unicode rules.</ref> 
|}

<syntaxhighlight lang="csharp">
// Example in C#
"Wiki means fast?".ToUpper();      // "WIKI MEANS FAST?" 
</syntaxhighlight>

<syntaxhighlight lang="perl">
# Example in Perl 5
uc("Wiki means fast?");             # "WIKI MEANS FAST?" 
</syntaxhighlight><syntaxhighlight lang="c">
# Example in Raku
uc("Wiki means fast?");             # "WIKI MEANS FAST?"
"Wiki means fast?".uc;              # "WIKI MEANS FAST?"

</syntaxhighlight><syntaxhighlight lang="c">
/* Example in Rexx */
translate("Wiki means fast?")      /* "WIKI MEANS FAST?" */

</syntaxhighlight><syntaxhighlight lang="c">
/* Example #2 */
A='This is an example.'
UPPER A                            /* "THIS IS AN EXAMPLE." */
</syntaxhighlight><syntaxhighlight lang="c">
/* Example #3 */
A='upper using Translate Function.'
Translate UPPER VAR A Z            /* Z="UPPER USING TRANSLATE FUNCTION." */

</syntaxhighlight><syntaxhighlight lang="c">
; Example in Scheme
(use-modules (srfi srfi-13))
(string-upcase "Wiki means fast?") ;  "WIKI MEANS FAST?"

</syntaxhighlight>
<syntaxhighlight lang="c">
' Example in Visual Basic
UCase("Wiki means fast?")          '  "WIKI MEANS FAST?"

</syntaxhighlight>

===ट्रिम===
{{main|ट्रिम (प्रोग्रामिंग)}}<code>trim</code>या<code>strip</code>का उपयोग किसी स्ट्रिंग के आरंभिक सिरे या शुरुआत और अंत दोनों से रिक्त स्थान को हटाने के लिए किया जाता है।

{| class="wikitable"
|- style="text-align:left;"
! उदाहरण उपयोग !! लैंग्वेज 
|-
| <code>''String''.Trim([''chars''])</code>
|[[C Sharp (programming language)|C#]], [[VB.NET]], [[Windows PowerShell]]
|-
| <code>''string''.strip();</code>
|[[D (programming language)|D]]
|-
| <code>(.trim ''string'')</code>
|[[Clojure]]
|-
|<code>''sequence'' [ predicate? ] trim</code>
|[[Factor (programming language)|Factor]]
|-
| <code>(string-trim '(#\Space #\Tab #\Newline) ''string'')</code>
|[[Common Lisp]] 
|-
| <code>(string-trim ''string'')</code>
|[[Scheme (programming language)|Scheme]] 
|-
| <code>''string''.trim()</code>
|[[Java (programming language)|Java]], [[JavaScript]] (1.8.1+, Firefox 3.5+), [[Rust (programming language)|Rust]]<ref>In Rust, the [https://doc.rust-lang.org/stable/std/primitive.str.html#method.trim <code>str::trim</code>] method returns a reference to the original <code>&str</code>.</ref>
|-
| <code>Trim(''String'')</code>
|[[Pascal (programming language)|Pascal]],<ref>{{cite web|url=http://gnu-pascal.de/gpc-hr/Trim.html |title=Trim – GNU Pascal priručnik |publisher=Gnu-pascal.de |access-date=2013-08-24}}</ref> [[QBasic]], [[Visual Basic (classic)|Visual Basic]], [[Delphi (programming language)|Delphi]]
|-
| <code>''string''.strip()</code>
|[[Python (programming language)|Python]]
|-
| <code>strings.Trim(''string'', ''chars'')</code>
|[[Go (programming language)|Go]]
|-
| <code>LTRIM(RTRIM(''String''))</code>
|[[Oracle Corporation|Oracle]] [[SQL]], [[T-SQL]]
|-
| <code>strip(''string'' [,''option'', ''char''])</code>
|[[REXX (programming language)|REXX]]
|-
| <code>string:strip(''string'' [,''option'', ''char''])</code>
|[[Erlang (programming language)|Erlang]]
|-
| <code>''string''.strip or ''string''.lstrip or ''string''.rstrip</code>
|[[Ruby (programming language)|Ruby]]
|-
| <code>''string''.trim</code>
|[[Raku (programming language)|Raku]]
|-
| <code>trim(''string'')</code>
|[[PHP]], [[Raku (programming language)|Raku]]
|-
| <code>[''string'' stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]]</code>
|[[Objective-C]] using [[Cocoa (API)|Cocoa]]
|-
| <code>''string'' withBlanksTrimmed<br>''string'' withoutSpaces<br>''string'' withoutSeparators</code>
|[[Smalltalk]] (Squeak, Pharo)<br>[[Smalltalk]]
|-
|<code>strip(string)</code>
|[[SAS System|SAS]]
|-
|<code>string trim ''$string''</code>
|[[Tcl]]
|-
| <code>TRIM(''string'') or TRIM(ADJUSTL(''string''))</code>
|[[Fortran]]
|-
| <code>TRIM(''string'')</code>
|[[SQL]]
|-
| <code>TRIM(''string'') or LTrim(''string'') or RTrim(''String'')</code>
|[[ColdFusion]]
|-
| <code>String.trim ''string''</code>
|[[OCaml]] 4+
|}
अन्य लैंग्वेज

बिना बिल्ट-इन ट्रिम फ़ंक्शन वाली लैंग्वेजो में, एक कस्टम फ़ंक्शन बनाना सामान्यतः सरल होता है जो समान कार्य को पूरा करता है।

====एपीएल====
[[एपीएल (प्रोग्रामिंग भाषा)|एपीएल (प्रोग्रामिंग लैंग्वेज )]] सीधे नियमित एक्सप्रेशन का उपयोग करता है
<syntaxhighlight lang="apl">
Trim←'^ +| +$'⎕R''
</syntaxhighlight>
वैकल्पिक रूप से, बूलियन मास्क को संयोजित करने वाला एक कार्यात्मक दृष्टिकोण जो अग्रणी और अनुगामी स्थानों को फ़िल्टर करता है।
<syntaxhighlight lang="apl">
Trim←{⍵/⍨(∨\∧∘⌽∨\∘⌽)' '≠⍵}
</syntaxhighlight>
या दो बार रिवर्स और प्रमुख रिक्त स्थान हटाता है।
<syntaxhighlight lang="apl">
Trim←{(∨\' '≠⍵)/⍵}∘⌽⍣2
</syntaxhighlight>


====[[AWK]]====
AWK में, कोई ट्रिम करने के लिए रेगुलर एक्सप्रेशन का उपयोग कर सकता है।

<syntaxhighlight lang="awk">
 ltrim(v) = gsub(/^[ \t]+/, "", v)
 rtrim(v) = gsub(/[ \t]+$/, "", v)
 trim(v)  = ltrim(v); rtrim(v)
</syntaxhighlight>
या:

<syntaxhighlight lang="awk">
 function ltrim(s) { sub(/^[ \t]+/, "", s); return s }
 function rtrim(s) { sub(/[ \t]+$/, "", s); return s }
 function trim(s)  { return rtrim(ltrim(s)); }
</syntaxhighlight>


====सी/सी++====
C या C++ में कोई मानक ट्रिम फ़ंक्शन नहीं होता है। इस प्रकार अधिकांश उपलब्ध स्ट्रिंग लाइब्रेरीज़<ref>{{cite web|url=http://www.and.org/vstr/comparison |title=स्ट्रिंग लाइब्रेरी तुलना|publisher=And.org |access-date=2013-08-24}}</ref> C के लिए कोड होता है, जो ट्रिमिंग के रूप में प्रयुक्त होता है या ऐसे फ़ंक्शन के रूप में प्रयुक्त होता है जो कुशल कार्यान्वयन को बहुत आसान बनाते हैं। कुछ गैर-मानक C पुस्तकालयों में फ़ंक्शन को अधिकांशतः [[ईटव्हाइटस्पेस]] भी कहा जाता है।

C में, प्रोग्रामर अधिकांशतः ट्रिम को प्रयुक्त करने के लिए एलट्रिम और आरट्रिम को जोड़ते हैं

<syntaxhighlight lang="c">
#include <string.h>
#include <ctype.h>

void rtrim(char *str)
{
  char *s;
  s = str + strlen(str);
  while (--s >= str) {
    if (!isspace(*s)) break;
    *s = 0;
  }
}

void ltrim(char *str)
{
  size_t n;
  n = 0;
  while (str[n] != '\0' && isspace((unsigned char) str[n])) {
    n++;
  }
  memmove(str, str + n, strlen(str) - n + 1);
}

void trim(char *str)
{
  rtrim(str);
  ltrim(str);
}
</syntaxhighlight>
[[खुला स्रोत सॉफ्टवेयर|ओपन सोर्स सॉफ्टवेयर]] C++[[ लाइब्रेरी को बूस्ट करें | लाइब्रेरी को बूस्ट करते है]] और इस प्रकार कई ट्रिम वेरिएंट हैं, जिनमें एक मानक के रूप में सम्मलित होते है,<ref>{{cite web|url=http://www.boost.org/doc/html/string_algo/usage.html#id2742817 |title=Usage – 1.54.0 |publisher=Boost.org |date=2013-05-22 |access-date=2013-08-24}}</ref>

<syntaxhighlight lang="cpp">
#include <boost/algorithm/string/trim.hpp>
trimmed = boost::algorithm::trim_copy("string");
</syntaxhighlight>
ध्यान दें कि बूस्ट के फ़ंक्शन का नाम <code>trim</code> है इनपुट अनुक्रम को जगह-जगह संशोधित किया जाता है और कोई परिणाम नहीं रीटर्न करता है।

एक अन्य ओपन-सोर्स सॉफ़्टवेयर C++ लाइब्रेरी Qt (टूलकिट) के कई ट्रिम वेरिएंट हैं, जिनमें एक मानक के रूप में सम्मलित है<ref>[http://doc.trolltech.com/4.5/qstring.html#trimmed]  {{webarchive |url=https://web.archive.org/web/20090802041055/http://doc.trolltech.com/4.5/qstring.html#trimmed |date=August 2, 2009 }}</ref>

<syntaxhighlight lang="cpp">
#include <QString>
trimmed = s.trimmed();
</syntaxhighlight>
[[लिनक्स कर्नेल]] में एक स्ट्रिप फ़ंक्शन के रूप में सम्मलित है, <code>strstrip()</code>,2.6.18-rc1 के बाद से जो स्ट्रिंग को उसके स्थान पर ट्रिम करता है। 2.6.33-rc1 के बाद से, कर्नेल का उपयोग होता है <code>strim()</code> के अतिरिक्त<code>strstrip()</code> झूठी चेतावनियों से बचने के लिए होता है.<ref>{{cite web|author=dankamongmen |url=https://github.com/dankamongmen/sprezzos-kernel-packaging/blob/master/changelog |title=sprezzos-kernel-packaging/changelog at master · dankamongmen/sprezzos-kernel-packaging · GitHub |publisher=Github.com |access-date=2016-05-29}}</ref>


====हास्केल====
[[हास्केल (प्रोग्रामिंग भाषा)|हास्केल (प्रोग्रामिंग लैंग्वेज )]] में एक ट्रिम एल्गोरिदम होता है

<syntaxhighlight lang="haskell">
 import Data.Char (isSpace)
 trim      :: String -> String
 trim      = f . f
    where f = reverse . dropWhile isSpace
</syntaxhighlight>
इसकी व्याख्या इस प्रकार की जा सकती है, f पूर्ववर्ती रिक्त स्थान को हटा देता है और स्ट्रिंग को रिवर्स कर देता है। इस प्रकार f को फिर से अपने आउटपुट पर प्रयुक्त किया जाता है। ध्यान दें कि टाइप हस्ताक्षर (दूसरी पंक्ति) वैकल्पिक है।

====जे====

[[जे (प्रोग्रामिंग भाषा)|जे (प्रोग्रामिंग लैंग्वेज )]] में ट्रिम एल्गोरिदम एक [[कार्यात्मक प्रोग्रामिंग]] विवरण है

<syntaxhighlight lang="j">
     trim =. #~ [: (+./\ *. +./\.) ' '&~:
</syntaxhighlight>
यह फ़िल्टर (<code>#~</code>) नॉन स्पेस करैक्टर के लिए (<code>' '&~:</code>) अग्रणी के बीच (<code>+./\</code>) और (<code>*.</code>) अनुगामी (<code>+./\.</code>) रिक्त स्थान के रूप में होता है 

====जावास्क्रिप्ट====
जावास्क्रिप्ट 1.8.1 फ़ायरफ़ॉक्स 3.5 और बाद के संस्करण और ईसीएमए स्क्रिप्ट 5 मानक में एक अंतर्निहित ट्रिम फ़ंक्शन के रूप में होता है। पहले के संस्करणों में इसे स्ट्रिंग ऑब्जेक्ट के प्रोटोटाइप में निम्नानुसार जोड़ा जा सकता है

<syntaxhighlight lang="javascript">
String.prototype.trim = function() {
  return this.replace(/^\s+/g, "").replace(/\s+$/g, "");
};
</syntaxhighlight>


====पर्ल====
पर्ल 5 में कोई अंतर्निहित ट्रिम फ़ंक्शन नहीं होता है । चूंकि, कार्यक्षमता सामान्यतः [[नियमित अभिव्यक्ति|नियमित एक्सप्रेशन]] का उपयोग करके प्राप्त की जाती है।

उदाहरण इस प्रकार है, 
<syntaxhighlight lang="perl">
$string =~ s/^\s+//;            # remove leading whitespace
$string =~ s/\s+$//;            # remove trailing whitespace
 </syntaxhighlight>
या: 
<syntaxhighlight lang="perl">
$string =~ s/^\s+|\s+$//g ;     # remove both leading and trailing whitespace
 </syntaxhighlight>
ये उदाहरण मूल चर के <code>$string</code>.मान को संशोधित करते हैं 

पर्ल के लिए '''StripLTSpace''' भी उपलब्ध है <code>String::Strip</code> [[सीपीएएन]] के रूप में होते है.

चूंकि, <code>chomp</code> और <code>chop</code>:दो फ़ंक्शन हैं जिनका उपयोग सामान्यतः स्ट्रिंग के अंत से रिक्त स्थान को हटाने के लिए किया जाता है 
* <code>[http://perldoc.perl.org/functions/chop.html chop]</code> किसी स्ट्रिंग से अंतिम अक्षर हटाता है और उसे रीटर्न करता है ।
* <code>[http://perldoc.perl.org/functions/chomp.html chomp]</code> यदि प्रस्तुत है तो स्ट्रिंग से पिछली न्यूलाइन करैक्टर को हटा देता है। एक नई पंक्ति का गठन [http://perldoc.perl.org/perlvar.html $INPUT_RECORD_SEPARATOR] पर निर्भर करता है।

[[राकू (प्रोग्रामिंग भाषा)|राकू (प्रोग्रामिंग लैंग्वेज )]] में, पर्ल की आगामी सिस्टर लैंग्वेज स्ट्रिंग्स में एक <code>trim</code> विधि होती है।

उदाहरण:<syntaxhighlight lang="c">
$string = $string.trim;     # remove leading and trailing whitespace
$string .= trim;            # same thing
</syntaxhighlight>

====[[ टी.सी.एल ]]====
टीसीएल <code>string</code> कमांड में तीन प्रासंगिक उपकमांड <code>trim</code>, <code>trimright</code> और <code>trimleft</code>.के रूप में होते है, उन कमांड में से प्रत्येक के लिए एक अतिरिक्त तर्क निर्दिष्ट किया जाता है: एक स्ट्रिंग जो हटाने के लिए करैक्टर के एक सेट का प्रतिनिधित्व करती है वह डिफ़ॉल्ट व्हाइटस्पेस, स्पेस, टैब, न्यूलाइन, कैरिज रिटर्न करती है।

वॉवेल्स को ट्रिम करने का उदाहरण इस प्रकार है।

<syntaxhighlight lang="tcl">
set string onomatopoeia
set trimmed [string trim $string aeiou]         ;# result is nomatop
set r_trimmed [string trimright $string aeiou]  ;# result is onomatop
set l_trimmed [string trimleft $string aeiou]   ;# result is nomatopoeia
</syntaxhighlight>


====एक्सएसएलटी====
[[एक्सएसएल परिवर्तन]] में फ़ंक्शन <code>normalize-space(''string)''</code>के रूप में सम्मलित है जो किसी भी रिक्त स्थान अनुक्रम (लाइन ब्रेक सहित) को एक ही स्थान से बदलने के अतिरिक्त, अग्रणी और अनुगामी रिक्त स्थान को हटा देता है।

उदाहरण:
<syntaxhighlight lang="xml">
<xsl:variable name='trimmed'>
   <xsl:value-of select='normalize-space(string)'/>
</xsl:variable>
</syntaxhighlight>
XSLT 2.0 में नियमित एक्सप्रेशन के रूप में सम्मलित है, जो स्ट्रिंग ट्रिमिंग करने के लिए एक और मैकेनिज्म प्रदान करती है।

ट्रिमिंग के लिए एक अन्य XSLT प्रौद्योगिकी XPath 2.0 <code>substring()</code>फंक्शन का उपयोग करता है।

==संदर्भ==
{{Reflist|refs=
<ref name="at1">the index can be negative, which then indicates the number of places before the end of the string.</ref>
<ref name="at2">the index can '''not''' be negative, use '''*-N''' where N indicate the number of places before the end of the string.</ref>

<ref name="substr2">''<code>startpos</code>'' can be negative, which indicates to start that number of places before the end of the string.</ref>
<ref name="substr3">''<code>endpos</code>'' can be negative, which indicates to end that number of places before the end of the string.</ref>
<ref name="substr4">''<code>numChars</code>'' can be negative, which indicates to end that number of places before the end of the string.</ref>
<ref name="substr5">''<code>startpos</code>'' can '''not''' be negative, use ''* - startpos'' to indicate to start that number of places before the end of the string.</ref>
<ref name="substr6">''<code>numChars</code>'' can '''not''' be negative, use ''* - numChars'' to indicate to end that number of places before the end of the string.</ref>
}}

[[Category:Articles with hatnote templates targeting a nonexistent page]]
[[Category:Created On 26/07/2023]]
[[Category:Machine Translated Page]]
[[Category:Missing redirects]]
[[Category:Pages with script errors]]
[[Category:Templates Vigyan Ready]]
[[Category:Webarchive template wayback links]]
[[Category:उदाहरण के लिए पायथन (प्रोग्रामिंग भाषा) कोड वाले लेख]]
[[Category:प्रोग्रामिंग भाषा तुलना|*स्ट्रिंग फ़ंक्शन]]
[[Category:स्ट्रिंग (कंप्यूटर विज्ञान)|प्रोग्रामिंग भाषा तुलना]]