Strip a set of characters from a string: Difference between revisions

<br>

The returned string should contain the first string, stripped of any characters in the second argument:

 

 

{{trans|Python}}

 

R s.filter(c -> c !C @chars).join(‘’)

 

 

{{out}}

{{trans|PL/I}}

The program uses two ASSIST macro (XDECO,XPRNT) to keep the code as short as possible.

STRIPCH CSECT

USING STRIPCH,R13 base register

* ---- -------------------------------------------------------

YREGS

{{out}}

<pre>

=={{header|8080 Assembly}}==

 

jmp demo

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

jmp 5

string: db 'She was a soul stripper. She took my heart!$'

 

{{out}}

=={{header|8086 Assembly}}==

 

cpu 8086

section .text

section .data

string: db 'She was a soul stripper. She took my heart!$'

 

{{out}}

 

<pre>Sh ws soul strppr. Sh took my hrt!</pre>

 

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

BYTE i,j,size,found

CHAR c

PrintE("Stripped string:")

PrintF("""%S""%E%E",result)

{{out}}

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

 

=={{header|Ada}}==

 

procedure Strip_Characters_From_String is

begin -- main

Ada.Text_IO.Put_Line(Strip(S, "aei"));

{{out}}

<pre>> ./strip_characters_from_string

 

=={{header|Aime}}==

stripchars1(data b, text w)

{

 

return 0;

 

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

{{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] - due to extensive use of '''format'''[ted] ''transput''.}}

 

PROC strip chars = (STRING mine, ore)STRING: (

);

 

{{out}}

<pre>

 

=={{header|ALGOL W}}==

% returns s with the characters in remove removed %

% as all strings in Algol W are fixed length, the length of remove %

write( " ->: ", stripped( 0 // 64 ) )

end

{{out}}

<pre>

text: She was a soul stripper. She took my heart!

->: Sh ws soul strppr. Sh took my hrt!

</pre>

 

a character vector, this can be used to remove characters from a string.

 

 

{{out}}

 

{{works with|AppleScript|Mac OS X 10.6}}

 

on stripChar(str, chrs)

end tell

return str

{{out}}

<pre>

(Following the Haskell contribution in reversing the argument order to the sequence more probable in a context of potential currying or partial application).

 

on stripChars(needles, haystack)

script notNeedles

end script

end if

{{Out}}

<pre>"Sh ws soul strppr. Sh took my hrt!"</pre>

OS X Yosemite onwards – importing the Foundation classes to use NSRegularExpression

 

 

 

end script

end if

{{Out}}

<pre>"Sh ws soul strppr. Sh took my hrt!"</pre>

 

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

110 LET RM$ = "AEI"

120 GOSUB 200STRIPCHARS

330 NEXT SI

340 RETURN

{{out}}

<pre>SH WS SOUL STRPPR. SH TOOK MY HRT!</pre>

 

=={{header|Arturo}}==

join select split str => [not? in? & split chars]

 

 

{{out}}

 

<pre>Sh ws soul strppr. Sh took my hrt!</pre>

 

=={{header|AutoHotkey}}==

 

StripChars(string, charsToStrip){

StringReplace, string, string, % A_LoopField, , All

return string

{{out}}

<pre>Sh ws soul strppr. Sh took my hrt!</pre>

 

=={{header|AWK}}==

BEGIN {

x = "She was a soul stripper. She took my heart!";

gsub(/[aei]/,"",x);

print x;

{{out}}

<pre>She was a soul stripper. She took my heart!

 

=={{header|BaCon}}==

PRINT text$

PRINT EXTRACT$(text$, "[aei]", TRUE)

{{out}}

<pre>She was a soul stripper. She took my heart!

=={{header|BASIC}}==

{{works with|QBasic}}

 

PRINT stripchars$("She was a soul stripper. She took my heart!", "aei")

NEXT

stripchars$ = s

{{out}}

Sh ws soul strppr. Sh took my hrt!

 

==={{header|IS-BASIC}}===

110 PRINT STRIPCHARS$("She was a soul stripper. She took my heart!","aei")

120 DEF STRIPCHARS$(SRC$,REMOVE$)

200 NEXT

210 LET STRIPCHARS$=T$

 

==={{header|Sinclair ZX81 BASIC}}===

Works with 1k of RAM. Since the ZX81 character set includes neither lower case nor <tt>!</tt>, the test string is not quite identical to the one suggested in the specification.

20 LET B$="AEI"

30 GOSUB 60

120 LET C$=C$+A$(I)

130 NEXT I

{{out}}

<pre>SH WS SOUL STRPPR. SH TOOK MY HRT.</pre>

 

See also: [[#Liberty BASIC|Liberty BASIC]], [[#PureBasic|PureBasic]]

 

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

END

UNTIL C% = 0

NEXT

Output:

<pre>

Sh ws soul strppr. Sh took my hrt!

</pre>

 

=={{header|BQN}}==

The key function here is set difference, which is <code>(¬∘∊/⊣)</code>.

 

¬∘∊/⊣

"She was a soul stripper. She took my heart!" StripChars "aei"

 

=={{header|Bracmat}}==

This solution handles Unicode (utf-8) characters. Optimizations are: (1) the <code>chars</code> string is hard-coded into the pattern before the pattern is used in the match expression, (2) the output characters are stacked (cheap) rather than appended (expensive). The result string is obtained by stringizing the stack and reversing. To make multibyte characters survive, they are reversed before being put onto the stack. A problem is that this code is negligent of diacritical marks.

= string chars s pat

. !arg:(?string.?chars)

& out

$ (strip$("Аппетит приходит во время еды".веп)

{{out}}

<pre>Атит риходит о рмя ды</pre>

=={{header|Burlesque}}==

 

blsq ) "She was a soul stripper. She took my heart!"{"aei"\/~[n!}f[

"Sh ws soul strppr. Sh took my hrt!"

 

=={{header|C}}==

#include <stdio.h>

#include <stdlib.h>

free(new);

return 0;

{{out|Result}}

<pre>Sh ws soul strppr. Sh took my hrt!</pre>

 

===With table lookup===

#include <stdlib.h>

#include <string.h>

 

return 0;

 

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

 

public static string RemoveCharactersFromString(string testString, string removeChars)

}

return returnString;

Usage:

using System;

 

}

}

{{out}}

<pre>Sh ws soul strppr. Sh took my hrt!</pre>

Using <code>Regex</code>:

using System;

using System.Text.RegularExpressions;

string pattern = "[" + removeChars + "]";

return Regex.Replace(testString, pattern, "");

 

<b>Alternative version</b> using <code>System.Span<T></code>:

 

public static System.ReadOnlySpan<T> RemoveItems<T>(System.Span<T> toStrip, System.ReadOnlySpan<T> toRemove)

 

return toStrip.Slice(toIndex);

Usage:

 

class Program

System.Console.WriteLine(RemoveItems<char>(stripString.ToCharArray(), removeString).ToString());

}

{{out}}

<pre>Sh ws soul strppr. Sh took my hrt!</pre>

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

{{works with|C++11}}

#include <iostream>

#include <string>

std::cout << stripchars("She was a soul stripper. She took my heart!", "aei") << '\n';

return 0;

{{out}}

<pre>

 

=={{header|Clojure}}==

(apply str (remove #((set chars) %) coll)))

 

(strip "She was a soul stripper. She took my heart!" "aei")

 

=={{header|COBOL}}==

This function takes the two arguments as specified in the task. However, the result will be returned in the string that had the characters stripped from it, and the string containing the characters to strip must be null-terminated (otherwise, a table would have to be used instead).

PROGRAM-ID. Strip-Chars.

 

 

GOBACK

 

=={{header|ColdFusion}}==

<Cfset theString = 'She was a soul stripper. She took my heart!'>

<Cfset theStrip = 'aei'>

</Cfloop>

<Cfoutput>#theString#</Cfoutput>

 

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

(remove-if (lambda (ch) (find ch chars)) str))

 

" A string ")

;; => "A string"

 

=={{header|D}}==

 

void main() {

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

Writeln(TEST_STRING);

Writeln(StripChars(TEST_STRING, 'aei'));

 

=={{header|EchoLisp}}==

;; using regexp /[chars]/g

 

(strip-chars "She was a soul stripper. She took my heart!" "aei")

→ "Sh ws soul strppr. Sh took my hrt!"

 

=={{header|Elena}}==

ELENA 4.x :

import extensions'text;

import system'routines;

var removeChars := "aei";

{{out}}

<pre>

=={{header|Elixir}}==

The easiest solution would be to use replace from the String module, which takes a Regex.

String.replace(str, ~r/[aei]/, "")

 

To get the desired interface, we just have to dynamically construct the Regex:

def stripchars(str, chars) do

String.replace(str, ~r/[#{chars}]/, "")

str = "She was a soul stripper. She took my heart!"

RC.stripchars(str, "aei")

 

=={{header|Erlang}}==

The work of this task is done by the <code>transmute</code> function; this function takes parameters separated by commas. Here it uses 3 parameters, up to 5, the other two are optional and aren't put in this time.

The <code>transmute</code> function's usage and examples can be searched for in the official Euphoria 4.0.0+ manual. Euphoria object identifiers (names) are case sensitive but don't need to be in a particular case to be recognized as an object type.

include std\console.e

 

originalString = transmute(originalString, {{} , "a", "e", "i"}, {{} , "", "", ""})

puts(1,"After : " & originalString & "\n")

{{out}}

<pre>Before : She was a soul stripper. She took my heart!

 

{{Works with|Office 365 betas 2021}}

=LAMBDA(excluded,

LAMBDA(src,

)

)

 

and also assuming the following generic bindings in the Name Manager for the WorkBook:

 

=LAMBDA(s,

MID(s,

FILTER(xs, p(xs))

)

 

{{Out}}

 

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

fun (s:string) c -> s.Replace(c.ToString(),"")

 

=={{header|Factor}}==

Example:

{{out}}

<pre>

character by character in a memory buffer called PAD. PAD is a standard Forth word.

SCAN is common in most Forth systems and is typically coded in Forth assembler

: strippers ( -- addr len) s" aeiAEI" ; \ a string literal returns addr and length

 

2drop \ we don't need STRIPPERS now

PAD count ; \ return PAD address and length

Test at the forth console

<pre>strippers s" She was a soul stripper. She took my heart!" stripchars cr type

This shorter version removes creating a new string and prints the "stripped" string immediately.

The macro called '?exit' speeds up the '.stripped' print loop by compiling its code inside the loop.

: .stripped ( a u c -- ) -rot bounds ?do dup i c@ ?exit loop emit ;

: stripchars ( a1 u1 a2 u2 -- ) bounds ?do 2dup i c@ .stripped loop 2drop ;

: "aei" s" aei" ;

 

 

=={{header|Fortran}}==

character(len=*), intent(inout) :: string

character(len=*), intent(in) :: set

end if

end do

 

=={{header|FreeBASIC}}==

 

Function stripChars(s As Const String, chars As Const String) As String

Print

Print "Press any key to quit"

 

{{out}}

 

=={{header|Frink}}==

{

set = toSet[chars[remove]]

 

println[stripchars["She was a soul stripper. She took my heart!","aei"]]

{{out}}

<pre>

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Gambas}}==

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

 

Print StripChars("She was a soul stripper. She took my heart!", "aei")

Return sText

 

Output:

<pre>

 

=={{header|Go}}==

 

import (

fmt.Println(stripchars("She was a soul stripper. She took my heart!",

"aei"))

{{out}}

<pre>

=={{header|Groovy}}==

Solution:

def list = string as List

list.removeAll(stripChars as List)

list.join()

Test:

{{out}}

<pre>Sh ws soul strppr. Sh took my hrt!</pre>

=={{header|Haskell}}==

I decided to make the string the second argument and the characters the first argument, because it is more likely for someone to partially apply the characters to be stripped (making a function that strips certain characters), than the string.

{{out|Testing in GHCI}}

<pre>> stripChars "aei" "She was a soul stripper. She took my heart!"

=={{header|Icon}} and {{header|Unicon}}==

The following works in both languages:

cs := \A[1] | 'aei' # argument is set of characters to strip

every write(stripChars(!&input, cs)) # strip all input lines

s ? while ns ||:= (not pos(0), tab(upto(cs)|0)) do tab(many(cs))

return ns

{{out|Sample runs}}

<pre>->strip

rdvrks r nt trs.

-></pre>

 

=={{header|J}}==

The dyadic primitive <code>-.</code> ([http://www.jsoftware.com/help/dictionary/d121.htm Less]) is probably the simplest way to solve this task.

{{out|Example Usage}}

 

=={{header|Java}}==

}

 

=={{header|JavaScript}}==

===ES5===

 

return string.replace(RegExp('['+chars+']','g'), '');

 

===ES6===

Reversing the order of the arguments, to simplify any currying:

 

'use strict';

 

 

// 'Sh ws soul strppr. Sh took my hrt!'

 

{{Out}}

Alternatively, we could also do this without a regex:

 

'use strict';

 

 

// 'Sh ws soul strppr. Sh took my hrt!'

 

{{Out}}

<pre>'Sh ws soul strppr. Sh took my hrt!'</pre>

 

=={{header|jq}}==

'''Note''': In jq, it would be more idiomatic to define the function as a filter:

In this case, we would write:

"She was a soul stripper. She took my heart!" | stripchars("aei")

{{works with|Julia|1.0}}

 

 

{{out}}

Sh ws soul strppr. Sh took my hrt!</pre>

 

 

 

fun main(args: Array<String>) {

println(stripChars("She was a soul stripper. She took my heart!", "aei"))

 

{{out}}

=={{header|Lambdatalk}}==

Text substitutions are easy to process directly using regular expressions :

{S.replace (a|e|i)

by // nothing

in She was a soul stripper. She took my heart!}

-> Sh ws soul strppr. Sh took my hrt!

and can be wrapped inside a fuction:

{def word2rex

{def word2rex.r

She was a soul stripper. She took my heart!}

-> Sh ws soul strppr. Sh took my hrt!

 

=={{header|Lasso}}==

with toremove in #destroy->values do => {

#in->replace(#toremove,'')

return #in

}

 

{{out}}

 

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

End

 

Next i

If (num <= Len(chars$)) Then stripchars$ = stripchars$(stripchars$, chars$, (num + 1))

 

=={{header|LiveCode}}==

local strstripped

put str into strstripped

end repeat

return strstripped

put stripchars("She was a soul stripper. She took my heart!","aei")

 

=={{header|Logo}}==

output filter [not substringp ? :chars] :string

end

print strip "She\ was\ a\ soul\ stripper.\ She\ took\ my\ heart! "aei

 

{{out}}

<pre>Sh ws soul strppr. Sh took my hrt!</pre>

 

=={{header|Lua}}==

function stripchars(str, chrs)

local s = str:gsub("["..chrs:gsub("%W","%%%1").."]", '')

print( stripchars( "She was a soul stripper. She took my heart!", "a-z" ) )

--> She ws soul stripper. She took my hert!

 

=={{header|Maple}}==

 

Output:

<pre> "Sh ws soul strppr. Sh took my hrt!"</pre>

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

stripchars["She was a soul stripper. She took my heart!","aei"]

 

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

% MATLAB after 2016b: str = erase(str, charlist);

{{out}}

<pre> >> stripchars('She was a soul stripper. She took my heart!','aei')

 

=={{header|Nanoquery}}==

for char in chars

string = string.replace(char, "")

end

return string

 

=={{header|Nemerle}}==

{

def chuck = Explode(remove);

Concat( "", Split(text, chuck))

 

=={{header|NetRexx}}==

 

options replace format comments java crossref savelog symbols

end c_

 

 

=={{header|NewLISP}}==

 

=={{header|Nim}}==

 

echo "She was a soul stripper. She took my heart!".split({'a','e','i'}).join()

echo "She was a soul stripper. She took my heart!".filterIt(it notin "aei").join()

 

{{out}}

<pre>Sh ws soul strppr. Sh took my hrt!

{{works with|Mac OS X|10.5+}}

{{works with|iOS|1.0}}

- (NSString *) stripCharactersInSet: (NSCharacterSet *) chars;

@end

return [[self componentsSeparatedByCharactersInSet:chars] componentsJoinedByString:@""];

}

{{out|To use}}

NSCharacterSet* chars = [NSCharacterSet characterSetWithCharactersInString:@"aei"];

 

// Display the NSString.

 

=={{header|OCaml}}==

let len = String.length s in

let res = Bytes.create len in

end

in

{{out|Testing in the toplevel}}

<pre># stripchars "She was a soul stripper. She took my heart!" "aei" ;;

=={{header|Oforth}}==

 

 

 

{{out}}

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

GP should not be used for string manipulation. A good solution to this problem would probably involve <code>system("perl -e</code>...

bad=Set(Vec(Vecsmall(bad)));

s=Vecsmall(s);

Strchr(v)

};

 

=={{header|Pascal}}==

=={{header|Perl}}==

Note: this example uses a regular expression character class. Certain characters, like hyphens and brackets, may need to be escaped.

my ($s, $chars) = @_;

$s =~ s/[$chars]//g;

}

 

{{out}}

<pre>

</pre>

Another good option for stripping characters is to use the <code>tr///</code> operator. This option is very efficient when the set of characters to strip is fixed at compile time, because <code>tr///</code> is specifically designed for transforming and deleting characters. Note that hyphens also have special meaning in this case.

Since the characters used for <code>tr///</code> must be fixed at compile time, unfortunately, it requires the use of an <code>eval</code> to do this generally for any set of characters provided at runtime:

my ($s, $chars) = @_;

eval("\$s =~ tr/$chars//d;");

return $s;

 

=={{header|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">filter</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"She was a soul stripper. She took my heart!"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"out"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"aei"</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

 

=={{header|PHP}}==

function stripchars($s, $chars) {

return str_replace(str_split($chars), "", $s);

 

echo stripchars("She was a soul stripper. She took my heart!", "aei"), "\n";

{{out}}

<pre>

=={{header|Picat}}==

===List comprehension===

 

===Recursion===

stripchars2(String, Chars, [], Res).

 

stripchars2(T, Chars, Res1, Res).

stripchars2([H|T], Chars, Res1, [H|Res]) :-

 

===Test===

S = "She was a soul stripper. She took my heart!",

println(stripchars(S, "aei")),

stripchars2(S, "aei", S2),

println(S2),

 

 

 

=={{header|PicoLisp}}==

{{out}}

<pre>: (strDiff "She was a soul stripper. She took my heart!" "aei")

 

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

declare text character (*) varying, chars character (*) varying;

declare out_text character (100);

end;

return (substr(out_text, 1, j) );

 

=={{header|Powershell}}==

Powershell have replace operator that by will replace a regex pattern with a given string:

 

Sh ws soul strppr. Sh took my hrt!

 

=={{header|Prolog}}==

Works with SWI-Prolog and module '''lambda.pl''' written by '''Ulrich Neumerkel''' found there http://www.complang.tuwien.ac.at/ulrich/Prolog-inedit/lambda.pl .

 

stripchars(String, Exclude, Result) :-

exclude(\X^(member(X, Exclude)), String, Result1),

string_to_list(Result, Result1).

{{out}}

<pre> ?- stripchars("She was a soul stripper. She took my heart!","aei", R).

=== alternative version using DCG strings ===

 

:- system:set_prolog_flag(double_quotes,chars) .

 

strip_chars(SOURCEz0,SETz0)

.

 

{{out}}

=={{header|PureBasic}}==

PureBasic uses a single (for ASCII) or a two-byte (for Unicode) null to signal the end of a string. Nulls are thus excluded from the allowable characters to strip as they can't be included in a PureBasic string.

Protected i, *ptrChar.Character, length = Len(source), result.s

*ptrChar = @source

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

CloseConsole()

{{out}}

<pre>Sh ws soul strppr. Sh took my hrt!</pre>

===Not using regular expressions===

{{works with|Python|2.6+}}

... return s.translate(None, chars)

...

>>> stripchars("She was a soul stripper. She took my heart!", "aei")

{{works with|Python|2.x}}

>>> def stripchars(s, chars):

... return s.translate(string.maketrans("", ""), chars)

...

>>> stripchars("She was a soul stripper. She took my heart!", "aei")

Implemented manually:

... return "".join(c for c in s if c not in chars)

...

>>> stripchars("She was a soul stripper. She took my heart!", "aei")

===Using regular expressions===

>>> def stripchars(s, chars):

return re.sub('[%s]+' % re.escape(chars), '', s)

>>> stripchars("She was a soul stripper. She took my heart!", "aei")

'Sh ws soul strppr. Sh took my hrt!'

 

=={{header|Quackery}}==

 

 

[ $ "" swap witheach [ lower join ] ] is lower$ ( $ --> $ )

 

$ "One is never alone with a rubber duck." dup echo$ cr

 

{{out}}

=={{header|Racket}}==

 

#lang racket

 

(define (stripchars2 text chars)

(regexp-replace* (~a "[" chars "]+") text ""))

 

=={{header|Raku}}==

(formerly Perl 6)

return $s.trans( $chars.comb X=> '' );

}

 

{{out}}

<pre>Sh ws soul strppr. Sh took my hrt!</pre>

 

=={{header|Red}}==

stripchars: func [str chars] [trim/with str chars]

 

=={{header|REXX}}==

===version 1===

In the REXX language, '''strip''' usually means to remove leading and/or trailing characters from a string (most often, blanks).

say stripChars('She was a soul stripper. She took my heart!', "iea") /*elide: iea */

exit /*stick a fork in it, we're all done. */

haystack=changestr( substr( remove, j, 1), haystack, '')

end /*j*/

Some older REXXes don't have a &nbsp; '''changestr''' &nbsp; BIF, so one is included here &nbsp; ───► &nbsp; [[CHANGESTR.REX]].

<br><br>

===version 2===

Using recursion:

say StripChars('She was a soul stripper. She took my heart!','iea')

exit 0

if removepos=0 then return strng

parse value strng with strng =(removepos) +1 rest

{{out}}

<pre>Sh ws soul strppr. Sh took my hart!rt!</pre>

This works on all Rexxes.

<br>(Except for R4 and ROO at the least, there may be others.)

/* REXX ***************************************************************

* If source and stripchars don't contain a hex 00 character, this works

result=space(result,0,' ') /* remove all blanks */

Return translate(result,' ','00'x) /* '00'x back to blanks */

 

===version 4===

Another neat (?) one

No x00 restriction and no changestr

stripchars: Procedure

Parse Arg i,s /* get input and chars to be removed */

End

Return o /* return the result */

 

=={{header|Ring}}==

aList = "She was a soul stripper. She took my heart!"

bList = "aei"

next

return cList

 

=={{header|Ruby}}==

 

=={{header|Rust}}==

Naive Implementation:

fn strip_characters(original : &str, to_strip : &str) -> String {

let mut result = String::new();

result

}

 

Functional Implementation:

fn strip_characters(original : &str, to_strip : &str) -> String {

original.chars().filter(|&c| !to_strip.contains(c)).collect()

}

 

Either can be executed thusly:

fn main() {

println!("{}", strip_characters("She was a soul stripper. She took my heart!", "aei"));

}

 

=={{header|SAS}}==

This code will write the resulting string to the log:

%let chars=aei;

%let stripped=%sysfunc(compress("&string","&chars"));

 

Log:

 

=={{header|Scala}}==

 

stripChars("She was a soul stripper. She took my heart!", "aei")

 

=={{header|Scheme}}==

The second uses the SRFI libraries to create a character set and delete those characters from the string.

 

(import (scheme base)

(scheme write)

(display (strip-chars2 "She was a soul stripper. She took my heart!" "aei"))

(newline)

 

{{out}}

 

=={{header|ScriptBasic}}==

str1 = "She was a soul stripper. She took my heart!"

rmv = "aei"

NEXT

PRINT str1,"\n"

 

=={{header|Sed}}==

Using echo and piping it through a sed filter:

 

strip_char()

{

echo "$1" | sed "s/[$2]//g"

 

=={{header|Seed7}}==

 

const func string: stripchars (in string: mainStri, in string: charList) is func

begin

writeln(stripchars("She was a soul stripper. She took my heart!", "aei"));

{{out}}

<pre>

Sh ws soul strppr. Sh took my hrt!

</pre>

 

=={{header|Sidef}}==

str.tr(char_list, "", "d");

 

or:

str.chars.grep {|c| !char_list.contains(c)}.join;

 

Calling the function:

{{out}}

<pre>Sh ws soul strppr. Sh took my hrt!</pre>

 

=={{header|Smalltalk}}==

{{works with|Pharo|1.3-13315}}

stripChars := [ :string :chars |

string reject: [ :c | chars includes: c ] ].

value: 'aei'.

 

 

=={{header|SNOBOL4}}==

Note: "strip" is a function, its argument, the label of its first executed line, and its returned value.

 

strip strip ANY(c) = :S(strip)F(RETURN)

strip_end

again line = INPUT :F(END)

OUTPUT = strip(line, chars) :(again)

{{out}}

<pre>snobol4 strip.sno aei

 

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

fun aux c =

if String.isSubstring (str c) chars then

in

String.translate aux string

{{out|Testing}}

<pre>- stripchars ("She was a soul stripper. She took my heart!", "aei") ;

val it = "Sh ws soul strppr. Sh took my hrt!" : string</pre>

Alternately:

{{out|Testing}}

<pre>- stripchars ("She was a soul stripper. She took my heart!", "aei") ;

val it = "Sh ws soul strppr. Sh took my hrt!" : string</pre>

 

=={{header|Swift}}==

func stripCharactersInSet(chars: [Character]) -> String {

return String(seq: filter(self) {find(chars, $0) == nil})

let chars: [Character] = ["a", "e", "i"]

 

{{out}}

<pre>Sh ws soul strppr. Sh took my hrt!</pre>

 

=={{header|Tcl}}==

foreach c [split $chars ""] {set str [string map [list $c ""] $str]}

return $str

 

set s "She was a soul stripper. She took my heart!"

 

=={{header|TorqueScript}}==

She was a soul stripper. She took my heart!

Sh ws soul strppr. Sh took my hrt!

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT,{}

string="She was a soul stripper. She took my heart!"

print string

print stringstrip

Output:

<pre>

Since the partial argument list (the arguments belonging to the TXR script) is a suffix of the full argument list (the complete arguments which include the invoking command and the script name), the classic Lisp function <code>ldiff</code> comes in handy in obtaining just the prefix, for printing the usage:

(let* ((regex-ast ^(set ,*(list-str set)))

(regex-obj (regex-compile regex-ast)))

((str set extra) (usage))

((str set . junk) (pprinl (strip-chars str set)))

{{out}}

<pre>$ txr strip-chars-2.tl

Now here is a rewrite of <code>strip-chars</code> which just uses classic Lisp that has been generalized to work over strings, plus the <code>do</code> syntax (a sibling of the <code>op</code> operator) that provides syntactic sugar for a lambda function whose body is an operator or macro form.

 

 

<code>(do if (memq @1 set) (list @1))</code> is just <code>(lambda (item) (if (memq item set) (list item)))</code>.

One would normally do this using the standard tr(1) command:

{{works with|sh}}

echo "$1" | tr -d "$2"

But it can also be accomplished with bash's built-in parameter expansions:

{{works with|bash}}

echo "${1//[$2]}"

Test code:

{{out}}

<pre>Sh ws soul strppr. Sh took my hrt!</pre>

=={{header|Ursala}}==

Normally there's no need to define this operation because it's built in.

 

#cast %s

 

{{out}}

<pre>

Pass the optional bSpace parameter True to replace stripped characters with spaces, otherwise replaced with null.

 

Dim i As Integer, stReplace As String

If bSpace = True Then

Next i

StripChars = stString

 

{{out}}

 

=={{header|VBScript}}==

Function stripchars(s1,s2)

For i = 1 To Len(s1)

 

WScript.StdOut.Write stripchars("She was a soul stripper. She took my heart!","aei")

 

{{Out}}

<pre>Sh ws soul strppr. Sh took my hrt!</pre>

 

=={{header|Wren}}==

return s.map { |c|

return (t.indexOf(c) == -1) ? c : ""

}

 

 

{{out}}

 

=={{header|XPL0}}==

 

func In(Char, Chars); \Is Char in the string Chars?

];

 

 

Output:

Sh ws soul strppr. Sh took my hrt!

</pre>

 

=={{header|zkl}}==