String case

Take the string "alphaBETA", and demonstrate how to convert it to UPPER-CASE and lower-case.

4D

$string:="alphaBETA"
$uppercase:=Uppercase($string)
$lowercase:=Lowercase($string)

ActionScript

var string:String = 'alphaBETA';
var upper:String = string.toUpperCase();
var lower:String = string.toLowerCase();

Ada

<ada> with Ada.Characters.Handling; use Ada.Characters.Handling;

with Ada.Text_Io; use Ada.Text_Io;

procedure Upper_Case_String is
   S : String := "alphaBETA";
begin
   Put_Line(To_Upper(S));
   Put_Line(To_Lower(S));
end Upper_Case_String;</ada>

ALGOL 68

# Demonstrate toupper and tolower for standard ALGOL 68 
strings.  This does not work for multibyte character sets. #

PROC to upper = ( CHAR c )CHAR:
(
  IF ABS "a" <= ABS c & ABS c <= ABS "z" THEN
     REPR ( ABS c - ABS "a" + ABS "A" )
  ELSE
     c
  FI
);

PROC to lower = ( CHAR c )CHAR:
(
  IF ABS "A" <= ABS c & ABS c <= ABS "Z" THEN
     REPR ( ABS c - ABS "A" + ABS "a" )
  ELSE
     c
  FI
);

# upper-cases s in place #
PROC str to upper = (REF STRING s)VOID :
(
    FOR i FROM LWB s TO UPB s DO
        s[i] := toupper(s[i])
    OD
);

# lower-cases s in place #
PROC str to lower = (REF STRING s)VOID :
(
    FOR i FROM LWB s TO UPB s DO
        s[i] := tolower(s[i])
    OD
);

main: (
    STRING t := "alphaBETA";
    str to upper(t);
    printf(($"uppercase: "gl$, t));
    str to lower(t);
    printf(($"lowercase: "gl$, t))
)

BASIC

Works with: QuickBasic version 4.5

s$ = "alphaBETA"
PRINT UCASE$(s$)
PRINT LCASE$(s$)

C

Works with: gcc version 3.4.4 (cygming special, gdc 0.12, using dmd 0.125)

Library: libc

 // Demonstrate toupper and tolower for 
 // standard C strings.
 // This does not work for multibyte character sets.
 #include <ctype.h>
 #include <stdio.h>
 
 //upper-cases s in place
 void str_toupper(char *s)
 {
     while(*s)
     {
         *s=toupper(*s);
         s++;
     }
 }
 
 
 //lower-cases s in place
 void str_tolower(char *s)
 {
     while(*s)
     {
         *s=tolower(*s);
         s++;
     }
 }
 
 int main(int argc, char *argv[])
 {
     char t[255]="alphaBETA";
     str_toupper(t);
     printf("uppercase: %s\n", t);
     str_tolower(t);
     printf("lowercase: %s\n", t);
     return 0;
 }

C++

Works with: g++ version 3.4.4 (cygming special)

Library: STL

This method does the transform in-place. Alternate methods might return a new copy or use a stream manipulator.

#include <algorithm>

/// \brief in-place convert string to upper case
/// \return ref to transformed string
void str_toupper(std::string &str) {
  std::transform(str.begin(), 
                 str.end(), 
                 str.begin(),
                 (int(*)(int)) std::toupper);
}

/// \brief in-place convert string to lower case
/// \return ref to transformed string
void str_tolower(std::string &str) {
  std::transform(str.begin(), 
                 str.end(), 
                 str.begin(),
                 (int(*)(int)) std::tolower);
}

Here is sample usage code:

#include <iostream> 

using namespace std;
int main() {
  string foo("_upperCas3Me!!");
  str_toupper(foo);
  cout << foo << endl;
  str_tolower(foo);
  cout << foo << endl;
  return 0;
}

C#

string array = "alphaBETA";
System.Console.WriteLine(array.ToUpper());
System.Console.WriteLine(array.ToLower());

ColdFusion

converting a string literal

<cfset upper = UCase("alphaBETA")>
<cfset lower = LCase("alphaBETA")>

converting the value of a variable

<cfset string = "alphaBETA">
<cfset upper = UCase(string)>
<cfset lower = LCase(string)>

Common Lisp

You can use the string-upcase function to perform upper casing:

CL-USER> (string-upcase "alphaBETA")
"ALPHABETA"

and you can do lower casing by using string-downcase:

