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

{{trans|Python}}

R s.filter(i -> Int(i.code) C 32..126).join(‘’)

{{out}}

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

.stack 1024

.data

int 10h

ret

{{out}}

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

IF c<32 OR c>124 OR c=96 OR c=123 THEN

RETURN (0)

Strip(src,dst)

PrintF("Stripped string: ""%S""%E",dst)

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

=={{header|Ada}}==

procedure Strip_ASCII is

Put_Line("Neither_Extended:", Filter(Full, Above => Character'Last)); -- defaults for From and To

end Strip_ASCII;

Output:

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

# assums ASCII is the character set #

PROC strip characters = ( STRING text, BOOL strip extended )STRING:

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

{{out}}

<pre>

=={{header|Arturo}}==

print "with extended characters"

print join select split str 'x ->

and? ascii? x

{{out}}

=={{header|AutoHotkey}}==

{{trans|Python}}

Loop Parse, x

if Asc(A_LoopField) > 31 and Asc(A_LoopField) < 128

return r

}

=={{header|AWK}}==

# syntax: GAWK -f STRIP_CONTROL_CODES_AND_EXTENDED_CHARACTERS.AWK

BEGIN {

exit(0)

}

<p>output:</p>

<pre>

While DOS does support ''some'' extended characters, they aren't entirely standardized, and shouldn't be relied upon.

DECLARE FUNCTION strip2$ (what AS STRING)

NEXT

strip2$ = outP

Output:

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

PRINT "Original ISO-8859-1 string: " test$ " (length " ; LEN(test$) ")"

test$ = FNstripcontrol(test$)

ENDIF

ENDWHILE

Output:

<pre>

Using BQN's character arithmetic and comparison, characters are binned using <code>⍋</code> and removed if they are inside the range.

(rand).Deal∘≠⊸⊏

ascii←RP @+↕256

967

≠StripCtEx unicode

=={{header|Bracmat}}==

characters and other ilk.\L\D§►↔◄

Rødgrød med fløde"

)

)

Output:

<pre>Control characters stripped:

A true/false function checks if the character is in the valid range.<br>

#include <stdio.h>

#include <string.h>

return 0;

{{out}}

===<tt>apply mask from a table</tt>===

#include <stdlib.h>

return 0;

!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

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

Uses the test string from REXX.

using System;

using System.Collections.Generic;

}

}

Output:

<pre>

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

#include <iostream>

#include <algorithm>

std::cout << "string without extended characters: " << no_extended << std::endl ;

return 0 ;

Output:

<PRE>string with all characters: K�O:~���7�5����

=={{header|Clojure}}==

(def range-of-chars (apply str (map char (range 256))))

; filter to return String of characters that are between 32 - 126:

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

=={{header|D}}==

S stripChars(S)(S s, bool function(dchar) pure nothrow mustStrip)

writeln(s.stripChars( c => isControl(c) || c == '\u007F' ));

writeln(s.stripChars( c => isControl(c) || c >= '\u007F' ));

{{out}}

<pre> abcédef�

=={{header|Erlang}}==

Exported functions to be used by [[Update_a_configuration_file]]

-module( strip_control_codes ).

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

{{out}}

<pre>

