View source for Substring/Top and tail

{{task}}
[[Category:String manipulation]]
The task is to demonstrate how to remove the first and last characters from a string. 

The solution should demonstrate how to obtain the following results:

* String with first character removed
* String with last character removed
* String with both the first and last characters removed

<br>
If the program uses UTF-8 or UTF-16, it must work on any valid Unicode code point, whether in the Basic Multilingual Plane or above it. 

The program must reference logical characters (code points), not 8-bit code units for UTF-8 or 16-bit code units for UTF-16. 

Programs for other encodings (such as 8-bit ASCII, or EUC-JP) are not required to handle all Unicode characters.


{{Template:Strings}}
<br><br>

=={{header|11l}}==
{{trans|Python}}

<syntaxhighlight lang="11l">print(‘knight’[1..])
print(‘socks’[0 .< (len)-1])
print(‘brooms’[1 .< (len)-1])</syntaxhighlight>

{{out}}
<pre>
night
sock
room
</pre>

=={{header|360 Assembly}}==
<syntaxhighlight lang="360asm">*        Substring/Top and tail    04/03/2017
SUBSTRTT CSECT
         USING  SUBSTRTT,R13       base register
         B      72(R15)            skip savearea
         DC     17F'0'             savearea
         STM    R14,R12,12(R13)    save previous context
         ST     R13,4(R15)         link backward
         ST     R15,8(R13)         link forward
         LR     R13,R15            set addressability
*
         XPRNT  S8,L'S8            print s8
         MVC    S7,S8+1            s7=substr(s8,2,7)
         XPRNT  S7,L'S7            print s7
         MVC    S7,S8              s7=substr(s8,1,7)
         XPRNT  S7,L'S7            print s7
         MVC    S6,S8+1            s6=substr(s8,2,6)
         XPRNT  S6,L'S6            print s6
*         
         L      R13,4(0,R13)       epilog
         LM     R14,R12,12(R13)    restore previous context
         XR     R15,R15            rc=0
         BR     R14                exit
S8       DC     CL8'12345678'
S7       DS     CL7
S6       DS     CL6
         YREGS
         END    SUBSTRTT</syntaxhighlight>
{{out}}
<pre>
12345678
2345678
1234567
234567
</pre>

