Strip control codes and extended characters from a string: Difference between revisions

m
(add BQN)
m (→‎{{header|Wren}}: Minor tidy)
 
(8 intermediate revisions by 7 users not shown)
Line 22:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">F stripped(s)
R s.filter(i -> Int(i.code) C 32..126).join(‘’)
 
print(stripped("\ba\u0000b\n\rc\fd\xc3"))</langsyntaxhighlight>
 
{{out}}
Line 33:
 
=={{header|8086 Assembly}}==
<langsyntaxhighlight lang="asm"> .model small
.stack 1024
.data
Line 104:
int 10h
ret
end start</langsyntaxhighlight>
 
{{out}}
Line 113:
 
=={{header|Action!}}==
<langsyntaxhighlight Actionlang="action!">BYTE FUNC IsAscii(CHAR c)
IF c<32 OR c>124 OR c=96 OR c=123 THEN
RETURN (0)
Line 142:
Strip(src,dst)
PrintF("Stripped string: ""%S""%E",dst)
RETURN</langsyntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Strip_control_codes_and_extended_characters_from_a_string.png Screenshot from Atari 8-bit computer]
Line 152:
=={{header|Ada}}==
 
<langsyntaxhighlight Adalang="ada">with Ada.Text_IO;
 
procedure Strip_ASCII is
Line 187:
Put_Line("Neither_Extended:", Filter(Full, Above => Character'Last)); -- defaults for From and To
end Strip_ASCII;
</syntaxhighlight>
</lang>
 
Output:
Line 197:
 
=={{header|ALGOL 68}}==
<langsyntaxhighlight lang="algol68"># remove control characters and optionally extended characters from the string text #
# assums ASCII is the character set #
PROC strip characters = ( STRING text, BOOL strip extended )STRING:
Line 226:
STRING t = REPR 2 + "abc" + REPR 10 + REPR 160 + "def~" + REPR 127 + REPR 10 + REPR 150 + REPR 152 + "!";
print( ( "<<" + t + ">> - without control characters: <<" + strip characters( t, FALSE ) + ">>", newline ) );
print( ( "<<" + t + ">> - without control or extended characters: <<" + strip characters( t, TRUE ) + ">>", newline ) )</langsyntaxhighlight>
{{out}}
<pre>
Line 238:
 
=={{header|Arturo}}==
<langsyntaxhighlight lang="rebol">str: {string of ☺☻♥♦⌂, may include control characters and other ♫☼§►↔◄░▒▓█┌┴┐±÷²¬└┬┘ilk.}
 
print "with extended characters"
Line 247:
print join select split str 'x ->
and? ascii? x
not? in? to :integer to :char x (0..31)++127</langsyntaxhighlight>
 
{{out}}
Line 258:
=={{header|AutoHotkey}}==
{{trans|Python}}
<langsyntaxhighlight AHKlang="ahk">Stripped(x){
Loop Parse, x
if Asc(A_LoopField) > 31 and Asc(A_LoopField) < 128
Line 264:
return r
}
MsgBox % stripped("`ba" Chr(00) "b`n`rc`fd" Chr(0xc3))</langsyntaxhighlight>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f STRIP_CONTROL_CODES_AND_EXTENDED_CHARACTERS.AWK
BEGIN {
Line 276:
exit(0)
}
</syntaxhighlight>
</lang>
<p>output:</p>
<pre>
Line 289:
While DOS does support ''some'' extended characters, they aren't entirely standardized, and shouldn't be relied upon.
 
<langsyntaxhighlight lang="qbasic">DECLARE FUNCTION strip$ (what AS STRING)
DECLARE FUNCTION strip2$ (what AS STRING)
 
Line 326:
NEXT
strip2$ = outP
END FUNCTION</langsyntaxhighlight>
 
Output:
Line 336:
 
=={{header|BBC BASIC}}==
<langsyntaxhighlight lang="bbcbasic"> test$ = CHR$(9) + "Fran" + CHR$(231) + "ais." + CHR$(127)
PRINT "Original ISO-8859-1 string: " test$ " (length " ; LEN(test$) ")"
test$ = FNstripcontrol(test$)
Line 362:
ENDIF
ENDWHILE
= A$</langsyntaxhighlight>
Output:
<pre>
Line 373:
Using BQN's character arithmetic and comparison, characters are binned using <code>⍋</code> and removed if they are inside the range.
 
<langsyntaxhighlight lang="bqn">StripCt←((1≠(@+0‿32)⊸⍋)∧(@+127)⊸≠)⊸/
StripCtEx←(1=(@+32‿127)⊸⍋)⊸/</langsyntaxhighlight>
<langsyntaxhighlight lang="bqn"> RP←•rand.Deal∘≠⊸⊏ # Random Permutation
(rand).Deal∘≠⊸⊏
ascii←RP @+↕256
Line 400:
967
≠StripCtEx unicode
95</langsyntaxhighlight>
=={{header|Bracmat}}==
<langsyntaxhighlight lang="bracmat">( "string of ☺☻♥♦⌂, may include control
characters and other ilk.\L\D§►↔◄
Rødgrød med fløde"
Line 429:
)
)
& );</langsyntaxhighlight>
Output:
<pre>Control characters stripped:
Line 447:
A true/false function checks if the character is in the valid range.<br>
 
<langsyntaxhighlight Clang="c">#include <stdlib.h>
#include <stdio.h>
#include <string.h>
Line 573:
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 585:
 
