Empty string: Difference between revisions

{{task}}

 

Languages may have features for dealing specifically with empty strings

::*   Demonstrate how to check that a string is empty.

::*   Demonstrate how to check that a string is not empty.

<br><br>

 

 

=={{header|8th}}==

Assign an empty string to a variable:

 

Check that the string is empty:

 

The check for a non-empty string is the same, but with "not" after the n:=

=={{header|ACL2}}==

To check if a string is empty:

 

=={{header|Ada}}==

 

 

function Is_Empty(S: String) return Boolean is

raise Program_Error with "something went wrong very very badly!!!";

end if;

 

=={{header|Aime}}==

s = "";

if (length(s) == 0) {

if (length(s) != 0) {

....

 

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

{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}

STRING s := "";

 

# as a string is an array of characters, we could also test for emptyness by #

# checking for lower bound > upper bound #

 

=={{header|Apex}}==

String.isBlank(record.txt_Field__c);

--Returns true if the specified String is white space, empty (''), or null; otherwise, returns false.

 

=={{header|AppleScript}}==

-- assign empty string to str

set str to ""

-- str is not empty

end if

 

=={{header|AutoHotkey}}==

AutoHotkey has both "Traditional" or literal text, and "Expression" mode.

This code demonstrates the task using both methods.

; Assign an empty string:

var =

; Check that a string is not empty

If (var != "")

 

=={{header|AWK}}==

BEGIN {

# Demonstrate how to assign an empty string to a variable.

print "Is b empty ?",length(b)==0;

print "Is b not empty ?",length(b)!=0;

{{out}}

<pre>$ awk -f R/tmp/string.awk

 

=={{header|Axe}}==

!If length(Str1)

Disp "EMPTY",i

Else

Disp "NOT EMPTY",i

 

=={{header|BASIC}}==

 

20 IF A$="" THEN PRINT "THE STRING IS EMPTY"

30 IF A$<>"" THEN PRINT "THE STRING IS NOT EMPTY"

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

The terminating quote may be left off. By default, strings are initially empty so the assignment is not necessary. Another way to check for an empty string is to use the LEN function.

40 IF LEN (A$) = 0 THEN PRINT "THE STRING IS EMPTY"

 

 

@echo off

 

::Alternatively,

if %var%@ neq @ echo Var is not a blank string.

 

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

var$ = ""

REM Check that a string is not empty:

IF var$ <> "" THEN PRINT "String is not empty"

 

=={{header|Bracmat}}==

There are two ways to assign a string to a variable. The variant using the <code>=</code> operator does not evaluate the value before the assignment, the variant using the <code>:</code> (match) operator does. If the value is a string, there is no difference, as a string always evaluates to itself.

& (b=)

& abra:?c

& !d:~ { neither is d an empty string }

)

 

=={{header|Burlesque}}==

Empty string is <tt>""</tt> and checking for empty strings (or empty lists) can be done with the <tt>nu</tt> command.

 

blsq ) ""

""

blsq ) "a"nu

0

 

=={{header|C}}==

In C the strings are <code>char</code> pointers. A string terminates with the null char (U+0000, <code>'\0'</code>), which is not considered part of the string. Thus an empty string is <code>"\0"</code>, while a null string is a null pointer which points to nothing.

const char *str = "";

/* to test a null string */

if (str) { ... }

/* to test if string is empty */

if (str[0] == '\0') { ... }

/* or compare to a known empty string, same thing. "== 0" means strings are equal */

if (strcmp(str, "") == 0) { ... }

 

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

 

// ...

 

 

if (str.empty()) { ... } // to test if string is empty

// we could also use the following

if (str.length() == 0) { ... }

 

 

 

=={{header|Clojure}}==

(def x "") ;x is "globally" declared to be the empty string

