Text between: Difference between revisions

{{trans|Python}}

 

X.try

Int startIndex

V startString = :argv[2]

V endString = :argv[3]

 

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

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

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

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

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

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

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>

 

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

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

text_between("FooBarBazFooBuxQuux", "Foo", "Foo") = "BarBaz"</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|Wren}}==

{{trans|Kotlin}}

{{libheader|Wren-fmt}}

 

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

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

i = i + 1

 

{{out}}

Output: "BarBaz"

</pre>

 

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