===<tt>apply mask from a table</tt>===
<langsyntaxhighlight Clang="c">#include <stdio.h>
#include <stdlib.h>
 
Line 648:
 
return 0;
}</langsyntaxhighlight>output:<syntaxhighlight lang="text"> !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ <odd stuff my xterm thinks are bad unicode hence can't be properly shown>
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
!"#$%&'()*+,-./0123456789:;<=>?@[\]^_`{|}~</langsyntaxhighlight>
 
=={{header|C sharp|C#}}==
Uses the test string from REXX.
<langsyntaxhighlight lang="csharp">
using System;
using System.Collections.Generic;
Line 697:
}
}
</syntaxhighlight>
</lang>
Output:
<pre>
Line 706:
 
=={{header|C++}}==
<langsyntaxhighlight Cpplang="cpp">#include <string>
#include <iostream>
#include <algorithm>
Line 748:
std::cout << "string without extended characters: " << no_extended << std::endl ;
return 0 ;
}</langsyntaxhighlight>
Output:
<PRE>string with all characters: K�O:~���7�5����
Line 758:
 
=={{header|Clojure}}==
<langsyntaxhighlight lang="clojure">; generate our test string of characters with control and extended characters
(def range-of-chars (apply str (map char (range 256))))
 
Line 765:
 
