Text between: Difference between revisions

{{draft task|Text between}}

 

;Task:

 

Example 1. Both delimiters set

<pre>

</pre>

 

Example 2. Start delimiter is the start of the string

<pre>

</pre>

 

Example 3. End delimiter is the end of the string

<pre>

</pre>

 

Example 4. End delimiter appears before and after start delimiter

<pre>

</pre>

 

Example 5. End delimiter not present

<pre>

</pre>

 

Example 6. Start delimiter not present

<pre>

</pre>

 

Example 7. Multiple instances of end delimiter after start delimiter (match until the first one)

<pre>

</pre>

 

Example 8. Multiple instances of the start delimiter (start matching at the first one)

<pre>

</pre>

 

Example 9. Start delimiter is end delimiter

 

<pre>

</pre>

 

 

=={{header|ALGOL 68}}==

Uses the Algol 68G specific string in string, for other compilers/interpreters, a version of string in string is here : [[ALGOL_68/prelude]].<br/>

As Algol 68 predates Unicode, the fourth example deviates from the task.

# some utility operators #

# returns the length of a string #

trace between := FALSE

END

{{out}}

<pre>

 

=={{header|AppleScript}}==

my text_between("Hello Rosetta Code world", "Hello ", " world")

 

return return_text

end text_between

=={{header|AWK}}==

# syntax: GAWK -f TEXT_BETWEEN.AWK

BEGIN {

printf("Output: '%s'\n\n",str)

}

{{out}}

<pre>

 

=={{header|C}}==

/*

* textBetween: Gets text between two delimiters

return startPointer;

 

=={{header|C++}}==

{{trans|C#}}

 

std::ostream& operator<<(std::ostream& out, const std::string& str) {

 

return 0;

{{out}}

<pre>text: 'Hello Rosetta Code world'

end: 'Foo'

result: 'BarBaz'</pre>

 

=={{header|D}}==

import std.stdio;

import std.string;

print("One fish two fish red fish blue fish", "fish ", " red");

print("FooBarBazFooBuxQuux", "Foo", "Foo");

{{out}}

<pre>text: 'Hello Rosetta Code world'

end: 'Foo'

result: 'BarBaz'</pre>

 

=={{header|Factor}}==

prettyprint.config sequences ;

IN: rosetta-code.text-between

] each ;

 

{{out}}

<pre>

Output: "BarBaz"

</pre>

 

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

fmt.Printf("Output: \"%s\"\n\n", b)

}

 

{{out}}

 

=={{header|Haskell}}==

import Data.List (intercalate)

import Data.Maybe (fromMaybe)

 

 

textBetween (start, end) txt =

 

samples :: [Text]

samples =

 

delims :: [(Either String Text, Either String Text)]

delims =

 

wrap :: String -> Either String Text

{{Out}}

<pre>"Rosetta Code"

=={{header|J}}==

'''Solution:'''

text=. y

'start end'=. x

end=. text"_^:('end'&-:) end

end taketo start takeafter text

 

'''Example Usage:'''

 

'''Examples:'''

Hello Rosetta Code world

Hello Rosetta Code world

 

Test_output = Test_delim textBetween&.> Test_text

 

=={{header|Java}}==

</pre>

 

public class textBetween

{

} // end class TextBetween

 

=={{header|JavaScript}}==

===ES5===

function textBetween(thisText, startString, endString)

{

return newText;

} // end textBetween

===ES6===

{{Trans|Haskell}}

Composed from a set of generic functions

'use strict';

 

)

);

{{Out}}

<pre>[

 

The implementation uses `explode` to ensure arbitrary Unicode will be handled properly.

def textbetween_strings($startdlm; $enddlm):

explode

end

| implode;

=== Verification ===

 

def testdata:

(["Hello Rosetta Code world", "Hello ", " world"],

| $in[0]

| textbetween_strings($in[1]; $in[2])

===Output===

"Rosetta Code"

"Hello Rosetta Code"

"two fish"

"BarBaz"

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

startind = startdlm != "start" ? last(search(text, startdlm)) + 1 : 1

endind = enddlm != "end" ? first(search(text, enddlm, startind)) - 1 : endof(text)

for (text, s, e) in testcases

println("\nText: ", text, "\nStart delim: ", s, "\nEnd delim: ", e, "\nOutput: ", textbetween(text, s, e))

 

{{out}}

=={{header|Kotlin}}==

In the third example, I've assumed that the start delimiter should be "Hello " (not "Hello") to match the required output.

 

fun String.textBetween(start: String, end: String): String {

println("Output: \"$b\"\n")

}

{{out}}

<pre>

Output: "BarBaz"

</pre>

 

=={{header|Maple}}==

local on, off,extra:

on := piecewise(delim1="start", 1, SearchText(delim1, str)):

if off <> 0 then off := off+on+extra-1: end if:

return str[on+extra..off-1]:

{{Out|Examples}}

<pre>>textBetween("Hello Rosetta Code world", "Hello ", " world");

 

=={{header|MiniScript}}==

startPos = s.indexOf(startDelim) + startDelim.len

if startDelim == "start" then startPos = 0

end function

 

print textBetween("The quick brown fox jumps over the lazy other fox", "quick ", " fox")

 

{{out}}

 

brown

BarBaz</pre>

 

=={{header|Objeck}}==

{{trans|Java}}

function : Main(args : String[]) ~ Nil {

if(args->Size() = 3) {

return thisText->SubString(startIndex, endIndex - startIndex);

}

 

=={{header|Perl}}==

 

sub text_between {

# Ignore start and end delimiter string embedded in longer words

$text = 'Soothe a guilty conscience today, string wrangling is not the best tool to use for this job.';

{{out}}

<pre>1> Rosetta Code

5> Hello <span>Rosetta Code</span> world</text><table style="myTable">

6>

7> brown

8> two fish

 

=={{header|Phix}}==

{{out}}

All tests pass, so no output.

</pre>

 

<?php

function text_between($string, $start, $end)

print_r($returnText);

?>

 

=={{header|PowerBASIC}}==

#DIM ALL

#COMPILER PBCC 6

CON.PRINT IIF$(TextBetween(sText, StartDelim, EndDelim) = Expected, "OK", "failed")

 

 

=={{header|Python}}==

#!/usr/bin/env python

from sys import argv

 

print textBetween( thisText, startString, endString )

 

=={{header|Racket}}==

(require (prefix-in 13: srfi/13))

 

(test-case "The quick brown fox jumps over the lazy other fox" "quick " " fox" "brown")

(test-case "One fish two fish red fish blue fish" "fish " " red" "two fish")

{{out}}

All tests pass, so no output.

 

=={{header|REXX}}==

===version 1===

{{trans|Kotlin}}

Call test "Hello Rosetta Code world","start"," world"

Call test "Hello Rosetta Code world","Hello ","end"

End

 

{{out|Output}}

<pre>Text: "Hello Rosetta Code world"

Also, it wasn't necessary, but I <u>assummed</u> (bad assumption?) that the &nbsp; <big>'''\'''</big> &nbsp; could be an escape character, but unless clarified,

<br>it's being treated as a commom character, &nbsp; REXX has no need for escape characters (within character strings).

call TB 'Hello Rosetta Code world', "Hello ", ' world'

call TB 'Hello Rosetta Code world', "start", ' world'

if E\=='end' then parse var $ $ (E) /* " " before " END. " */

