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

```fsharp

let s = "alphaBETA"
let upper = s.ToUpper()
let lower = s.ToLower()

Factor

"alphaBETA" >lower  ! "alphabeta"
"alphaBETA" >upper  ! "ALPHABETA"
"alphaBETA" >title  ! "Alphabeta"
"ß" >case-fold      ! "ss"

Falcon

printl("alphaBETA".lower())
printl("alphaBETA".upper())

Fantom

fansh> a := "alphaBETA"
alphaBETA
fansh> a.upper // convert whole string to upper case
ALPHABETA
fansh> a.lower // convert whole string to lower case
alphabeta
fansh> a.capitalize  // make sure first letter is capital
AlphaBETA
fansh> "BETAalpha".decapitalize  // make sure first letter is not capital
bETAalpha

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

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

Output:

alphaBETA ALPHABETA alphabeta

Fortran

{{works with|Fortran|90 and later}}

 program example

   implicit none

   character(9) :: teststring = "alphaBETA"

   call To_upper(teststring)
   write(*,*) teststring
   call To_lower(teststring)
   write(*,*) teststring

 contains

   subroutine To_upper(str)
     character(*), intent(in out) :: str
     integer :: i

     do i = 1, len(str)
       select case(str(i:i))
         case("a":"z")
           str(i:i) = achar(iachar(str(i:i))-32)
       end select
     end do
   end subroutine To_upper

   subroutine To_lower(str)
     character(*), intent(in out) :: str
     integer :: i

     do i = 1, len(str)
       select case(str(i:i))
         case("A":"Z")
           str(i:i) = achar(iachar(str(i:i))+32)
       end select
     end do
   end subroutine To_Lower

 end program example

Functions could be used instead, especially with later compilers that enable lengths not fixed at compile time, but this involves copying the text about. By contrast, the subroutines alter the text in-place, though if something like Utext = Uppercase(text) is desired so that both versions are available, a subroutine is less convenient.

F90 introduced the intrinsic function i = I'''A'''CHAR(c), which returns the integer value of the position of character c ''in the'' '''ASCII''' character set, even if the processor's default character set is different, such as perhaps '''EBCDIC'''. Function ACHAR is the inverse. If the bit pattern of the character was not being interpreted as in the ASCII set, this will cause odd results, say on a system using EBCDIC or (on an ASCII-using cpu) for a file originating from an EBCDIC-using system. Some systems offer additional options to the file OPEN statement that enable character conversion between ASCII and EBCDIC, and there may also be options concerning big- and little-endian usage. But much will depend on the format of the data in the file. If the data are a mixture of text, integers, floating-point, ''etc.'' all in binary, there will be no hope for such simple translations.

For converting lower-case text to upper, the following will work both on an ASCII system and an EBCDIC system (or any other encodement), once it is compiled for that system:

      SUBROUTINE UPCASE(TEXT)
       CHARACTER*(*) TEXT
       INTEGER I,C
        DO I = 1,LEN(TEXT)
          C = INDEX("abcdefghijklmnopqrstuvwxyz",TEXT(I:I))
          IF (C.GT.0) TEXT(I:I) = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"(C:C)
        END DO
      END

The INDEX function of course returning zero if the character is not found. Converting from upper to lower case is the obvious inverse and it might be worthwhile defining a MODULE with suitable named character constants to avoid repetition - one might hope the compiler will share duplicated constants rather than producing a fresh version every time, but it might not too. The repeated text scanning done by the INDEX function for each character of TEXT will of course be a lot slower. A still-more advanced compiler might be able to take advantage of special translation op-codes, on systems that offer them. If storage space is not at a premium a swifter method would be to create something like CHARACTER*1 XLATUC(0:255) with most entries being equal to their index, except for those corresponding to the lower case letters for which the value is the corresponding upper case letter. Then

      DO I = 1,LEN(TEXT)
        TEXT(I:I) = XLATUC(ICHAR(TEXT(I:I)))
      END DO

Note that in EBCDIC the offset is not 32 but 64. Rather than using an undocumented "magic constant" such as 32, one could define PARAMETER (HIC = ICHAR("A") - ICHAR("a")) instead or just place such code in-line and have hope for the compiler. This would also handle the small detail that "A" > "a" in EBCDIC rather than ASCII's "A" < "a". But alas, in EBCDIC the letter codes are ''not'' contiguous (there are many non-letter symbols between "a" and "z" as well as between "A" and "Z"), so the bounds of "A" to "Z" will ''not'' isolate only letters for attack. And it was not just IBM mainframes that used various versions of EBCDIC, so also did Burroughs, among others.

Here a complete example, using functions, and as far as I can tell, will work also with EBCDIC:

module uplow
   implicit none
   character(len=26), parameter, private :: low  = "abcdefghijklmnopqrstuvwxyz"
   character(len=26), parameter, private :: high = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
contains

   function to_upper(s) result(t)
      ! returns upper case of s
      implicit none
      character(len=*), intent(in) :: s
      character(len=len(s))        :: t

      character(len=1), save       :: convtable(0:255)
      logical, save                :: first = .true.
      integer                      :: i

      if(first) then
         do i=0,255
            convtable(i) = char(i)
         enddo
         do i=1,len(low)
            convtable(iachar(low(i:i))) = char(iachar(high(i:i)))
         enddo
         first = .false.
      endif

      t = s

      do i=1,len_trim(s)
         t(i:i) = convtable(iachar(s(i:i)))
      enddo

   end function to_upper

   function to_lower(s) result(t)
      ! returns lower case of s
      implicit none
      character(len=*), intent(in) :: s
      character(len=len(s))        :: t

      character(len=1), save :: convtable(0:255)
      logical, save          :: first = .true.
      integer                :: i

      if(first) then
         do i=0,255
            convtable(i) = char(i)
         enddo
         do i = 1,len(low)
            convtable(iachar(high(i:i))) = char(iachar(low(i:i)))
         enddo
         first = .false.
      endif

      t = s

      do i=1,len_trim(s)
         t(i:i) = convtable(iachar(s(i:i)))
      enddo

   end function to_lower


end module uplow


program doit
   use uplow
   character(len=40) :: s

   s = "abcdxyz ZXYDCBA _!@"
   print *,"original: ",'[',s,']'
   print *,"to_upper: ",'[',to_upper(s),']'
   print *,"to_lower: ",'[',to_lower(s),']'

end program doit

FreeBASIC

' FB 1.05.0 Win64

Dim s As String = "alphaBETA"
Print UCase(s)
Print LCase(s)
Sleep

{{out}}

ALPHABETA
alphabeta

Frink

a = "alphaBETA"
println[lc[a]]
println[uc[a]]

These functions use Unicode single- and multiple-character mapping tables and thus try to do the right thing with Unicode, possibly making the string longer in some cases:

uc["Imbiß"] // Last char is \u00df

Produces:

IMBISS

As the Unicode standard for casing states, "it is important to note that no casing operations on strings are reversible:"

lc[ uc["Imbiß"] ]

imbiss

FutureBasic

include "ConsoleWindow"

dim as Str255 a

a = "alphaBETA"

print a
print ucase$(a)
fn lcase(a)
print a

Output:

alphaBETA
ALPHABETA
alphabeta

Gambas

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

Public Sub Main()
Dim sString As String = "alphaBETA "

Print UCase(sString)
Print LCase(sString)

End

Output:

ALPHABETA
alphabeta

GAP

LowercaseString("alphaBETA");
UppercaseString("alphaBETA");

GML

#define cases
{
    x = 'alphaBETA';
    y = string_upper(x); // returns ALPHABETA
    z = string_lower(x); // returns alphabeta
    show_message(y);
    show_message(z);
}

Go

"Title case" in Go's Unicode package does not mean capitalize the first letter of each word, but rather capitalize each letter as if it were the first letter of a word. The distinction matters in languages such as Croatian with digraphs with a capitialized form that is different from the all-caps form. ToTitle() converts a string to all title case.

It is Title() on the other hand, that capitalizes the first letter of each word. It identifies word boundaries and capitalizes first letters, leaving other letters unmodified. As of Go 1.2 though, the word breaking algorithm is not Unicode compliant.

package main

import (
    "fmt"
    "strings"
    "unicode"
    "unicode/utf8"
)

func main() {
    show("alphaBETA")
    show("alpha BETA")
    // Three digraphs that should render similar to DZ, Lj, and nj.
    show("DŽLjnj")
    // Unicode apostrophe in third word.
    show("o'hare O'HARE o’hare don't")
}

func show(s string) {
    fmt.Println("\nstring:         ",
        s, " len:", utf8.RuneCountInString(s), "runes") // DZLjnj
    fmt.Println("All upper case: ", strings.ToUpper(s)) // DZLJNJ
    fmt.Println("All lower case: ", strings.ToLower(s)) // dzljnj
    fmt.Println("All title case: ", strings.ToTitle(s)) // DzLjNj
    fmt.Println("Title words:    ", strings.Title(s))   // Dzljnj
    fmt.Println("Swapping case:  ",                     // DzLjNJ
        strings.Map(unicode.SimpleFold, s))
}

Output:

string:          alphaBETA  len: 9 runes
All upper case:  ALPHABETA
All lower case:  alphabeta
All title case:  ALPHABETA
Title words:     AlphaBETA
Swapping case:   ALPHAbeta

string:          alpha BETA  len: 10 runes
All upper case:  ALPHA BETA
All lower case:  alpha beta
All title case:  ALPHA BETA
Title words:     Alpha BETA
Swapping case:   ALPHA beta

string:          DŽLjnj  len: 3 runes
All upper case:  DŽLJNJ
All lower case:  džljnj
All title case:  DžLjNj
Title words:     DžLjnj
Swapping case:   DžljNJ

string:          o'hare O'HARE o’hare don't  len: 26 runes
All upper case:  O'HARE O'HARE O’HARE DON'T
All lower case:  o'hare o'hare o’hare don't
All title case:  O'HARE O'HARE O’HARE DON'T
Title words:     O'Hare O'HARE O’hare Don'T
Swapping case:   O'HARE o'hare O’HARE DON'T

Groovy

def str = 'alphaBETA'

println str.toUpperCase()
println str.toLowerCase()

Output:

ALPHABETA
alphabeta

Haskell

import Data.Char

s = "alphaBETA"

lower = map toLower s
upper = map toUpper s

HicEst

CHARACTER str = "alphaBETA"
EDIT(Text=str, UpperCase=LEN(str))
EDIT(Text=str, LowerCase=LEN(str))
EDIT(Text=str, UpperCase=1)

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

procedure main()
    write(map("alphaBETA"))
    write(map("alphaBETA",&lcase,&ucase))
end

IDL

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

J

Use standard utilities:

   toupper 'alphaBETA'
ALPHABETA
   tolower 'alphaBETA'
alphabeta

or alternative definitions:

upper=: {&((65+i.26) +&32@[} i.256)&.(a.&i.)
lower=: {&((97+i.26) -&32@[} i.256)&.(a.&i.)

For example:

   upper 'alphaBETA'
ALPHABETA
   lower 'alphaBETA'
alphabeta

Java

String str = "alphaBETA";
System.out.println(str.toUpperCase());
System.out.println(str.toLowerCase());
//Also works with non-English characters with no modification
System.out.println("äàâáçñßæεбế".toUpperCase());
System.out.println("ÄÀÂÁÇÑSSÆΕБẾ".toLowerCase()); //does not transalate "SS" to "ß"

You could also easily create a swapCase method using Character.isLowerCase(), Character.isUpperCase(), and Character.isLetter().

JavaScript

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

Output: ALPHABETA alphabeta

{{works with|NJS| 0.2.5}}

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

jq

If your version of jq does not have ascii_downcase and ascii_upcase, then you might want to use their definitions:

# like ruby's downcase - only characters A to Z are affected
def ascii_downcase:
  explode | map( if 65 <= . and . <= 90 then . + 32  else . end) | implode;

# like ruby's upcase - only characters a to z are affected
def ascii_upcase:
  explode | map( if 97 <= . and . <= 122 then . - 32  else . end) | implode;

'''Examples''':

"alphaBETA" | ascii_upcase
#=> "ALPHABETA"

"alphaBETA" | ascii_downcase
#=> "alphabeta"

Jsish

var msg = "alphaBETA";
;msg;
;msg.toUpperCase();
;msg.toLowerCase();

;msg.toTitle();
;msg.toLocaleUpperCase();
;msg.toLocaleLowerCase();

{{out}}

prompt$ jsish --U string-case.jsi
msg ==> alphaBETA
msg.toUpperCase() ==> ALPHABETA
msg.toLowerCase() ==> alphabeta
msg.toTitle() ==> Alphabeta
msg.toLocaleUpperCase() ==> ALPHABETA
msg.toLocaleLowerCase() ==> alphabeta

Julia

 uppercase("alphaBETA")
"ALPHABETA"

julia> lowercase("alphaBETA")
"alphabeta"

K

  s:"alphaBETA"
  upper:{i:_ic x; :[96<i; _ci i-32;_ci i]}'
  lower:{i:_ic x; :[91>i; _ci i+32;_ci i]}'
  upper s
"ALPHABETA"
  lower s
"alphabeta"

Kotlin

// version 1.0.6

fun main(args: Array<String>) {
    val s = "alphaBETA"
    println(s.toUpperCase())
    println(s.toLowerCase())
    println(s.capitalize())
    println(s.decapitalize())
}

{{out}}

ALPHABETA
alphabeta
AlphaBETA
alphaBETA

Lasso

// Direct string return
'alphaBETA'->uppercase&
'alphaBETA'->lowercase&

// Assignment and manipulation of variables
local(toupper = 'alphaBETA')
#toupper->uppercase
#toupper

local(tolower = 'alphaBETA')
#tolower->lowercase
#tolower

Lingo

Lingo has no case conversion functions, but for ASCII strings they can e.g. be implemented like this:

----------------------------------------
-- Lower to upper case (ASCII only)
-- @param {string} str
-- @return {string}
----------------------------------------
on toUpper (str)
  alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  len = str.length
  repeat with i = 1 to len
    pos = offset(str.char[i], alphabet)
    if pos > 0 then put alphabet.char[pos] into char i of str
  end repeat
  return str
end

----------------------------------------
-- Upper to lower case (ASCII only)
-- @param {string} str
-- @return {string}
----------------------------------------
on toLower (str)
  alphabet = "abcdefghijklmnopqrstuvwxyz"
  len = str.length
  repeat with i = 1 to len
    pos = offset(str.char[i], alphabet)
    if pos > 0 then put alphabet.char[pos] into char i of str
  end repeat
  return str
end

put toUpper("alphaBETA")
-- "ALPHABETA"

put toLower("alphaBETA")
-- "alphabeta"

LiveCode

put upper("alphaBETA") && lower("alphaBETA")
ALPHABETA alphabeta

Logo

print uppercase "alphaBETA ; ALPHABETA print lowercase "alphaBETA ; alphabeta

Lua

str = "alphaBETA"
print( string.upper(str) )
print( string.lower(str) )

M4

define(`upcase', `translit(`$*', `a-z', `A-Z')')
define(`downcase', `translit(`$*', `A-Z', `a-z')')

define(`x',`alphaBETA')
upcase(x)
downcase(x)

Maple

str := "alphaBETA";
StringTools:-UpperCase(str);
StringTools:-LowerCase(str);

produces

     alphabeta

     ALPHABETA

Mathematica

str="alphaBETA";
ToUpperCase[str]
ToLowerCase[str]

gives:

 ALPHABETA
 alphabeta

MATLAB

 upper('alphaBETA')

ans =

ALPHABETA

>> lower('alphaBETA')

ans =

alphabeta

Maxima

supcase('alphaBETA');
sdowncase('alphaBETA');

MAXScript

Requires MAX 2008

str = "alphaBETA"
print (toUpper str)
print (toLower str)

Mercury

The functions to_upper/1, to_lower/1, capitalize_first/1 and uncapitalize_first/1 only affect unaccented Latin characters.

:- module string_case. :- interface.

:- import_module io. :- pred main(io::di, io::uo) is det.

:- implementation. :- import_module list, string.

main(!IO) :- S = "alphaBETA", io.format("uppercase : %s\n", [s(to_upper(S))], !IO), io.format("lowercase : %s\n", [s(to_lower(S))], !IO), io.format("capitalize first: %s\n", [s(capitalize_first(S))], !IO). % We can use uncaptitalize_first/1 to ensure the first character in a % string is lower-case.

## Metafont

We need to implement it, since it is not already given; the following code works only for ASCII or ASCII based encodings. (It could work anyway also for single byte encodings where letters are contiguous).


```metafont
vardef isbetween(expr a, i, f) =
  if string a:
    if (ASCII(a) >= ASCII(i)) and (ASCII(a) <= ASCII(f)):
      true
    else:
      false
    fi
  else:
    false
  fi enddef;

vardef toupper(expr s) =
  save ?; string ?; ? := ""; d := ASCII"A" - ASCII"a";
  for i = 0 upto length(s)-1:
    if isbetween(substring(i, i+1) of s, "a", "z"):
      ? := ? & char(ASCII(substring(i,i+1) of s) + d)
    else:
      ? := ? & substring(i, i+1) of s
    fi;
  endfor
  ?
enddef;

vardef tolower(expr s) =
  save ?; string ?; ? := ""; d := ASCII"a" - ASCII"A";
  for i = 0 upto length(s)-1:
    if isbetween(substring(i, i+1) of s, "A", "Z"):
      ? := ? & char(ASCII(substring(i,i+1) of s) + d)
    else:
      ? := ? & substring(i, i+1) of s
    fi;
  endfor
  ?
enddef;

message toupper("alphaBETA");
message tolower("alphaBETA");

end

min

{{works with|min|0.19.3}}

"alphaBETA" uppercase
"alphaBETA" lowercase
"alphaBETA" capitalize

MiniScript

mixedString = "alphaBETA"
print "Upper Case of " + mixedString + " is " + mixedString.upper
print "Lower Case of " + mixedString + " is " + mixedString.lower

{{out}}

Upper Case of alphaBETA is ALPHABETA
Lower Case of alphaBETA is alphabeta

mIRC Scripting Language

echo -ag $upper(alphaBETA)
echo -ag $lower(alphaBETA)

=={{header|Modula-3}}==

MODULE TextCase EXPORTS Main;

IMPORT IO, Text, ASCII;

PROCEDURE Upper(txt: TEXT): TEXT =
  VAR
    len := Text.Length(txt);
    res := "";
  BEGIN
    FOR i := 0 TO len - 1 DO
      res := Text.Cat(res, Text.FromChar(ASCII.Upper[Text.GetChar(txt, i)]));
    END;
    RETURN res;
  END Upper;

PROCEDURE Lower(txt: TEXT): TEXT =
  VAR
    len := Text.Length(txt);
    res := "";
  BEGIN
    FOR i := 0 TO len - 1 DO
      res := Text.Cat(res, Text.FromChar(ASCII.Lower[Text.GetChar(txt, i)]));
    END;
    RETURN res;
  END Lower;

BEGIN
  IO.Put(Upper("alphaBETA\n"));
  IO.Put(Lower("alphaBETA\n"));
END TextCase.

Output:

ALPHABETA
alphabeta

MUMPS

STRCASE(S)
 SET UP="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 SET LO="abcdefghijklmnopqrstuvwxyz"
 WRITE !,"Given: "_S
 WRITE !,"Upper: "_$TRANSLATE(S,LO,UP)
 WRITE !,"Lower: "_$TRANSLATE(S,UP,LO)
 QUIT

Output:

USER>DO STRCASE^ROSETTA("alphaBETA")

Given: alphaBETA
Upper: ALPHABETA
Lower: alphabeta

Nemerle

using System.Console;
using System.Globalization;

module StringCase
{
    Main() : void
    {
        def alpha = "alphaBETA";
        WriteLine(alpha.ToUpper());
        WriteLine(alpha.ToLower());

        WriteLine(CultureInfo.CurrentCulture.TextInfo.ToTitleCase("exAmpLe sTrinG"));

    }
}

NetRexx

/* NetRexx */

options replace format comments java crossref savelog symbols

abc = 'alphaBETA'

say abc.upper
say abc.lower
say abc.upper(1, 1) -- capitalize 1st character

NewLISP

(upper-case "alphaBETA")
(lower-case "alphaBETA")

Nial

toupper 'alphaBETA'
=ALPHABETA
tolower 'alphaBETA'
=alphabeta

Nim

import strutils

var s: string = "alphaBETA_123"
echo s," as upper case: ", toUpper(s)
echo s," as lower case: ", toLower(s)
echo s," as Capitalized: ", capitalize(s)
echo s," as normal case: ", normalize(s)  # remove underscores, toLower

{{out}}

alphaBETA_123 as upper case: ALPHABETA_123
alphaBETA_123 as lower case: alphabeta_123
alphaBETA_123 as Capitalized: AlphaBETA_123
alphaBETA_123 as normal case: alphabeta123

Objeck

string := "alphaBETA";
string->ToUpper()->PrintLine();
string->ToLower()->PrintLine();

=={{header|Objective-C}}== {{works with|GNUstep}} {{works with|Cocoa}}

NSLog(@"%@", @"alphaBETA".uppercaseString);
NSLog(@"%@", @"alphaBETA".lowercaseString);

NSLog(@"%@", @"foO BAr".capitalizedString); // "Foo Bar"

OCaml

let () =
  let str = "alphaBETA" in
  print_endline (String.uppercase_ascii str); (* ALPHABETA *)
  print_endline (String.lowercase_ascii str); (* alphabeta *)

  print_endline (String.capitalize_ascii str); (* AlphaBETA *)
;;

Octave

s = "alphaBETA";
slc = tolower(s);
suc = toupper(s);
disp(slc);
disp(suc);

Oforth

"alphaBETA" toUpper
"alphaBETA" toLower

OpenEdge/Progress

<lang Progress (OpenEdge ABL)>caps("alphaBETA") lc("alphaBETA")

## Oz

Convert to upper/lower-case:

```oz
declare
  Str = "alphaBETA"
in
  {System.showInfo {Map Str Char.toUpper}}
  {System.showInfo {Map Str Char.toLower}}

Capitalize:

declare
  [StringX] = {Link ['x-oz://system/String.ozf']}
in
  {System.showInfo {StringX.capitalize "alphaBETA"}} %% prints "AlphaBETA"

Pascal

// Uppercase and Lowercase functions for a minimal standard Pascal
// where no library routines for these operations exist
PROGRAM upperlower;

// convert a character to uppercase
FUNCTION uch(ch: CHAR): CHAR;
	BEGIN
		uch := ch;
		IF ch IN ['a'..'z'] THEN
			uch := chr(ord(ch) AND $5F);
	END;

// convert a character to lowercase
FUNCTION lch(ch: CHAR): CHAR;
	BEGIN
		lch := ch;
		IF ch IN ['A'..'Z'] THEN
			lch := chr(ord(ch) OR $20);
	END;

// toggle uper/lower case character
FUNCTION ulch(ch: CHAR): CHAR;
	BEGIN
		ulch := ch;
		IF ch IN ['a'..'z'] THEN ulch := uch(ch);
		IF ch IN ['A'..'Z'] THEN ulch := lch(ch);
	END;

// convert a string to uppercase
FUNCTION ucase(str: STRING): STRING;
	var i: Integer;
	BEGIN
		ucase := '';
		FOR i := 1 TO Length(str) DO
			ucase := ucase + uch(str[i]);
	END;

// convert a string to lowercase
FUNCTION lcase(str: STRING): STRING;
	var i: Integer;
	BEGIN
		lcase := '';
		FOR i := 1 TO Length(str) DO
			lcase := lcase + lch(str[i]);
	END;

// reverse cases in a given string
FUNCTION ulcase(str: STRING): STRING;
	var i: Integer;
	BEGIN
		ulcase := '';
		FOR i := 1 TO Length(str) DO
			ulcase := ulcase + ulch(str[i]);
	END;

VAR
	ab : STRING = 'alphaBETA';

BEGIN
	// demonstration
	Writeln('Original string : ',ab);
	Writeln('Reversed case   : ',ulcase(ab));
	Writeln('Upper case      : ',ucase(ab));
	Writeln('Lower case      : ',lcase(ab));
END.

Demonstration:

Original string : alphaBETA
Reversed case   : ALPHAbeta
Upper case      : ALPHABETA
Lower case      : alphabeta

Peloton

Iterating through the peerset

<@ ENU$$$LSTPSTLITLIT>UPP|
[<@ SAYELTLST>...</@>] <@ SAYHLPELTLST>...</@><@ DEFKEYELTLST>__SuperMacro|...</@>
<@ SAY&&&LIT>alphaBETA</@>

</@>

Same code in padded-out, variable-length English dialect

UPP|
[<# SAY ELEMENT LIST>...</#>] <# SAY HELP ELEMENT LIST>...</#><# DEFINE KEYWORD ELEMENT LIST>__SuperMacro|...</#>
<# SAY SUPERMACRO LITERAL>alphaBETA</#>

</#>

Output.

[FLC] 410400001 Flip case (410400001)  [Transformers^Abstract type transforms^Text transformers^Platform relative encoding and encrypting]
ALPHAbeta

[LOW] 410400002 Lower case (410400002)  [Transformers^Abstract type transforms^Text transformers^Platform relative encoding and encrypting]
alphabeta

[PRP] 410400003 Proper Case (410400003)  [Transformers^Abstract type transforms^Text transformers^Platform relative encoding and encrypting]
Alphabeta

[SNT] 410400004 Sentence case (410400004)  [Transformers^Abstract type transforms^Text transformers^Platform relative encoding and encrypting]
Alphabeta

[UPP] 410400005 Upper case (410400005)  [Transformers^Abstract type transforms^Text transformers^Platform relative encoding and encrypting]
ALPHABETA

Perl

{{works with|Perl|5.x}}

my $string = "alphaBETA";
print uc($string), "\n"; # => "ALPHABETA"
print lc($string), "\n"; # => "alphabeta"
$string =~ tr/[a-z][A-Z]/[A-Z][a-z]/; print "$string\n"; # => ALPHAbeta

print ucfirst($string), "\n"; # => "AlphaBETA"
print lcfirst("FOObar"), "\n"; # => "fOObar"

Also works in Perl 4 if the '''my''' is removed.

Perl 6

In Perl 6, case modification is implemented as builtin subroutine or method:

my $word = "alpha BETA" ;
say uc $word;         # all uppercase (subroutine call)
say $word.uc;         # all uppercase (method call)
# from now on we use only method calls as examples
say $word.lc;         # all lowercase
say $word.tc;         # first letter titlecase
say $word.tclc;       # first letter titlecase, rest lowercase
say $word.wordcase;   # capitalize each word

Output:

ALPHA BETA
alpha beta
Alpha BETA
Alpha beta
Alpha Beta

Phix

constant s = "alphaBETA"
?upper(s)
?lower(s)

There is also a bespoke convertCase function in demo\Edix\Edix.exw which accepts five operators: LOWER, UPPER, CAPITALISE, SENTENCE, and INVERT, which is obviously not part of the language, and a bit too long, messy, ugly, and unedifying, to bother reproducing here.

PHP

$str = "alphaBETA";
echo strtoupper($str), "\n"; // ALPHABETA
echo strtolower($str), "\n"; // alphabeta

echo ucfirst($str), "\n"; // AlphaBETA
echo lcfirst("FOObar"), "\n"; // fOObar
echo ucwords("foO baR baZ"), "\n"; // FoO BaR BaZ
echo lcwords("FOo BAr BAz"), "\n"; // fOo bAr bAz

PicoLisp

(let Str "alphaBETA"
   (prinl (uppc Str))
   (prinl (lowc Str)) )

PL/I

declare s character (20) varying initial ('alphaBETA');

put skip list (uppercase(s));
put skip list (lowercase(s));

/* An alternative to the above, which might be used if some */
/* non-standard conversion is required, is shown for        */
/* converting to upper case:                                */
put skip list ( translate(s, 'abcdefghijklmnopqrstuvwxyz',
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ') );

PL/SQL

declare
    vc  VARCHAR2(40) := 'alphaBETA';
    ivc VARCHAR2(40);
    lvc VARCHAR2(40);
    uvc VARCHAR2(40);
begin
    ivc := INITCAP(vc); -- 'Alphabeta'
    lvc := LOWER(vc);   -- 'alphabeta'
    uvc := UPPER(vc);   -- 'ALPHABETA'
end;

Pop11

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

Potion

lowercase = (str) :
   low = ("")
   str length times (i) :
      low append(if (65 <= str(i) ord and str(i) ord <= 90) :
         "abcdefghijklmnopqrstuvwxyz"(str(i) ord - 65)
      . else :
         str(i)
      .)
   .
   low join("")
.
uppercase = (str) :
   upp = ("")
   str length times (i) :
      upp append(if (97 <= str(i) ord and str(i) ord <= 122) :
         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"(str(i) ord - 97)
      . else :
         str(i)
      .)
   .
   upp join("")
.

lowercase("alphaBETA") print
uppercase("alphaBETA") print

Powerbuilder

string ls_string
ls_string = 'alphaBETA'
ls_string  = Upper(ls_string)
ls_string  = Lower(ls_string)

PowerShell

$string = 'alphaBETA'
$lower  = $string.ToLower()
$upper  = $string.ToUpper()
$title  = (Get-Culture).TextInfo.ToTitleCase($string)

$lower, $upper, $title

{{Out}}

alphabeta
ALPHABETA
Alphabeta

Python

s = "alphaBETA"
print s.upper() # => "ALPHABETA"
print s.lower() # => "alphabeta"

print s.swapcase() # => "ALPHAbeta"

print "fOo bAR".capitalize() # => "Foo bar"
print "fOo bAR".title() # => "Foo Bar"

import string
print string.capwords("fOo bAR") # => "Foo Bar"

string.capwords() allows the user to define word separators, and by default behaves slightly differently than title().

print "foo's bar".title()          # => "Foo'S Bar"
print string.capwords("foo's bar") # => "Foo's Bar"

QB64

DIM s AS STRING * 9
s = "alphaBETA"
PRINT "The original string: " + s
PRINT ""
PRINT "Translated to lowercase: " + LCASE$(s)
PRINT "Translated to uppercase: " + UCASE$(s)

R

 str <- "alphaBETA"
 toupper(str)
 tolower(str)

Racket

#lang racket
(define example "alphaBETA")

(string-upcase example)
;"ALPHABETA"
(string-downcase example)
;"alphabeta"
(string-titlecase example)
;"Alphabeta"

Raven

'alphaBETA' upper
'alhpaBETA' lower

REBOL

print ["Original: " original: "alphaBETA"]
print ["Uppercase:" uppercase original]
print ["Lowercase:" lowercase original]

Output:

Original:  alphaBETA
Uppercase: ALPHABETA
Lowercase: alphabeta

Red

str: "alphaBETA"
>> uppercase str
== "ALPHABETA"
>> lowercase str
== "alphabeta"
>> uppercase/part str 5
== "ALPHAbeta"

Retro

with strings'
"alphaBETA" toUpper puts
"alphaBETA" toLower puts

REXX

with TRANSLATE BIF

The following code will execute correctly in '''ASCII''' and '''EBCDIC.

abc  = "abcdefghijklmnopqrstuvwxyz"              /*define all  lowercase  Latin letters.*/
abcU = translate(abc)                            /*   "    "   uppercase    "      "    */

x = 'alphaBETA'                                  /*define a string to a REXX variable.  */
y = translate(x)                                 /*uppercase  X  and store it ───►  Y   */
z = translate(x, abc, abcU)                      /*translate uppercase──►lowercase chars*/

===with PARSE UPPER & PARSE LOWER statements=== The following code will execute correctly in '''ASCII''' and '''EBCDIC.

x = "alphaBETA"                                  /*define a string to a REXX variable.  */
parse upper var x y                              /*uppercase  X  and  store it ───►  Y  */
parse lower var x z                              /*lowercase  X   "     "    " ───►  Z  */

                 /*Some REXXes don't support the  LOWER  option for the  PARSE  command.*/

===with UPPER & LOWER BIFs=== The following code will execute correctly in '''ASCII''' and '''EBCDIC.

x = 'alphaBETA'                                  /*define a string to a REXX variable.  */
y = upper(x)                                     /*uppercase  X  and  store it ───►  Y  */
z = lower(x)                                     /*lowercase  X   "     "    " ───►  Z  */

         /*Some REXXes don't support the  UPPER  and  LOWER  BIFs  (built-in functions).*/

with UPPER statement

The following code will execute correctly in '''ASCII''' and '''EBCDIC.

x = "alphaBETA"                                  /*define a string to a REXX variable.  */
y=x;   upper y                                   /*uppercase  X  and  store it ───►  Y  */
parse lower var x z                              /*lowercase  Y   "     "    " ───►  Z  */

                 /*Some REXXes don't support the  LOWER  option for the  PARSE  command.*/

with capitalized words

The following code will execute correctly in '''ASCII''' and '''EBCDIC.

/*REXX program  capitalizes  each word in string, and maintains imbedded blanks.        */
x= "alef bet gimel dalet he vav zayin het tet yod kaf lamed mem nun samekh",
   "ayin pe tzadi qof resh shin  tav."           /*the "old" spelling of Hebrew letters.*/
y= capitalize(x)                                 /*capitalize each word in the string.  */
say x                                            /*display the original string of words.*/
say y                                            /*   "     "    capitalized      words.*/
exit                                             /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
capitalize: procedure;  parse arg z;   $=' 'z    /*prefix    $    string with a  blank. */
            abc = "abcdefghijklmnopqrstuvwxyz"   /*define all  Latin  lowercase letters.*/

                      do j=1  for 26             /*process each letter in the alphabet. */
                      _=' 'substr(abc,j,1); _U=_ /*get a  lowercase  (Latin) letter.    */
                      upper _U                   /* "  "  uppercase     "       "       */
                      $=changestr(_, $, _U)      /*maybe capitalize some word(s).       */
                      end   /*j*/

            return substr($, 2)                  /*return the capitalized words.        */

Some older REXXes don't have a '''changestr''' BIF, so one is included here ───► [[CHANGESTR.REX]].

{{out|output|:}}

alef bet gimel dalet he vav zayin het tet yod kaf lamed mem nun samekh ayin pe tzadi qof resh shin  tav.
Alef Bet Gimel Dalet He Vav Zayin Het Tet Yod Kaf Lamed Mem Nun Samekh Ayin Pe Tzadi Qof Resh Shin  Tav.

Note: there are many variant spellings of the Hebrew alphabet.

with case swap

The following code will execute correctly in '''ASCII''' and '''EBCDIC.

/*REXX program  swaps the letter case of a string:  lower ──► upper  &  upper ──► lower.*/
abc = "abcdefghijklmnopqrstuvwxyz"               /*define all the  lowercase  letters.  */
abcU = translate(abc)                            /*   "    "   "   uppercase     "      */

x = 'alphaBETA'                                  /*define a string to a REXX variable.  */
y = translate(x,  abc || abcU,  abcU || abc)     /*swap case of  X  and store it ───► Y */
say x
say y
                                                 /*stick a fork in it,  we're all done. */

'''output'''

alphaBETA
ALPHAbeta

version 2

x='alphaBETA';                    Say '  x='||x
                                  Say 'three ways to uppercase'
u1=translate(x);                  Say '  u1='u1
u2=upper(x);                      Say '  u2='u2
parse upper var x u3;             Say '  u3='u3

abc ='abcdefghijklmnopqrstuvwxyz'
abcu=translate(abc);              Say 'three ways to lowercase'
l1=translate(x,abc,abcu);         Say '  l1='l1
l2=lower(x);                      Say '  l2='l2
parse lower var x l3;             Say '  l3='l3

:Note: Parse options upper and lower not available in every Rexx :Builtin functions upper and lower not available in every Rexx :Upper instruction not available in ooRexx

For German input (considering umlaute) these will uppercase them:

uppercase: /*courtesy Gerard Schildberger */
 return translate(changestr("ß",translate(arg(1),'ÄÖÜ',"äöü"),'SS'))

uppercase2: Procedure
Parse Arg a
  a=translate(arg(1),'ÄÖÜ',"äöü")     /* translate lowercase umlaute */
  a=changestr("ß",a,'SS')             /* replace ß with SS           */
  return translate(a)                 /* translate lowercase letters */

Translation to lowercase is not similarly possible because of 'SS'->'ß' or -> 'ss' ??

Note: Recently an uppercase ß was introduced in Austria. I haven't used it yet.

Ring

aString = "WELCOME TO THE ring programming language"
see lower(aString) + nl
see upper(aString) + nl

Ruby

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

"alphaBETA".swapcase # => "ALPHAbeta"
"alphaBETA".capitalize # => "Alphabeta"

These methods used to affect ASCII letters A-Z and a-z only. From Ruby 2.4 onward however, these methods support Full Unicode case mapping, suitable for most languages, by default. (Options can be specified for Turkic, Lithuanian and ascii) {{works with|Ruby| 2.4}}

'ĥåçýджк'.upcase  # => "ĤÅÇÝДЖК"

Rust

{{works with|Rust| 1.3}}

fn main() {
    println!("{}", "jalapeño".to_uppercase()); // JALAPEÑO
    println!("{}", "JALAPEÑO".to_lowercase()); // jalapeño
}

Scala

val s="alphaBETA"
println(s.toUpperCase)   //-> ALPHABETA
println(s.toLowerCase)   //-> alphabeta
println(s.capitalize)    //-> AlphaBETA
println(s.reverse)       //-> ATEBahpla

Scheme

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

Using SRFI-13:

> (define s "alphaBETA gammaDELTA")
> (string-upcase s)     ;; turn all into upper case
"ALPHABETA GAMMADELTA"
> (string-downcase s)   ;; turn all into lower case
"alphabeta gammadelta"
> (string-titlecase s)  ;; capitalise start of each word
"Alphabeta Gammadelta"

Sed

Piping through sed in bash:

echo "alphaBETA" | sed 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'
echo "alphaBETA" | sed 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/'

Other functions:

# Invert case
echo "alphaBETA" | sed 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ/'

GNU sed supports special sequences to change case:

# to uppercase
$ echo alphaBETA | sed 's/.*/\U&/'
ALPHABETA
# to lowercase
$ echo alphaBETA | sed 's/.*/\L&/'
alphabeta

Seed7

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

Sidef

say "alphaBETA".lc;             #=> alphabeta
say "alphaBETA".uc;             #=> ALPHABETA
say "alphaBETA".tc;             #=> AlphaBETA
say "alpha BETA".wc;            #=> Alpha Beta
say "alpha BETA".tc;            #=> Alpha BETA
say "alpha BETA".tclc;          #=> Alpha beta

Simula

TEXT soup, lower;
soup :- "alphaBETA";
lower :- LOWCASE(COPY(soup)); ! COPY, else soup is changed;
OutText("upper: "); OutText(UPCASE("alphaBETA"));
OutText(", lower: "); OutText(lower);
OutText(", soup: "); OutText(soup); Outimage;

Slate

'alphaBETA' toLowercase.
'alphaBETA' toUppercase.

Smalltalk

'ALPHAbeta' asUppercase  "->'ALPHABETA' "
'ALPHAbeta' asLowercase "-> 'alphabeta' "

{{works with|Smalltalk/X}} {{works with|VisualWorks Smalltalk}}

'alphabeta' asUppercaseFirst "-> 'Alphabeta' "

Unicode (notice, that this cannot be done simply with a straight forward "ch := ch -$a + $A" loop): {{works with|Smalltalk/X}} (may with others too, but I have not verified)

'ĥåçýджк' asUppercase "->  'ĤÅÇÝДЖК'

SNOBOL4

There are no standard Snobol libraries or case conversion built-ins. But case functions are easy to roll using the character class keywords. Native charset only.

        define('uc(str)') :(uc_end)
uc      uc = replace(str,&lcase,&ucase) :(return)
uc_end

        define('lc(str)') :(lc_end)
lc      lc = replace(str,&ucase,&lcase) :(return)
lc_end

        define('ucfirst(str)ch') :(ucfirst_end)
ucfirst str len(1) . ch = uc(ch)
        ucfirst = str :(return)
ucfirst_end

        define('swapc(str)') :(swapc_end)
swapc   str = replace(str,&ucase &lcase, &lcase &ucase)
        swapc = str :(return)
swapc_end

*       # Test and display
        str = 'alphaBETA'
        output = str
        output = lc(str)
        output = uc(str)
        output = ucfirst(str)
        output = swapc(str)
end

An alternative way of constructing the above that groups related functions together in a denser display:

        define('UC(STR)')
        define('LC(STR)')
        define('UCFIRST(STR)')
        define('SWAPC(STR)')                               :(CASES.END)
UC      uc = replace(str,&lcase,&ucase)                    :(RETURN)
LC      lc = replace(str,&ucase,&lcase)                    :(RETURN)
UCFIRST str len(1) . ch = uc(ch) ; ucfirst = str           :(RETURN)
SWAPC   swapc = replace(str, &ucase &lcase, &lcase &ucase) :(RETURN)
CASES.END

*       # Test and display
        str = 'alphaBETA'
        output = str
        output = lc(str)
        output = uc(str)
        output = ucfirst(str)
        output = swapc(str)
END

Output:

alphaBETA
alphabeta
ALPHABETA
AlphaBETA
ALPHAbeta

SQL

{{works with|MS SQL| 2005}}

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

SQL PL

{{works with|Db2 LUW}} With SQL only:

values upper('alphaBETA');
values lower('alphaBETA');
values initcap('alphaBETA');
-- Within a SQL query.
select upper('alphaBETA') from sysibm.sysdummy1;

Output:

db2 -t
db2 => values upper('alphaBETA');

1
---------
ALPHABETA

  1 record(s) selected.

db2 => values lower('alphaBETA');

1
---------
alphabeta

  1 record(s) selected.

db2 => values initcap('alphaBETA');

1
---------
Alphabeta

  1 record(s) selected.
db2 => select upper('alphaBETA') from sysibm.sysdummy1;

1
---------
ALPHABETA

  1 record(s) selected.

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

Stata

Use '''[https://www.stata.com/help.cgi?f_strupper strupper]''' and '''strlower''' to change case of ASCII characters. Use '''[https://www.stata.com/help.cgi?f_ustrupper ustrupper]''' and '''ustrlower''' to change case of all Unicode letters.

. scalar s="alphaBETA"
. di strupper(s)
ALPHABETA
. di strlower(s)
alphabeta

Notice there may be some difficulties with Unicode characters. In the following, the uppercase '''[https://en.wikipedia.org/wiki/Sigma sigma]''' is correctly converted back to the lowercase variant, but the '''[https://en.wikipedia.org/wiki/Iota_subscript iota subscript]''' is not.

. scalar a="Ἐν ἀρχῇ ἐποίησεν ὁ θεὸς τὸν οὐρανὸν καὶ τὴν γῆν"
. scalar b=ustrupper(a)
. di b
ἘΝ ἈΡΧΗ͂Ι ἘΠΟΊΗΣΕΝ Ὁ ΘΕῸΣ ΤῸΝ ΟΥ̓ΡΑΝῸΝ ΚΑῚ ΤῊΝ ΓΗ͂Ν
. di ustrlower(b)
ἐν ἀρχῆι ἐποίησεν ὁ θεὸς τὸν οὐρανὸν καὶ τὴν γῆν

Swift

import Foundation

println("alphaBETA".uppercaseString)
println("alphaBETA".lowercaseString)
println("foO BAr".capitalizedString)

{{output}}

ALPHABETA
alphabeta
Foo Bar

Tcl

set string alphaBETA

# three built-in case conversion commands
string toupper $string  ;# ==> ALPHABETA
string tolower $string  ;# ==> alphabeta
string totitle $string  ;# ==> Alphabeta

# not built-in
proc swapcase {s} {
    foreach char [split $s ""] {
        if {$char eq [set CHAR [string toupper $char]]} {
            append new [string tolower $char]
        } else {
            append new $CHAR
        }
    }
    return $new
}
swapcase $string  ;# ==> ALPHAbeta

# better performance, but English alphabet only
proc swapcase_en {s} {
    string map {
        a A b B c C d D e E f F g G h H i I j J k K l L m M n N o O p P q Q r R s S t T u U v V w W x X y Y z Z
        A a B b C c D d E e F f G g H h I i J j K k L l M m N n O o P p Q q R r S s T t U u V v W w X x Y y Z z
    } $s
}

swapcase Père     ;# ==> pÈRE
swapcase_en Père  ;# ==> pèRE

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

TorqueScript

$string = "alphaBETA"; $upperCase = strUpr($string); $lowerCase = strLwr($string);

TUSCRIPT

$$ MODE TUSCRIPT,{}
string="alphaBETA"
lowercase =EXCHANGE(string," {&a} {-0-} ")
uppercase1=EXCHANGE(string," {&a} {-0+} ")
uppercase2=CAPS    (string)
PRINT lowercase
PRINT uppercase1
PRINT uppercase2

Output:

alphabeta
ALPHABETA
ALPHABETA

UNIX Shell

{{works with|Bourne Shell}}

For System V tr:

echo alphaBETA | tr '[a-z]' '[A-Z]'     # => ALPHABETA
echo alphaBETA | tr '[A-Z]' '[a-z]'     # => alphabeta

For [[BSD]] tr, [[GNU]] tr, or any [[POSIX]] system:

echo alphaBETA | tr a-z A-Z             # => ALPHABETA
echo alphaBETA | tr A-Z a-z             # => alphabeta

System V has a different syntax, and requires square brackets around ranges. Portable scripts can use System V syntax; the other systems handle square brackets as literal characters, translating [ to [ and ] to ], which is harmless.

Bash

{{works with|bash}}

s="alphaBETA"
echo ${s^^}     # => ALPHABETA
echo ${s,,}     # => alphabeta
echo ${s^}      # => AlphaBETA

Z Shell

{{works with|zsh}}

s="alphaBETA"
echo ${s:u}     # => ALPHABETA
echo ${s:l}     # => alphabeta

Ursa

out (lower "alphaBETA") endl console
out (upper "alphaBETA") endl console

Ursala

Case conversion functions aren't built in but can be defined using the reification operator (-:) to construct a function from a list of pairs.

#import std

to_upper = * -:~& ~=`A-~p letters
to_lower = * -:~& ~=`A-~rlp letters

#show+

examples = <to_upper 'alphaBETA',to_lower 'alphaBETA'>

output:

ALPHABETA
alphabeta

Vala

string s = "alphaBeta";
// stores ALPHABETA to string
string s_upper = s.up();
// stores alphabeta to string
string s_lower = s.down();

VBA

Function StringCase()
Dim s As String
s = "alphaBETA"
Debug.Print UCase(s)
Debug.Print LCase(s)
Debug.Print WorksheetFunction.Proper(s)
End Function

Output:

ALPHABETA
alphabeta
Alphabeta

VBScript

Dim MyWord
MyWord = UCase("alphaBETA")   ' Returns "ALPHABETA"
MyWord = LCase("alphaBETA")   ' Returns "alphabeta"

Visual Basic

{{works with|Visual Basic|VB6 Standard}}

Sub Main()
Const TESTSTRING As String = "alphaBETA"
Debug.Print "initial   =                                      " _
   & TESTSTRING
Debug.Print "uppercase =                                      " _
   & UCase(TESTSTRING)
Debug.Print "lowercase =                                      " _
   & LCase(TESTSTRING)
Debug.Print "first letter capitalized =                       " _
   & StrConv(TESTSTRING, vbProperCase)
Debug.Print "length (in characters) =                         " _
   & CStr(Len(TESTSTRING))
Debug.Print "length (in bytes) =                              " _
   & CStr(LenB(TESTSTRING))
Debug.Print "reversed =                                       " _
   & StrReverse(TESTSTRING)
Debug.Print "first position of letter A (case-sensitive) =    " _
   & InStr(1, TESTSTRING, "A", vbBinaryCompare)
Debug.Print "first position of letter A (case-insensitive) =  " _
   & InStr(1, TESTSTRING, "A", vbTextCompare)
Debug.Print "concatenated with '123' =                        " _
   & TESTSTRING & "123"
End Sub

{{out}}

initial   =                                      alphaBETA
uppercase =                                      ALPHABETA
lowercase =                                      alphabeta
first letter capitalized =                       Alphabeta
length (in characters) =                         9
length (in bytes) =                              18
reversed =                                       ATEBahpla
first position of letter A (case-sensitive) =    9
first position of letter A (case-insensitive) =  1
concatenated with '123' =                        alphaBETA123

Vedit macro language

#1 = CP
IT("alphaBETA")
Case_Upper_Block(#1, CP)
Case_Lower_Block(#1, CP)

XPL0

string 0;                       \use zero-terminated string convention
include c:\cxpl\stdlib;         \ToUpper, ToLower, and 'code' declarations

proc StrToUpper(S);             \Convert string to uppercase characters
char S;
while S(0) do [S(0):= ToUpper(S(0));  S:=S+1];

proc StrToLower(S);             \Convert string to lowercase characters
char S;
while S(0) do [S(0):= ToLower(S(0));  S:=S+1];

char Str;
[Str:= "alphaBETA";
StrToUpper(Str);
Text(0, Str);  CrLf(0);
StrToLower(Str);
Text(0, Str);  CrLf(0);
]

Output:

ALPHABETA
alphabeta

zkl

s:="alphaBETA";
s.toLower(); //--> "alphabeta"
s.toUpper(); //--> "ALPHABETA"

{{omit from|Openscad}} {{omit from|PARI/GP|No real capacity for string manipulation}}

[[Category: String manipulation]] [[Category: Encodings]]

[[Wikipedia::https://en.wikipedia.org/wiki/Letter_case]]