String matching: Difference between revisions

::#   Print the location of the match for part 2

::#   Handle multiple occurrences of a string for part 2.

<br><br>

 

=={{header|360 Assembly}}==

STRMATCH CSECT

USING STRMATCH,R15

PG DC CL80' '

YREGS

{{out}}

<pre>

</pre>

 

 

=={{header|Ada}}==

with Ada.Strings.Fixed; use Ada.Strings.Fixed;

with Ada.Text_IO; use Ada.Text_IO;

);

end Match_Strings;

{{out}}

<pre>

 

=={{header|Aime}}==

data b;

 

 

 

 

t = "ok";

 

 

t = "Summer";

 

{{out}}

<pre>starts with, embeds, ends with "Bang": 1, 1, 0

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - string in string is non-standard?}}

PRIO STARTSWITH = 5, ENDSWITH = 5;

OP STARTSWITH = (STRING str, prefix)BOOL: # assuming LWB = 1 #

(string in string("ab",loc,"abab")|loc|-1), # returns +1 #

(string in string("ab",loc2,"abab"[loc+1:])|loc+loc2|-1) # returns +3 #

{{out}}

<pre>

TFFT -1 +1 +3

</pre>

 

=={{header|AutoHotkey}}==

String1 = abcd

String2 = abab

If TempVar = %String2%

MsgBox, "%String1%" ends with "%String2%".

 

=={{header|AutoIt}}==

$string2 = "ard"

 

EndIf

 

 

=={{header|AWK}}==

}

 

=={{header|BASIC}}==

{{works with|QBasic}}

 

'Determining if the first string starts with second string

END IF

 

 

{{out}}

 

==={{header|Applesoft BASIC}}===

20 S$ = "TH"

30 DEF FN S(P) = MID$(A$, P, LEN(S$)) = S$

310 E$(1) = "ENDS"

320 E$(0) = "DOES NOT END"

 

=={{header|Batch File}}==

::you put some of the CMD special characters (ex. %,!, etc) inside the strings.

::

set /a length+=1

goto loop

{{out}}

<pre>"qwertyuiop" begins with "qwerty".

 

Press any key to continue . . .</pre>

 

=={{header|BBC BASIC}}==

FOR test% = 1 TO 3

UNTIL I% = 0

= N%

{{out}}

<pre>"The fox jumps over the dog" starts with "The"

"The fox jumps over the dog" contains "dog" at position 24

"The fox jumps over the dog" contains "dog" 1 time(s)</pre>

 

=={{header|Bracmat}}==

Bracmat does pattern matching in expressions <code><i>subject</i>:<i>pattern</i></code> and in strings <code>@(<i>subject</i>:<i>pattern</i>)</code>. The (sub)pattern <code>?</code> is a wild card.

& out$(@(!sentence:I ?) & "sentence starts with 'I'" | "sentence does not start with 'I'")

& out$(@(!sentence:? such ?) & "sentence contains 'such'" | "sentence does not contain 'such'")

| out$str$("sentence contains " !N " occurrences of 'be'")

)

In the last line, Bracmat is forced by the always failing node <code>~</code> to backtrack until all occurrences of 'be' are found.

Thereafter the pattern match expression fails.

=={{header|C}}==

Case sensitive matching:

#include <stdio.h>

 

 

return 0;

{{out}}

<pre>Starts with Test ( Hello,Hell ) : 1

Contains Test ( Google,msn ) : 0</pre>

Code without using string library to demonstrate how char strings are just pointers:

 

/* returns 0 if no match, 1 if matched, -1 if matched and at end */

 

return 0;

{{out}}

<pre>matching `A Short String' with `ort S':

matching `something random' with `Rand':

end match</pre>

 