CL-USER> (string-downcase "alphaBETA")
"alphabeta"

Delphi

 writeln(uppercase('alphaBETA'));
 writeln(lowercase('alphaBETA'));

E

["alphaBETA".toUpperCase(),
 "alphaBETA".toLowerCase()]

Factor

"alphaBETA" >lower
"alphaBETA" >upper

Forth

ANS Forth does not have words to convert case for either strings or characters. For known alpha-numeric ASCII characters, the following can be used:

: tolower ( C -- c ) 32 or ;
: toupper ( c -- C ) 32 invert and ;
: lower ( addr len -- ) over + swap  do i c@ tolower i c!  loop ;
: upper ( addr len -- ) over + swap  do i c@ toupper i c!  loop ;

If the character range is unknown, these definitions are better:

: tolower ( C -- c ) dup [char] A [char] Z 1+ within if 32 + then ;
: toupper ( c -- C ) dup [char] a [char] z 1+ within if 32 - then ;

Works with: Win32Forth version 4.2

create s ," alphaBETA"
s count type
s count 2dup upper type
s count 2dup lower type

Output:

alphaBETA
ALPHABETA
alphabeta

Haskell

import Data.Char

s = "alphaBETA"

lower = map toLower s
upper = map toUpper s

IDL

str = "alphaBETA"
print, str
print, strupcase(str) 
print, strlowcase(str)

J

upper=: (a.,~a.{~65+i.26) {~ (a.,~a.{~97+i.26) i. ]
lower=: (a.,~a.{~97+i.26) {~ (a.,~a.{~65+i.26) i. ]

For example:

   upper 'alphaBETA'
ALPHABETA
   lower 'alphaBETA'
alphabeta

Java

String str = "alphaBETA";
System.out.println(str.toUpperCase());
System.out.println(str.toLowerCase());

JavaScript

alert( "alphaBETA".toUpperCase() );
alert( "alphaBETA".toLowerCase() );

Output:

ALPHABETA
alphabeta

Works with: NJS version 0.2.5

var string = "alphaBETA";
var uppercase = string.toUpperCase();
var lowercase = string.toLowerCase();

OCaml

let _ =
 let str = "alphaBETA" in
 Printf.printf "%s\n" (String.uppercase str);
 Printf.printf "%s\n" (String.lowercase str);

OpenEdge/Progress

   caps("alphaBETA") 
   lc("alphaBETA")

Perl

Works with: Perl version 5.x

my $string = "alphaBETA";
print uc($string), "\n";
print lc($string), "\n";

Also works in Perl 4 if the my is removed.

Works with: Perl version 6

my $string = "alphaBETA";
say $string.uc
say $string.lc

Pop11

lvars str = 'alphaBETA';
lowertoupper(str) =>
uppertolower(str) =>

Python

s = "alphaBETA"
print s.upper()
print s.lower()

Raven

'alphaBETA' upper
'alhpaBETA' lower

Ruby

Works with: Ruby version 1.8

"alphaBETA".downcase # => "alphabeta"
"alphaBETA".upcase # => "ALPHABETA"
"alphaBETA".swapcase # => "ALPHAbeta"

Scheme

(define s "alphaBETA")
(list->string (map char-upcase (string->list s)))
(list->string (map char-downcase (string->list s)))

Seed7

writeln(upper("alphaBETA"));
writeln(lower("alphaBETA"));

Smalltalk

'ALPHAbeta' asUppercase.
'ALPHAbeta' asLowercase.

Standard ML

val strupr = String.map Char.toUpper;
val strlwr = String.map Char.toLower;

Test

- strupr "alphaBETA";
val it = "ALPHABETA" : string
- strlwr "alphaBETA";
val it = "alphabeta" : string

SQL

Works with: MS SQL version 2005

declare @s varchar(10)
set @s = 'alphaBETA'
print upper(@s)
print lower(@s)

Tcl

set string alphaBETA
string toupper $string
# ==> ALPHABETA
string tolower $string
#==>  alphabeta

Toka

 needs ctype
 
 [ i 1 - ] is i
 [ string.getLength 0 [ dup i + c@ toupper over i + c! ] countedLoop ] is string.toUpper
 [ string.getLength 0 [ dup i + c@ tolower over i + c! ] countedLoop ] is string.toLower
 
 " alphaBETA" string.toUpper type cr
 " alphaBETA" string.toLower type cr