=={{header|ACL2}}==
<syntaxhighlight lang="lisp">(defun str-rest (str)
   (coerce (rest (coerce str 'list)) 'string))

(defun rdc (xs)
   (if (endp (rest xs))
       nil
       (cons (first xs)
             (rdc (rest xs)))))

(defun str-rdc (str)
   (coerce (rdc (coerce str 'list)) 'string))

(str-rdc "string")
(str-rest "string")
(str-rest (str-rdc "string"))</syntaxhighlight>

=={{header|Action!}}==
<syntaxhighlight lang="action!">PROC Main()
  CHAR ARRAY text="qwertyuiop"
  CHAR ARRAY res(20)
  BYTE n,m

  PrintF("Original string:%E  ""%S""%E%E",text)

  SCopyS(res,text,2,text(0))
  PrintF("String without the top:%E  ""%S""%E%E",res)

  SCopyS(res,text,1,text(0)-1)
  PrintF("String without the tail:%E  ""%S""%E%E",res)

  SCopyS(res,text,2,text(0)-1)
  PrintF("String without the top and the tail:%E  ""%S""%E%E",res)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Top_and_tail.png Screenshot from Atari 8-bit computer]
<pre>
Original string:
  "qwertyuiop"

String without the top:
  "wertyuiop"

String without the tail:
  "qwertyuio"

String without the top and the tail:
  "wertyuio"
</pre>

=={{header|Ada}}==

<syntaxhighlight lang="ada">with Ada.Text_IO;

procedure Remove_Characters is
   S: String := "upraisers";
   use Ada.Text_IO;
begin
   Put_Line("Full String:   """ & S & """");
   Put_Line("Without_First: """ & S(S'First+1 .. S'Last) & """");
   Put_Line("Without_Last:  """ & S(S'First   .. S'Last-1) & """");
   Put_Line("Without_Both:  """ & S(S'First+1 .. S'Last-1) & """");
end Remove_Characters;</syntaxhighlight>

Output:

<pre>Full String:   "upraisers"
Without_First: "praisers"
Without_Last:  "upraiser"
Without_Both:  "praiser"</pre>

With UTF8 support in Ada 2012 (Wide_Character of literals is automatic):

<syntaxhighlight lang="ada">with Ada.Text_IO;
with Ada.Strings.UTF_Encoding.Wide_Strings;

procedure Remove_Characters
is
   use Ada.Text_IO;
   use Ada.Strings.UTF_Encoding;
   use Ada.Strings.UTF_Encoding.Wide_Strings;
   
   S : String := "upraisers";
   U : Wide_String := Decode (UTF_8_String'(S));
   
   function To_String (X : Wide_String)return String
   is
   begin
      return String (UTF_8_String'(Encode (X)));
   end To_String;
   
begin
   Put_Line
     (To_String
        ("Full String:   """ & U & """"));
   Put_Line
     (To_String
        ("Without_First: """ & U (U'First + 1 .. U'Last) & """"));
   Put_Line
     (To_String
        ("Without_Last:  """ & U (U'First   .. U'Last - 1) & """"));
   Put_Line
     (To_String
        ("Without_Both:  """ & U (U'First + 1 .. U'Last - 1) & """"));

end Remove_Characters;</syntaxhighlight>

Output:

<pre>Full String:   "upraisers"
Without_First: "praisers"
Without_Last:  "upraiser"
Without_Both:  "praiser"</pre>

=={{header|Aime}}==
<syntaxhighlight lang="aime">o_text(delete("knights", 0));
o_newline();
o_text(delete("knights", -1));
o_newline();
o_text(delete(delete("knights", 0), -1));
o_newline();</syntaxhighlight>
{{out}}
<pre>nights
knight
night</pre>

=={{header|ALGOL 68}}==
{{trans|AWK}}
{{works with|ALGOL 68|Revision 1 - no extensions to language used.}}
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny].}}
{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}
<syntaxhighlight lang="algol68">#!/usr/local/bin/a68g --script #

STRING str="upraisers";
printf(($gl$,
  str,                      # remove no characters #
  str[LWB str+1:         ], # remove the first character #
  str[         :UPB str-1], # remove the last character #
  str[LWB str+1:UPB str-1], # remove both the first and last character #
  str[LWB str+2:         ], # remove the first 2 characters #
  str[         :UPB str-2], # remove the last 2 characters #
  str[LWB str+1:UPB str-2], # remove 1 before and 2 after #
  str[LWB str+2:UPB str-1], # remove 2 before and one after #
  str[LWB str+2:UPB str-2]  # remove both the first and last 2 characters #
))</syntaxhighlight>
Output:
<pre>
upraisers
praisers
upraiser
praiser
raisers
upraise
praise
raiser
raise
</pre>

=={{header|Amazing Hopper}}==
<syntaxhighlight lang="amazing hopper">
#include <hopper.h>
#proto showmessage(_X_)
main:
  s="message", t=s
  ++s, _show message(s)
  s=t
  --s, _show message(s)
  ++s, _show message(s)
{0}return

.locals
showmessage(_S_)
  {_S_,"\n"}print
back
</syntaxhighlight>
{{out}}
<pre>
essage
messag
essag
</pre>

=={{header|Apex}}==
<syntaxhighlight lang="java">
String strOrig = 'brooms';
String str1 = strOrig.substring(1, strOrig.length());
system.debug(str1);
String str2 = strOrig.substring(0, strOrig.length()-1);
system.debug(str2);
String str3 = strOrig.substring(1, strOrig.length()-1);
system.debug(str3);

// Regular Expressions approach
String strOrig = 'brooms';
String str1 = strOrig.replaceAll( '^.', '' );
system.debug(str1);
String str2 = strOrig.replaceAll( '.$', '' ) ;
system.debug(str2);
String str3 = strOrig.replaceAll( '^.|.$', '' );
system.debug(str3);
</syntaxhighlight>

{{out}}
<pre>
rooms

broom

room
</pre>

=={{header|AppleScript}}==

<syntaxhighlight lang="applescript">set aString to "This is some text"

set stringLength to (count aString) -- The number of characters in the text.

-- AppleScript indices are 1-based. Ranges can be specified in several different ways.
if (stringLength > 1) then
    set substring1 to text 2 thru stringLength of aString
    -- set substring1 to text 2 thru -1 of aString
    -- set substring1 to text 2 thru end of aString
    -- set substring1 to text from character 2 to character stringLength of aString
    -- set substring1 to aString's text from 2 to -1
    -- Some combination of the above.
else
    set substring1 to ""
end if

if (stringLength > 1) then
    set substring2 to text 1 thru -2 of aString
else
    set substring2 to ""
end if

if (stringLength > 2) then
    set substring3 to text 2 thru -2 of aString
else
    set substring3 to ""
end if

return substring1 & linefeed & substring2 & linefeed & substring3</syntaxhighlight>

{{output}}
<pre>"his is some text
This is some tex
his is some tex"</pre>

=={{header|Arturo}}==

<syntaxhighlight lang="rebol">knight: "knight"
socks: "socks"
brooms: "brooms"

print drop knight.                      ; strip first character
print slice knight 1 (size knight)-1    ; alternate way to strip first character

print chop socks                        ; strip last character
print take socks (size socks)-1         ; alternate way to strip last character
print slice socks 0 (size socks)-2      ; yet another way to strip last character

print chop drop brooms                  ; strip both first and last characters
print slice brooms 1 (size brooms)-2    ; alternate way to strip both first and last characters</syntaxhighlight>

{{out}}

<pre>night
night
sock
sock
sock
room
room</pre>

=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">myString := "knights"
MsgBox % SubStr(MyString, 2)
MsgBox % SubStr(MyString, 1, StrLen(MyString)-1)
MsgBox % SubStr(MyString, 2, StrLen(MyString)-2)</syntaxhighlight>

=={{header|AWK}}==
<syntaxhighlight lang="awk">BEGIN {
  mystring="knights"
  print substr(mystring,2)                       # remove the first letter
  print substr(mystring,1,length(mystring)-1)    # remove the last character
  print substr(mystring,2,length(mystring)-2)    # remove both the first and last character
}</syntaxhighlight>

=={{header|BASIC}}==
<syntaxhighlight lang="basic">10 PRINT FN F$("KNIGHTS"): REM STRIP THE FIRST LETTER
20 PRINT FN L$("SOCKS"): REM STRIP THE LAST LETTER
30 PRINT FN B$("BROOMS"): REM STRIP BOTH THE FIRST AND LAST LETTER
100 END
 
9000 DEF FN F$(A$)=RIGHT$(A$,LEN(A$)-1)
9010 DEF FN L$(A$)=LEFT$(A$,LEN(A$)-1)
9020 DEF FN B$(A$)=FN L$(FN F$(A$))</syntaxhighlight>

==={{header|Applesoft BASIC}}===
<syntaxhighlight lang="qbasic">10 s$ = "Rosetta Code"
20 PRINT s$
30 PRINT MID$(s$,2)           
40 PRINT LEFT$(s$,LEN(s$)-1)  
50 PRINT MID$(s$,2,LEN(s$)-2) </syntaxhighlight>

==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
<syntaxhighlight lang="qbasic">10 s$ = "Rosetta Code"
20 print s$
30 print mid$(s$,2)'strip first
40 print left$(s$,len(s$)-1)'strip last
50 print mid$(s$,2,len(s$)-2)'strip first and last</syntaxhighlight>

==={{header|MSX Basic}}===
{{works with|GW-BASIC}}
<syntaxhighlight lang="qbasic">10 S$ = "Rosetta Code"
20 PRINT S$
30 PRINT MID$(S$, 2)              'strip first
40 PRINT LEFT$(S$, LEN(S$) - 1)   'strip last
50 PRINT MID$(S$, 2, LEN(S$) - 2) 'strip first and last</syntaxhighlight>

==={{header|QBasic}}===
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<syntaxhighlight lang="qbasic">s$ = "Rosetta Code"

PRINT s$
PRINT MID$(s$, 2)               'strip first
PRINT LEFT$(s$, LEN(s$) - 1)    'strip last
PRINT MID$(s$, 2, LEN(s$) - 2)  'strip first and last</syntaxhighlight>

==={{header|BASIC256}}===
<syntaxhighlight lang="freebasic">s$ = "Rosetta Code"

print s$
PRINT MID$(s$, 2)               'strip first
PRINT LEFT$(s$, LEN(s$) - 1)    'strip last
PRINT MID$(s$, 2, LEN(s$) - 2)  'strip first and last</syntaxhighlight>

==={{header|True BASIC}}===
<syntaxhighlight lang="qbasic">LET s$ = "Rosetta Code"
PRINT s$
PRINT (s$)[2:maxnum]              !strip first
PRINT (s$)[1:len(s$)-1]           !strip last
PRINT (s$)[2:2+len(s$)-2-1]       !strip first and last
END</syntaxhighlight>

==={{header|XBasic}}===
{{works with|Windows XBasic}}
<syntaxhighlight lang="xbasic">PROGRAM	"Substring"
VERSION	"0.0000"

DECLARE FUNCTION  Entry ()

FUNCTION  Entry ()
s$ = "Rosetta Code"

PRINT s$
PRINT MID$(s$, 2)               'strip first
PRINT LEFT$(s$, LEN(s$) - 1)    'strip last
PRINT MID$(s$, 2, LEN(s$) - 2)  'strip first and last

END FUNCTION
END PROGRAM</syntaxhighlight>

==={{header|Yabasic}}===
<syntaxhighlight lang="freebasic">s$ = "Rosetta Code"

print s$
PRINT MID$(s$, 2)               'strip first
PRINT LEFT$(s$, LEN(s$) - 1)    'strip last
PRINT MID$(s$, 2, LEN(s$) - 2)  'strip first and last</syntaxhighlight>

==={{header|IS-BASIC}}===
<syntaxhighlight lang="is-basic">100 LET S$="Knights"
110 PRINT S$(2:)
120 PRINT S$(:LEN(S$)-1)
130 PRINT S$(2:LEN(S$)-1)</syntaxhighlight>

==={{header|Sinclair ZX81 BASIC}}===
Note that strings are indexed from 1.
<syntaxhighlight lang="basic">10 REM STRING SLICING EXAMPLE
20 LET S$="KNIGHTS"
30 REM WITH FIRST CHARACTER REMOVED:
40 PRINT S$(2 TO )
50 REM WITH LAST CHARACTER REMOVED:
60 PRINT S$( TO LEN S$-1)
70 REM WITH BOTH REMOVED:
80 PRINT S$(2 TO LEN S$-1)</syntaxhighlight>
{{out}}
<pre>NIGHTS
KNIGHT
NIGHT</pre>

==={{header|Microsoft Small Basic}}===
When I tried using Unicode characters, it printed question marks, though ASCII works fine.
<syntaxhighlight lang="vbnet">
string = "Small Basic"
TextWindow.WriteLine(Text.GetSubTextToEnd(string, 2)) 'Without the first character
TextWindow.WriteLine(Text.GetSubText(string, 1, Text.GetLength(string) - 1)) 'Without the last character
TextWindow.WriteLine(Text.GetSubText(string, 2, Text.GetLength(string) - 2)) 'Without the first and last characters
</syntaxhighlight>
{{out}}
<pre>
mall Basic
Small Basi
mall Basi
</pre>

=={{header|BQN}}==
Drop(<code>↓</code>) is the main function used here.

<syntaxhighlight lang="bqn">  str ← "substring"
"substring"
  1↓str
"ubstring"
  ¯1↓str
"substrin"
  1↓¯1↓str
"ubstrin"</syntaxhighlight>

=={{header|BBC BASIC}}==
<syntaxhighlight lang="bbcbasic">      s$ = "Rosetta Code"
      PRINT MID$(s$, 2)
      PRINT LEFT$(s$)
      PRINT LEFT$(MID$(s$, 2))</syntaxhighlight>

=={{header|Bracmat}}==
Bracmat uses UTF-8 internally. The function <code>utf</code> fails if its argument isn't a valid UTF-8 multibyte string, but in two slightly different ways: an indefinite and a definite way. If the argument does not have the required number of bytes but otherwise seems to be ok, Bracmat's backtacking mechanism lenghtens the argument and then calls <code>utf</code> again. This is repeated until utf either succeeds or definitely fails. The code is far from efficient.

<syntaxhighlight lang="bracmat">(substringUTF-8=
  @( Δημοτική
   : (%?a&utf$!a) ?"String with first character removed"
   )
& @( Δημοτική
   : ?"String with last character removed" (?z&utf$!z)
   )
& @( Δημοτική
   :   (%?a&utf$!a)
       ?"String with both the first and last characters removed"
       (?z&utf$!z)
   )
&   out
  $ ("String with first character removed:" !"String with first character removed")
&   out
  $ ("String with last character removed:" !"String with last character removed")
&   out
  $ ( "String with both the first and last characters removed:"
      !"String with both the first and last characters removed"
    ));</syntaxhighlight>

<pre>!substringUTF-8
String with first character removed: ημοτική
String with last character removed: Δημοτικ
String with both the first and last characters removed: ημοτικ</pre>

If the string is known to consist of 8-byte characters, we can use a simpler method. Essential are the <code>%</code> and <code>@</code> prefixes. The <code>%</code> prefix matches 1 or more elements (bytes, in the case of string pattern matching), while <code>@</code> matches 0 or 1 elements. In combination these prefixes match 1 and only 1 byte.

<syntaxhighlight lang="bracmat">(substring-8-bit=
  @("8-bit string":%@ ?"String with first character removed")
& @("8-bit string":?"String with last character removed" @)
& @( "8-bit string"
   : %@ ?"String with both the first and last characters removed" @
   )
&   out
  $ ("String with first character removed:" !"String with first character removed")
&   out
  $ ("String with last character removed:" !"String with last character removed")
&   out
  $ ( "String with both the first and last characters removed:"
      !"String with both the first and last characters removed"
    ));</syntaxhighlight>

<pre>!substring-8-bit
String with first character removed: -bit string
String with last character removed: 8-bit strin
String with both the first and last characters removed: -bit strin</pre>

=={{header|Burlesque}}==
<syntaxhighlight lang="blsq">
blsq ) "RosettaCode"[-
"osettaCode"
blsq ) "RosettaCode"-]
'R
blsq ) "RosettaCode"~]
"RosettaCod"
blsq ) "RosettaCode"[~
'e
blsq ) "RosettaCode"~-
"osettaCod"
</syntaxhighlight>

=={{header|C}}==
<syntaxhighlight lang="c">#include <string.h>
#include <stdlib.h>
#include <stdio.h>

int main( int argc, char ** argv ){
  const char * str_a = "knight";
  const char * str_b = "socks";
  const char * str_c = "brooms";

  char * new_a = malloc( strlen( str_a ) - 1 );
  char * new_b = malloc( strlen( str_b ) - 1 );
  char * new_c = malloc( strlen( str_c ) - 2 );

  strcpy( new_a, str_a + 1 );
  strncpy( new_b, str_b, strlen( str_b ) - 1 );
  strncpy( new_c, str_c + 1, strlen( str_c ) - 2 );

  printf( "%s\n%s\n%s\n", new_a, new_b, new_c );

  free( new_a );
  free( new_b );
  free( new_c );

  return 0;
}</syntaxhighlight>

Result:
<pre>night
sock
room</pre>

ANSI C provides little functionality for text manipulation outside of string.h.  While a number of libraries for this purpose have been written, this example uses only ANSI C.

=={{header|C sharp}}==
<syntaxhighlight lang="c sharp">
using System;

class Program
{
    static void Main(string[] args)
    {
        string testString = "test";
        Console.WriteLine(testString.Substring(1));
        Console.WriteLine(testString.Substring(0, testString.Length - 1));
        Console.WriteLine(testString.Substring(1, testString.Length - 2));
    }
}
</syntaxhighlight>

Result:
<pre>est
tes
es</pre>

=={{header|C++}}==
<syntaxhighlight lang="cpp">#include <string>
#include <iostream>

int main( ) {
   std::string word( "Premier League" ) ;
   std::cout << "Without first letter: " << word.substr( 1 ) << " !\n" ;
   std::cout << "Without last letter: " << word.substr( 0 , word.length( ) - 1 ) << " !\n" ;
   std::cout << "Without first and last letter: " << word.substr( 1 , word.length( ) - 2 ) << " !\n" ;
   return 0 ;
}</syntaxhighlight>
Output:
<PRE>Without first letter: remier League !
Without last letter: Premier Leagu !
Without first and last letter: remier Leagu !
</PRE>

=={{header|Clojure}}==
<syntaxhighlight lang="clojure">; using substring:
user=> (subs "knight" 1)
"night"
user=> (subs "socks" 0 4)
"sock"
user=> (.substring "brooms" 1 5)
"room"

; using rest and drop-last:
user=> (apply str (rest "knight"))
"night"
user=> (apply str (drop-last "socks"))
"sock"
user=> (apply str (rest (drop-last "brooms")))
"room"</syntaxhighlight>

=={{header|COBOL}}==
<syntaxhighlight lang="cobol">       identification division.
       program-id. toptail.

       data division.
       working-storage section.
       01 data-field.
          05 value "[this is a test]".

       procedure division.
       sample-main.
       display data-field
      *> Using reference modification, which is (start-position:length)
       display data-field(2:)
       display data-field(1:length of data-field - 1)
       display data-field(2:length of data-field - 2)
       goback.
       end program toptail.</syntaxhighlight>

{{out}}
<pre>prompt$ cobc -xj toptail.cob
[this is a test]
this is a test]
[this is a test
this is a test</pre>

=={{header|Common Lisp}}==
<code>subseq</code> will signal an error if you provide invalid start or end values.
<syntaxhighlight lang="lisp">> (defvar *str* "∀Ꮺ✤Л◒")
*STR*
> (subseq *str* 1) ; remove first character
"Ꮺ✤Л◒"
> (subseq *str* 0 (1- (length *str*))) ; remove last character
"∀Ꮺ✤Л"
> (subseq *str* 1 (1- (length *str*))) ; remove first and last character
"Ꮺ✤Л"</syntaxhighlight>

=={{header|D}}==
Version for ASCII strings or Unicode dstrings:
<syntaxhighlight lang="d">import std.stdio;

void main() {
    // strip first character
    writeln("knight"[1 .. $]);

    // strip last character
    writeln("socks"[0 .. $ - 1]);

    // strip both first and last characters
    writeln("brooms"[1 .. $ - 1]);
}</syntaxhighlight>
{{out}}
<pre>night
sock
room</pre>

=={{header|Dart}}==
<syntaxhighlight lang="dart">void main() {
  String word = "Premier League";
  print("Without first letter: ${word.substring(1)} !");
  print("Without last letter: ${word.substring(0, word.length - 1)} !");
  print("Without first and last letter: ${word.substring(1, word.length - 1)} !");
}</syntaxhighlight>
{{out}}
<pre>Same as C++ entry.</pre>

=={{header|Delphi}}==
<syntaxhighlight lang="delphi">program TopAndTail;

{$APPTYPE CONSOLE}

const
  TEST_STRING = '1234567890';
begin
  Writeln(TEST_STRING);                                    // full string
  Writeln(Copy(TEST_STRING, 2, Length(TEST_STRING)));      // first character removed
  Writeln(Copy(TEST_STRING, 1, Length(TEST_STRING) - 1));  // last character removed
  Writeln(Copy(TEST_STRING, 2, Length(TEST_STRING) - 2));  // first and last characters removed

  Readln;
end.</syntaxhighlight>

=={{header|EasyLang}}==
<syntaxhighlight>
s$ = "Easylang"
print substr s$ 1 (len s$ - 1)
print substr s$ 2 (len s$ - 1)
print substr s$ 2 (len s$ - 2)
</syntaxhighlight>
{{out}}
<pre>
Easylan
asylang
asylan
</pre>

=={{header|Ecstasy}}==
Generally, extracting substrings in Ecstasy is most easily performed using the slice operator, but there is also a <code>substring()</code> method:

<syntaxhighlight lang="ecstasy">
module Substrings {
    void run(String[] args = []) {
        String s = args.size > 0 ? args[0] : "hello";
        @Inject Console console;
        console.print(
            $|Original    : { s                                 .quoted()=}
             |Remove first: { s.substring(1)                    .quoted()=}
             |Remove first: {(s.size < 1 ? "" : s[1..<s.size  ]).quoted()=}
             |Remove last : {(s.size < 1 ? "" : s[0..<s.size-1]).quoted()=}
             |Remove both : {(s.size < 2 ? "" : s[1..<s.size-1]).quoted()=}
        );
    }
}
</syntaxhighlight>

{{out}}
<pre>
x$ xec Substrings
Original    :  s                                 .quoted()="hello"
Remove first:  s.substring(1)                    .quoted()="ello"
Remove first: (s.size < 1 ? "" : s[1..<s.size  ]).quoted()="ello"
Remove last : (s.size < 1 ? "" : s[0..<s.size-1]).quoted()="hell"
Remove both : (s.size < 2 ? "" : s[1..<s.size-1]).quoted()="ell"
x$ xec Substrings a
Original    :  s                                 .quoted()="a"
Remove first:  s.substring(1)                    .quoted()=""
Remove first: (s.size < 1 ? "" : s[1..<s.size  ]).quoted()=""
Remove last : (s.size < 1 ? "" : s[0..<s.size-1]).quoted()=""
Remove both : (s.size < 2 ? "" : s[1..<s.size-1]).quoted()=""
x$ xec Substrings ab
Original    :  s                                 .quoted()="ab"
Remove first:  s.substring(1)                    .quoted()="b"
Remove first: (s.size < 1 ? "" : s[1..<s.size  ]).quoted()="b"
Remove last : (s.size < 1 ? "" : s[0..<s.size-1]).quoted()="a"
Remove both : (s.size < 2 ? "" : s[1..<s.size-1]).quoted()=""
x$ xec Substrings abc
Original    :  s                                 .quoted()="abc"
Remove first:  s.substring(1)                    .quoted()="bc"
Remove first: (s.size < 1 ? "" : s[1..<s.size  ]).quoted()="bc"
Remove last : (s.size < 1 ? "" : s[0..<s.size-1]).quoted()="ab"
Remove both : (s.size < 2 ? "" : s[1..<s.size-1]).quoted()="b"
</pre>

=={{header|Eero}}==
<syntaxhighlight lang="objc">#import <Foundation/Foundation.h>

int main()
  autoreleasepool

    s := 'knight'
    Log( '%@', s[1 .. s.length-1] )  // strip first character

    s = 'socks'
    Log( '%@', s[0 .. s.length-2] )  // strip last character
   
    s = 'brooms'   
    Log( '%@', s[1 .. s.length-2] )  // strip both first and last characters

    s = 'Δημοτική'   
    Log( '%@', s[1 .. s.length-2] )  // strip both first and last characters

  return 0</syntaxhighlight>

Output:<pre>
2013-09-04 17:08:09.453 a.out[2257:507] night
2013-09-04 17:08:09.454 a.out[2257:507] sock
2013-09-04 17:08:09.454 a.out[2257:507] room
2013-09-04 17:08:09.455 a.out[2257:507] ημοτικ</pre>

=={{header|Elena}}==
ELENA 4.x :
<syntaxhighlight lang="elena">import extensions;
 
public program()
{
    var testString := "test";
 
    console.printLine(testString.Substring(1));
    console.printLine(testString.Substring(0, testString.Length - 1));
    console.printLine(testString.Substring(1, testString.Length - 2))
}</syntaxhighlight>
{{out}}
<pre>
est
tes
es
</pre>

=={{header|Elixir}}==
<syntaxhighlight lang="elixir">iex(1)> str = "abcdefg"
"abcdefg"
iex(2)> String.slice(str, 1..-1)
"bcdefg"
iex(3)> String.slice(str, 0..-2)
"abcdef"
iex(4)> String.slice(str, 1..-2)
"bcdef"</syntaxhighlight>

=={{header|Emacs Lisp}}==
<syntaxhighlight lang="lisp">(let ((string "top and tail"))
  (substring string 1) ;=> "op and tail"
  (substring string 0 (1- (length string))) ;=> "top and tai"
  (substring string 1 (1- (length string)))) ;=> "op and tai"</syntaxhighlight>

=={{header|Erlang}}==
<syntaxhighlight lang="erlang">1> Str = "Hello".
"Hello"
2> string:sub_string(Str, 2).                   % To strip the string from the right by 1
"ello"
3> string:sub_string(Str, 1, length(Str)-1).    % To strip the string from the left by 1
"Hell"
4> string:sub_string(Str, 2, length(Str)-1).    % To strip the string from both sides by 1
"ell"</syntaxhighlight>

=={{header|Euphoria}}==
<syntaxhighlight lang="euphoria">function strip_first(sequence s)
    return s[2..$]
end function

function strip_last(sequence s)
    return s[1..$-1]
end function

function strip_both(sequence s)
    return s[2..$-1]
end function

puts(1, strip_first("knight"))  -- strip first character
puts(1, strip_last("write"))    -- strip last character
puts(1, strip_both("brooms"))   -- strip both first and last characters</syntaxhighlight>

=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">[<EntryPoint>]
let main args =
    let s = "一二三四五六七八九十"
    printfn "%A" (s.Substring(1))
    printfn "%A" (s.Substring(0, s.Length - 1))
    printfn "%A" (s.Substring(1, s.Length - 2))
    0</syntaxhighlight>
Output
<pre>"二三四五六七八九十"
"一二三四五六七八九"
"二三四五六七八九"</pre>

=={{header|Factor}}==
<syntaxhighlight lang="factor">USING: io kernel sequences ;
"Rosetta code" [ rest ] [ but-last ] [ rest but-last ] tri
[ print ] tri@</syntaxhighlight>
{{out}}
<pre>
osetta code
Rosetta cod
osetta cod
</pre>

=={{header|Forth}}==
In Forth, strings typically take up two cells on the stack, diagrammed ( c-addr u ), with C-ADDR the address of the string and U its length. Dropping leading and trailing characters then involves simple mathematical operations on the address or length, without mutating or copying the string.

<syntaxhighlight lang="forth">: hello ( -- c-addr u )
  s" Hello" ;  

hello 1 /string type     \ => ello

hello 1- type            \ => hell

hello 1 /string 1- type  \ => ell</syntaxhighlight>

This works for ASCII, and a slight variation (2 instead of 1 per character) will suffice for BIG5, GB2312, and like, but Unicode-general code can use +X/STRING and X\STRING- from Forth-200x's XCHAR wordset.

=={{header|Fortran}}==
<syntaxhighlight lang="fortran">program substring

  character(len=5) :: string
  string = "Hello"
  
  write (*,*) string
  write (*,*) string(2:)
  write (*,*) string( :len(string)-1)
  write (*,*) string(2:len(string)-1)

end program substring</syntaxhighlight>

=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64

Dim s As String  = "panda"
Dim s1 As String = Mid(s, 2)
Dim s2 As String = Left(s, Len(s) - 1)
Dim s3 As String = Mid(s, 2, Len(s) - 2)
Print s
Print s1
Print s2
Print s3
Sleep</syntaxhighlight>

{{out}}
<pre>
panda
anda
pand
and
</pre>


=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
void local fn DoIt
  CFStringRef s = @"knights"
  print s
  CFStringRef s1 = mid(s, 1, len(s) - 1)
  print s1
  CFStringRef s2 = left(s,   len(s) - 1)
  print s2
  CFStringRef s3 = mid(s, 1, len(s) - 2)
  print s3
end fn

fn DoIt

HandleEvents
</syntaxhighlight>
{{output}}
<pre>
knights
nighs
knight
night
</pre>



=={{header|Go}}==
Go strings are byte arrays that can hold whatever you want them to hold.  Common contents are ASCII and UTF-8.  You use different techniques depending on how you are interpreting the string.  The utf8 package functions shown here allows efficient extraction of first and last runes without decoding the entire string.
<syntaxhighlight lang="go">package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    // ASCII contents:  Interpreting "characters" as bytes.
    s := "ASCII"
    fmt.Println("String:                ", s)
    fmt.Println("First byte removed:    ", s[1:])
    fmt.Println("Last byte removed:     ", s[:len(s)-1])
    fmt.Println("First and last removed:", s[1:len(s)-1])
    // UTF-8 contents:  "Characters" as runes (unicode code points)
    u := "Δημοτική"
    fmt.Println("String:                ", u)
    _, sizeFirst := utf8.DecodeRuneInString(u)
    fmt.Println("First rune removed:    ", u[sizeFirst:])
    _, sizeLast := utf8.DecodeLastRuneInString(u)
    fmt.Println("Last rune removed:     ", u[:len(u)-sizeLast])
    fmt.Println("First and last removed:", u[sizeFirst:len(u)-sizeLast])
}</syntaxhighlight>
Output:
<pre>
String:                 ASCII
First byte removed:     SCII
Last byte removed:      ASCI
First and last removed: SCI
String:                 Δημοτική
First rune removed:     ημοτική
Last rune removed:      Δημοτικ
First and last removed: ημοτικ
</pre>

=={{header|Golfscript}}==
When I tried using Unicode characters, the interpreter generated a mess, though ASCII works fine.
<syntaxhighlight lang="golfscript">
"Golfscript"(;n
"Golfscript");n
"Golfscript"(;);
</syntaxhighlight>
{{out}}
<pre>
olfscript
Golfscrip
olfscrip
</pre>

=={{header|Groovy}}==
Solution:
<syntaxhighlight lang="groovy">def top  = { it.size() > 1 ? it[0..-2] : '' }
def tail = { it.size() > 1 ? it[1..-1] : '' }</syntaxhighlight>

Test:
<syntaxhighlight lang="groovy">def testVal = 'upraisers'
println """
original: ${testVal}
top:      ${top(testVal)}
tail:     ${tail(testVal)}
top&tail: ${tail(top(testVal))}
"""</syntaxhighlight>

Output:
<pre>original: upraisers
top:      upraiser
tail:     praisers
top&tail: praiser</pre>

=={{header|GW-BASIC}}==
<syntaxhighlight lang="qbasic">10 A$="knight":B$="socks":C$="brooms"
20 PRINT MID$(A$,2)
30 PRINT LEFT$(B$,LEN(B$)-1)
40 PRINT MID$(C$,2,LEN(C$)-2)</syntaxhighlight>

=={{header|Haskell}}==
<syntaxhighlight lang="haskell">-- We define the functions to return an empty string if the argument is too
-- short for the particular operation.

remFirst, remLast, remBoth :: String -> String

remFirst "" = ""
remFirst cs = tail cs

remLast "" = ""
remLast cs = init cs

remBoth (c:cs) = remLast cs
remBoth  _     = ""

main :: IO ()
main = do
  let s = "Some string."  
  mapM_ (\f -> putStrLn . f $ s) [remFirst, remLast, remBoth]</syntaxhighlight>

Alternative solution with builtin functions:
<syntaxhighlight lang="haskell">word = "knights"

main = do
    -- You can drop the first item
    -- using `tail`
    putStrLn (tail word)

    -- The `init` function will drop
    -- the last item
    putStrLn (init word)

    -- We can combine these two to drop
    -- the last and the first characters
    putStrLn (middle word)

-- You can combine functions using `.`,
-- which is pronounced "compose" or "of"
middle = init . tail</syntaxhighlight>

In short:
<syntaxhighlight lang="haskell">main :: IO ()
main = mapM_ print $ [tail, init, init . tail] <*> ["knights"]</syntaxhighlight>
{{Out}}
<pre>"nights"
"knight"
"night"</pre>

=={{header|Icon}} and {{header|Unicon}}==
The task is accomplished by sub-stringing.  
<syntaxhighlight lang="icon">procedure main()
write(s := "knight"," --> ", s[2:0])  # drop 1st char
write(s := "sock"," --> ", s[1:-1])   # drop last
write(s := "brooms"," --> ", s[2:-1]) # drop both
end</syntaxhighlight>

It could also be accomplished (less clearly) by assigning into the string as below.  Very awkward for both front and back.
<syntaxhighlight lang="icon">write(s := "knight"," --> ", s[1] := "", s)  # drop 1st char</syntaxhighlight>

=={{header|J}}==
The monadic primitives <code>}.</code> ([http://www.jsoftware.com/help/dictionary/d531.htm Behead]) and <code>}:</code> ([http://www.jsoftware.com/help/dictionary/d532.htm Curtail]) are useful for this task.

'''Example use:'''<br>
<syntaxhighlight lang="j">   }. 'knight'      NB. drop first item
night
   }: 'socks'       NB. drop last item
sock
   }: }. 'brooms'   NB. drop first and last items
room</syntaxhighlight>

=={{header|Java}}==
I solve this problem two ways.  First I use substring which is relatively fast for small strings, since it simply grabs the characters within a set of given bounds.  The second uses regular expressions, which have a higher overhead for such short strings, but work correctly with all Unicode code points, not just those in the Basic Multilingual Plane.

<syntaxhighlight lang="java">public class RM_chars {
  public static void main( String[] args ){
    System.out.println( "knight".substring( 1 ) );
    System.out.println( "socks".substring( 0, 4 ) );
    System.out.println( "brooms".substring( 1, 5 ) );
      // first, do this by selecting a specific substring
      // to exclude the first and last characters
    
    System.out.println( "knight".replaceAll( "^.", "" ) );
    System.out.println( "socks".replaceAll( ".$", "" ) );
    System.out.println( "brooms".replaceAll( "^.|.$", "" ) );
      // then do this using a regular expressions
  }
}</syntaxhighlight>

Results:
<pre>night
sock
room
night
sock
room</pre>

Nearly all current solutions for this task fail to work correctly: the task says "The program must reference logical characters (code points), not 8-bit code units for UTF-8 or 16-bit code units for UTF-16." The code below works correctly with all Unicode characters, without using regular expressions as the above program does.

<syntaxhighlight lang="java">public class SubstringTopAndTail {
  public static void main( String[] args ){
    var s = "\uD83D\uDC0Eabc\uD83D\uDC0E";  // Horse emoji, a, b, c, horse emoji: "🐎abc🐎"

    var sizeOfFirstChar = Character.isSurrogate(s.charAt(0)) ? 2 : 1;
    var sizeOfLastChar = Character.isSurrogate(s.charAt(s.length() - 1)) ? 2 : 1;

    var removeFirst = s.substring(sizeOfFirstChar);
    var removeLast = s.substring(0, s.length() - sizeOfLastChar);
    var removeBoth = s.substring(sizeOfFirstChar, s.length() - sizeOfLastChar);

    System.out.println(removeFirst);
    System.out.println(removeLast);
    System.out.println(removeBoth);
  }
}</syntaxhighlight>

Results:
<pre>abc🐎
🐎abc
abc</pre>

=={{header|JavaScript}}==
<syntaxhighlight lang="javascript">alert("knight".slice(1));       // strip first character
alert("socks".slice(0, -1));    // strip last character
alert("brooms".slice(1, -1));   // strip both first and last characters</syntaxhighlight>

=={{header|Joy}}==
<syntaxhighlight lang="joy">DEFINE
  dropfirst == 1 drop;
  droplast == dup size pred take.

"abcd" dropfirst.
"abcd" droplast.
"abcd" dropfirst droplast.</syntaxhighlight>
If a string is known to be non-empty, the <code>rest</code> operator could be used instead of <code>dropfirst</code>.
{{out}}
<pre>"bcd"
"abc"
"bc"</pre>

=={{header|jq}}==
jq uses 0-based indexing, so [1:] yields all but the first character, it being understood that data strings in jq are JSON strings. [0:-1], which can be abbreviated to [:-1], yields all but the last character, and so on. Here are some examples:<syntaxhighlight lang="jq">"一二三四五六七八九十"[1:]' => "二三四五六七八九十"

"一二三四五六七八九十"[:-1]' => "一二三四五六七八九"

"一二三四五六七八九十"[1:-1]' => "二三四五六七八九"

"a"[1:-1] # => ""
</syntaxhighlight>
Recent versions of jq also have regular expression support, with named captures. This leads to many other possibilities, e.g.<syntaxhighlight lang="jq">"abc" | capture( ".(?<monkey>.*)." ).monkey => "b"</syntaxhighlight>

=={{header|Julia}}==
<syntaxhighlight lang="julia">julia> "My String"[2:end] # without first character
"y String"

julia> "My String"[1:end-1] # without last character
"My Strin"

julia> "My String"[2:end-1] # without first and last characters
"y Strin"</syntaxhighlight>

=={{header|K}}==
K provides the system function <code>_di</code> to delete  an element at
a specified index. The following code is implemented using this feature.
<syntaxhighlight lang="k">
    s: "1234567890"
"1234567890"
    s _di 0 /Delete 1st character
"234567890"
    s _di -1+#s /Delete last character
"123456789"
    (s _di -1+#s) _di 0 /String with both 1st and last character removed
"23456789"
</syntaxhighlight>
Another way to implement without using the above system function:
<syntaxhighlight lang="k">
    s: "1234567890"
"1234567890"
    1 _ s  /Delete 1st character
"234567890"
    -1 _ s /Delete last character
"123456789"
    1 - -1 _ s /Delete 1st and last character
"23456789"
</syntaxhighlight>

=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.0.6
fun main(args: Array<String>) {
    val s = "Rosetta"
    println(s.drop(1))
    println(s.dropLast(1))
    println(s.drop(1).dropLast(1))
}</syntaxhighlight>

{{out}}
<pre>
osetta
Rosett
osett
</pre>

=={{header|Lambdatalk}}==
<syntaxhighlight lang="lisp">
{def R rosetta}                               -> rosetta

{W.rest {R}}                                  ->  osetta
{W.reverse {W.rest {W.reverse {R}}}}          -> rosett
{W.rest {W.reverse {W.rest {W.reverse {R}}}}} ->  osett

or 

{W.slice 1 {W.length {R}} {R}}                ->  osetta
{W.slice 0 {- {W.length {R}} 1} {R}}          -> rosett
{W.slice 1 {- {W.length {R}} 1} {R}}          ->  osett

{def J ストリング}                              -> ストリング

{W.rest {J}}                                  ->   トリング
{W.reverse {W.rest {W.reverse {J}}}}          -> ストリン
{W.rest {W.reverse {W.rest {W.reverse {J}}}}} ->   トリン

</syntaxhighlight>

=={{header|Lasso}}==

<syntaxhighlight lang="lasso">local(str = 'The quick grey rhino jumped over the lazy green fox.')

// String with first character removed
string_remove(#str,-startposition=1,-endposition=1)

// String with last character removed
string_remove(#str,-startposition=#str->size,-endposition=#str->size)

// String with both the first and last characters removed
string_remove(string_remove(#str,-startposition=#str->size,-endposition=#str->size),-startposition=1,-endposition=1)</syntaxhighlight>
{{out}}
<pre>he quick grey rhino jumped over the lazy green fox.
The quick grey rhino jumped over the lazy green fox
he quick grey rhino jumped over the lazy green fox</pre>

<syntaxhighlight lang="lasso">local(mystring = 'ÅÜÄÖカ')

#mystring -> remove(1,1)
#mystring
'<br />'
#mystring -> remove(#mystring -> size,1)
#mystring
'<br />'
#mystring -> remove(1,1)& -> remove(#mystring -> size,1)
#mystring</syntaxhighlight>
-> ÜÄÖカ

ÜÄÖ

Ä =={{header|Lasso}}==
<syntaxhighlight lang="lasso">local(str = 'The quick grey rhino jumped over the lazy green fox.')

// String with first character removed
string_remove(#str,-startposition=1,-endposition=1)
// > he quick grey rhino jumped over the lazy green fox.

// String with last character removed
string_remove(#str,-startposition=#str->size,-endposition=#str->size)
// > The quick grey rhino jumped over the lazy green fox

// String with both the first and last characters removed
string_remove(string_remove(#str,-startposition=#str->size,-endposition=#str->size),-startposition=1,-endposition=1)
// > he quick grey rhino jumped over the lazy green fox</syntaxhighlight>

=={{header|Liberty BASIC}}==
<syntaxhighlight lang="lb">string$ = "Rosetta Code"
Print Mid$(string$, 2)
Print Left$(string$, (Len(string$) - 1))
Print Mid$(string$, 2, (Len(string$) - 2))</syntaxhighlight>

=={{header|LiveCode}}==
<syntaxhighlight lang="livecode">put "pple" into x
answer char 2 to len(x) of x // pple
answer char 1 to -2 of x  // ppl
answer char 2 to -2 of x // ppl</syntaxhighlight>

=={{header|Locomotive Basic}}==

<syntaxhighlight lang="locobasic">10 a$="knight":b$="socks":c$="brooms"
20 PRINT MID$(a$,2)
30 PRINT LEFT$(b$,LEN(b$)-1)
40 PRINT MID$(c$,2,LEN(c$)-2)</syntaxhighlight>

=={{header|Logo}}==
<syntaxhighlight lang="logo">make "s "|My string|
print butfirst :s
print butlast :s
print butfirst butlast :s</syntaxhighlight>

=={{header|Logtalk}}==
Using atoms for representing strings: 
<syntaxhighlight lang="logtalk">
:- object(top_and_tail).

    :- public(test/1).
    test(String) :-
        sub_atom(String, 1, _, 0, MinusTop),
        write('String with first character cut: '), write(MinusTop), nl,
        sub_atom(String, 0, _, 1, MinusTail),
        write('String with last character cut: '), write(MinusTail), nl,
        sub_atom(String, 1, _, 1, MinusTopAndTail),
        write('String with first and last characters cut: '), write(MinusTopAndTail), nl.

:- end_object.
</syntaxhighlight>
Sample output:
<syntaxhighlight lang="text">
| ?- top_and_tail::test('Rosetta').
String with first character cut: osetta
String with last character cut: Rosett
String with first and last characters cut: osett
yes
</syntaxhighlight>

=={{header|Lua}}==

<syntaxhighlight lang="lua">print (string.sub("knights",2))    -- remove the first character
print (string.sub("knights",1,-2))    -- remove the last character
print (string.sub("knights",2,-2))    -- remove the first and last characters</syntaxhighlight>

=={{header|Maple}}==
There are several ways to do this.  The first is, I think, the simplest.
<syntaxhighlight lang="maple">> s := "some string":
> s[2..-1];
                              "ome string"

> s[1..-2];
                              "some strin"

> s[2..-2];
                              "ome strin"</syntaxhighlight>
The same functionality exists in the form of a procedure:
<syntaxhighlight lang="maple">> substring( s, 2 .. -1 );
                              "ome string"

> substring( s, 1 .. -2 );
                              "some strin"

> substring( s, 2 .. -2 );
                              "ome strin"</syntaxhighlight>
Furthermore, there is a slightly different version in the "StringTools" package:
<syntaxhighlight lang="maple">> use StringTools in
>     SubString( s, 2 .. -1 );
>     SubString( s, 1 .. -1 );
>     SubString( s, 2 .. -2 ) 
> end use;
                              "ome string"

                             "some string"

                              "ome strin"</syntaxhighlight>
(The difference between "substring" and "StringTools:-SubString" lies in how each treats a name as input; the former returns a name, while the latter returns a string.)

=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">StringDrop["input string",1]
StringDrop["input string",-1]
StringTake["input string",{2,-2}]
</syntaxhighlight>

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

The following case will not handle UTF-8. However, Matlab supports conversion of utf-8 to utf-16 using native2unicode().
<syntaxhighlight lang="matlab"> 
    % String with first character removed
    str(2:end)
    % String with last character removed
    str(1:end-1)
    % String with both the first and last characters removed 
    str(2:end-1)
</syntaxhighlight>

=={{header|MiniScript}}==
<syntaxhighlight lang="miniscript">test = "This thing"
print test[1:]
print test[:-1]
print test[1:-1]
</syntaxhighlight>
{{out}}
<pre>
his thing
This thin
his thin
</pre>

=={{header|MIPS Assembly}}==
Thanks to [https://www.chibialiens.com/mips/ Chibialiens] for the header/footer, font, and print routines.
<syntaxhighlight lang="mips">.include "\SrcAll\Header.asm"
.include "\SrcAll\BasicMacros.asm"
.include "\SrcALL\AdvancedMacros.asm"
.include "\SrcALL\MemoryMap.asm"

; .definelabel UserRam,0xA0010000		(this is defined in the header)

CursorX equ 0x100 ;offset from label UserRam
CursorY equ 0x101 ;offset from label UserRam

main:
	jal Cls
	nop
	
	la a0,MyString
	la a1,UserRam+0x1000
	push a0
	push a1
		jal strcpy
		addiu a0,1		;branch delay slot - increment base address prior to branching
	pop a0				;deliberately pop in the "wrong order"
	pop a1				;because printString uses $a0
	
	jal PrintString
	nop
	jal NewLine
	nop
	
	
	
	la a0,MyString
	la a1,UserRam+0x1000
	
	push a0
	push a1
		jal strcpy
		nop				;branch delay slot
		;after a strcpy, a0/a1 both point to the null terminator
		subiu a1,1
		move t0,zero
		sb t0,(a1)
		.ifdef buildPSX
			nop		;load delay slot
		.endif
	pop a0
	pop a1
	
	jal PrintString
	nop
	jal NewLine
	nop
	
	la a0,MyString
	la a1,UserRam+0x1000
	
	push a0
	push a1
		jal strcpy
		addiu a0,1	;branch delay slot
		;after a strcpy, a0/a1 both point to the null terminator
		subiu a1,1
		move t0,zero
		sb t0,(a1)
		.ifdef buildPSX
			nop		;load delay slot
		.endif
	pop a0
	pop a1
	
	jal PrintString
	nop
	jal NewLine
	nop
	
	
halt:
	nop
	j halt
	nop
	
	
MyString:
	.ascii "Hello World"
	.byte 0
	.align 4
	
MyFont:

.ifdef buildn64				
	.incbin "\ResN64\ChibiAkumas.fnt"
.endif
.ifdef buildPSX				
	.incbin "\ResPSX\ChibiAkumas.fnt"
.endif

.include "\SrcALL\graphics.asm"
.include "\SrcAll\monitor.asm"
.include "\SrcALL\Multiplatform_Math_Integer.asm"
.include "\SrcALL\BasicFunctions_v2.asm"
.include "\SrcN64\Footer.asm"</syntaxhighlight>
{{out}}
<pre>ello World
Hello Worl
ello Worl</pre>
[https://ibb.co/CHwTrMb Screenshot of PlayStation 1 Emulator]

=={{header|Neko}}==
Neko strings are mutable, fixed length buffers.  The '''$ssize''' builtin uses the allocated size, not any internal sentinel terminator byte.  With literals, the allocated size is the size of the data between quotes, i.e. no NUL byte appended.

'''$ssub''' ''sub-string'' takes string, position (zero-relative), length arguments. 
<syntaxhighlight lang="actionscript">/**
 Subtring/Top-Tail in Neko
*/

var data = "[this is a test]"
var len = $ssize(data)

$print(data, "\n")
$print($ssub(data, 1, len - 1), "\n")
$print($ssub(data, 0, len - 1), "\n")
$print($ssub(data, 1, len - 2), "\n")</syntaxhighlight>

{{out}}
<pre>prompt$ nekoc toptail.neko
prompt$ neko toptail.n
[this is a test]
this is a test]
[this is a test
this is a test</pre>

=={{header|Nemerle}}==
<syntaxhighlight lang="nemerle">using System;
using System.Console;

module RemoveChars
{
    Main() : void
    {
        def str = "*A string*";
        def end = str.Remove(str.Length - 1);  // from pos to end
        def beg = str.Remove(0, 1);            // start pos, # of chars to remove
        def both = str.Trim(array['*']);       // with Trim() you need to know what char's you're removing
        
        WriteLine($"$str -> $beg -> $end -> $both");
    }
}</syntaxhighlight>

=={{header|NetRexx}}==
<syntaxhighlight lang="netrexx">/**********************************************************************
* 02.08.2013 Walter Pachl  translated from REXX
**********************************************************************/
z = 'abcdefghijk'
l=z.length()
say '                  the original string =' z
If l>=1 Then Do
  Say 'string first        character removed =' z.substr(2)
  say 'string         last character removed =' z.left(l-1)
  End
If l>=2 Then
  Say 'string first & last character removed =' z.substr(2,l-2)</syntaxhighlight>

=={{header|NewLISP}}==
<syntaxhighlight lang="newlisp">(let (str "rosetta")
  ;; strip first char
  (println (1 str))
  ;; strip last char
  (println (0 -1 str))
  ;; strip both first and last characters
  (println (1 -1 str)))</syntaxhighlight>

=={{header|Nim}}==
<syntaxhighlight lang="nim">import unicode

let s = "Hänsel  ««: 10,00€"
echo "Original: ", s
echo "With first character removed: ", s.runeSubStr(1)
echo "With last character removed: ", s.runeSubStr(0, s.runeLen - 1)
echo "With first and last characters removed: ", s.runeSubStr(1, s.runeLen - 2)
# Using the runes type and slices
let r = s.toRunes
echo "With first and last characters removed (other way): ", r[1 .. ^2]</syntaxhighlight>
{{out}}
<pre>Original: Hänsel  ««: 10,00€
With first character removed: änsel  ««: 10,00€
With last character removed: Hänsel  ««: 10,00
With first and last characters removed: änsel  ««: 10,00
With first and last characters removed (other way): änsel  ««: 10,00</pre>

=={{header|Objeck}}==
<syntaxhighlight lang="objeck">
bundle Default {
   class TopTail {
      function : Main(args : System.String[]) ~ Nil {
         string := "test";
         string->SubString(1, string->Size() - 1)->PrintLine();
         string->SubString(string->Size() - 1)->PrintLine();
         string->SubString(1, string->Size() - 2)->PrintLine();
      }
   }
}
</syntaxhighlight>

=={{header|OCaml}}==

<syntaxhighlight lang="ocaml">let strip_first_char str =
  if str = "" then "" else
  String.sub str 1 ((String.length str) - 1)

let strip_last_char str =
  if str = "" then "" else
  String.sub str 0 ((String.length str) - 1)

let strip_both_chars str =
  match String.length str with
  | 0 | 1 | 2 -> ""
  | len -> String.sub str 1 (len - 2)

let () =
  print_endline (strip_first_char "knight");
  print_endline (strip_last_char "socks");
  print_endline (strip_both_chars "brooms");
;;</syntaxhighlight>

=={{header|Oforth}}==

<syntaxhighlight lang="oforth">: topAndTail(s)
    s right(s size 1-) println
    s left(s size 1-) println
    s extract(2, s size 1- ) println ;</syntaxhighlight>

{{out}}
<pre>
topAndTail("MyString")
yString
MyStrin
yStrin
</pre>

=={{header|PARI/GP}}==
<syntaxhighlight lang="parigp">df(s)=concat(vecextract(Vec(s),1<<#s-2));
dl(s)=concat(vecextract(Vec(s),1<<(#s-1)-1));
db(s)=concat(vecextract(Vec(s),1<<(#s-1)-2));</syntaxhighlight>

=={{header|Pascal}}==
''See also [[#Delphi|Delphi]]''
{{works with|Extended Pascal}}
<syntaxhighlight lang="pascal">program topAndTail(output);
var
	line: string(20);
begin
	line := 'ABCDEF';
	
	if length(line) > 1 then
	begin
		{ string with first character removed }
		writeLn(subStr(line, 2));
		{ index range expression: only possible for strings }
		{ _not_ designated `bindable` [e.g. `bindable string(20)`] }
		writeLn(line[2..length(line)]);
		
		{ string with last character removed }
		
		writeLn(subStr(line, 1, length(line) - 1));
		{ only legal with non-bindable strings: }
		writeLn(line[1..length(line)-1])
	end;
	
	{ string with both the first and last characters removed }
	if length(line) > 2 then
	begin
		writeLn(subStr(line, 2, length(line) - 2));
		{ only for non-bindable strings: }
		writeLn(line[2..length(line)-1])
	end
end.</syntaxhighlight>It is imperative that <tt>firstCharacterIndex + substringLength</tt> specified to <tt>subStr(source, firstCharacterIndex, substringLength)</tt> must be valid index in <tt>source</tt>. Therefore you need to perform checks beforehand.

=={{header|Perl}}==

<syntaxhighlight lang="perl">print substr("knight",1), "\n";        # strip first character
print substr("socks", 0, -1), "\n";    # strip last character
print substr("brooms", 1, -1), "\n";   # strip both first and last characters</syntaxhighlight>

In perl, we can also remove the last character from a string variable with the chop function:

<syntaxhighlight lang="perl">$string = 'ouch';
$bits = chop($string);       # The last letter is returned by the chop function
print $bits;        # h
print $string;      # ouc    # See we really did chop the last letter off</syntaxhighlight>

=={{header|Phix}}==
{{libheader|Phix/basics}}
<!--<syntaxhighlight lang="phix">-->
 <span style="color: #008080;">constant</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"(test)"</span>
 <span style="color: #0000FF;">?</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">2</span><span style="color: #0000FF;">..-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span>
 <span style="color: #0000FF;">?</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..-</span><span style="color: #000000;">2</span><span style="color: #0000FF;">]</span>
 <span style="color: #0000FF;">?</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">2</span><span style="color: #0000FF;">..-</span><span style="color: #000000;">2</span><span style="color: #0000FF;">]</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
"test)"
"(test"
"test"
</pre>

=={{header|Phixmonti}}==
<syntaxhighlight lang="phixmonti">include ..\Utilitys.pmt

"(test)"
dup 1 del ?
dup -1 del ?
dup 1 del -1 del ?</syntaxhighlight>
Or...
<syntaxhighlight lang="phixmonti">include ..\Utilitys.pmt

"(test)"
len 1 - 2 swap slice ?
len 1 - 1 swap slice ?
len 2 - 2 swap slice ?</syntaxhighlight>

=={{header|PHP}}==

<syntaxhighlight lang="php"><?php
echo substr("knight", 1), "\n";       // strip first character
echo substr("socks", 0, -1), "\n";    // strip last character
echo substr("brooms", 1, -1), "\n";   // strip both first and last characters
?></syntaxhighlight>

=={{header|Picat}}==
===Functions===
<syntaxhighlight lang="picat">go =>
  test("upraisers"),
  test("Δημοτική"),
  nl.

test(S) =>
  println(s=S),
  println(butfirst=S.slice(2)),
  println(butfirst=S.tail),
  println(butfirst=S[2..S.len]),  
  
  println(butlast=S.but_last()),
  
  println(butfirst_butlast=S.tail.but_last),
  println(butfirst_butlast=slice(S,2,S.length-1)),
  println(butfirst_butlast=[S[I] : I in 2..S.length-1]),
  println(butfirst_butlast=S[2..S.length-1]),  
  nl.

but_last(S)  = S.slice(1,S.length-1).</syntaxhighlight>

{{out}}
<pre>s = upraisers
butfirst = praisers
butfirst = praisers
butfirst = praisers
butlast = upraiser
butfirst_butlast = praiser
butfirst_butlast = praiser
butfirst_butlast = praiser
butfirst_butlast = praiser

s = Δημοτική
butfirst = ημοτική
butfirst = ημοτική
butfirst = ημοτική
butlast = Δημοτικ
butfirst_butlast = ημοτικ
butfirst_butlast = ημοτικ
butfirst_butlast = ημοτικ
butfirst_butlast = ημοτικ</pre>

===Using append/3===
{{trans|Prolog}}
<syntaxhighlight lang="picat">go2 =>
  test2("upraisers"),
  nl,
  test2("Δημοτική"),
  nl.

test2(L) :-
    L = [_|L1],
    remove_last(L, L2),
    remove_last(L1, L3),
    writef("Original string          : %s\n", L),
    writef("Without first char       : %s\n", L1),
    writef("Without last char        : %s\n", L2),
    writef("Without first/last chars : %s\n", L3).
 
remove_last(L, LR) :-
    append(LR, [_], L).</syntaxhighlight>

{{out}}
<pre>Original string          : upraisers
Without first char       : praisers
Without last char        : upraiser
Without first/last chars : praiser

Original string          : Δημοτική
Without first char       : ημοτική
Without last char        : Δημοτικ
Without first/last chars : ημοτικ</pre>

=={{header|PicoLisp}}==
<syntaxhighlight lang="picolisp">: (pack (cdr (chop "knight")))         # Remove first character
-> "night"

: (pack (head -1 (chop "socks")))      # Remove last character
-> "sock"

: (pack (cddr (rot (chop "brooms"))))  # Remove first and last characters
-> "room"</syntaxhighlight>

=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
declare s character (100) varying;
s = 'now is the time to come to the aid of the party';
if length(s) <= 2 then stop;
put skip list ('First character removed=' || substr(s,2) );
put skip list ('Last character removed='  || substr(s, 1, length(s)-1) );
put skip list ('One character from each end removed=' ||
   substr(s, 2, length(s)-2) );
</syntaxhighlight>
OUTPUT:
<pre>
First character removed=ow is the time to come to the aid of the party
Last character removed=now is the time to come to the aid of the part 
One character from each end removed=ow is the time to come to the aid of the part 
</pre>

=={{header|Plain English}}==
<syntaxhighlight lang="plainenglish">To run:
Start up.
Demonstrate removing the first and last characters from "Rosetta Code".
Wait for the escape key.
Shut down.

To demonstrate removing the first and last characters from a string:
Slap a substring on the string.
Add 1 to the substring's first.
Write the substring on the console.
Subtract 1 from the substring's first.
Subtract 1 from the substring's last.
Write the substring on the console.
Add 1 to the substring's first.
Write the substring on the console.</syntaxhighlight>
{{out}}
<pre>
osetta Code
Rosetta Cod
osetta Cod
</pre>

=={{header|PowerShell}}==
{{works with|PowerShell|4.0}}
===First method===
<syntaxhighlight lang="powershell">
$string = "top and tail"
$string
$string.Substring(1)
$string.Substring(0, $string.Length - 1)
$string.Substring(1, $string.Length - 2)
</syntaxhighlight>
===Second method===
<syntaxhighlight lang="powershell">
$string = "top and tail"
$string
$string[1..($string.Length - 1)] -join ""
$string[0..($string.Length - 2)] -join ""
$string[1..($string.Length - 2)] -join ""
</syntaxhighlight>
<b>Output:</b>
<pre>
top and tail
op and tail
top and tai
op and tai
</pre>

=={{header|Prolog}}==
Works with SWI-Prolog.

<syntaxhighlight lang="prolog">remove_first_last_chars :-
    L = "Rosetta",
    L = [_|L1],
    remove_last(L, L2),
    remove_last(L1, L3),
    writef('Original string      : %s\n', [L]),
    writef('Without first char       : %s\n', [L1]),
    writef('Without last char        : %s\n', [L2]),
    writef('Without first/last chars : %s\n', [L3]).

remove_last(L, LR) :-
    append(LR, [_], L).</syntaxhighlight>
Output :
<pre> ?- remove_first_last_chars.
Original string          : Rosetta
Without first char       : osetta
Without last char        : Rosett
Without first/last chars : osett
true.
</pre>

=={{header|PureBasic}}==
<syntaxhighlight lang="purebasic">If OpenConsole()  
  PrintN(Right("knight", Len("knight") - 1))  ;strip the first letter
  PrintN(Left("socks", Len("socks")- 1))      ;strip the last letter
  PrintN(Mid("brooms", 2, Len("brooms") - 2)) ;strip both the first and last letter
  
  Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
  CloseConsole()
EndIf</syntaxhighlight>
Sample output:
<pre>night
sock
room</pre>

=={{header|Python}}==

<syntaxhighlight lang="python">print "knight"[1:]     # strip first character
print "socks"[:-1]     # strip last character
print "brooms"[1:-1]   # strip both first and last characters</syntaxhighlight>


Or, composing atomic functional expressions for these slices:
<syntaxhighlight lang="python">from functools import (reduce)


def main():
    for xs in transpose(
        (chunksOf(3)(
            ap([tail, init, compose(init)(tail)])(
                ['knights', 'socks', 'brooms']
            )
        ))
    ):
        print(xs)


# GENERIC -------------------------------------------------

# tail :: [a] -> [a]
def tail(xs):
    return xs[1:]


# init::[a] - > [a]
def init(xs):
    return xs[:-1]


# ap (<*>) :: [(a -> b)] -> [a] -> [b]
def ap(fs):
    return lambda xs: reduce(
        lambda a, f: a + reduce(
            lambda a, x: a + [f(x)], xs, []
        ), fs, []
    )


# chunksOf :: Int -> [a] -> [[a]]
def chunksOf(n):
    return lambda xs: reduce(
        lambda a, i: a + [xs[i:n + i]],
        range(0, len(xs), n), []
    ) if 0 < n else []


# compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
def compose(g):
    return lambda f: lambda x: g(f(x))


# transpose :: [[a]] -> [[a]]
def transpose(xs):
    return list(map(list, zip(*xs)))


if __name__ == '__main__':
    main()</syntaxhighlight>
{{Out}}
<pre>['nights', 'knight', 'night']
['ocks', 'sock', 'ock']
['rooms', 'broom', 'room']</pre>

=={{header|Quackery}}==

As a dialogue in the Quackery shell.

<pre>/O> $ "callipygian"
... say "original string:   "
... dup echo$ cr
... say "without head:      "
... dup behead drop echo$ cr
... say "without tail:      "
... -1 split drop dup echo$ cr
... say "topped and tailed: "
... behead drop echo$ cr
... 
original string:   callipygian
without head:      allipygian
without tail:      callipygia
topped and tailed: allipygia
</pre>

=={{header|Racket}}==

<syntaxhighlight lang="racket">
#lang racket

(define str "ストリング")

(substring str 1)
(substring str 0 (sub1 (string-length str)))
(substring str 1 (sub1 (string-length str)))
</syntaxhighlight>

Output:

<pre>
"トリング"
"ストリン"
"トリン"
</pre>

=={{header|Raku}}==
(formerly Perl 6)

Raku provides both functional and method forms of substr. Note that, unlike in Perl 5, offsets from the end do not use negative numbers, but instead require a function expressing the negative offset relative to the length parameter, which is supplied by the operator.  The form <tt>*-1</tt> is just a simple way to write such a function. 

We use musical sharps and flats to illustrate that Raku is comfortable with characters from any Unicode plane.

<syntaxhighlight lang="raku" line>my $s = '𝄪♯♮♭𝄫';

print qq:to/END/;
    Original:
    $s

    Remove first character:
    { substr($s, 1) }
    { $s.substr(1) }

    Remove last character:
    { substr($s, 0, *-1) }
    { $s.substr( 0, *-1) }
    { $s.chop }

    Remove first and last characters:
    { substr($s, 1, *-1) }
    { $s.substr(1, *-1) }
    END</syntaxhighlight>
{{out}}
<pre>Original:
𝄪♯♮♭𝄫

Remove first character:
♯♮♭𝄫
♯♮♭𝄫
 
Remove last character:
𝄪♯♮♭
𝄪♯♮♭
𝄪♯♮♭
 
Remove first and last characters:
♯♮♭
♯♮♭</pre>

=={{header|Raven}}==
<syntaxhighlight lang="raven">define println use $s
   $s print "\n" print

"0123456789" as $str

define offTheTop use $s
   $s 1 0x7FFFFFFF extract

define offTheTail use $s
   $s 0 -1 extract


$str offTheTop  println
$str offTheTail println
$str offTheTop  offTheTail  println</syntaxhighlight>
{{out}}
<pre>123456789
012345678
12345678</pre>

=={{header|REXX}}==
===error prone===
This REXX version is error prone in that if the string is less than two characters, then the &nbsp; '''left''' &nbsp; and/or &nbsp; '''substr''' &nbsp; BIFs will fail &nbsp; (because of an invalid length specified).  
<syntaxhighlight lang="rexx">/*REXX program demonstrates removal of  1st/last/1st-and-last  characters from a string.*/
@ = 'abcdefghijk'
say '                  the original string ='  @
say 'string first        character removed ='  substr(@, 2)
say 'string         last character removed ='  left(@, length(@) -1)
say 'string first & last character removed ='  substr(@, 2, length(@) -2)
                                                 /*stick a fork in it,  we're all done. */
   /* ╔═══════════════════════════════════════════════════════════════════════════════╗
      ║  However, the original string may be null or exactly one byte in length which ║
      ║  will cause the  BIFs to fail because of  either zero  or  a negative length. ║
      ╚═══════════════════════════════════════════════════════════════════════════════╝ */</syntaxhighlight>
'''output'''
<pre>
                  the original string = abcdefghijk
string first        character removed = bcdefghijk
string         last character removed = abcdefghij
string first & last character removed = bcdefghij
</pre>

===robust version===
This REXX version correctly handles a string of zero (null) or one byte.
<syntaxhighlight lang="rexx">/*REXX program demonstrates removal of  1st/last/1st-and-last  characters from a string.*/
@ = 'abcdefghijk'
say '                  the original string ='  @
say 'string first        character removed ='  substr(@, 2)
say 'string         last character removed ='  left(@, max(0, length(@) -1))
say 'string first & last character removed ='  substr(@, 2, max(0, length(@) -2))
exit                                             /*stick a fork in it,  we're all done. */

                              /* [↓]  an easier to read version using a length variable.*/
@ = 'abcdefghijk'
L=length(@)
say '                  the original string ='  @
say 'string first        character removed ='  substr(@, 2)
say 'string         last character removed ='  left(@, max(0, L-1) )
say 'string first & last character removed ='  substr(@, 2, max(0, L-2) )</syntaxhighlight>
'''output''' &nbsp; is the same as the 1<sup>st</sup> REXX version.

===faster version===
This REXX version is faster &nbsp; (uses &nbsp; '''parse''' &nbsp; instead of multiple BIFs).
<syntaxhighlight lang="rexx">/*REXX program demonstrates removal of  1st/last/1st-and-last  characters from a string.*/
@ = 'abcdefghijk'
say '                  the original string =' @

parse var @ 2 z
say 'string first        character removed =' z

m=length(@) - 1
parse var @ z +(m)
say 'string         last character removed =' z

n=length(@) - 2
parse var @ 2 z +(n)
if n==0  then z=                                /*handle special case of a length of 2.*/
say 'string first & last character removed =' z /*stick a fork in it,  we're all done. */</syntaxhighlight>
'''output''' &nbsp; is the same as the 1<sup>st</sup> REXX version. <br><br>

=={{header|Ring}}==
<syntaxhighlight lang="ring">
aString = "1Welcome to the Ring Programming Language2"
see substr(aString,2,len(aString)-1) + nl +
substr(aString,1,len(aString)-1) + nl +
substr(aString,2,len(aString)-2) + nl
</syntaxhighlight>

=={{header|RPL}}==
Basic RPL:
 "Knight" 2 OVER SIZE SUB
 "Socks" 1 OVER SIZE 1 - SUB
 "Brooms" 2 OVER SIZE 1 - SUB
From HP-48 versions, one can also do this way:
 "Knight" TAIL
 "Socks" REVLIST TAIL REVLIST
 "Brooms" TAIL REVLIST TAIL REVLIST
{{out}}
<pre>
3: night
2: Sock
1: room
</pre>

=={{header|Ruby}}==

<syntaxhighlight lang="ruby">puts "knight"[1..-1]   # strip first character
puts "socks"[0..-2]    # strip last character
puts "socks".chop      # alternate way to strip last character
puts "brooms"[1..-2]   # strip both first and last characters
puts "与今令"[1..-2]    # => 今</syntaxhighlight>

=={{header|Run BASIC}}==
<syntaxhighlight lang="runbasic">s$  = "Run BASIC"
print mid$(s$,2)             'strip first
print left$(s$,len(s$) -1)   'strip last
print mid$(s$,2,len(s$) -2)  'strip first and last</syntaxhighlight>

=={{header|Rust}}==
One possibility is to modify the owned string representation:
<syntaxhighlight lang="rust">fn main() {
    let s = String::from("žluťoučký kůň");

    let mut modified = s.clone();
    modified.remove(0);
    println!("{}", modified);

    let mut modified = s.clone();
    modified.pop();
    println!("{}", modified);

    let mut modified = s;
    modified.remove(0);
    modified.pop();
    println!("{}", modified);
}</syntaxhighlight>

Another possibility is to cut a string slice (moreover, this version assumes
nothing about the string length):
<syntaxhighlight lang="rust">fn main() {
    let s = "žluťoučký kůň";

    println!(
        "{}",
        s.char_indices()
            .nth(1)
            .map(|(i, _)| &s[i..])
            .unwrap_or_default()
    );

    println!(
        "{}",
        s.char_indices()
            .nth_back(0)
            .map(|(i, _)| &s[..i])
            .unwrap_or_default()
    );

    println!(
        "{}",
        s.char_indices()
            .nth(1)
            .and_then(|(i, _)| s.char_indices().nth_back(0).map(|(j, _)| i..j))
            .map(|range| &s[range])
            .unwrap_or_default()
    );
}</syntaxhighlight>

=={{header|Scala}}==
{{libheader|Scala}}
<syntaxhighlight lang="scala">println("knight".tail)               // strip first character
println("socks".init)         // strip last character
println("brooms".tail.init)   // strip both first and last characters</syntaxhighlight>

=={{header|Scheme}}==
<syntaxhighlight lang="scheme">(define (string-top s)
  (if (string=? s "") s (substring s 0 (- (string-length s) 1))))

(define (string-tail s)
  (if (string=? s "") s (substring s 1 (string-length s))))

(define (string-top-tail s)
  (string-tail (string-top s)))</syntaxhighlight>

=={{header|sed}}==
Remove the first character:
<syntaxhighlight lang="sed">s/.//</syntaxhighlight>
Remove the last character:
<syntaxhighlight lang="sed">s/.$//</syntaxhighlight>
Remove the first and the last character in one step (a bit more complex, to correctly handle single-character strings):
<syntaxhighlight lang="sed">s/.\(\(.*\).\)\{0,1\}/\2/</syntaxhighlight>

=={{header|Seed7}}==
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";

const proc: main is func
  local
    const string: stri is "upraisers";
  begin
    writeln("Full string:   " <& stri);
    writeln("Without first: " <& stri[2 ..]);
    writeln("Without last:  " <& stri[.. pred(length(stri))]);
    writeln("Without both:  " <& stri[2 .. pred(length(stri))]);
  end func;</syntaxhighlight>

Output:
<pre>
Full string:   upraisers
Without first: praisers
Without last:  upraiser
Without both:  praiser
</pre>

=={{header|SenseTalk}}==
<syntaxhighlight lang="sensetalk">
set message to peaceSymbol & "Peace!"
put message
put characters second to last of message
put characters 1 to -2 of message
put the second to penultimate characters of message
</syntaxhighlight>
Output:
<syntaxhighlight lang="sensetalk">
☮Peace!
Peace!
☮Peace
Peace
</syntaxhighlight>

=={{header|Sidef}}==
Strip any characters:
<syntaxhighlight lang="ruby">say "knight".substr(1);       # strip first character
say "socks".substr(0, -1);    # strip last character
say "brooms".substr(1, -1);   # strip both first and last characters
say "与今令".substr(1, -1);    # => 今</syntaxhighlight>
{{out}}
<pre>
night
sock
room
今
</pre>

Strip graphemes:
<syntaxhighlight lang="ruby">var gstr = "J\x{332}o\x{332}s\x{332}e\x{301}\x{332}";
say gstr-/^\X/;                    # strip first grapheme
say gstr-/\X\z/;                   # strip last grapheme
say gstr.sub(/^\X/).sub(/\X\z/);   # strip both first and last graphemes</syntaxhighlight>
{{out}}
<pre>
o̲s̲é̲
J̲o̲s̲
o̲s̲
</pre>

=={{header|Smalltalk}}==
{{works with|GNU Smalltalk}}
These all use built-in collection methods that will work with any kind of ordered collection, not just Strings. There is no error checking. They will fail if the string is not at least two characters long.
<syntaxhighlight lang="smalltalk">
s := 'upraisers'.
Transcript show: 'Top: ', s allButLast; nl. 
Transcript show: 'Tail: ', s allButFirst; nl.   
Transcript show: 'Without both: ', s allButFirst allButLast; nl.    
Transcript show: 'Without both using substring method: ', (s copyFrom: 2 to: s size - 1); nl.
</syntaxhighlight>
{{out}}
<pre>
Top: upraiser                                                                                                                           
Tail: praisers                                                                                                                          
Without both: praiser                                                                                                                   
Without both using substring method: praiser </pre>

=={{header|SNOBOL4}}==
<syntaxhighlight lang="snobol4">     "knight" len(1) rem . output       ;* strip first character
     "socks" rtab(1) . output           ;* strip last character
     "brooms" len(1) rtab(1) . output   ;* strip both first and last characters</syntaxhighlight>

=={{header|Standard ML}}==
<syntaxhighlight lang="sml">- val str = "abcde";
val str = "abcde" : string
- String.substring(str, 1, String.size str - 1);
val it = "bcde" : string
- String.substring(str, 0, String.size str - 1);
val it = "abcd" : string
- String.substring(str, 1, String.size str - 2);
val it = "bcd" : string</syntaxhighlight>

=={{header|Swift}}==
Swift strings are native Unicode strings and do not index through the code points. Swift's <code>String.Index</code> refers to true Unicode characters (Unicode grapheme clusters). Swift standard library has generic functionality that not only works with strings, but also with any type that conforms to relevant protocols. The first method presented here uses generic functions from Swift standard library: 

<syntaxhighlight lang="swift">let txt = "0123456789"
println(dropFirst(txt))
println(dropLast(txt))
println(dropFirst(dropLast(txt)))</syntaxhighlight>
{{out}}
<pre>123456789
012345678
12345678</pre>
The other method is slicing by range subscripting:
<syntaxhighlight lang="swift">let txt = "0123456789"
println(txt[txt.startIndex.successor() ..< txt.endIndex])
println(txt[txt.startIndex             ..< txt.endIndex.predecessor()])
println(txt[txt.startIndex.successor() ..< txt.endIndex.predecessor()])</syntaxhighlight>
{{out}}
<pre>123456789
012345678
12345678</pre>
Another way is mutating the string:
<syntaxhighlight lang="swift">var txt = "0123456789"
txt.removeAtIndex(txt.startIndex)
txt.removeAtIndex(txt.endIndex.predecessor())</syntaxhighlight>
The above functions return what they remove.
You can also extend String type and define BASIC-style functions:
<syntaxhighlight lang="swift">extension String {
    
    /// Ensure positive indexes
    
    private func positive(index: Int) -> Int {
        
        if index >= 0 { return index }
        
        return count(self) + index
    }
    
    /// Unicode character by zero-based integer (character) `index`
    /// Supports negative character index to count from end. (-1 returns character before last)
    
    subscript(index: Int) -> Character {
        
        return self[advance(startIndex, positive(index))]
    }
    
    /// String slice by character index
    
    subscript(range: Range<Int>) -> String {
        
        return self[advance(startIndex, range.startIndex) ..<
                    advance(startIndex, range.endIndex, endIndex)]
    }
    
    /// Left portion of text to `index`
    
    func left(index : Int) -> String {
        
        return self[0 ..< positive(index)]
    }
    
    /// Right portion of text from `index`
    
    func right(index : Int) -> String{
        
        return self[positive(index) ..< count(self)]
    }
    
    /// From `start` index until `end` index
    
    func mid(start: Int, _ end: Int) -> String {
        
        return self[positive(start) ..< positive(end)]
    }
    
}

let txt = "0123456789"

txt.right(1) // Right part without first character
txt.left(-1) // Left part without last character
txt.mid(1,-1) // Middle part without first and last character</syntaxhighlight>

=={{header|Tcl}}==
<syntaxhighlight lang="tcl">puts [string range "knight" 1 end];       # strip first character
puts [string range "write" 0 end-1];        # strip last character
puts [string range "brooms" 1 end-1];       # strip both first and last characters</syntaxhighlight>

=={{header|TorqueScript}}==
String with first character removed
  %string = "Moo";
  %string = getSubStr(%string, 1, strLen(%string) - 1);
  echo(%string);
String with last character removed
  %string = "Moo";
  %string = getSubStr(%string, 0, strLen(%string) - 1);
  echo(%string);
String with both the first and last characters removed
  %string = "Moo";
  %string = getSubStr(%string, 1, strLen(%string) - 2);
  echo(%string);


Output:
  oo
  Mo
  o

=={{header|TUSCRIPT}}==
<syntaxhighlight lang="tuscript">
$$ MODE TUSCRIPT
str="upraisers"
str1=EXTRACT (str,2,0)
str2=EXTRACT (str,0,-1)
str3=EXTRACT (str,2,-1)
PRINT str
PRINT str1
PRINT str2
PRINT str3
</syntaxhighlight>
Output:
<pre>
upraisers
praisers
upraiser
upraiser 
</pre>

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

First ''or'' last character:

<syntaxhighlight lang="bash">str='abcdefg'
echo "${str#?}"   # Remove first char
echo "${str%?}"   # Remove last char</syntaxhighlight>

First ''and'' last character:

: Only zsh supports nested string manipulation.
: <syntaxhighlight lang="bash">echo ${${str#?}%?}   # Remove first & last chars</syntaxhighlight>
: bash and ksh, use substring expansion, from character index 1 for length of (string length) minus 2
: <syntaxhighlight lang="bash">echo "${s:1:${#s}-2}"</syntaxhighlight>
: POSIX shells like dash, need a temp variable
: <syntaxhighlight lang="bash">tmp=${s#?}; tmp=${tmp%?}; echo "$tmp"</syntaxhighlight>

=={{header|Vala}}==
<syntaxhighlight lang="vala">
// declare test string
string s = "Hello, world!";
// remove first letter
string s_first = s[1:s.length];
//remove last letter
string s_last = s[0:s.length - 1];
// remove first and last letters
string s_first_last = s[1:s.length - 1];
</syntaxhighlight>

=={{header|VBScript}}==
<syntaxhighlight lang="vbscript">Function TopNTail(s,mode)
    Select Case mode
        Case "top"
            TopNTail = Mid(s,2,Len(s)-1)
        Case "tail"
            TopNTail = Mid(s,1,Len(s)-1)
        Case "both"
            TopNTail = Mid(s,2,Len(s)-2)
    End Select
End Function

WScript.Echo "Top: UPRAISERS = " & TopNTail("UPRAISERS","top")
WScript.Echo "Tail: UPRAISERS = " & TopNTail("UPRAISERS","tail")
WScript.Echo "Both: UPRAISERS = " & TopNTail("UPRAISERS","both")</syntaxhighlight>

{{out}}
<pre>Top: UPRAISERS = PRAISERS
Tail: UPRAISERS = UPRAISER
Both: UPRAISERS = PRAISER</pre>

=={{header|Wren}}==
{{libheader|Wren-str}}
As Wren's string slicing and other built-in methods generally work at the byte level, we use the above module for this task which works at the code-point level. 
<syntaxhighlight lang="wren">import "./str" for Str

var a = "Beyoncé"
var b = Str.delete(a, 0)
var len = a.codePoints.count
var c = Str.delete(a, len-1)
var d = Str.delete(c, 0)
for (e in [a, b, c, d]) System.print(e)</syntaxhighlight>

{{out}}
<pre>
Beyoncé
eyoncé
Beyonc
eyonc
</pre>

=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">include c:\cxpl\stdlib;
char S, P;
[S:= "Smiles";
Text(0, S+1);           \first character removed
CrLf(0);
P:= S + StrLen(S) - 2;  \point to last character in string
P(0):= P(0) ! $80;      \set the MSb on the last character
Text(0, S);             \last character removed
CrLf(0);
Text(0, S+1);           \first and last characters removed
CrLf(0);
]</syntaxhighlight>

Output:
<pre>
miles
Smile
mile
</pre>

=={{header|zkl}}==
<syntaxhighlight lang="zkl">"Smiles"[1,*]  //-->miles
"Smiles"[0,-1] //-->Smile
"Smiles"[1,-1] //-->mile</syntaxhighlight>
[] format is [offset (zero based), length].  * means "to the end", a
negative number means from the end.

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

<syntaxhighlight lang="zxbasic">10 PRINT FN f$("knight"): REM strip the first letter. You can also write PRINT "knight"(2 TO)
20 PRINT FN l$("socks"): REM strip the last letter
30 PRINT FN b$("brooms"): REM strip both the first and last letter
100 STOP

9000 DEF FN f$(a$)=a$(2 TO LEN(a$))
9010 DEF FN l$(a$)=a$(1 TO LEN(a$)-(1 AND (LEN(a$)>=1)))
9020 DEF FN b$(a$)=FN l$(FN f$(a$)) </syntaxhighlight>

{{omit from|GUISS}}
{{omit from|Openscad}}