=={{header|C sharp|C#}}==

{{works with|Mono|2.6}}

class Program

{

}

}

 

=={{header|Clojure}}==

{{trans|Java}}

(. "abcd" endsWith "zn")

(. "abab" contains "bb")

 

user> (for [i evals] [i (eval i)])

 

=={{header|CoffeeScript}}==

This example uses string slices, but a better implementation might use indexOf for slightly better performance.

 

matchAt = (s, frag, i) ->

s[i...i+frag.length] == frag

console.log matchLocations "bababab", "bab" # [0,2,4]

console.log matchLocations "xxx", "x" # [0,1,2]

 

=={{header|Common Lisp}}==

(defun starts-with-p (str1 str2)

"Determine whether `str1` starts with `str2`"

(print (containsp "ababaBa" "ba")) ; (1 3)

(print (containsp "foobar" "x")) ; NIL

 

=={{header|Component Pascal}}==

BlackBox Component Builder

MODULE StringMatch;

IMPORT StdLog,Strings;

END Do;

END StringMatch.

Execute: ^Q StringMatching.Do <br/>

{{out}}

 

=={{header|D}}==

import std.stdio;

import std.algorithm: startsWith, endsWith, find, countUntil;

[1, 2, 3].countUntil(3).writeln; // 2

[1, 2, 3].countUntil([2, 3]).writeln; // 1

{{out}}

<pre>true

2

1</pre>

=={{header|DCL}}==

$ length_of_first_string = f$length( first_string )

$ second_string = p2

$ else

$ write sys$output "first string does not end with the second string"

{{out}}

<pre>$ @string_matching efabcdef ef

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Writeln(AnsiContainsText('abcd', 'ab')); // True

WriteLn(Pos('ab', 'abcd')); // 1

 

=={{header|E}}==

 

println(string1.startsWith(string2))

 

println(string1.endsWith(string2))

 

=={{header|EchoLisp}}==

(string-suffix? "nette" "Antoinette") → #t

(string-prefix? "Simon" "Simon & Garfunkel") → #t

(string-match "Antoinette" "net") → #t ;; contains

(string-index "net" "Antoinette") → 5 ;; substring location

 

=={{header|Elena}}==

public program()

var s := "abcd";

console.printLine(s," index of az: ",s.indexOf(0, "az"));

console.readChar()

 

=={{header|Elixir}}==

The String module has functions that cover the base requirements.

s2 = "adab"

s3 = "ab"

 

Regex.scan(~r/#{s3}/, "abcabc", return: :index)

 

=={{header|Emacs Lisp}}==

 

 

 

 

=={{header|Erlang}}==

-module(character_matching).

-export([starts_with/2,ends_with/2,contains/2]).

contains(_S1,_S2,_N,Acc) ->

Acc.

=={{header|Euphoria}}==

integer x

 

else

printf(1, "'%s' does not end with '%s'\n", {first, second})

 

{{out}}

 

=={{header|F_Sharp|F#}}==

let main args =

 

if idx < 0 then None else Some (idx, idx+1)) 0

|> Seq.iter (printfn "substring %A begins at position %d (zero-based)" contains)

{{out}}

<pre>text = "一二三四五六七八九十"

=={{header|Factor}}==

Does <code>cheesecake</code> start with <code>cheese</code>?

Does <code>cheesecake</code> contain <code>sec</code> at any location?

Does <code>cheesecake</code> end with <code>cake</code>?

Where in <code>cheesecake</code> is the leftmost <code>sec</code>?

Where in <code>Mississippi</code> are all occurrences of <code>iss</code>?

 

=={{header|Falcon}}==

'''VBA/Python programmer's approach. I'm just a junior Falconeer but this code seems falconic''

/* created by Aykayayciti Earl Lamont Montgomery

April 9th, 2018 */

 

> s1.endsWith(s2) ? @ "s1 ends with $s2" : @ "$s1 does not end with $s2"

{{out}}

<pre>

* <code>indexrIgnoreCase</code> (like above, ignoring case for ASCII characters)

 

class Main

{

}

}

 

{{out}}

 

=={{header|FBSL}}==

 

DIM s = "roko, mat jane do"

WHILE INSTR(mane, match, INSTR + 1): PRINT " ", INSTR;: WEND

END SUB

{{out}}

<pre>"roko, mat jane do" starts with "roko"

 

=={{header|Forth}}==

tuck 2>r min 2r> compare 0= ;

: ends-with ( a l a2 l2 -- ? )

tuck 2>r negate over + 0 max /string 2r> compare 0= ;

 

=={{header|Fortran}}==

In the case of STARTS, these annoyances can be left to the INDEX function rather than comparing the start of A against B. At the cost of it searching the whole of A if B is not at the start. Otherwise, it would be the mirror of ENDS.

 

SUBROUTINE STARTS(A,B) !Text A starts with text B?

CHARACTER*(*) A,B

CALL ENDS("Brief","Much longer")

END

Output: text strings are bounded by >''etc.''< in case of leading or trailing spaces.

<pre>

 

Similar program using modern Fortran style

!-----------------------------------------------------------------------

!Main program string_matching

end function ends

end program string_matching

Output: false = 0, true = 1 ( + multiple occurrences if applicable)

<pre>

 

=={{header|FreeBASIC}}==

 

Dim As String s1 = "abracadabra"

Print

Print "Press any key to quit"

 

{{out}}

First string contains second string : at index 1 and at index 8

First string ends with second string : true

</pre>

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=07bb32f4e8e8f7d81898cf41d4431a2e Click this link to run this code]'''

Dim sString1 As String = "Hello world"

Dim sString2 As String = "Hello"

Print sString1 Ends Left(sString2, 5) 'Determine if the first string ends with the second string

 

Output:

<pre>

False

</pre>

 

=={{header|GML}}==

{{trans|BASIC}}

 

{

first = "qwertyuiop";

show_message("'" + first + "' does not end with '" + second + "'");

}

 

{{out}} (in message boxes, 1 per line):

 

=={{header|Go}}==

 

import (

func main() {

match("abracadabra", "abr")

{{out}}

<pre>

=={{header|Groovy}}==

Examples:

assert ! "abcd".startsWith("zn")

assert "abcd".endsWith("cd")

assert indicesOf("abab", "ab") == [0, 2]

assert indicesOf("abab", "ba") == [1]

 

All assertions pass, so there is no output.

 

=={{header|Haskell}}==

> "abc" `isPrefixOf` "abcdefg"

True

> let infixes a b = findIndices (isPrefixOf a) $ tails b

> infixes "ab" "abcdefabqqab"

 

 

write("Matching s2 :=",image(s2 := "ab")," within s1:= ",image(s1 := "abcdabab"))

write("Test #3 ending ", if s1[0-:*s2] == s2 then "matches" else "fails")

 

{{out}}

 

=={{header|J}}==

contains=: +./@:E.~

 

Example use:

 

1

'abcd' startswith 'cd'

1

'abab' I.@E.~ 'ab' NB. find starting indicies

 

Note that these verbs contain no constraints restricting them to sequences of characters and so also apply to arrays of type other than character:

1

4.2 5.1 1.3 9 3 contains 1.3 4.2 NB. floating point

0

4.2 5.1 1.3 4.2 9 3 contains 1.3 4.2

 

=={{header|Java}}==

"abcd".endsWith("zn") //returns false

"abab".contains("bb") //returns false

int loc = "abab".indexOf("bb") //returns -1

loc = "abab".indexOf("ab") //returns 0

public class JavaApplication6 {

public static void main(String[] args) {

String strOne = "complexity";

String strTwo = "udacity";

stringMatch(strOne, strTwo);

}

 

}

}

 

=={{header|JavaScript}}==

 

, stringB = "co"

, q1, q2, q2multi, m

console.log(" In fact, it happens "+q2matches.length+" times within '"+stringA+"', at index"+(q2matches.length > 1 ? "es" : "")+" "+q2matches.join(', ')+".")

}

 

{{out}}

In fact, it happens 2 times within 'tacoloco', at indexes 2, 6.

3: Does 'tacoloco' end with 'co'? Yes.</pre>

 

=={{header|jq}}==

Using the builtins of jq 1.4 and later:

"abc" | startswith("ab")

 

# so the jq test "if index(_) then ...." can be used

# without any type conversion.

 

"abcd" | index( "bc")

 

"abc" | endswith("bc")

 

Using the regex functions available in jq 1.5:

 

"abcd" | test("bc")

 

 

===Multiple Occurrences===

To determine all the indices of one string in another:

jq -n '"abcdabcd" | indices("bc")'

[

1,

5

 

In jq 1.5, the regex function match/1 can also be used:

1

 

startswith("abcd","ab") #returns true

findfirst("ab", "abcd") #returns 1:2, indices range where string was found

println(r.offset)

end #returns 1, then 3 matching the two starting indices where the substring was found

 

=={{header|K}}==

endswith: {0=(-#y)+(#x)-*_ss[x;y]}

 

'''Example:'''

 

1

startswith["abcd";"bc"]

0

_ss["abcdabceabc";"abc"] / location of matches

 

=={{header|Kotlin}}==

val s1 = "abracadabra"

val s2 = "abra"

 

{{out}}

<pre>

</pre>

 

=={{header|LabVIEW}}==

[[File:LabVIEW_Character_matching_3.png]]

 

 

 

 

 

 

 

=={{header|Lang5}}==

: comb "" split ; : concat "" join ; : dip swap '_ set execute _ ;

: first 0 extract swap drop ; : flip comb reverse concat ;

"rosettacode" "ocat" contains . # 0

"rosettacode" "edoc" end-with . # 0

 

=={{header|Liberty BASIC}}==

st1$="first string"

st2$="first"

print "First string ends with second string."

end if

 

=={{header|Lingo}}==

b = "Hello"

 

-- Print the location of the match for part 2

put offset(b, a)

 

=={{header|Logo}}==

if empty? :sub [output "true]

if empty? :thing [output "false]

show starts.with? "dog "doghouse ; true

show ends.with? "house "doghouse ; true

=={{header|Lua}}==

s2 = "str"

s3 = "ing"

print( "s1 ends with s2: ", select( 2, string.find( s1, s2 ) ) == string.len( s1 ) )

=={{header|M2000 Interpreter}}==

Module StringMatch {

A$="Hello World"

Print A$ ~ "*orld"

}

{{out}}

<pre>

True

</pre>

=={{header|Maple}}==

These facilities are all to be found in the StringTools package in Maple.

> with( StringTools ): # bind package exports at the top-level

> s := "dzrIemaWWIMidXYZwGiqkOOn":

> {seq}( s[ i .. i + 2 ], i = p ); # check them

{"XYZ"}

The StringTools package also contains facilities for regular expression matching, but for fixed string patterns, the Search and SearchAll tools are much faster.

 

EndWith[x_, y_] := MemberQ[Flatten[StringPosition[x, y]], StringLength[x]]

StartWith["XYZaaabXYZaaaaXYZXYZ", "XYZ"]

EndWith["XYZaaabXYZaaaaXYZXYZ", "XYZ"]

{{out}}

<pre>True

True

{{1,3},{8,10},{15,17},{18,20}}</pre>

 

=={{header|MATLAB}} / {{header|Octave}}==

% 1. Determining if the first string starts with second string

strcmp(str1,str2,length(str2))

% 2. Handle multiple occurrences of a string for part 2.

ix = strfind(s1,s2); % ix is a vector containing the starting positions of s2 within s1

 

 

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols

 

 

return

 

----

=={{header|NewLISP}}==

 

;; test if str starts with "ab"

(push idx pos -1))))

 

 

=={{header|Nim}}==

 

{{out}}

 

=={{header|Objeck}}==

bundle Default {

class Matching {

}

}

 

=={{header|OCaml}}==

 

let len1 = String.length s1

and len2 = String.length s2 in

if len1 < len2 then false else

let sub = String.sub s1 0 len2 in

 

testing in the top-level:

- : bool = true

 

let len1 = String.length s1

and len2 = String.length s2 in

if (sub = s2) then true else aux (pred i)

in

 

# match2 "It's raining, Hello World!" "umbrella" ;;

- : bool = true

 

let len1 = String.length s1

and len2 = String.length s2 in

if len1 < len2 then false else

let sub = String.sub s1 (len1 - len2) len2 in

 

# match3 "Hello World" "Hello" ;;

- : bool = true

 

let len1 = String.length s1

and len2 = String.length s2 in

if (sub = s2) then (true, i) else aux (pred i)

in

 

# match2_loc "The sun's shining, Hello World!" "raining" ;;

- : bool * int = (true, 10)

 

let len1 = String.length s1

and len2 = String.length s2 in

else aux (pred i) (n)

in

 

# match2_num "This cloud looks like a camel, \

that other cloud looks like a llama" "cloud" ;;

- : bool * int = (true, 2)

 

=={{header|Oforth}}==

 

| i |

s2 isAllAt(s1, 1) ifTrue: [ System.Out s1 << " begins with " << s2 << cr ]

System.Out s1 << " includes " << s2 << " at position : " << i << cr

i s2 size + ->i

 

{{out}}

 

=={{header|OxygenBasic}}==

string s="sdfkjhgsdfkdfgkbopefioqwurti487sdfkrglkjfs9wrtgjglsdfkdkjcnmmb.,msfjflkjsdfk"

 

'

'Total matches: 5

 

=={{header|PARI/GP}}==

This meets the first but not the second of the optional requirements. Note that GP treats any nonzero value as true so the location found by contains() can be ignore if not needed.

string=Vec(string);

prefix=Vec(prefix);

for(i=1,#suffix,if(prefix[i]!=string[i+#string-#suffix], return(0)));

1

 

=={{header|Perl}}==

Using regexes:

 

$str1 =~ /\Q$str2\E/ # true if $str1 contains $str2

 

Using <code>index</code>:

 

index($str1, $str2) != -1 # true if $str1 contains $str2

 

Using <code>substr</code>:

 

 

Bonus task ''(printing all positions where <code>$str2</code> appears in <code>$str1</code>)'':

 

 

 

 

 

 

 

 

 

 

 

{{out}}

<pre>

 

=={{header|PHP}}==

/**********************************************************************************

* This program gets needle and haystack from the caller (chm.html) (see below)

<p style="color: red";><strong><?php echo "$tx1" ?></strong></p>

</body>

<!DOCTYPE html>

<!--

</form>

</body>

 

=={{header|PicoLisp}}==

-> "abcd"

: (pre? "xy" "abcd")

 

: (positions "bc" "abcdabcd")

 

=={{header|PL/I}}==

/* Let s be one string, t be the other that might exist within s. */

/* 8-1-2011 */

 

if k > 0 then put skip edit (t, ' starts at position ', k) (a);

 

Optional extra:

 

/* Handle multiple occurrences. */

n = 1;

else stop;

end;

 

=={{header|PureBasic}}==

Protected Result

If FindString(String1$, String2$, 1) =1 ; E.g Found in possition 1

EndIf

ProcedureReturn Result

And a verification

PrintN(Str(StartsWith("Rosettacode", "Rosetta"))) ; = 1

PrintN(Str(StartsWith("Rosettacode", "code"))) ; = 0

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

 

An alternate and more complete solution:

;returns one if string1$ starts with string2$, otherwise returns zero

If FindString(string1$, string2$, 1) = 1

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

{{out}}

<pre>1

0

1</pre>

 

=={{header|Python}}==

"abcd".endswith("zn") #returns False

"bb" in "abab" #returns False

loc = "abab".find("bb") #returns -1

loc = "abab".find("ab") #returns 0

 

=={{header|Racket}}==

#lang racket

(require srfi/13)

(string-contains "abab" "bb")

(string-contains "abab" "ba")

{{out}}

<pre>

</pre>

 

 

=={{header|Retro}}==

withLength &swap dip 0 swap ^strings'getSubset compare ;

 

 

"abcdefghijkl" "ijkl" endsWith?

 

=={{header|REXX}}==

Extra coding was added to take care of using plurals in the last output message.

if left(A, LB)==B then say 'string A starts with string B'

else say "string A doesn't start with string B"

say /* [↓] another method using COMPARE BIF*/

if p==0 then say "string A doesn't contain string B"

else say 'string A contains string B (starting in position' p")"

say

else say "string A doesn't end with string B"

say

if #==0 then say "string A doesn't contain string B"

else say 'string A contains string B ' # " time"left('s', #>1),

{{out|output|text=&nbsp; when the following is specified (the five Marx brothers): &nbsp; <tt> Chico_Harpo_Groucho_Zeppo_Gummo p </tt> }}

<pre>

 

=={{header|Ring}}==

aString = "Welcome to the Ring Programming Language"

bString = "Ring"

bStringIndex = substr(aString,bString)

if bStringIndex > 0 see "" + bStringIndex + " : " + bString ok

 

=={{header|Ruby}}==

p 'abcd'.end_with?('ab') #returns false

p 'abab'.include?('bb') #returns false

p 'abab'.index('ab') #returns 0

p 'abab'.index('ab', 1) #returns 2

 

=={{header|Run BASIC}}==

s2$ = "abc" ' begins with

s3$ = "ef" ' is in the string

 

if mid$(s1$,len(s1$) + 1 - len(sn4$),len(sn4$)) <> sn4$ then a$ = "Not "

{{out}}

<pre>

 

=={{header|Rust}}==

match possible_match {

Some(match_pos) => println!("Found match at pos {}", match_pos),

// Determining if the first string ends with the second string

assert!(s2.ends_with(s3));

 

fn main(){

let hello = String::from("Hello world");

hello.ends_with("ld"),

hello.contains("wi"));

 

{{out}}

 

=={{header|Scala}}==

"abcd".endsWith("zn") //returns false

"abab".contains("bb") //returns false

var loc="abab".indexOf("bb") //returns -1

loc = "abab".indexOf("ab") //returns 0

 

=={{header|Seed7}}==

 

const proc: main is func

position := pos("abab", "ab", succ(position));

writeln(position); # position is 3

 

{{out}}

 

=={{header|Sidef}}==

var second = "abc";

 

while (pos = first.index(second, pos+1) != -1) {

say "Match at pos: #{pos}";

 

=={{header|Smalltalk}}==

a endsWith: b

 

=={{header|SNOBOL4}}==

s2 = 'ab'

s3 = 'xy'

 

p3 OUTPUT = ?(s1 ? s2 RPOS(0)) "3. " s2 " ends " s1

{{out}}

<pre>1. ab begins abcdabefgab

 

=={{header|Standard ML}}==

String.isSuffix "zn" "abcd"; (* returns false *)

String.isSubstring "bb" "abab"; (* returns false *)

#2 (Substring.base (#2 (Substring.position "bb" (Substring.full "abab")))); (* returns 4 *)

val loc = #2 (Substring.base (#2 (Substring.position "ab" (Substring.full "abab")))); (* returns 0 *)

 

=={{header|Swift}}==

str.hasPrefix("Hell") //True

str.hasPrefix("hell") //False

 

str.hasSuffix("playground") //True

 

=={{header|Tcl}}==

In this code, we are looking in various ways for the string in the variable <tt>needle</tt> in the string in the variable <tt>haystack</tt>.

set isContained [expr {[string first $needle $haystack] >= 0}]

 

Of course, in the cases where the needle is a glob-safe string (i.e., doesn't have any of the characters “<tt>*?[\</tt>” in), this can be written far more conveniently:

set isContained [string match *$needle* $haystack]

 

Another powerful technique is to use the regular expression engine in literal string mode:

This can be extended by getting the <code>regexp</code> to return the locations of the matches, enabling the other forms of match to be done:

# Each match location is a pair, being the index into the string where the needle started

# to match and the index where the needle finished matching

foreach location $matchLocations {

puts "needle matched at index [lindex $location 0]"

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

ASK "string1", string1=""

PRINT string1," not ends with ",string2

ENDIF

{{out}}

<pre>string1 >Rosetta Code

===TXR Lisp===

 

((big small)

(cond

(put-line `@small does not occur in @big`)))))

(otherwise

{{out}}

<pre>$ txr cmatch2.tl x

===Pattern Language===

 

@(cases)

@ line

first line is not found in the second line

@ (end)

 

{{out}}

0123

first line is a suffix of the second line</pre>

 

=={{header|VBA}}==

word = "the" '-- (also try this with "th"/"he")

sentence = "the last thing the man said was the"

r = InStr(r + 1, sentence, word)

Loop

<pre>yes(1)

yes(2)

16

33 </pre>

=={{header|VBScript}}==

StartsWith = False

If Left(s1,Len(s2)) = s2 Then

WScript.StdOut.Write "Contains test, 'o' in 'fooooobar': " & Contains("fooooobar","o")

WScript.StdOut.WriteLine

 

{{out}}

{{works with|Visual Basic|VB6 Standard}}

works the same as in VBA, see [[String_matching#VBA]]

 

=={{header|XPL0}}==

string 0; \use zero-terminated strings

 

Text(0, if StrFind(Str, "with") = StrLen(Str)-StrLen("with") then "yes" else "no"); CrLf(0); \3.

Text(0, if StrFind(Str, "x w" ) = StrLen(Str)-StrLen("x w" ) then "yes" else "no"); CrLf(0);

 

{{out}}

no

</pre>

 

=={{header|zkl}}==

f("foobar","foo") //--> Yep

f("foobar","ob") //--> Contained @2

if( Void!=(n:=text.rfind(p)) and n+p.len()==text.len() )

println("tail gunner") else println("Nope")

f("foobar","r"); f("foobar","ar"); //--> tail gunners

f("foobar","ob"); //--> Nope

 

{{omit from|bc|No string operations in bc}}