=={{header|F Sharp|F#}}==

Uses test string from REXX.

open System

printfn "Stripped of extended: %s" (stripExtended test)

0//main must return integer, much like in C/C++

Output:

<pre>

=={{header|Factor}}==

: strip-control-codes ( str -- str' ) [ control? not ] filter ;

: strip-control-codes-and-extended ( str -- str' )

=={{header|Forth}}==

over + over swap over ( buf dst limit src )

do

then

loop

=={{header|Fortran}}==

implicit none

write (*,*) strip(string,not_extended)

end program test

=={{header|FreeBASIC}}==

Function stripControlChars(s As Const String) As String

Print

Print "Press any key to quit"

{{out}}

=={{header|Frink}}==

stripControl[str] := str =~ %s/[\u0000-\u001F\u007f]//g

println[stripExtended[char[0 to 127]]]

{{out}}

<pre>

=={{header|Gambas}}==

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

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

Return sResult

Output:

<pre>

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

import (

fmt.Println("\nas decomposed and stripped Unicode:")

fmt.Println(stripCtlAndExtFromUnicode(src))

Output: (varies with display configuration)

<pre>

=={{header|Groovy}}==

Test:

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

=={{header|Haskell}}==

strip, strip2 :: String -> String

main =

(putStrLn . unlines) $

{{Out}}

<pre>alphabetic with some less parochial parts

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

write(image(deletec(&ascii,&ascii--(&ascii)[33:127])))

end

link strings

{{libheader|Icon Programming Library}}

The IPL procedure ''deletec'' is equivalent to this:

result := ""

s ? {

return result ||:= tab(0)

}

=={{header|J}}==

'''Solution:'''

'''Usage:'''

#mystring NB. length of string

256

95

stripControlExtCodes myunicodestring

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.

=={{header|Java}}==

{{works with|Java|8+}}

public class StripControlCodes {

StringBuilder::appendCodePoint, StringBuilder::append).toString();

}

<pre> abcédef

abcdef</pre>

===ES 5===

// s -> s

return strip(strTest);

{{Out}}

=={{header|jq}}==

{{works with|jq|1.4}}

explode | map(select(. > 31 and . != 127)) | implode;

def strip_extended_characters:

'''Example''':

"string | strip_control_codes\n => \(string | strip_control_codes)",

{{out}}

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

=={{header|Julia}}==

stripc0{T<:String}(a::T) = replace(a, r"[\x00-\x1f\x7f]", "")

stripc0x{T<:String}(a::T) = replace(a, r"[^\x20-\x7e]", "")

println("\nWith C0 control characters removed:\n ", stripc0(a))

println("\nWith C0 and extended characters removed:\n ", stripc0x(a))

{{out}}

=={{header|Kotlin}}==

fun String.strip(extendedChars: Boolean = false): String {

val u = s.strip(true)

println("String = $u Length = ${u.length}")

{{out}}

=={{header|langur}}==

writeln "original : ", .str

writeln "without ctrl chars: ", replace(.str, RE/\p{Cc}/, ZLS)

{{out}}

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

all$ =""

for i =0 to 255

extendedStripped$ =r$

end function

=={{header|Lua}}==

local s = ""

for i in str:gmatch( "%C+" ) do

print( Strip_Control_Codes(q) )

<pre> !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€�‚ƒ„…†‡ˆ‰Š‹Œ�Ž��‘’“”•–—˜™š›œ�žŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ

!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~</pre>

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

MemberQ[CharacterRange["!","~"]~Join~Characters[FromCharacterCode[Range[128,255]]],#]&]]

stripCtrlExt[x_]:=StringJoin[Select[Characters[x],

Test:

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

str = str(31<str & str<127);

=={{header|Nim}}==

result = ""

for c in str:

echo strippedControl "\ba\x00b\n\rc\fdÄ"

Output:

<pre>abcdÄ

=={{header|OCaml}}==

let d = int_of_char c in

d < 32 || d = 127

print_endline (strip is_control_code s);

print_endline (strip (fun c -> (is_control_code c) || (is_extended_char c)) s);

=={{header|Pascal}}==

{{works with|Free_Pascal}}

function Strip (s: string; control, extended: boolean): string;

writeln ('No extnd: ', Strip(test, false, true));

writeln ('ASCII: ', Strip(test, true, true));

Output:

<pre>% ./StripCharacters

=={{header|Peloton}}==

Peloton has a native instruction for removing control codes from a string, SAL, the Low ASCII Strip. From the manual:

- - - - - -

Assign infix <@ LETVARSALVAR>j|i</@> <@ SAYVAR>j</@>

Assign prepend <@ LETSALVARVAR>k|i</@> <@ SAYVAR>k</@>

Peloton also has SAH, High ASCII Strip. Again, from the manual:

Strip high ANSI <@ SAYSAHVAR>i</@>

Assign infix <@ LETVARSAHVAR>j|i</@> <@ SAYVAR>j</@>

Assign prepend <@ LETSAHVARVAR>k|i</@> <@ SAYVAR>k</@>

=={{header|Perl}}==

use strict ;

print "\nWithout extended: " ;

print join( '' , map { chr( $_ ) } @noextended ) ;

Output:

<PRE>before sanitation : �L08&YH�O��n)�:���O�G$���.���"zO���Q�?��

to build a new one character-by-character.<br>

I credited Ada solely for the sensible fromch / toch / abovech idea.

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

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

{{out}}

(desktop/Phix, in a grubby Windows console)

(pwa/p2js)

<pre>

No Control Chars: " abcédef", Length:8

" and no Extended: " abcdef", Length:7

=={{header|PicoLisp}}==

Control characters in strings are written with a hat (^) in PicoLisp. ^? is the DEL character.

(pack

(filter

(filter

'((C) (> "^?" C "^_"))

Test:

<pre>: (char "^?")

=={{header|Pike}}==

> (string)((array)input-enumerate(32)-enumerate(255-126,1,127));

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

stripper: proc options (main);

declare s character (100) varying;

end stripper;

Output:

<pre>

=={{header|PowerShell}}==

function Remove-Character

{

}

}

$test = "$([char]9)Français."

"Extended characters stripped : `"$($test | Remove-Character -Extended)`""

"Control & extended stripped : `"$($test | Remove-Character)`""

{{Out}}

<pre>

Control & extended stripped : "Franais."

</pre>

"Français", "Čeština" | Remove-Character -Extended

{{Out}}

<pre>

=={{header|PureBasic}}==

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

*ptrChar = @source

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

CloseConsole()

Sample output:

<pre>»╫=┐C─≡G(═ç╤â√╝÷╔¬ÿ▌x  è4∞|)ï└⌐ƒ9²òτ┌ºáj)▓<~-vPÿφQ╨ù¿╖îFh"[ü╗dÉ₧q#óé├p╫■

=={{header|Python}}==

=={{header|Racket}}==

#lang racket

;; Works on both strings (Unicode) and byte strings (raw/ASCII)

(define (strip-controls-and-extended str)

(regexp-replace* #rx"[^\040-\176]+" str ""))

=={{header|Raku}}==

{{works with|Rakudo|2018.03}}

say $str;

say $str.subst(/<:Cc>/, '', :g); # unicode property: control character

<pre>kşaNĹĭŗ�|Ęw���"ÄlĄWł8iCƁę��Ż�¬�5ĎĶ'óü¸'ÍŸ;ŢƐ¦�´ŷQċűÒŴ$ÃŅ�Đįð+=ĥƂ+Ōĭħ¼ŕc¤H~ìïēÕ

kşaNĹĭŗ|Ęw"ÄlĄWł8iCƁ꯬5ĎĶ'óü¸'ÍŸ;ŢƐ¦´ŷQċűÒŴ$ÃŅĐįð+=ĥƂ+Ōĭħ¼ŕc¤H~ìïēÕ

===idiomatic version===

This REXX version processes each character in an idiomatic way &nbsp; (if it's a wanted character, then keep it).

z= 'string of ☺☻♥♦⌂, may include control characters and other ♫☼§►↔◄░▒▓█┌┴┐±÷²¬└┬┘ilk.'

@=' !"#$%&''()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~'

say 'old = »»»'z"«««" /*add ««fence»» before & after old text*/

{{out|output}}

<pre>

Because there are &nbsp; (or should be) &nbsp; fewer unwanted characters than wanted characters, this version is faster.

x= 'string of ☺☻♥♦⌂, may include control characters and other ♫☼§►↔◄░▒▓█┌┴┐±÷²¬└┬┘ilk.'

@=' !"#$%&''()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghij' || ,

say 'old = »»»' || x || "«««" /*add ««fence»» before & after old text*/

{{out|output|text=&nbsp; is identical to the 1^st REXX version.}} <br><br>

=={{header|Ring}}==

s = char(31) + "abc" + char(13) + "def" + char(11) + "ghi" + char(10)

see strip(s) + nl

next

return strip

=={{header|Ruby}}==

def strip_control_characters()

chars.each_with_object("") do |char, str|

p s = "\ba\x00b\n\rc\fd\xc3\x7ffoo"

p s.strip_control_characters

{{out}}

=={{header|Run BASIC}}==

print strip$(s$)

end if

next i

<pre>

input : chr$(31)+"abc"+chr$(13)+"def"+chr$(11)+"ghi"+chr$(10)

=={{header|Scala}}==

===ASCII: Using StringOps Class===

val extendedCode : (Char) => Boolean = (c:Char) => (c <= 32 || c > 127)

println( "ctrl and extended filtered out: \n\n" +

{{out}}

<pre>ctrl filtered out:

===Unicode: Using Regular Expressions===

// A Unicode test string

//

val htmlNoExtCode = for( i <- sNoExtCode.indices ) yield

"&#" + sNoExtCode(i).toInt + ";" + (if( (i+1) % 10 == 0 ) "\n" else "")

{{out}}

<pre>ctrl filtered out:

Unicode characters with UTF-8 encoding to the console.

include "utf8.s7i";

writeln("Stripped of control codes and extended characters:");

writeln(stripControlAndExtended(src));

Output:

=={{header|Sidef}}==

var letters = str.chars.map{.ord}

var noextended = nocontrols.grep{ _ < 127 }

{{out}}

<pre>

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

val stripCntrl = concat o String.tokens Char.isCntrl

(* string -> string *)

=={{header|Tcl}}==

regsub -all {[\u0000-\u001f\u007f]+} $str ""

}

proc stripCC str {

regsub -all {[^\u0020-\u007e]+} $str ""

=={{header|TI-83 BASIC}}==

The following "normal characters" do exist, but can't be typed on the calculator and a hex editor must be used to enter them:

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.

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.

:Input ">",Str1

:":"+Str1+":"→Str1

:End

:sub(Str1,2,length(Str1)-1)→Str1

=={{header|TXR}}==

{{trans|Racket}}

(regsub #/[\x0-\x1F\x7F]+/ "" str))

(defun strip-controls-and-extended (str)

=={{header|VBScript}}==

Derived from the BASIC version.

Function StripCtrlCodes(s)

tmp = ""

WScript.StdOut.Write "ab�cd�ef�gh�ij†klð€" & " = " & StripCtrlCodesExtChrs("ab�cd�ef�gh�ij†klð€")

WScript.StdOut.WriteLine

{{Out}}

=={{header|Vlang}}==

{{trans|AutoHotkey}}

println(stripped("\ba\x00b\n\rc\fd\xc3"))

}

for value in source {if value > 31 && value < 128 {result += value.ascii_str()}}

return result

{{Out}}

=={{header|Wren}}==

{{libheader|Wren-pattern}}

var s = "\t\n\r\x01\0\fabc\v\v\b\a\x1f\x7f🌇Páez😃É"

r = p.replaceAll(s, "")

System.print("%(r) -> length %(r.count)")

{{out}}

=={{header|XPL0}}==

string 0; \use zero-terminated string convention

Strip(String, true);

Text(0, String); CrLf(0);

Output:

=={{header|zkl}}==

ASCII

var extdChars=[127..255].pump(String,"toChar");

(test-extdChars).println("<< no extended chars");

(test-extdChars-ctlCodes).println("<< text");

{{out}}

<pre>