; filter to return String of characters that are between 32 - 126:
(apply str (filter #(<= 32 (int %) 126) range-of-chars))</langsyntaxhighlight>
 
=={{header|Common Lisp}}==
Line 786:
 
=={{header|D}}==
<langsyntaxhighlight lang="d">import std.traits;
 
S stripChars(S)(S s, bool function(dchar) pure nothrow mustStrip)
Line 804:
writeln(s.stripChars( c => isControl(c) || c == '\u007F' ));
writeln(s.stripChars( c => isControl(c) || c >= '\u007F' ));
}</langsyntaxhighlight>
{{out}}
<pre> abcédef�
abcédef
abcdef</pre>
 
 
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
{String pack with control and extened chars}
 
const TestStr ='N'+#$01 +'o'+#$02 +'w'+#$03 +' '+#$04 +'i'+#$05 +'s'+#$06 +' '+#$07 +'t'+#$08 +'h'+#$09 +'e'+#$0A +' '+#$0B +'t'+#$0C +'i'+#$0D +'m'+#$0E +'e'+#$0F +' '+#$10 +'f'+#$11 +'o'+#$12 +'r'+#$13 +' '+#$14 +'a'+#$15 +'l'+#$16 +'l'+#$17 +' '+#$18 +'g'+#$19 +'o'+#$1A +'o'+#$1B +'d'+#$1C +' '+#$1D +'m'+#$1E +'e'+#$1F +'n'+#$80 +' '+#$81 +'t'+#$82 +'o'+#$83 +' '+#$84 +'c'+#$85 +'o'+#$86 +'m'+#$87 +'e'+#$88 +' '+#$89 +'t'+#$8A +'o'+#$8B +' '+#$8C +'t'+#$8D +'h'+#$8E +'e'+#$8F +' '+#$90 +'a'+#$91 +'i'+#$92 +'d'+#$93 +' '+#$94 +'o'+#$95 +'f'+#$96 +' '+#$97 +'t'+#$98 +'h'+#$99 +'e'+#$9A +' '+#$9B +'p'+#$9C +'a'+#$9D +'r'+#$9E +'t'+#$9F +'y'+#$A0;
 
function StripControls(S: string): string;
{Strip control characters from string}
var I: integer;
begin
Result:='';
for I:=1 to Length(S) do
if byte(S[I])>=$20 then Result:=Result+S[I];
end;
 
function StripExtended(S: string): string;
{Strip extended characters from string}
var I: integer;
begin
Result:='';
for I:=1 to Length(S) do
if byte(S[I])<$80 then Result:=Result+S[I];
end;
 
 
procedure StripString(Memo: TMemo);
begin
Memo.Lines.Add('String full of controls and extended chars: ');
Memo.Lines.Add(TestStr);
Memo.Lines.Add('String stripped of controls chars: ');
Memo.Lines.Add(StripControls(TestStr));
Memo.Lines.Add('String stripped of extended chars: ');
Memo.Lines.Add(StripExtended(TestStr));
Memo.Lines.Add('String stripped of both control and extended chars: ');
Memo.Lines.Add(StripControls(StripExtended(TestStr)));
end;
 
 
</syntaxhighlight>
{{out}}
<pre>
String full of controls and extended chars:
N�o�w� �i�s� �t�h e
�t�i
m�e� �f�o�r� �a�l�l� �g�o�o�d� �m�e�n€ t‚oƒ „c…o†m‡eˆ ‰tŠo‹ ŒthŽe a‘i’d“ ”o•f– —t˜h™eš ›pœaržtŸy 
String stripped of controls chars:
Now is the time for all good men€ t‚oƒ „c…o†m‡eˆ ‰tŠo‹ ŒthŽe a‘i’d“ ”o•f– —t˜h™eš ›pœaržtŸy 
String stripped of extended chars:
N�o�w� �i�s� �t�h e
�t�i
m�e� �f�o�r� �a�l�l� �g�o�o�d� �m�e�n to come to the aid of the party
String stripped of both control and extended chars:
Now is the time for all good men to come to the aid of the party
Elapsed Time: 51.012 ms.
 
</pre>
 
 
=={{header|EasyLang}}==
 
<syntaxhighlight lang=easylang>
func$ strip s$ .
for c$ in strchars s$
if strcode c$ >= 32 and strcode c$ <= 126
r$ &= c$
.
.
return r$
.
print strip "\tHellö world"
</syntaxhighlight>
 
=={{header|Erlang}}==
Exported functions to be used by [[Update_a_configuration_file]]
<syntaxhighlight lang="erlang">
<lang Erlang>
-module( strip_control_codes ).
 
Line 831 ⟶ 909:
String_without_cc_nor_ec = lists:filter( fun is_not_control_code_nor_extended_character/1, String ),
io:fwrite( "String without control codes nor extended characters (~p characters): ~s~n", [erlang:length(String_without_cc_nor_ec), String_without_cc_nor_ec] ).
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 843 ⟶ 921:
=={{header|F Sharp|F#}}==
Uses test string from REXX.
<langsyntaxhighlight lang="fsharp">
open System
 
Line 862 ⟶ 940:
printfn "Stripped of extended: %s" (stripExtended test)
0//main must return integer, much like in C/C++
</syntaxhighlight>
</lang>
Output:
<pre>
Line 871 ⟶ 949:
 
=={{header|Factor}}==
<syntaxhighlight lang="text">USING: ascii kernel sequences ;
 
: strip-control-codes ( str -- str' ) [ control? not ] filter ;
 
: strip-control-codes-and-extended ( str -- str' )
strip-control-codes [ ascii? ] filter ;</langsyntaxhighlight>
 
=={{header|Forth}}==
<langsyntaxhighlight lang="forth">: strip ( buf len -- buf len' ) \ repacks buffer, so len' <= len
over + over swap over ( buf dst limit src )
do
Line 886 ⟶ 964:
then
loop
over - ;</langsyntaxhighlight>
 
=={{header|Fortran}}==
<langsyntaxhighlight lang="fortran">module stripcharacters
implicit none
 
Line 943 ⟶ 1,021:
write (*,*) strip(string,not_extended)
end program test
</syntaxhighlight>
</lang>
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">' FB 1.05.0 Win64
 
Function stripControlChars(s As Const String) As String
Line 1,023 ⟶ 1,101:
Print
Print "Press any key to quit"
Sleep</langsyntaxhighlight>
 
{{out}}
Line 1,039 ⟶ 1,117:
 
=={{header|Frink}}==
<langsyntaxhighlight lang="frink">stripExtended[str] := str =~ %s/[^\u0020-\u007e]//g
 
stripControl[str] := str =~ %s/[\u0000-\u001F\u007f]//g
 
println[stripExtended[char[0 to 127]]]
println[stripControl[char[0 to 127]]]</langsyntaxhighlight>
{{out}}
<pre>
Line 1,053 ⟶ 1,131:
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=19db658a6c44cfb1f6f887ff53e549bb Click this link to run this code]'''
<langsyntaxhighlight lang="gambas">Public Sub Main()
Dim sString As String = "The\t \equick\n \fbrownfox \vcost £125.00 or €145.00 or $160.00 \bto \ncapture ©®"
Dim sStd, sExtend As String
Line 1,083 ⟶ 1,161:
Return sResult
 
End</langsyntaxhighlight>
Output:
<pre>
Line 1,097 ⟶ 1,175:
=={{header|Go}}==
Go works for ASCII and non-ASCII systems. The first pair of functions below interpret strings as byte strings, presumably useful for strings consisting of ASCII and 8-bit extended ASCII data. The second pair of functions interpret strings as UTF-8.
<langsyntaxhighlight lang="go">package main
 
import (
Line 1,186 ⟶ 1,264:
fmt.Println("\nas decomposed and stripped Unicode:")
fmt.Println(stripCtlAndExtFromUnicode(src))
}</langsyntaxhighlight>
Output: (varies with display configuration)
<pre>
Line 1,211 ⟶ 1,289:
 
=={{header|Groovy}}==
<langsyntaxhighlight Groovylang="groovy">def stripControl = { it.replaceAll(/\p{Cntrl}/, '') }
def stripControlAndExtended = { it.replaceAll(/[^\p{Print}]/, '') }</langsyntaxhighlight>
Test:
<langsyntaxhighlight Groovylang="groovy">def text = (0..255).collect { (char) it }.join('')
def textMinusControl = text.findAll { int v = (char)it; v > 31 && v != 127 }.join('')
def textMinusControlAndExtended = textMinusControl.findAll {((char)it) < 128 }.join('')
 
assert stripControl(text) == textMinusControl
assert stripControlAndExtended(text) == textMinusControlAndExtended</langsyntaxhighlight>
 
=={{header|Haskell}}==
<langsyntaxhighlight Haskelllang="haskell">import Control.Applicative (liftA2)
 
strip, strip2 :: String -> String
Line 1,233 ⟶ 1,311:
main =
(putStrLn . unlines) $
[strip, strip2] <*> ["alphabetic 字母 with some less parochial parts"]</langsyntaxhighlight>
{{Out}}
<pre>alphabetic with some less parochial parts
Line 1,240 ⟶ 1,318:
=={{header|Icon}} and {{header|Unicon}}==
We'll use ''deletec'' to remove unwanted characters (2nd argument) from a string (1st argument). The procedure below coerces types back and forth between string and cset. The character set of unwanted characters is the difference of all ASCII characters and the ASCII characters from 33 to 126.
<langsyntaxhighlight Iconlang="icon">procedure main(A)
write(image(deletec(&ascii,&ascii--(&ascii)[33:127])))
end
link strings
</syntaxhighlight>
</lang>
 
{{libheader|Icon Programming Library}}
Line 1,250 ⟶ 1,328:
 
The IPL procedure ''deletec'' is equivalent to this:
<langsyntaxhighlight Iconlang="icon">procedure deletec(s, c) #: delete characters
result := ""
s ? {
Line 1,256 ⟶ 1,334:
return result ||:= tab(0)
}
end</langsyntaxhighlight>
 
 
Line 1,263 ⟶ 1,341:
=={{header|J}}==
'''Solution:'''
<langsyntaxhighlight lang="j">stripControlCodes=: -.&(DEL,32{.a.)
stripControlExtCodes=: ([ -. -.)&(32}.127{.a.)</langsyntaxhighlight>
'''Usage:'''
<langsyntaxhighlight lang="j"> mystring=: a. {~ ?~256 NB. ascii chars 0-255 in random order
#mystring NB. length of string
256
Line 1,280 ⟶ 1,358:
95
stripControlExtCodes myunicodestring
k}w:]U3xEh9"GZdr/#^B.Sn%\uFOo[(`t2-J6*IA=Vf&N;lQ8,${XLz5?D0~s)'Y7Kq|ip4<WRCaM!b@cgv_T +mH>1ejPy</langsyntaxhighlight>
 
Generally speaking, <code>([-.-.)</code> gives us the contents from the sequence on the left, restricted to only the items which appear in the sequence on the right.
Line 1,288 ⟶ 1,366:
=={{header|Java}}==
{{works with|Java|8+}}
<langsyntaxhighlight lang="java">import java.util.function.IntPredicate;
 
public class StripControlCodes {
Line 1,302 ⟶ 1,380:
StringBuilder::appendCodePoint, StringBuilder::append).toString();
}
}</langsyntaxhighlight>
<pre> abcédef
abcdef</pre>
Line 1,310 ⟶ 1,388:
===ES 5===
 
<langsyntaxhighlight JavaScriptlang="javascript">(function (strTest) {
 
// s -> s
Line 1,323 ⟶ 1,401:
return strip(strTest);
 
})("\ba\x00b\n\rc\fd\xc3");</langsyntaxhighlight>
 
{{Out}}
 
<langsyntaxhighlight JavaScriptlang="javascript">"abcd"</langsyntaxhighlight>
 
=={{header|jq}}==
{{works with|jq|1.4}}
<langsyntaxhighlight lang="jq">def strip_control_codes:
explode | map(select(. > 31 and . != 127)) | implode;
 
def strip_extended_characters:
explode | map(select(31 < . and . < 127)) | implode;</langsyntaxhighlight>
 
'''Example''':
<langsyntaxhighlight lang="jq">def string: "string of ☺☻♥♦⌂, may include control characters such as null(\u0000) and other ilk.\n§►↔◄\nRødgrød med fløde";
 
"string | strip_control_codes\n => \(string | strip_control_codes)",
"string | strip_extended_characters\n => \(string | strip_extended_characters)"</langsyntaxhighlight>
{{out}}
<langsyntaxhighlight lang="sh">$ jq -n -r -f Strip_control_codes_and_extended_characters.jq
string | strip_control_codes
=> string of ☺☻♥♦⌂, may include control characters such as null() and other ilk.§►↔◄Rødgrød med fløde
string | strip_extended_characters
=> string of , may include control characters such as null() and other ilk.Rdgrd med flde</langsyntaxhighlight>
 
=={{header|Julia}}==
<syntaxhighlight lang="julia">
<lang Julia>
stripc0{T<:String}(a::T) = replace(a, r"[\x00-\x1f\x7f]", "")
stripc0x{T<:String}(a::T) = replace(a, r"[^\x20-\x7e]", "")
Line 1,359 ⟶ 1,437:
println("\nWith C0 control characters removed:\n ", stripc0(a))
println("\nWith C0 and extended characters removed:\n ", stripc0x(a))
</syntaxhighlight>
</lang>
 
{{out}}
Line 1,375 ⟶ 1,453:
 
=={{header|Kotlin}}==
<langsyntaxhighlight lang="scala">// version 1.1.2
 
fun String.strip(extendedChars: Boolean = false): String {
Line 1,396 ⟶ 1,474:
val u = s.strip(true)
println("String = $u Length = ${u.length}")
}</langsyntaxhighlight>
 
{{out}}
Line 1,411 ⟶ 1,489:
 
=={{header|langur}}==
<langsyntaxhighlight lang="langur">val .str = "()\x15abcd\uFFFF123\uBBBB!@#$%^&*\x01"
 
writeln "original : ", .str
writeln "without ctrl chars: ", replace(.str, RE/\p{Cc}/, ZLS"")
writeln "print ASCII only : ", replace(.str, re/[^ -~]/, ZLS"")</langsyntaxhighlight>
 
{{out}}
Line 1,423 ⟶ 1,501:
 
=={{header|Liberty BASIC}}==
<syntaxhighlight lang="lb">
<lang lb>
all$ =""
for i =0 to 255
Line 1,461 ⟶ 1,539:
extendedStripped$ =r$
end function
</syntaxhighlight>
</lang>
 
=={{header|Lua}}==
<langsyntaxhighlight lang="lua">function Strip_Control_Codes( str )
local s = ""
for i in str:gmatch( "%C+" ) do
Line 1,488 ⟶ 1,566:
 
print( Strip_Control_Codes(q) )
print( Strip_Control_and_Extended_Codes(q) )</langsyntaxhighlight>
<pre> !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€�‚ƒ„…†‡ˆ‰Š‹Œ�Ž��‘’“”•–—˜™š›œ�žŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">stripCtrl[x_]:=StringJoin[Select[Characters[x],
MemberQ[CharacterRange["!","~"]~Join~Characters[FromCharacterCode[Range[128,255]]],#]&]]
 
stripCtrlExt[x_]:=StringJoin[Select[Characters[x],
MemberQ[CharacterRange["!","~"],#]&]]</langsyntaxhighlight>
 
Test:
Line 1,521 ⟶ 1,599:
=={{header|MATLAB}} / {{header|Octave}}==
 
<langsyntaxhighlight MATLABlang="matlab"> function str = stripped(str)
str = str(31<str & str<127);
end; </langsyntaxhighlight>
 
=={{header|Nim}}==
<langsyntaxhighlight lang="nim">proc stripped(str: string): string =
result = ""
for c in str:
Line 1,539 ⟶ 1,617:
 
echo strippedControl "\ba\x00b\n\rc\fdÄ"
echo stripped "\ba\x00b\n\rc\fd\xc3"</langsyntaxhighlight>
Output:
<pre>abcdÄ
Line 1,546 ⟶ 1,624:
=={{header|OCaml}}==
 
<langsyntaxhighlight lang="ocaml">let is_control_code c =
letc d< ='\032' int_of_char|| c in= '\127'
 
d < 32 || d = 127
let is_extended_char c =
c > '\127'
let d = int_of_char c in
 
d > 127
let strip f str =
let len = String.length str in
Line 1,559 ⟶ 1,635:
let rec aux i j =
if i >= len
then Bytes.to_string (Bytes.subsub_string res 0 j)
else if f str.[i]
then aux (succ i) j
Line 1,568 ⟶ 1,644:
in
aux 0 0
 
let () =
Random.self_init ();
Line 1,577 ⟶ 1,653:
in
print_endline (strip is_control_code s);
print_endline (strip (fun c -> (is_control_code c) || (is_extended_char c)) s);</syntaxhighlight>
;;</lang>
 
=={{header|Pascal}}==
{{works with|Free_Pascal}}
<langsyntaxhighlight lang="pascal">program StripCharacters(output);
 
function Strip (s: string; control, extended: boolean): string;
Line 1,607 ⟶ 1,682:
writeln ('No extnd: ', Strip(test, false, true));
writeln ('ASCII: ', Strip(test, true, true));
end.</langsyntaxhighlight>
Output:
<pre>% ./StripCharacters
Line 1,620 ⟶ 1,695:
=={{header|Peloton}}==
Peloton has a native instruction for removing control codes from a string, SAL, the Low ASCII Strip. From the manual:
<langsyntaxhighlight lang="sgml">Create variable with control characters: <@ SAYLETVARLIT>i|This string has control characters
- - - - - -
 
Line 1,627 ⟶ 1,702:
Assign infix <@ LETVARSALVAR>j|i</@> <@ SAYVAR>j</@>
Assign prepend <@ LETSALVARVAR>k|i</@> <@ SAYVAR>k</@>
Reflexive assign <@ ACTSALVAR>i</@> <@ SAYVAR>i</@></langsyntaxhighlight>
 
Peloton also has SAH, High ASCII Strip. Again, from the manual:
<langsyntaxhighlight lang="sgml">Create variable with high and low ANSI: <@ SAYLETVARLIT>i|This string has both low ansi and high ansi characters - il doit d'être prévenu</@>
Strip high ANSI <@ SAYSAHVAR>i</@>
Assign infix <@ LETVARSAHVAR>j|i</@> <@ SAYVAR>j</@>
Assign prepend <@ LETSAHVARVAR>k|i</@> <@ SAYVAR>k</@>
Reflexive assign <@ ACTSAHVAR>i</@> <@ SAYVAR>i</@></langsyntaxhighlight>
 
=={{header|Perl}}==
<langsyntaxhighlight Perllang="perl">#!/usr/bin/perl -w
use strict ;
 
Line 1,655 ⟶ 1,730:
print "\nWithout extended: " ;
print join( '' , map { chr( $_ ) } @noextended ) ;
print "\n" ;</langsyntaxhighlight>
Output:
<PRE>before sanitation : �L08&YH�O��n)�:���O�G$���.���"zO���Q�?��
Line 1,667 ⟶ 1,742:
to build a new one character-by-character.<br>
I credited Ada solely for the sensible fromch / toch / abovech idea.
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1.0.2"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (param default fixes in pwa/p2js)</span>
Line 1,690 ⟶ 1,765:
<span style="color: #000000;">put_line</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"No Control Chars:"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">filter_it</span><span style="color: #0000FF;">(</span><span style="color: #000000;">full</span><span style="color: #0000FF;">))</span> <span style="color: #000080;font-style:italic;">-- default values for fromch, toch, and abovech</span>
<span style="color: #000000;">put_line</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"\" and no Extended:"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">filter_it</span><span style="color: #0000FF;">(</span><span style="color: #000000;">full</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">abovech</span><span style="color: #0000FF;">:=</span><span style="color: #000000;">#FF</span><span style="color: #0000FF;">))</span> <span style="color: #000080;font-style:italic;">-- defaults for fromch and toch</span>
<!--</langsyntaxhighlight>-->
{{out}}
(desktop/Phix, in a grubby Windows console)
Line 1,700 ⟶ 1,775:
(pwa/p2js)
<pre>
The full string: " abcédef abcédef�", Length:10
No Control Chars: " abcédef", Length:8
" and no Extended: " abcdef", Length:7
Line 1,709 ⟶ 1,784:
=={{header|PicoLisp}}==
Control characters in strings are written with a hat (^) in PicoLisp. ^? is the DEL character.
<langsyntaxhighlight PicoLisplang="picolisp">(de stripCtrl (Str)
(pack
(filter
Line 1,720 ⟶ 1,795:
(filter
'((C) (> "^?" C "^_"))
(chop Str) ) ) )</langsyntaxhighlight>
Test:
<pre>: (char "^?")
Line 1,735 ⟶ 1,810:
 
=={{header|Pike}}==
<langsyntaxhighlight Pikelang="pike">> string input = random_string(100);
> (string)((array)input-enumerate(32)-enumerate(255-126,1,127));
Result: "p_xx08M]cK<FHgR3\\I.x>)Tm<VgakYddy&P7"</langsyntaxhighlight>
 
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
<lang PL/I>
stripper: proc options (main);
declare s character (100) varying;
Line 1,806 ⟶ 1,881:
 
end stripper;
</syntaxhighlight>
</lang>
Output:
<pre>
Line 1,816 ⟶ 1,891:
 
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
<lang PowerShell>
function Remove-Character
{
Line 1,864 ⟶ 1,939:
}
}
</syntaxhighlight>
</lang>
 
<syntaxhighlight lang="powershell">
<lang PowerShell>
$test = "$([char]9)Français."
 
Line 1,873 ⟶ 1,948:
"Extended characters stripped : `"$($test | Remove-Character -Extended)`""
"Control & extended stripped : `"$($test | Remove-Character)`""
</syntaxhighlight>
</lang>
{{Out}}
<pre>
Line 1,881 ⟶ 1,956:
Control & extended stripped : "Franais."
</pre>
<syntaxhighlight lang="powershell">
<lang PowerShell>
"Français", "Čeština" | Remove-Character -Extended
</syntaxhighlight>
</lang>
{{Out}}
<pre>
Line 1,891 ⟶ 1,966:
 
=={{header|PureBasic}}==
<langsyntaxhighlight PureBasiclang="purebasic">Procedure.s stripControlCodes(source.s)
Protected i, *ptrChar.Character, length = Len(source), result.s
*ptrChar = @source
Line 1,928 ⟶ 2,003:
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf</langsyntaxhighlight>
Sample output:
<pre>»╫=┐C─≡G(═ç╤â√╝÷╔¬ÿ▌x  è4∞|)ï└⌐ƒ9²òτ┌ºáj)▓<~-vPÿφQ╨ù¿╖îFh"[ü╗dÉ₧q#óé├p╫■
Line 1,935 ⟶ 2,010:
 
=={{header|Python}}==
<langsyntaxhighlight Pythonlang="python">stripped = lambda s: "".join(i for i in s if 31 < ord(i) < 127)
 
print(stripped("\ba\x00b\n\rc\fd\xc3"))</langsyntaxhighlight>Output:<syntaxhighlight lang="text">abcd</langsyntaxhighlight>
 
=={{header|Racket}}==
 
<syntaxhighlight lang="racket">
<lang Racket>
#lang racket
;; Works on both strings (Unicode) and byte strings (raw/ASCII)
Line 1,948 ⟶ 2,023:
(define (strip-controls-and-extended str)
(regexp-replace* #rx"[^\040-\176]+" str ""))
</syntaxhighlight>
</lang>
 
=={{header|Raku}}==
Line 1,954 ⟶ 2,029:
{{works with|Rakudo|2018.03}}
 
<syntaxhighlight lang="raku" perl6line>my $str = (0..400).roll(80)».chr.join;
 
say $str;
say $str.subst(/<:Cc>/, '', :g); # unicode property: control character
say $str.subst(/<-[\ ..~]>/, '', :g);</langsyntaxhighlight>
<pre>kşaNĹĭŗ�|Ęw���"ÄlĄWł8iCƁę��Ż�¬�5ĎĶ'óü¸'ÍŸ;ŢƐ¦�´ŷQċűÒŴ$ÃŅ�Đįð+=ĥƂ+Ōĭħ¼ŕc¤H~ìïēÕ
kşaNĹĭŗ|Ęw"ÄlĄWł8iCƁ꯬5ĎĶ'óü¸'ÍŸ;ŢƐ¦´ŷQċűÒŴ$ÃŅĐįð+=ĥƂ+Ōĭħ¼ŕc¤H~ìïēÕ
Line 1,967 ⟶ 2,042:
===idiomatic version===
This REXX version processes each character in an idiomatic way &nbsp; (if it's a wanted character, then keep it).
<langsyntaxhighlight lang="rexx">/*REXX program strips all "control codes" from a character string (ASCII or EBCDIC). */
z= 'string of ☺☻♥♦⌂, may include control characters and other ♫☼§►↔◄░▒▓█┌┴┐±÷²¬└┬┘ilk.'
@=' !"#$%&''()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~'
Line 1,976 ⟶ 2,051:
 
say 'old = »»»'z"«««" /*add ««fence»» before & after old text*/
say 'new = »»»'$"«««" /* " " " " " new " */</langsyntaxhighlight>
{{out|output}}
<pre>
Line 1,989 ⟶ 2,064:
 
Because there are &nbsp; (or should be) &nbsp; fewer unwanted characters than wanted characters, this version is faster.
<langsyntaxhighlight lang="rexx">/*REXX program strips all "control codes" from a character string (ASCII or EBCDIC). */
x= 'string of ☺☻♥♦⌂, may include control characters and other ♫☼§►↔◄░▒▓█┌┴┐±÷²¬└┬┘ilk.'
@=' !"#$%&''()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghij' || ,
Line 1,999 ⟶ 2,074:
 
say 'old = »»»' || x || "«««" /*add ««fence»» before & after old text*/
say 'new = »»»' || $ || "«««" /* " " " " " new " */</langsyntaxhighlight>
{{out|output|text=&nbsp; is identical to the 1<sup>st</sup> REXX version.}} <br><br>
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
s = char(31) + "abc" + char(13) + "def" + char(11) + "ghi" + char(10)
see strip(s) + nl
Line 2,016 ⟶ 2,091:
next
return strip
</syntaxhighlight>
</lang>
 
=={{header|RPL}}==
RPL has a character set based on ASCII but does not support extended characters.
≪ → text
≪ "" 1 text SIZE '''FOR''' j
text j DUP SUB NUM
'''IF''' DUP 32 ≥ OVER 126 ≤ '''THEN''' CHR + '''ELSE''' DROP '''END'''
'''NEXT'''
≫ ≫ '<span style="color:blue">NOCTRL</span>' STO
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">class String
def strip_control_characters()
chars.each_with_object("") do |char, str|
Line 2,035 ⟶ 2,119:
p s = "\ba\x00b\n\rc\fd\xc3\x7ffoo"
p s.strip_control_characters
p s.strip_control_and_extended_characters</langsyntaxhighlight>
 
{{out}}
Line 2,043 ⟶ 2,127:
 
=={{header|Run BASIC}}==
<langsyntaxhighlight lang="runbasic">s$ = chr$(31) + "abc" + chr$(13) + "def" + chr$(11) + "ghi" + chr$(10)
print strip$(s$)
 
Line 2,063 ⟶ 2,147:
end if
next i
END FUNCTION</langsyntaxhighlight>
<pre>
input : chr$(31)+"abc"+chr$(13)+"def"+chr$(11)+"ghi"+chr$(10)
Line 2,070 ⟶ 2,154:
=={{header|Scala}}==
===ASCII: Using StringOps Class===
<langsyntaxhighlight Scalalang="scala">val controlCode : (Char) => Boolean = (c:Char) => (c <= 32 || c == 127)
val extendedCode : (Char) => Boolean = (c:Char) => (c <= 32 || c > 127)
 
Line 2,081 ⟶ 2,165:
 
println( "ctrl and extended filtered out: \n\n" +
teststring.filterNot(controlCode).filterNot(extendedCode) + "\n" )</langsyntaxhighlight>
{{out}}
<pre>ctrl filtered out:
Line 2,097 ⟶ 2,181:
 
===Unicode: Using Regular Expressions===
<syntaxhighlight lang="scala">//
<lang Scala>//
// A Unicode test string
//
Line 2,116 ⟶ 2,200:
val htmlNoExtCode = for( i <- sNoExtCode.indices ) yield
"&#" + sNoExtCode(i).toInt + ";" + (if( (i+1) % 10 == 0 ) "\n" else "")
println( "ctrl and extended filtered out: <br/><br/>\n\n" + htmlNoExtCode.mkString + "<br/><br/>\n" )</langsyntaxhighlight>
{{out}}
<pre>ctrl filtered out:
Line 2,148 ⟶ 2,232:
&#32;&#68;&#113;&#49;&#91;&#58;&#51;&#83;&#80;&#77;&#110;&#67;&#90;&#60;&#74;&#43;&#102;&#117;&#34;&#93;&#109;&#92;&#50;&#54;&#124;&#106;&#85;&#64;&#101;&#96;&#78;&#63;&#95;&#39;&#75;&#126;&#112;&#115;&#46;&#98;&#105;&#72;&#55;&#62;&#122;&#65;&#88;&#86;&#70;&#53;
&#61;&#79;&#103;&#66;&#104;&#89;&#71;&#99;&#45;&#52;&#41;&#69;&#47;&#42;&#97;&#44;&#37;&#119;&#84;&#76;&#111;&#82;&#38;&#87;&#123;&#107;&#100;&#125;&#56;&#108;&#94;&#59;&#48;&#35;&#40;&#33;&#116;&#114;&#118;&#73;&#120;&#36;&#81;&#121;&#57;</pre>
 
=={{header|sed}}==
To strip control codes only:
<syntaxhighlight lang="sed">s/[[:cntrl:]]//g</syntaxhighlight>
To strip control codes and extended characters:
<syntaxhighlight lang="sed">s/[^[:print:]]//g</syntaxhighlight>
For this to work properly with sed implementations supporting multibyte character encodings (like UTF-8), the environment variable LC_ALL=C might need to be set.
{{out}}
<pre>
$ printf 'Just\tä\tString\n' | LC_ALL=C sed 's/[[:cntrl:]]//g'
JustäString
$ printf 'Just\tä\tString\n' | LC_ALL=C sed 's/[^[:print:]]//g'
JustString
</pre>
 
=={{header|Seed7}}==
Line 2,156 ⟶ 2,254:
Unicode characters with UTF-8 encoding to the console.
 
<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";
include "utf8.s7i";
 
Line 2,206 ⟶ 2,304:
writeln("Stripped of control codes and extended characters:");
writeln(stripControlAndExtended(src));
end func;</langsyntaxhighlight>
 
Output:
Line 2,221 ⟶ 2,319:
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">var str = "\ba\x00b\n\rc\fd\xc3\x7ffoo"
 
var letters = str.chars.map{.ord}
Line 2,230 ⟶ 2,328:
 
var noextended = nocontrols.grep{ _ < 127 }
say noextended.map{.chr}.join.dump</langsyntaxhighlight>
{{out}}
<pre>
Line 2,239 ⟶ 2,337:
 
=={{header|Standard ML}}==
<langsyntaxhighlight lang="sml">(* string -> string *)
val stripCntrl = concat o String.tokens Char.isCntrl
 
(* string -> string *)
val stripCntrlAndExt = concat o String.tokens (not o Char.isPrint)</langsyntaxhighlight>
 
=={{header|Tcl}}==
<langsyntaxhighlight lang="tcl">proc stripAsciiCC str {
regsub -all {[\u0000-\u001f\u007f]+} $str ""
}
proc stripCC str {
regsub -all {[^\u0020-\u007e]+} $str ""
}</langsyntaxhighlight>
 
=={{header|TI-83 BASIC}}==
Line 2,258 ⟶ 2,356:
The following "normal characters" do exist, but can't be typed on the calculator and a hex editor must be used to enter them:
 
<syntaxhighlight lang ="ti83b">#$&@;_`abcdefghijklmnopqrstuvwxyz|~</langsyntaxhighlight>
 
The double quote character (ASCII decimal 34) can be entered, but cannot be escaped and thus cannot be stored to strings without the use of hex editors. The following program will remove double quotes from the input string if they were hacked in simply because having one stored to the "check" string is syntactically invalid.
Line 2,264 ⟶ 2,362:
So, in sum, you have to hack the calculator to enter in this program, but once it's entered you can transfer it to unhacked calculators and it will work.
 
<langsyntaxhighlight lang="ti83b">:" !#$%&'()*+,-./0123456789:;<=>?ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"→Str0
:Input ">",Str1
:":"+Str1+":"→Str1
Line 2,272 ⟶ 2,370:
:End
:sub(Str1,2,length(Str1)-1)→Str1
:Pause Str1</langsyntaxhighlight>
 
=={{header|TXR}}==
Line 2,278 ⟶ 2,376:
{{trans|Racket}}
 
<langsyntaxhighlight lang="txrlisp">(defun strip-controls (str)
(regsub #/[\x0-\x1F\x7F]+/ "" str))
 
(defun strip-controls-and-extended (str)
(regsub #/[^\x20-\x7F]+/ "" str))</langsyntaxhighlight>
 
=={{header|VBScript}}==
Derived from the BASIC version.
<syntaxhighlight lang="vb">
<lang vb>
Function StripCtrlCodes(s)
tmp = ""
Line 2,313 ⟶ 2,411:
WScript.StdOut.Write "ab�cd�ef�gh�ij†klð€" & " = " & StripCtrlCodesExtChrs("ab�cd�ef�gh�ij†klð€")
WScript.StdOut.WriteLine
</syntaxhighlight>
</lang>
 
{{Out}}
Line 2,321 ⟶ 2,419:
</pre>
 
=={{header|V (Vlang)}}==
{{trans|AutoHotkey}}
<syntaxhighlight lang="v (vlang)">fn main() {
println(stripped("\ba\x00b\n\rc\fd\xc3"))
}
Line 2,331 ⟶ 2,429:
for value in source {if value > 31 && value < 128 {result += value.ascii_str()}}
return result
}</langsyntaxhighlight>
 
{{Out}}
Line 2,340 ⟶ 2,438:
=={{header|Wren}}==
{{libheader|Wren-pattern}}
<langsyntaxhighlight ecmascriptlang="wren">import "./pattern" for Pattern
 
var s = "\t\n\r\x01\0\fabc\v\v\b\a\x1f\x7f🌇Páez😃É"
Line 2,353 ⟶ 2,451:
r = p.replaceAll(s, "")
System.print("%(r) -> length %(r.count)")
</syntaxhighlight>
</lang>
 
{{out}}
Line 2,362 ⟶ 2,460:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">include c:\cxpl\codes; \intrinsic 'code' declarations
string 0; \use zero-terminated string convention
 
Line 2,390 ⟶ 2,488:
Strip(String, true);
Text(0, String); CrLf(0);
]</langsyntaxhighlight>
 
Output:
Line 2,402 ⟶ 2,500:
=={{header|zkl}}==
ASCII
<langsyntaxhighlight lang="zkl">var ctlCodes=([1..31].pump(String,"toChar") +(127).toChar());
var extdChars=[127..255].pump(String,"toChar");
 
Line 2,410 ⟶ 2,508:
(test-extdChars).println("<< no extended chars");
(test-extdChars-ctlCodes).println("<< text");
</syntaxhighlight>
</lang>
{{out}}
<pre>
9,482

edits