say ' Output: "'$'"' /*display the extracted string to term.*/

{{out|output}}

<pre>

 

=={{header|Ring}}==

# Project : Text between

 

next

see '"' + substr(list2str(textdel), nl, " ") +'"' + nl + nl

Output:

<pre>

Output = "Rosetta Code world"

</pre>

 

=={{header|Ruby}}==

Test

class String

def textBetween startDelimiter, endDelimiter

 

puts returnText

=={{header|Rust}}==

//Use Into<String> so input can be String, &str or anything else that implements Into<String>

fn text_between<S: Into<String>>(input: S, start: S, end: S) -> String {

println!("'{}'", text_between("FooBarBazFooBuxQuux", "Foo", "Foo"));

}

{{out}}

<pre>

'BarBaz'

</pre>

=={{header|Scala}}==

val (thisText, startDelimiter, endDelimiter) = (args(0), args(1),args(2))

 

println(textBetween(thisText, startDelimiter, endDelimiter))

 

 

=={{header|Sidef}}==

Uses /^/ and /$/ as start and end delimiters. Additionally, the start and end delimiters can be regular expressions.

 

beg.escape! if beg.kind_of(String)

assert_eq(t{:out}, r)

say "text_between(#{t{:text}.dump}, #{t{:start}.dump}, #{t{:end}.dump}) = #{r.dump}"

{{out}}<pre>

text_between("Hello Rosetta Code world", "Hello ", " world") = "Rosetta Code"

text_between("One fish two fish red fish blue fish", "fish ", " red") = "two fish"

text_between("FooBarBazFooBuxQuux", "Foo", "Foo") = "BarBaz"</pre>

 

=={{header|UNIX Shell}}==

The "hard" assertions when unpacking the arguments to the "text_between" function reflect the assumptions in the requirements for this problem: that null/empty arguments will never be provided. If any empty arguments are given, the interpreter running this function will exit after printing an error. If this function is invoked without a subshell, that will crash the invoking program as well. In practical use, that may not be desirable, in which case the ":?" assertions should be replaced with less harsh conditional-unpack code (e.g. <code>if [ -z "${1:-}" ]; then echo "Invalid input!" && return 127; else local var="$1"; fi</code>).

 

local search="${1:?Search text not provided}"

local start_str="${2:?Start text not provided}"

text_between "Hello Rosetta Code world" "Hello " " world"

text_between "Hello Rosetta Code world" "start" " world"

 

=={{header|VBA}}==

 

Private Const STRING_START As String = "Start"

Text_Between = Mid(T, Len(F) + InStr(T, F), InStr(InStr(T, F), T, L) - (Len(F) + InStr(T, F)))

End Select

{{out}}

<pre>1- Rosetta Code

=={{header|Visual Basic}}==

{{works with|Visual Basic|6}}

Dim indS As Long

Dim indE As Long

Text = StartDelim & Expected & EndDelim & "FooBuxQuux"

Debug.Assert TextBetween(Text, StartDelim, EndDelim) = Expected

 

=={{header|zkl}}==

s = (if((s:=text.find(start))==Void) 0 else s + start.len());

e = (if((e:=text.find(end,s))==Void) text.len() else e);

getText("Hello Rosetta Code world","Hello "," world").println();

getText("Hello Rosetta Code world","start", " world").println();

{{out}}

<pre>