Text between: Difference between revisions

{{trans|Python}}

X.try

Int startIndex

V startString = :argv[2]

V endString = :argv[3]

=={{header|Action!}}==

CHAR ARRAY tmp(255)

Test(8,"One fish two fish red fish blue fish","fish "," red")

Test(9,"FooBarBazFooBuxQuux","Foo","Foo")

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Text_between.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

with Ada.Strings.Fixed;

Test_Between ("One fish two fish red fish blue fish", First => "fish ", Last => " red");

Test_Between ("FooBarBazFooBuxQuux", First => "Foo", Last => "Foo");

{{out}}

<pre>

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|AutoHotkey}}==

(

Hello Rosetta Code world|Hello | world|

RegExMatch(text,(start="start"?"^":"\Q" start "\E") "(.*?)" (end="end"?"$":"\Q" end "\E?"),m)

return m1

{{out}}

<pre>text: "Hello Rosetta Code world"

=={{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 sharp|C#}}==

{{trans|D}}

namespace TextBetween {

}

}

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

{{trans|C#}}

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

return 0;

{{out}}

<pre>text: 'Hello Rosetta Code world'

=={{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'

{{libheader| System.SysUtils}}

{{Trans|C#}}

program Text_between;

Readln;

=={{header|Factor}}==

prettyprint.config sequences ;

IN: rosetta-code.text-between

] each ;

{{out}}

<pre>

=={{header|FreeBASIC}}==

{{trans|VBA}}

Const DELIM_FINAL As String = "end"

'Resultado:

Print Salida

{{out}}

<pre>

=={{header|Go}}==

{{trans|Kotlin}}

import (

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

}

{{out}}

=={{header|Haskell}}==

import Data.Bifunctor (bimap)

import Data.List (intercalate)

wrap x

| x `elem` ["start", "end"] = Left x

{{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>

=={{header|Lua}}==

French (instead of Chinese) in #4 to avoid off-topic unicode complications. Coded to satisfy this task as worded, though in actual use reader might be better served by directly applying native pattern matching facilities to specific problems.

-- case #5 (end delimiter not present) is only problem for simplest approach, so preprocess:

if not text:find(edelim=="end" and "$" or edelim) then edelim = "end" end

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

test( "One fish two fish red fish blue fish", "fish ", " red", "two fish" )

{{Out}}

All tests pass, output not given.

=={{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

print textBetween("Hello Rosetta Code world", "Hello ", "end")

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

{{out}}

=={{header|Nim}}==

func textBetween(text, startStr, endStr: string): string =

echo "End: ", endStr.quote

echo "Output: ", text.textBetween(startStr, endStr).quote

{{out}}

=={{header|Objeck}}==

{{trans|Java}}

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

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

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

}

=={{header|Perl}}==

{{trans|Raku}}

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

=={{header|Phix}}==

<span style="color: #008080;">function</span> <span style="color: #000000;">text_between</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">text</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">start_delimiter</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">end_delimiter</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">if</span> <span style="color: #000000;">start_delimiter</span><span style="color: #0000FF;">!=</span><span style="color: #008000;">"start"</span> <span style="color: #008080;">then</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{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.

This version doesn't use strings for meta indexes ('start' and 'end'), rather it accepts regex assertions which are parsed differently from strings. This allows much more robust and fine grained control over what does and doesn't match. (and allows delimiter strings of 'start' and 'end' incidentally.) See the 11th example below which will confound nearly all of the current string-only based implementations.

return $/»[0]».Str if $text ~~ m:g/ $start (.*?) $end /;

[]

# Ignore start and end delimiter string embedded in longer words

put '11> ', 'Soothe a guilty conscience today, string wrangling is not the best tool to use for this job.'\

{{out}}

===version 1===

{{trans|Kotlin}}

/*REXX*/

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>

=={{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>

=={{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.

{{trans|Raku}}

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"

=={{header|SNOBOL4}}==

{{works with|SNOBOL4, SPITBOL for Linux}}

* Program: text_between.sbl

* To run: sbl -r text_between.sbl

One fish two fish red fish blue fish|fish | red

FooBarBazFooBuxQuux|Foo|Foo

{{out}}

<pre>

=={{header|Swift}}==

public extension String {

print("End delimiter: \"\(end)\"")

print("Text between: \"\(input.textBetween(start, and: end))\"\n")

{{out}}

=={{header|Tcl}}==

proc between {str start end} {

puts " [format %15s $t]: $v"

}

{{out}}

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|Visual Basic .NET}}==

{{trans|C#}}

Function TextBetween(source As String, pre As String, suf As String) As String

Dim startIndex As Integer

End Sub

{{out}}

<pre>text: 'Hello Rosetta Code world'

=={{header|Vlang}}==

{{trans|Go}}

if str == "" || start == "" || end == "" {

return str

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

}

{{out}}

{{trans|Kotlin}}

{{libheader|Wren-fmt}}

var textBetween = Fn.new { |str, start, end|

Fmt.print("Output: $q\n", b)

i = i + 1

{{out}}

=={{header|Yabasic}}==

{{trans|Wren}}

// by Galileo, 04/2022

print "End delimiter: ", end$

print "Output: ", textBetween$(text$, start$, end$), "\n"

{{out}}

<pre>Text: Hello Rosetta Code world

=={{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>