(let [x ""]

(= x "") ;true if x is the empty string

(not= x "") ;true if x is not the empty string

 

=={{header|COBOL}}==

IDENTIFICATION DIVISION.

PROGRAM-ID. EMPTYSTR.

 

STOP RUN.

 

=={{header|CoffeeScript}}==

Empty strings are mostly straightforward in CoffeeScript, but there's one gotcha.

 

isEmptyString = (s) ->

# Returns true iff s is an empty string.

console.log (s = '') == "" # true

console.log new String() == '' # false, due to underlying JavaScript's distinction between objects and primitives

 

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

Common Lisp treats empty strings as true (T in Common Lisp), therefore one must check the length of the string to know if it is empty or not.

(defparameter *s* "") ;; Binds dynamic variable *S* to the empty string ""

(let ((s "")) ;; Binds the lexical variable S to the empty string ""

(= (length s) 0) ;; Check if the string is empty

 

=={{header|Component Pascal}}==

BlackBox Component Builder

MODULE EmptyString;

IMPORT StdLog;

END Do;

END EmptyString.

Execute: ^Q EmptyString.Do<br/>

{{out}}

Is not 's' empty?:> $FALSE

</pre>

=={{header|D}}==

D treats null strings and empty strings as equal on the value level, but different on object level. You need to take this into account when checking for emptiness.

 

bool isEmptyNotNull(in string s) pure nothrow @safe {

assert(s1.empty);

assert(s2.isEmptyNotNull());

 

=={{header|Dart}}==

 

var empty = '';

 

print('it is not empty');

}

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

s := 'abc';

Writeln(StringIsEmpty(s)); // False

 

=={{header|DWScript}}==

 

s := ''; // assign an empty string (can also use "")

 

if s <> '' then

 

 

 

 

=={{header|Elixir}}==

To check whether a given variable holds an empty string, either compare it to the empty string literal, check its length - O(M), or check it's byte size - O(1)).

empty_string = ""

not_empty_string = "a"

byte_size(not_empty_string) == 0

# => false

 

=={{header|Emacs Lisp}}==

 

(if (= 0 (length str))

(message "string is empty"))

(if (/= 0 (length str))

 

Also possible is <code>(string= "" str)</code>.

 

=={{header|Erlang}}==

1> S = "". % erlang strings are actually lists, so the empty string is the same as the empty list [].

[]

4> case "aoeu" of [] -> empty; [H|T] -> not_empty end.

not_empty

 

=={{header|Euphoria}}==

 

-- assign an empty string

if length(s) then

-- string is not empty

 

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

 

[<EntryPoint>]

printfn "Is empty %A: %A" emptyString (emptyString = String.Empty)

printfn "Is not empty %A: %A" emptyString (emptyString <> String.Empty)

{{out}}

<pre>Is empty "": true

Is not empty "": false</pre>

 

=={{header|Fantom}}==

Fantom uses "" to represent an empty string, and provides the isEmpty method to check if a string is empty.

 

a := "" // assign an empty string to 'a'

a.isEmpty // method on sys::Str to check if string is empty

a == "" // alternate check for an empty string

!a.isEmpty // check that a string is not empty

 

=={{header|Forth}}==

Strings are represented as an addr-len pair on the stack. An empty string has len 0.

\ string words operate on the address and count left on the stack by a string

\ ? means the word returns a true/false flag on the stack

: filled? ( c-addr u -- ? ) empty? 0= ;

: ="" ( c-addr u -- ) drop 0 ; \ It's OK to copy syntax from other languages

 

Forth Console Test (True= -1, False=0)

 

Such variables, or text literals, may be passed as a parameter to a subprogram, and it may use the LEN function to ascertain the size of the parameter, which in that sense could be considered a string because CHARACTER parameters are passed with a secret additional parameter, their size, which is available to the LEN function within the subprogram.

CHARACTER*(*) T !This form allows for any size.

IF (LEN(T).LE.0) WRITE(6,*) "Empty!"

TEXT = "" !Fills the entire variable with space characters.

CALL TASTE(TEXT) !Passes all 24 of them. Result is Not empty!

Otherwise, you could employ the Fortran protocol that trailing spaces are irrelevant in text comparisons. Thus <code>TEXT .EQ. ""</code> would give ''true'' even though TEXT might contain thousands of space characters, and so would <code>TEXT .EQ. " "</code> - thus an empty string is one containing nothing other than spaces.

 

 

With F90, compound data aggregates can be defined and as well procedures for operating on them, so that, after a great deal of syntactic struggle, a string data type will be available. F2000 standardised one such scheme whereby character variables are de-allocated and re-allocated with usage so that a statement such as <code>TEXT = "This" // "That"</code> would cause a de-allocation of whatever storage had been associated with TEXT followed by a re-allocation of storage for eight characters, the required size, and LEN(TEXT) would give 8.

 

=={{header|FutureBasic}}==

 

 

 

 

=={{header|Go}}==

In Go variables are always initialized to a provided value or to the "zero value" of the type.

The zero value of a string is the empty string.

var s string

s2 := ""

// check that a string is not empty, any of:

s != ""

 

=={{header|Groovy}}==

assert s.empty

 

s = '1 is the loneliest number'

 

=={{header|Haskell}}==

 

-- In Haskell strings are just lists (of characters), so we can use the function

let s = ""

when (null s) (putStrLn "Empty.")

 

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

Icon and Unicon can produce empty strings in several ways:

s := string('A'--'A') # ... converted from cset difference

s := char(0)[0:0] # ... by slicing

s := &null # NOT a null string, null type

/s # test for null type

 

=={{header|J}}==

 

0=#variable

1

0<#variable

 

Note that J attempts to make no distinction between empty lists, regardless of their type. In other words, while some operations can reveal the type of an empty list (for example, anything that can introduce padding based on the type of the list itself) this distinction is ignored whenever possible. You can perform arithmetic on an empty string, and you can append text to an empty list of numbers even though these operations would not succeed on non-empty lists of the same type.

 

 

Note also that in an <code>if.</code> or <code>while.</code> statement, J treats an empty string (or the absence of any argument) as true.

 

=={{header|Java}}==

<code>String.isEmpty()</code> is part of Java 1.6. Other options for previous versions are noted.

if(s != null && s.isEmpty()){//optionally, instead of "s.isEmpty()": "s.length() == 0" or "s.equals("")"

System.out.println("s is empty");

}else{

System.out.println("s is not empty");

 

=={{header|JavaScript}}==

Create an empty String

 

Boolean expressions representing emptiness

s.length == 0

!s

 

Non-emptiness

s != ""

s.length != 0

s.length > 0

 

=={{header|jq}}==

 

# or:

# or:

 

=={{header|Julia}}==

blank = ""

nonblank = "!"

println("That nonblank is empty is ", isempty(nonblank))

println("That nonblank is not empty is ", !isempty(nonblank))

 

{{out}}

{{trans|J}}

 

0=#variable

1

0<#variable

 

=={{header|Kotlin}}==

 

=={{header|LabVIEW}}==

{{VI solution|LabVIEW_Empty_string.png}}

 

=={{header|Lasso}}==

local(str = string)

local(str = '')

local(str = 'Hello, World!')

#str->size > 0 // true

 

=={{header|LFE}}==

{{trans|Erlang}}

 

> (set str "")

()

> (case "apple" ('() 'empty) ((cons head tail) 'not-empty))

not-empty

 

=={{header|Lhogho}}==

Lhogho is a Logo compiler for Windows and Linux

print empty? :str ;prints 'true'

print not empty? :str ;prints 'false'

 

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

'assign empty string to variable

a$ = ""

if a$<>"" then print "Not empty."

if len(a$)>0 then print "Not empty."

 

=={{header|LOLCODE}}==

The empty string is a false value in LOLCODE, and is thus amenable to use as the condition of an <tt>O RLY?</tt>

 

I HAS A string ITZ ""

OIC

 

 

=={{header|Lua}}==

 

-- test for empty string

if str ~= "" then

print "The string is not empty"

 

=={{header|Maple}}==

s := ""; # Create an empty string

evalb(s = ""); # test if the string is empty

evalb(s <> ""); # test if the string is not empty

 

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

str=""; (*Create*)

str==="" (*test empty*)

str=!="" (*test not empty*)

 

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

 

str = '';

% Demonstrate how to check that a string is empty.

% Demonstrate how to check that a string is not empty.

~isempty(str)

 

=={{header|Maxima}}==

 

/* check using string contents */

/* check using string length */

slength(s) = "";

 

=={{header|Mirah}}==

empty_string2 = String.new

 

puts "empty string is empty" if empty_string1.isEmpty()

puts "empty string has no length" if empty_string2.length() == 0

 

=={{header|Nemerle}}==

Assign an empty string:

Check if a string is empty/not empty:

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols binary

 

 

return

{{out}}

<pre>

 

=={{header|Nim}}==

 

if x == "":

echo "empty"

if x.len > 0:

 

=={{header|oberon-2}}==

{{works with|oo2c version 2}}

MODULE EmptyString;

IMPORT Out;

Out.String("checking str[0] = 0X. Is Empty? ");Out.Bool(str[0] = 0X);Out.Ln;

END EmptyString.

{{out}}

<pre>

 

=={{header|Objeck}}==

s := "";

if(s->IsEmpty()) {

"s is not empty"->PrintLine();

};

 

=={{header|OCaml}}==

 

(s = "")

 

Printf.printf "s1 empty? %B\n" (is_string_empty s1);

Printf.printf "s2 empty? %B\n" (is_string_empty s2);

 

{{out}}

isEmpty can be used on all collections, not only strings.

 

 

 

 

 

=={{header|ooRexx}}==

should work with each and every REXX interpreter/compiler.

w=' '

if v=='' Then Say 'v contains the empty string'<

If length(w)>0 Then Say 'Variable w does not contain the empty string'

{{out}}

<pre>v contains the empty string

Variable w does not contain the empty string

this is not a good test</pre>

 

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

isEmpty(s)=s=="" \\ Alternately:

isEmpty(s)=#s==0

isNonempty(s)=s!="" \\ Alternatively:

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

print "The string is empty";

}

if ($s ne "") { # Test for non empty string

print "The string is not empty";

 

In Perl, an empty string is often used to represent a false value.

if ($s) { ... } # false

 

# but a string that converts to number 0 is not always false, though:

$s = "0 but true";

 

=={{header|Phix}}==

 

 

 

=={{header|PHP}}==

 

$str = ''; // assign an empty string to a variable

 

if (strlen($str) == 0) { ... }

 

=={{header|PicoLisp}}==

The empty string is represented by '[http://software-lab.de/doc/ref.html#nilSym NIL]' in PicoLisp. During input, two subsequent double quotes '""' return the symbol NIL.

(off String)

(setq String "")

(and String ..)

(if String ..)

 

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

s = ''; /* assign an empty string to a variable. */

if length(s) = 0 then ... /* To test whether a string is empty */

if length(s) > 0 then ... /* to test for a non-empty string */

 

 

<pre>

False

</pre>

 

=={{header|Prolog}}==

{{works with|SWI-Prolog|7}}

 

is_empty_string(String) :- String == "".

not_empty_string(String) :- String \== "".

 

=={{header|PureBasic}}==

In PureBasic we can just test a string for truth to determine if it has a value.

If a

ProcedureReturn "String is not empty, it contains '" + a + "'."

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

CloseConsole()

{{out}}

<pre>String is empty, or null.

 

=={{header|Python}}==

 

 

 

if (s == '') cat('Empty\n')

if (s != '') cat('Not empty\n')

#or

 

=={{header|Racket}}==

 

 

(define empty-string "")

(define (string-null? s) (string=? "" s))

 

=={{header|Rascal}}==

if (s=="") print("string s is empty");

if (s!="") print("string s is not empty");

Or the build-in operator:

if (isEmpty(s)) print("string s is empty");

 

=={{header|Retro}}==

Create an empty string and assign it to a variable. In these '''keepString''' is used to ensure that the string is permanent.

( by creating a variable )

"" keepString variable: foo

( by setting an existing variable 'foo' )

"" keepString !foo

 

Checking that a string is empty. A string with a length of zero is assumed to be empty.

 

: emtpy? ( $-f ) getLength 0 = ;

 

"" empty? putn

"hello" empty? putn

 

Check that a string is not empty.

 

: notEmpty? ( $-f ) getLength 0 > ;

 

"" notEmpty? putn

"hello" notEmpty? putn

 

=={{header|REXX}}==

 

/*─────────────── 3 simple ways to assign an empty string to a variable.*/

if length(cod)\=0 then fish=cod /*a not-as-fast compare. */

 

 

=={{header|Ring}}==

cStr = NULL # empty string

if cStr = NULL

see "cstr is not empty string!" + nl

ok

=={{header|Ruby}}==

 

Create an empty string

s = String.new

 

These expressions all evaluate to true to determine emptiness:

s.eql?("")

s.empty?

 

# also silly things like

 

Non-empty expressions, in addition to simply negating the above expressions:

s.length > 0

 

Note that we can '''not''' do the following, because the empty string is equivalent to true in Ruby ([[Boolean values#Ruby]]):

 

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

' --------------

'empty string

' -------------

if var$<>"" then print "String Not empty."

 

=={{header|Scala}}==

val s=""

// check that string is empty

s.nonEmpty // false

s!="" // false

 

=={{header|Scheme}}==

(define (string-null? s) (string=? "" s))

 

=={{header|Seed7}}==

s := ""

 

 

# check that string is not empty

 

=={{header|Self}}==

"Put an empty string in a slot called 'str'"

str: ''.

"Check that string is not empty"

 

=={{header|Sidef}}==

Create an empty string:

 

These expressions all evaluate to true to determine emptiness:

s.length == 0;

s.is_empty;

s ~~ /^\z/;

 

Non-empty expressions, in addition to simply negating the above expressions:

s.length > 0;

s ~~ /./s;

 

=={{header|Smalltalk}}==

 

"Check that string is empty"

 

"Check that string is not empty"

 

=={{header|SNOBOL4}}==

An assignment statement with nothing to the right of the <tt>=</tt> operator assigns the empty string (or, as it is more commonly called in SNOBOL, the null string).

X =

* CHECK THAT X IS INDEED NULL

YES OUTPUT = 'NULL'

END

{{out}}

<pre>NULL</pre>

 

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

val s = ""

(* Check that a string is empty*)

s = ""

(* Check that a string is nonempty *)

 

=={{header|Swift}}==

if s.isEmpty { // alternately, s == ""

println("s is empty")

} else {

println("s is not empty")

 

=={{header|Tcl}}==

The only special position that the empty string has in Tcl is that a great many commands return it, and the REPL of [[tclsh]] and [[wish]] doesn't print it. Otherwise, it is just like any other value.

if {$s eq ""} {puts "s contains an empty string"}

There are other ways to check for emptiness and non-emptiness too (though the above are favored for reasons of simplicity, clarity and speed):

if {[string length $s] == 0} {puts "is empty"}

 

=={{header|TorqueScript}}==

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

s=""

IF (s=="") PRINT "s is an empty string"

IF (s!="") PRINT "s is a non-empty string"

{{out}}

<pre>

====Pattern Matching====

 

 

If <code>a</code> is unbound, a binding is created, containing the empty string.

====TXR Lisp====

 

 

(if (equal a "")

 

(if (zerop (length a))

 

=={{header|UNIX Shell}}==

 

s=""

 

# examine the length of the string

if [ -z "$s" ]; then echo "the string has length zero: it is empty"; fi

 

When using comparison operators, it is crucial to double-quote the variable within the conditional expression. This will ensure the shell sees the correct number of arguments. For example, if one were to write <tt>[ $s = "" ]</tt>, then after variable substitition, the shell will try to evaluate <tt>[ = "" ]</tt> which is a syntax error.

 

=={{header|Ursa}}==

set s ""

 

else

out "not empty" endl console

 

=={{header|VBA}}==

dim s as string

 

s = ""

 

' test if a string is empty:

'or:

if Len(s) > 0 then Debug.Print "not empty."

 

=={{header|XPL0}}==

string 0; \use zero-terminated convention, instead of MSb set

char S;

if S(0) # 0 then Text(0, "not empty

");

 

=={{header|zkl}}==

s.toBool() //-->False

 

=={{header|ZX Spectrum Basic}}==

:''See [[#BASIC|BASIC]]''

 

{{omit from|GUISS}}