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

{{task|String manipulation}}

 

;Task:

<br>

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

<br><br>

 

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

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

Sh ws soul strppr. Sh took my hrt!

</pre>

 

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

{

integer p;

 

}

 

}

 

text

{

}

 

 

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>

Sh ws soul strppr. Sh took my hrt!

</pre>

=={{header|AppleScript}}==

 

 

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

 

script notNeedles

on |λ|(x)

end |λ|

end script

end stripChars

 

 

on run

 

 

 

-- filter :: (a -> Bool) -> [a] -> [a]

end filter

 

 

-- intercalate :: Text -> [Text] -> Text

return strJoined

end intercalate

 

-- Lift 2nd class handler function into 1st class script wrapper

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

 

 

 

-- stripChars :: String -> String -> String

end stripChars

 

 

on run

 

 

 

-- splitRegex :: RegexPattern -> String -> [String]

end if

end splitRegex

 

-- regexMatches :: RegexPattern -> String -> [{location:Int, length:Int}]

lstMatches

end regexMatches

 

-- foldl :: (a -> b -> a) -> a -> [b] -> a

end tell

end foldl

 

-- intercalate :: Text -> [Text] -> Text

return strJoined

end intercalate

 

-- Lift 2nd class handler function into 1st class script wrapper

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

 

 

 

{{out}}

<pre>

</pre>

 

=={{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, "");

 

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

 

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

After : Sh ws soul strppr. Sh took my hrt!

Press Any Key to continue...</pre>

 

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

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

 

 

=={{header|Forth}}==

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

 

===Shorter version, using ]] [[ macros===

: .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}}

<pre>

Sh ws soul strppr. Sh took my hrt!

</pre>

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

 

=={{header|Julia}}==

 

 

 

{{out}}

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

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

 

{{out}}

Sh ws soul strppr. Sh took my hrt!

</pre>

 

=={{header|Lasso}}==

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

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

return #in

}

 

{{out}}

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

 

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

 

Output:

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

 

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')

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

 

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

 

 

 

{{out}}

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

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

 

{{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 rec aux i j =

else if String.contains cs s.[i] then

aux (succ i) (j)

else begin

aux (succ i) (succ j)

end

in

{{out|Testing in the toplevel}}

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

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

 

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

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

Sh ws soul strppr. Sh took my hrt!

</pre>

 

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

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

</pre>

 

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

 

#lang racket

 

(define (stripchars2 text chars)

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

 

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

 

===version 3===

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

She was a soul stripper. She took my heart.

Sh ws soul strppr. Sh took my hrt.</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>

{{omit from|Bc}}

{{omit from|Openscad}}

 

=={{header|VBA}}==

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