文字変数を操作するための基本手順#
len#
名前#
len(3) - [CHARACTER] 文字エンティティの長さ
概要#
result = len(string [,kind])
integer(kind=KIND) function len(string,KIND)
character(len=*),intent(in) :: string(..)
integer,optional,intent(in) :: KIND
特性#
string はスカラーまたは配列の文字変数です。
KIND はスカラー整数定数式です。
返される値は、kind 引数と同じ整数種類、またはkind が指定されていない場合はデフォルトの整数種類です。
説明#
len(3) は文字列の長さを返します。
string が配列の場合、配列のすべての要素の長さが同じであるため、string の単一要素の長さが返されます。
この組込み関数が呼び出されたときにstring が定義されている必要はありません。string の長さ（内容ではない）のみが必要だからです。
オプション#
- string
長さを返すスカラーまたは配列文字列。割り当て済みの割り当て可能な変数、または関連付けられていないポインタの場合、その長さ型パラメータは遅延指定されてはいけません。
- kind
結果のkind パラメータを示す定数。
結果#
結果は、STRING がスカラーの場合、STRING の文字数と等しくなります。STRING が配列の場合は、STRING の要素の文字数と等しくなります。
例#
サンプルプログラム
program demo_len
implicit none
! fixed length
character(len=40) :: string
! allocatable length
character(len=:),allocatable :: astring
character(len=:),allocatable :: many_strings(:)
integer :: ii
! BASIC USAGE
ii=len(string)
write(*,*)'length =',ii
! ALLOCATABLE VARIABLE LENGTH CAN CHANGE
! the allocatable string length will be the length of RHS expression
astring=' How long is this allocatable string? '
write(*,*)astring, ' LEN=', len(astring)
! print underline
write(*,*) repeat('=',len(astring))
! assign new value to astring and length changes
astring='New allocatable string'
write(*,*)astring, ' LEN=', len(astring)
! print underline
write(*,*) repeat('=',len(astring))
! THE STRING LENGTH WILL BE CONSTANT FOR A FIXED-LENGTH VARIABLE
string=' How long is this fixed string? '
write(*,*)string,' LEN=',len(string)
string='New fixed string '
write(*,*)string,' LEN=',len(string)
! ALL STRINGS IN AN ARRAY ARE THE SAME LENGTH
! a scalar is returned for an array, as all values in a Fortran
! character array must be of the same length.
many_strings = [ character(len=7) :: 'Tom', 'Dick', 'Harry' ]
write(*,*)'length of ALL elements of array=',len(many_strings)
! NAME%LEN IS ESSENTIALLY THE SAME AS LEN(NAME)
! you can also query the length (and other attributes) of a string
! using a "type parameter inquiry" (available since fortran 2018)
write(*,*)'length from type parameter inquiry=',string%len
! %len is equivalent to a call to LEN() except the kind of the integer
! value returned is always of default kind.
! LOOK AT HOW A PASSED STRING CAN BE USED ...
call passed(' how long? ')
contains
subroutine passed(str)
character(len=*),intent(in) :: str
! the length of str can be used in the definitions of variables
! you can query the length of the passed variable
write(*,*)'length of passed value is ', LEN(str)
end subroutine passed
end program demo_len
結果
> length = 40
> How long is this allocatable string? LEN= 38
> ======================================
> New allocatable string LEN= 22
> ======================
> How long is this fixed string? LEN= 40
> New fixed string LEN= 40
> length of ALL elements of array= 7
> length from type parameter inquiry= 40
> length of passed value is 11
標準#
FORTRAN 77; kind 引数付き - Fortran 2003
関連項目#
len_trim(3)、adjustr(3)、trim(3)、およびadjustl(3) は、先頭と末尾の空白を処理できる関連ルーチンです。
文字列に対して操作を実行し、引数の長さを返し、特定の引数を検索する関数
非要素関数: len_trim(3)、len(3)、repeat(3)、trim(3)
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
new_line#
名前#
new_line(3) - [CHARACTER:INQUIRY] 改行文字
概要#
result = new_line(c)
character(len=1,kind=KIND) function new_line(c)
character(len=1,kind=KIND),intent(in) :: c(..)
特性#
c は文字型である必要があります。スカラーまたは配列にすることができます。
結果は、c と同じ kind 型パラメータを持つ長さ1の文字スカラーです。
説明#
new_line(3) は改行文字を返します。
通常、改行は、各ステートメントの完了時にWRITE()およびPRINT()などの通常のフォーマット済みI/Oステートメントによって生成されます。
print *, 'x=11'
print *
print *, 'y=22'
end
生成します
x=11
y=22
あるいは、フォーマット内の「/」記述子は、出力に改行を生成するために使用されます。例えば
write(*,'(a,1x,i0,/,a)') 'x =',11,'is the answer'
end
生成します
x = 11
is the answer
また、フォーマット済み順次出力の場合、出力ステートメントに、フォーマットステートメントで表現できるよりも多くのデータがリストされている場合、改行が生成され、出力リストがなくなるまでフォーマットが再利用されます。
write(*,'(a,"=",i0)') 'x', 10, 'y', 20
end
生成します
x=10
y=20
しかし、特に、非アドバンシングI/OまたはストリームI/Oが生成されている場合（通常発生するように、各WRITEステートメントの最後に改行を生成しません）、出力に指定された箇所に改行を明示的に配置することが望ましい場合があります。
そのためには、上記の方法で自動的に行われるように、正しい改行文字を生成していることを確認する必要があります。
改行文字はプラットフォームによって異なり、出力ファイルのエンコーディング（つまり、どの文字セットが使用されているか）にも依存する場合があります。これらの場合、出力する正しい文字の選択は、new_line(3) プロシージャによって決定できます。
オプション#
- c
改行を表す出力文字を決定するために使用される kind を持つ任意の文字。
結果#
- ケース(i)
a がデフォルトの文字であり、ASCII 照合シーケンスの位置10の文字がデフォルトの文字セットで表現可能な場合、結果はachar(10)になります。
これは典型的なケースであり、「new_line('a')」を使用するだけで済みます。
- ケース(ii)
a がASCII文字またはISO 10646文字の場合、結果はchar(10, kind(a))になります。
- ケース(iii)
それ以外の場合、結果は、フォーマット済みストリーム出力用に接続されたファイルへの出力において改行を表すプロセッサ依存の文字です（そのような文字が存在する場合）。
- ケース(iv)
上記のケースのいずれにも当てはまらない場合、結果は空白文字になります。
例#
サンプルプログラム
program demo_new_line
implicit none
character,parameter :: nl=new_line('a')
character(len=:),allocatable :: string
real :: r
integer :: i, count
! basics
! print a string with a newline embedded in it
string='This is record 1.'//nl//'This is record 2.'
write(*,'(a)') string
! print a newline character string
write(*,'(*(a))',advance='no') &
nl,'This is record 1.',nl,'This is record 2.',nl
! output a number of words of random length as a paragraph
! by inserting a new_line before line exceeds 70 characters
! simplistic paragraph print using non-advancing I/O
count=0
do i=1,100
! make some fake word of random length
call random_number(r)
string=repeat('x',int(r*10)+1)
count=count+len(string)+1
if(count.gt.70)then
write(*,'(a)',advance='no')nl
count=len(string)+1
endif
write(*,'(1x,a)',advance='no')string
enddo
write(*,'(a)',advance='no')nl
end program demo_new_line
結果
This is record 1.
This is record 2.
This is record 1.
This is record 2.
x x xxxx xxxxxxx xxxxxxxxxx xxxxxxxxx xxxx xxxxxxxxxx xxxxxxxx
xxxxxxxxx xxxx xxxxxxxxx x xxxxxxxxx xxxxxxxx xxxxxxxx xxxx x
xxxxxxxxxx x x x xxxxxx xxxxxxxxxx x xxxxxxxxxx x xxxxxxx xxxxxxxxx
xx xxxxxxxxxx xxxxxxxx x xx xxxxxxxxxx xxxxxxxx xxx xxxxxxx xxxxxx
xxxxx xxxxxxxxx x xxxxxxxxxx xxxxxx xxxxxxxx xxxxx xxxxxxxx xxxxxxxx
xxxxx xxx xxxxxxxx xxxxxxx xxxxxxxx xxx xxxx xxx xxxxxxxx xxxxxx
xxxxxxx xxxxxxx xxxxx xxxxx xx xxxxxx xx xxxxxxxxxx xxxxxx x xxxx
xxxxxx xxxxxxx x xxx xxxxx xxxxxxxxx xxx xxxxxxx x xxxxxx xxxxxxxxx
xxxx xxxxxxxxx xxxxxxxx xxxxxxxx xxx xxxxxxx xxxxxxx xxxxxxxxxx
xxxxxxxxxx xxxxxx xxxxx xxxx xxxxxxx xx xxxxxxxxxx xxxxxx xxxxxx
xxxxxx xxxx xxxxx
標準#
Fortran 2003
関連項目#
achar(3)、char(3)、iachar(3)、ichar(3)、selected_char_kind(3)
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
repeat#
名前#
repeat(3) - [CHARACTER] 文字列の繰り返し連結
概要#
result = repeat(string, ncopies)
character(len=len(string)*ncopies) function repeat(string, ncopies)
character(len=*),intent(in) :: string
integer(kind=**),intent(in) :: ncopies
特性#
**として指定された kind は、型の任意のサポートされている kind にすることができます。
string はスカラーの文字型です。
ncopies はスカラー整数です。
結果は、string と同じ kind の文字型のスカラーです。
説明#
repeat(3) は、文字列のコピーを連結します。
オプション#
- string
繰り返し処理する入力文字列
- ncopies
文字列のコピー数。0以上の整数。
結果#
文字列をncopies回繰り返して生成された新しい文字列。
例#
サンプルプログラム
program demo_repeat
implicit none
write(*,'(a)') repeat("^v", 35) ! line break
write(*,'(a)') repeat("_", 70) ! line break
write(*,'(a)') repeat("1234567890", 7) ! number line
write(*,'(a)') repeat(" |", 7) !
end program demo_repeat
結果
> ^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v
> ______________________________________________________________________
> 1234567890123456789012345678901234567890123456789012345678901234567890
> | | | | | | |
標準#
Fortran 95
参照#
文字列操作を行う関数
非要素関数: len_trim(3)、len(3)、repeat(3)、trim(3)
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
#
achar#
名前#
achar(3) - [CHARACTER:CONVERSION] ASCII照合順序における指定位置の文字を返す
概要#
result = achar(i [,kind])
elemental character(len=1,kind=KIND) function achar(i,KIND)
integer(kind=**),intent(in) :: i
integer(kind=**),intent(in),optional :: KIND
特性#
**として指定された kind は、型の任意のサポートされている kind にすることができます。
返される文字の種類は、kindが指定されている場合はその値、そうでない場合はデフォルトの単一文字。
説明#
achar(3)は、ASCII照合順序における位置i（一般的にADEまたはASCII Decimal Equivalentと呼ばれる）にある文字を返す。
achar(3)関数は、エスケープやタブなどの非表示文字の出力も容易であるため、ターミナル属性を制御するためのインバンドエスケープシーケンスの生成によく使用される。例えば
write(*,'(*(a))')achar(27),'[2J'
は、ANSI互換のターミナルディスプレイで画面をクリアする。
注記#
ASCIIのADE（ASCII Decimal Equivalent）は次のとおりです。
*-------*-------*-------*-------*-------*-------*-------*-------*
| 00 nul| 01 soh| 02 stx| 03 etx| 04 eot| 05 enq| 06 ack| 07 bel|
| 08 bs | 09 ht | 10 nl | 11 vt | 12 np | 13 cr | 14 so | 15 si |
| 16 dle| 17 dc1| 18 dc2| 19 dc3| 20 dc4| 21 nak| 22 syn| 23 etb|
| 24 can| 25 em | 26 sub| 27 esc| 28 fs | 29 gs | 30 rs | 31 us |
| 32 sp | 33 ! | 34 " | 35 # | 36 $ | 37 % | 38 & | 39 ' |
| 40 ( | 41 ) | 42 * | 43 + | 44 , | 45 - | 46 . | 47 / |
| 48 0 | 49 1 | 50 2 | 51 3 | 52 4 | 53 5 | 54 6 | 55 7 |
| 56 8 | 57 9 | 58 : | 59 ; | 60 < | 61 = | 62 > | 63 ? |
| 64 @ | 65 A | 66 B | 67 C | 68 D | 69 E | 70 F | 71 G |
| 72 H | 73 I | 74 J | 75 K | 76 L | 77 M | 78 N | 79 O |
| 80 P | 81 Q | 82 R | 83 S | 84 T | 85 U | 86 V | 87 W |
| 88 X | 89 Y | 90 Z | 91 [ | 92 \ | 93 ] | 94 ^ | 95 _ |
| 96 ` | 97 a | 98 b | 99 c |100 d |101 e |102 f |103 g |
|104 h |105 i |106 j |107 k |108 l |109 m |110 n |111 o |
|112 p |113 q |114 r |115 s |116 t |117 u |118 v |119 w |
|120 x |121 y |122 z |123 { |124 | |125 } |126 ~ |127 del|
*-------*-------*-------*-------*-------*-------*-------*-------*
オプション#
- i
ASCII文字に変換する整数値。0から127の範囲。
achar(3)は、デフォルト文字として表現可能な任意の文字Cに対して値Cを持つ。
- kind
結果のkindパラメータを示す整数初期化式。
結果#
iの値が0 <= I <= 127の範囲にあると仮定すると、結果はASCII照合順序の位置iにある文字である。ただし、プロセッサが結果の文字の種類でその文字を表すことができない場合は、結果はプロセッサ依存となる。
例#
サンプルプログラム
program demo_achar
use,intrinsic::iso_fortran_env,only:int8,int16,int32,int64
implicit none
integer :: i
i=65
write(*,'("decimal =",i0)')i
write(*,'("character =",a1)')achar(i)
write(*,'("binary =",b0)')achar(i)
write(*,'("octal =",o0)')achar(i)
write(*,'("hexadecimal =",z0)')achar(i)
write(*,'(8(i3,1x,a,1x),/)')(i,achar(i), i=32,126)
write(*,'(a)')upper('Mixed Case')
contains
! a classic use of achar(3) is to convert the case of a string
pure elemental function upper(str) result (string)
!
!$@(#) upper(3f): function to return a trimmed uppercase-only string
!
! input string to convert to all uppercase
character(*), intent(in) :: str
! output string that contains no miniscule letters
character(len(str)) :: string
integer :: i, iend
integer,parameter :: toupper = iachar('A')-iachar('a')
iend=len_trim(str)
! initialize output string to trimmed input string
string = str(:iend)
! process each letter in the string
do concurrent (i = 1:iend)
select case (str(i:i))
! located miniscule letter
case ('a':'z')
! change miniscule to majuscule letter
string(i:i) = achar(iachar(str(i:i))+toupper)
end select
enddo
end function upper
end program demo_achar
結果
decimal =65
character =A
binary =1000001
octal =101
hexadecimal =41
32 33 ! 34 " 35 # 36 $ 37 % 38 & 39 '
40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 /
48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7
56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ?
64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G
72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O
80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W
88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _
96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g
104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o
112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w
120 x 121 y 122 z 123 { 124 | 125 } 126 ~
MIXED CASE
標準#
FORTRAN 77。KIND引数はFortran 2003で追加
参照#
リソース#
M_attrモジュール（ANSI互換ターミナルの制御用）
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
char#
名前#
char(3) - [CHARACTER] コード値から文字を生成する
概要#
result = char(i [,kind])
elemental character(kind=KIND) function char(i,KIND)
integer(kind=**),intent(in) :: i
integer(kind=**),intent(in),optional :: KIND
特性#
**として指定された kind は、型の任意のサポートされている kind にすることができます。
iは任意の種類の整数
kindは、結果のkindパラメータを示す整数初期化式。
返される値は、kindで指定されたkindを持つ文字、またはkindが指定されていない場合はデフォルトの文字kindを持つ文字。
説明#
指定されたkindkindに関連付けられた照合順序における位置iを表す数値コードから文字値を生成する。
achar(3)は、ASCII文字専用の同様の関数であり、ASCIIのみを処理する場合は、char(i,kind=selected_char_kind(“ascii”) )と同等であるため、そちらが推奨される。
ichar(3)関数はchar(3)の逆関数であり、文字を照合順序値に変換する。
オプション#
- i
指定されたkind型パラメータに関連付けられた照合順序における文字数がnである場合、0 <= I <= n-1の範囲の値。
ASCIIの場合、nは127。デフォルトの文字セットでは、それ以上の値が許可されない場合もある。
- kind
結果のkindパラメータを示す定数整数初期化式。指定されていない場合は、デフォルトのkindが使用される。
結果#
返される値は、指定されたkindに関連付けられた照合順序におけるiの位置によって決定される、指定されたkindの単一の文字。
例#
サンプルプログラム
program demo_char
implicit none
integer, parameter :: ascii = selected_char_kind ("ascii")
character(len=1, kind=ascii ) :: c
integer :: i
! basic
i=74
c=char(i)
write(*,*)'ASCII character ',i,'is ',c
!
print *, 'a selection of ASCII characters (shows hex if not printable)'
do i=0,127,10
c = char(i,kind=ascii)
select case(i)
case(32:126)
write(*,'(i3,1x,a)')i,c
case(0:31,127)
! print hexadecimal value for unprintable characters
write(*,'(i3,1x,z2.2)')i,c
case default
write(*,'(i3,1x,a,1x,a)')i,c,'non-standard ASCII'
end select
enddo
end program demo_char
結果
ASCII character 74 is J
a selection of ASCII characters (shows hex if not printable)
0 00
10 0A
20 14
30 1E
40 (
50 2
60 <
70 F
80 P
90 Z
100 d
110 n
120 x
標準#
FORTRAN 77
参照#
文字列に対して操作を実行し、引数の長さを返し、特定の引数を検索する関数
非要素関数: len_trim(3)、len(3)、repeat(3)、trim(3)
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
iachar#
名前#
iachar(3) - [CHARACTER:CONVERSION] 文字のASCIIコードを整数で返す
概要#
result = iachar(c [,kind])
elemental integer(kind=KIND) function iachar(c,kind)
character(len=1),intent(in) :: c
integer(kind=**),intent(in),optional :: KIND
特性#
cは単一の文字
返される値は整数型で、kindはKIND。KINDが省略された場合は、デフォルトの整数kind。
- 注記
**として指定された kind は、型の任意のサポートされている kind にすることができます。
説明#
iachar(3)は、Cの最初の文字位置にあるASCII文字のコードを返す。
オプション#
- c
ASCIIコードを取得する文字。
一般的な拡張機能として文字列が許可されるが、最初の文字以外は無視される。
- kind
結果のkindパラメータを示す定数初期化式。
結果#
結果は、ASCII照合順序における文字cの位置。0以上、127以下。
ASCIIとは、ISO/IEC 646:1991（国際参照バージョン）で指定されたコードによって定義された照合順序におけるcを意味する。
cがASCII照合順序にない場合、結果はプロセッサ依存となる。
結果は、lge(3)、lgt(3)、lle(3)、llt(3)比較関数と一致する。例えば、lle(C, D)が真の場合、CとDがプロセッサで表現可能な任意の2文字であれば、iachar(C) <= iachar (D)は真である。
例#
サンプルプログラム
program demo_iachar
implicit none
! basic usage
! just does a string one character long
write(*,*)iachar('A')
! elemental: can do an array of letters
write(*,*)iachar(['A','Z','a','z'])
! convert all characters to lowercase
write(*,'(a)')lower('abcdefg ABCDEFG')
contains
!
pure elemental function lower(str) result (string)
! Changes a string to lowercase
character(*), intent(In) :: str
character(len(str)) :: string
integer :: i
string = str
! step thru each letter in the string in specified range
do i = 1, len(str)
select case (str(i:i))
case ('A':'Z') ! change letter to miniscule
string(i:i) = char(iachar(str(i:i))+32)
case default
end select
end do
end function lower
!
end program demo_iachar
結果
65
65 90 97 122
abcdefg abcdefg
標準#
Fortran 95、KIND引数付き - Fortran 2003
参照#
数値とフォーマット済み文字列表現間の変換に関する説明については、特にichar(3)を参照。
文字列に対して操作を実行し、引数の長さを返し、特定の引数を検索する関数
非要素関数: len_trim(3)、len(3)、repeat(3)、trim(3)
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
ichar#
名前#
ichar(3) - [CHARACTER:CONVERSION] 文字から整数コードへの変換関数
概要#
result = ichar(c [,kind])
elemental integer(kind=KIND) function ichar(c,KIND)
character(len=1,kind=**),intent(in) :: c
integer,intent(in),optional :: KIND
特性#
cはスカラー文字
kindは、結果のkindパラメータを示す定数整数初期化式。
返される値は整数型で、kindはkind。kindが省略された場合は、デフォルトの整数kind。
説明#
ichar(3)は、システムのネイティブ文字セットにおける文字のコードを返す。文字とそのコードの対応は、Fortran実装間で必ずしも同じではない。例えば、EBCDICを使用するプラットフォームは、ASCIIプラットフォームとは異なる値を返す。
ASCII文字セットを扱う場合は、iachar(3)を参照。
オプション#
- c
コードを取得する入力文字。その値は、プロセッサで表現可能な文字の値でなければならない。
- kind
結果のkindパラメータを示す。kindが省略された場合、返される値はデフォルトの整数kindとなる。
結果#
クエリ対象の文字のシステムデフォルト文字セットにおけるコードが返される。
結果は、cのkind型パラメータに関連付けられたプロセッサ照合順序におけるcの位置。
0以上、n未満で、nは照合順序における文字数。
結果のkind型パラメータは、nを表すことができる整数kindを指定する必要がある。
プロセッサで表現可能な任意の文字CとDについて、C <= Dは、ICHAR (C) <= ICHAR (D)が真である場合に限り真であり、C == Dは、ICHAR (C) == ICHAR (D)が真である場合に限り真である。
例#
サンプルプログラム
program demo_ichar
implicit none
write(*,*)ichar(['a','z','A','Z'])
end program demo_ichar
結果
97 122 65 90
標準#
Fortran 95、KIND引数付き - Fortran 2003
参照#
文字列に対して操作を実行し、引数の長さを返し、特定の引数を検索する関数
要素関数: adjustl(3)、adjustr(3)、index(3)、
非要素関数: len_trim(3)、len(3)、repeat(3)、trim(3)
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
索引#
名前#
index(3) - [文字列:検索] 文字列内の部分文字列の位置
概要#
result = index( string, substring [,back] [,kind] )
elemental integer(kind=KIND) function index(string,substring,back,kind)
character(len=*,kind=KIND),intent(in) :: string
character(len=*,kind=KIND),intent(in) :: substring
logical(kind=**),intent(in),optional :: back
integer(kind=**),intent(in),optional :: kind
特性#
string は任意の種類の文字変数です。
substring はstringと同じ種類の文字変数です。
back は任意のサポートされている種類の論理変数です。
KIND はスカラー整数定数式です。
説明#
index(3) は、文字列string内で、左端または右端のsubstringの最初の出現位置を返します。位置は1から数えます。substringがstringに存在しない場合、0を返します。
オプション#
- string
一致を検索する文字列
- 部分文字列
string内で検索しようとする文字列
- back
back引数が存在し、真の場合、戻り値は左端ではなく右端の出現位置の先頭になります。
- kind
kindが存在する場合、kind型パラメータはkindの値で指定されたものになります。そうでない場合、kind型パラメータはデフォルトの整数型になります。
結果#
結果は、string内で最初に検出された部分文字列substringの先頭位置です。
substringの長さがstringより長い場合、結果は0です。
部分文字列が見つからない場合、結果は0です。
backが.true.の場合、最大の開始位置（つまり、一番右側のマッチの位置）が返されます。それ以外の場合は、マッチの開始位置のうち最小の位置（つまり、一番左側のマッチ）が返されます。
返される位置は、stringの最初の文字を位置1として左から測定されます。
それ以外の場合、一致が見つからない場合は0が返されます。
例#
例題プログラム
program demo_index
implicit none
character(len=*),parameter :: str=&
'Search this string for this expression'
!1234567890123456789012345678901234567890
write(*,*)&
index(str,'this').eq.8, &
! return value is counted from the left end even if BACK=.TRUE.
index(str,'this',back=.true.).eq.24, &
! INDEX is case-sensitive
index(str,'This').eq.0
end program demo_index
期待される結果
T T T
標準#
FORTRAN 77、KIND引数付きFortran 2003
参照#
文字列に対して操作を実行し、引数の長さを返し、特定の引数を検索する関数
非要素関数: len_trim(3)、len(3)、repeat(3)、trim(3)
fortran-lang組込み関数の説明
scan#
名前#
scan(3) - [文字列:検索] 文字の集合の存在について文字列をスキャンする
概要#
result = scan( string, set, [,back] [,kind] )
elemental integer(kind=KIND) function scan(string,set,back,kind)
character(len=*,kind=**),intent(in) :: string
character(len=*,kind=**),intent(in) :: set
logical,intent(in),optional :: back
integer,intent(in),optional :: kind
特性#
string は任意の種類の文字列です。
set はstringと同じkindの文字列でなければなりません。
back は論理型です。
kind はスカラー整数定数式です。
結果は、kindで指定されたkindを持つ整数です。kindが存在しない場合、結果はデフォルトの整数です。
説明#
scan(3) は、文字の集合set内のいずれかの文字について、stringをスキャンします。
back が存在しないか、.false.に等しい場合、この関数は、STRING内でsetに含まれる左端の文字の位置を返します。backが.true.の場合、右端の位置が返されます。setの文字がstringに見つからない場合、結果は0です。
オプション#
- string
スキャンされる文字列
- set
一致する文字の集合
- back
.true.の場合、左端の文字ではなく、一致する右端の文字の位置が返されます。
- kind
戻り値のkindは、kindが存在する場合はそれと同じです。それ以外の場合は、デフォルトの整数kindが返されます。
結果#
backが存在しないか、値がfalseで、stringにsetに含まれる少なくとも1つの文字が含まれている場合、結果は、string内でsetに含まれる左端の文字の位置になります。
backが存在し、値がtrueで、stringにsetに含まれる少なくとも1つの文字が含まれている場合、結果は、string内でsetに含まれる右端の文字の位置になります。
STRINGの文字がSETに含まれていない場合、またはSTRINGまたはSETの長さが0の場合、結果は0になります。
例#
サンプルプログラム
program demo_scan
implicit none
write(*,*) scan("fortran", "ao") ! 2, found 'o'
write(*,*) scan("fortran", "ao", .true.) ! 6, found 'a'
write(*,*) scan("fortran", "c++") ! 0, found none
end program demo_scan
結果
> 2
> 6
> 0
標準#
Fortran 95、KIND引数付き - Fortran 2003
参照#
文字列に対して操作を実行し、引数の長さを返し、特定の引数を検索する関数
非要素関数: len_trim(3)、len(3)、repeat(3)、trim(3)
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
verify#
名前#
verify(3) - [文字列:検索] 指定された文字の集合に現れない文字列内の文字の位置
概要#
result = verify(string, set [,back] [,kind] )
elemental integer(kind=KIND) function verify(string,set,back,KIND)
character(len=*,kind=**),intent(in) :: string
character(len=*,kind=**),intent(in) :: set
logical,intent(in),optional :: back
integer,intent(in),optional :: KIND
特性#
stringとsetは文字型でなければならず、個々の呼び出しでは同じkindでなければなりませんが、サポートされている任意の文字kindにすることができます。
KINDは定数整数初期化式でなければならず、整数型の有効なkindでなければなりません。
backは論理型でなければなりません。
戻り値のkindは、kindが存在する場合はそれと同じです。それ以外の場合は、デフォルトの整数kindが返されます。
説明#
verify(3) は、文字列内のすべての文字がset内の文字の集合に属しているかどうかを、集合にない文字列内の最初の文字の位置を識別することで検証します。
これにより、文字列がすべて大文字または小文字であるか、基本的な構文に従っているか、印刷可能な文字のみが含まれているか、Cルーチンisalnum(3c)、isalpha(3c)、isascii(3c)、isblank(3c)、iscntrl(3c)、isdigit(3c)、isgraph(3c)、islower(3c)、isprint(3c)、ispunct(3c)、isspace(3c)、isupper(3c)、isxdigit(3c)でテストされた多くの条件を簡単に検証できます。ただし、文字列だけでなく、文字列の配列についても検証できます。
オプション#
- string
一致しない文字を検索する文字列。
- set
一致しなければならない文字の集合。
- back
一致しない文字を探す方向。backが存在し.false.でない限り、左端の一致しない文字の位置が返され、その場合、左端の一致しない文字の位置の代わりに右端の一致しない文字の位置が返されます。
- kind
結果のkindパラメータを示す整数初期化式。
結果#
stringのすべての文字がsetに見つかった場合、結果は0です。
stringの長さが0の場合、常に0が返されます。
それ以外の場合、一致しない文字が見つかった場合、string内の一番目または最後（backが.false.の場合）の一致しない文字の位置が返されます。文字列の左端を位置1として開始します。
例#
サンプルプログラム I:#
program demo_verify
implicit none
! some useful character sets
character,parameter :: &
& int*(*) = '1234567890', &
& low*(*) = 'abcdefghijklmnopqrstuvwxyz', &
& upp*(*) = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', &
& punc*(*) = "!""#$%&'()*+,-./:;<=>?@[\]^_`{|}~", &
& blank*(*) = ' ', &
& tab = char(11), &
& prnt*(*) = int//low//upp//blank//punc
character(len=:),allocatable :: string
integer :: i
print *, 'basics:'
print *, VERIFY ('ABBA', 'A') ! has the value 2.
print *, VERIFY ('ABBA', 'A', BACK = .TRUE.) ! has the value 3.
print *, VERIFY ('ABBA', 'AB') ! has the value 0.
print *,'find first non-uppercase letter'
! will produce the location of "d", because there is no match in UPP
write(*,*) 'something unmatched',verify("ABCdEFG", upp)
print *,'if everything is matched return zero'
! will produce 0 as all letters have a match
write(*,*) 'everything matched',verify("ffoorrttrraann", "nartrof")
print *,'easily categorize strings as uppercase, lowercase, ...'
! easy C-like functionality but does entire strings not just characters
write(*,*)'isdigit 123?',verify("123", int) == 0
write(*,*)'islower abc?',verify("abc", low) == 0
write(*,*)'isalpha aBc?',verify("aBc", low//upp) == 0
write(*,*)'isblank aBc dEf?',verify("aBc dEf", blank//tab ) /= 0
! check if all printable characters
string="aB;cde,fgHI!Jklmno PQRSTU vwxyz"
write(*,*)'isprint?',verify(string,prnt) == 0
! this now has a nonprintable tab character in it
string(10:10)=char(11)
write(*,*)'isprint?',verify(string,prnt) == 0
print *,'VERIFY(3) is very powerful using expressions as masks'
! verify(3f) is often used in a logical expression
string=" This is NOT all UPPERCASE "
write(*,*)'all uppercase/spaces?',verify(string, blank//upp) == 0
string=" This IS all uppercase "
write(*,*) 'string=['//string//']'
write(*,*)'all uppercase/spaces?',verify(string, blank//upp) == 0
! set and show complex string to be tested
string=' Check this out. Let me know '
! show the string being examined
write(*,*) 'string=['//string//']'
write(*,*) ' '//repeat(int,4) ! number line
! the Fortran functions returns a position just not a logical like C
print *, 'returning a position not just a logical is useful'
! which can be very useful for parsing strings
write(*,*)'first non-blank character',verify(string, blank)
write(*,*)'last non-blank character',verify(string, blank,back=.true.)
write(*,*)'first non-letter non-blank',verify(string,low//upp//blank)
!VERIFY(3) is elemental so you can check an array of strings in one call
print *, 'elemental'
! are strings all letters (or blanks)?
write(*,*) 'array of strings',verify( &
! strings must all be same length, so force to length 10
& [character(len=10) :: "YES","ok","000","good one","Nope!"], &
& low//upp//blank) == 0
! rarer, but the set can be an array, not just the strings to test
! you could do ISPRINT() this (harder) way :>
write(*,*)'isprint?',.not.all(verify("aBc", [(char(i),i=32,126)])==1)
! instead of this way
write(*,*)'isprint?',verify("aBc",prnt) == 0
end program demo_verify
結果
> basics:
> 2
> 3
> 0
> find first non-uppercase letter
> something unmatched 4
> if everything is matched return zero
> everything matched 0
> easily categorize strings as uppercase, lowercase, ...
> isdigit 123? T
> islower abc? T
> isalpha aBc? T
> isblank aBc dEf? T
> isprint? T
> isprint? F
> VERIFY(3) is very powerful using expressions as masks
> all uppercase/spaces? F
> string=[ This IS all uppercase ]
> all uppercase/spaces? F
> string=[ Check this out. Let me know ]
> 1234567890123456789012345678901234567890
> returning a position not just a logical is useful
> first non-blank character 3
> last non-blank character 29
> first non-letter non-blank 17
> elemental
> array of strings T T F T F
> isprint? T
> isprint? T
サンプルプログラム II:#
文字列が有効な整数表現かどうかを判定する
program fortran_ints
implicit none
integer :: i
character(len=*),parameter :: ints(*)=[character(len=10) :: &
'+1 ', &
'3044848 ', &
'30.40 ', &
'September ', &
'1 2 3', &
' -3000 ', &
' ']
! show the strings to test
write(*,'("|",*(g0,"|"))') ints
! show if strings pass or fail the test done by isint(3f)
write(*,'("|",*(1x,l1,8x,"|"))') isint(ints)
contains
elemental function isint(line) result (lout)
!
! determine if string is a valid integer representation
! ignoring trailing spaces and leading spaces
!
character(len=*),parameter :: digits='0123456789'
character(len=*),intent(in) :: line
character(len=:),allocatable :: name
logical :: lout
lout=.false.
! make sure at least two characters long to simplify tests
name=adjustl(line)//' '
! blank string
if( name == '' )return
! allow one leading sign
if( verify(name(1:1),'+-') == 0 ) name=name(2:)
! was just a sign
if( name == '' )return
lout=verify(trim(name), digits) == 0
end function isint
end program fortran_ints
結果
|+1 |3044848 |30.40 |September|1 2 3 | -3000 | |
| T | T | F | F | F | T | F |
サンプルプログラム III:#
文字列が有効なFortranシンボル名を表しているかどうかを判定する
program fortran_symbol_name
implicit none
integer :: i
character(len=*),parameter :: symbols(*)=[character(len=10) :: &
'A_ ', &
'10 ', &
'September ', &
'A B', &
'_A ', &
' ']
write(*,'("|",*(g0,"|"))') symbols
write(*,'("|",*(1x,l1,8x,"|"))') fortran_name(symbols)
contains
elemental function fortran_name(line) result (lout)
!
! determine if a string is a valid Fortran name
! ignoring trailing spaces (but not leading spaces)
!
character(len=*),parameter :: int='0123456789'
character(len=*),parameter :: lower='abcdefghijklmnopqrstuvwxyz'
character(len=*),parameter :: upper='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
character(len=*),parameter :: allowed=upper//lower//int//'_'
character(len=*),intent(in) :: line
character(len=:),allocatable :: name
logical :: lout
name=trim(line)
if(len(name).ne.0)then
! first character is alphameric
lout = verify(name(1:1), lower//upper) == 0 &
! other characters are allowed in a symbol name
& .and. verify(name,allowed) == 0 &
! allowable length
& .and. len(name) <= 63
else
lout = .false.
endif
end function fortran_name
end program fortran_symbol_name
結果
|A_ |10 |September |A B |_A | |
| T | F | T | F | F | F |
サンプルプログラム IV:#
文字列がNN-HHHHHの形式かどうかを確認する
program checkform
! check if string is of form NN-HHHHH
implicit none
character(len=*),parameter :: int='1234567890'
character(len=*),parameter :: hex='abcdefABCDEF0123456789'
logical :: lout
character(len=80) :: chars
chars='32-af43d'
lout=.true.
! are the first two characters integer characters?
lout = lout.and.(verify(chars(1:2), int) == 0)
! is the third character a dash?
lout = lout.and.(verify(chars(3:3), '-') == 0)
! is remaining string a valid representation of a hex value?
lout = lout.and.(verify(chars(4:8), hex) == 0)
if(lout)then
write(*,*)trim(chars),' passed'
else
write(*,*)trim(chars),' failed'
endif
end program checkform
結果
32-af43d passed
サンプルプログラム V:#
要素関数の使用方法と微妙な点を調べる
program more_verify
implicit none
character(len=*),parameter :: &
& int='0123456789', &
& low='abcdefghijklmnopqrstuvwxyz', &
& upp='ABCDEFGHIJKLMNOPQRSTUVWXYZ', &
& blank=' '
! note character variables in an array have to be of the same length
character(len=6) :: strings(3)=["Go ","right ","home! "]
character(len=2) :: sets(3)=["do","re","me"]
! elemental -- you can use arrays for both strings and for sets
! check each string from right to left for non-letter/non-blank
write(*,*)'last non-letter',verify(strings,upp//low//blank,back=.true.)
! even BACK can be an array
! find last non-uppercase character in "Howdy "
! and first non-lowercase in "there "
write(*,*) verify(strings(1:2),[upp,low],back=[.true.,.false.])
! using a null string for a set is not well defined. Avoid it
write(*,*) 'null',verify("for tran ", "", .true.) ! 8,length of string?
! probably what you expected
write(*,*) 'blank',verify("for tran ", " ", .true.) ! 7,found 'n'
! first character in "Go " not in "do",
! and first letter in "right " not in "ri"
! and first letter in "home! " not in "me"
write(*,*) verify(strings,sets)
end program more_verify
結果
> last non-letter 0 0 5
> 6 6
> null 9
> blank 8
> 1 2 1
標準#
Fortran 95、kind引数付き - Fortran 2003
参照#
文字列に対して操作を実行し、引数の長さを返し、特定の引数を検索する関数
要素関数: adjustl(3)、adjustr(3)、index(3)、scan(3)、
非要素関数: len_trim(3)、len(3)、repeat(3)、trim(3)
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
lge#
名前#
lge(3) - [文字列:比較] ASCII辞書順で大きいか等しい
概要#
result = lge(string_a, stringb)
elemental logical function lge(string_a, string_b)
character(len=*),intent(in) :: string_a
character(len=*),intent(in) :: string_b
特性#
string_a はデフォルトの文字型またはASCII文字です。
string_b はstring_aと同じ型とkindです。
結果はデフォルトの論理型です。
説明#
lge(3) は、2つの文字列がASCII文字コードを含むものとして解釈された場合に、一方の文字列がもう一方の文字列よりも辞書順で大きいか等しいかどうかを判定します。string_aとstring_bの長さが異なる場合、短い方は、同じ長さの値を形成するようにスペースが追加されたものとして比較されます。
辞書順比較の組込み関数lge(3)、lgt(3)、lle(3)、llt(3)は、対応する組込み演算子.ge.、.gt.、.le.、.lt.とは異なります。後者はプロセッサの文字順序を使用しますが（一部のターゲットではASCIIではありません）、前者は常にASCII順序を使用します。
オプション#
- string_a
テストされる文字列
- string_b
string_aと比較する文字列
結果#
ASCII照合順序に基づいて、string_a == string_bの場合.true.を、それ以外の場合は.false.を返します。
両方の入力引数が空文字列の場合、常に.true.が返されます。
いずれかの文字列にASCII文字集合にない文字が含まれている場合、結果はプロセッサ依存です。
例#
サンプルプログラム
program demo_lge
implicit none
integer :: i
print *,'the ASCII collating sequence for printable characters'
write(*,'(1x,19a)')(char(i),i=32,126) ! ASCII order
write(*,*) lge('abc','ABC') ! [T] lowercase is > uppercase
write(*,*) lge('abc','abc ') ! [T] trailing spaces
! If both strings are of zero length the result is true
write(*,*) lge('','') ! [T]
write(*,*) lge('','a') ! [F] the null string is padded
write(*,*) lge('a','') ! [T]
! elemental
write(*,*) lge('abc',['abc','123']) ! [T T] scalar and array
write(*,*) lge(['cba', '123'],'abc') ! [T F]
write(*,*) lge(['abc','123'],['cba','123']) ! [F T] both arrays
end program demo_lge
結果
> the ASCII collating sequence for printable characters
> !"#$%&'()*+,-./012
> 3456789:;<=>?@ABCDE
> FGHIJKLMNOPQRSTUVWX
> YZ[\]^_`abcdefghijk
> lmnopqrstuvwxyz{|}~
> T
> T
> T
> F
> T
> T T
> T F
> F T
標準#
FORTRAN 77
参照#
文字列に対して操作を実行し、引数の長さを返し、特定の引数を検索する関数
要素関数: adjustl(3)、adjustr(3)、index(3)、
非要素関数: len_trim(3)、len(3)、repeat(3)、trim(3)
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
lgt#
名前#
lgt(3) - [CHARACTER:COMPARE] ASCII辞書順比較（大なり）
概要#
result = lgt(string_a, string_b)
elemental logical function lgt(string_a, string_b)
character(len=*),intent(in) :: string_a
character(len=*),intent(in) :: string_b
特性#
string_a はデフォルトの文字型またはASCII文字です。
string_b はstring_aと同じ型とkindです。
結果はデフォルトの論理型です。
説明#
lgt(3) は、2つの文字列がASCII文字コードとして解釈された場合に、一方の文字列がもう一方の文字列よりも辞書順で大きいかどうかを判定します。文字列aと文字列bの長さが異なる場合、短い方の文字列には、長い方と同じ長さになるまでスペースが追加されたものとして比較されます。
一般的に、辞書順比較の組込み関数lge、lgt、lle、lltは、対応する組込み演算子.ge.、.gt.、.le.、.lt.とは異なります。後者はプロセッサの文字順序を使用しますが（一部のターゲットではASCIIではありません）、前者は常にASCII順序を使用します。
オプション#
- string_a
テストされる文字列
- string_b
string_aと比較する文字列
結果#
ASCII順序に基づいて、string*a > string_b の場合.true.を、それ以外の場合は.false.を返します。
両方の入力引数がヌル文字列の場合、.false.が返されます。
いずれかの文字列にASCII文字集合にない文字が含まれている場合、結果はプロセッサ依存です。
例#
サンプルプログラム
program demo_lgt
implicit none
integer :: i
print *,'the ASCII collating sequence for printable characters'
write(*,'(1x,19a)')(char(i),i=32,126)
write(*,*) lgt('abc','ABC') ! [T] lowercase is > uppercase
write(*,*) lgt('abc','abc ') ! [F] trailing spaces
! If both strings are of zero length the result is false.
write(*,*) lgt('','') ! [F]
write(*,*) lgt('','a') ! [F] the null string is padded
write(*,*) lgt('a','') ! [T]
write(*,*) lgt('abc',['abc','123']) ! [F T] scalar and array
write(*,*) lgt(['cba', '123'],'abc') ! [T F]
write(*,*) lgt(['abc','123'],['cba','123']) ! [F F] both arrays
end program demo_lgt
結果
> the ASCII collating sequence for printable characters
> !"#$%&'()*+,-./012
> 3456789:;<=>?@ABCDE
> FGHIJKLMNOPQRSTUVWX
> YZ[\]^_`abcdefghijk
> lmnopqrstuvwxyz{|}~
> T
> F
> F
> F
> T
> F T
> T F
> F F
標準#
FORTRAN 77
参照#
文字列に対して操作を実行し、引数の長さを返し、特定の引数を検索する関数
要素関数: adjustl(3)、adjustr(3)、index(3)、
非要素関数: len_trim(3)、len(3)、repeat(3)、trim(3)
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
lle#
名前#
lle(3) - [CHARACTER:COMPARE] ASCII辞書順比較（小なりイコール）
概要#
result = lle(string_a, stringb)
elemental logical function lle(string_a, string_b)
character(len=*),intent(in) :: string_a
character(len=*),intent(in) :: string_b
特性#
string_a はデフォルトの文字型またはASCII文字です。
string_b はstring_aと同じ型とkindです。
結果はデフォルトの論理型です。
説明#
lle(3) は、2つの文字列がASCII文字コードとして解釈された場合に、一方の文字列がもう一方の文字列よりも辞書順で小さいか等しいかどうかを判定します。
string_aとstring_bの長さが異なる場合、短い方の文字列には、長い方と同じ長さになるまでスペースが追加されたものとして比較されます。
先頭のスペースは有効です。
一般的に、辞書順比較の組込み関数lge、lgt、lle、lltは、対応する組込み演算子.ge.、.gt.、.le.、.lt.とは異なります。後者はプロセッサの文字順序を使用しますが（一部のターゲットではASCIIではありません）、lle(3)は常にASCII順序を使用します。
オプション#
- string_a
テストされる文字列
- string_b
string_aと比較する文字列
結果#
結果 string_a <= string_b の場合.true.を、それ以外の場合は.false.を、ASCII照合順序に基づいて返します。
両方の入力引数が空文字列の場合、常に.true.が返されます。
いずれかの文字列にASCII文字集合にない文字が含まれている場合、結果はプロセッサ依存です。
例#
サンプルプログラム
program demo_lle
implicit none
integer :: i
print *,'the ASCII collating sequence for printable characters'
write(*,'(1x,19a)')(char(i),i=32,126)
! basics
print *,'case matters'
write(*,*) lle('abc','ABC') ! F lowercase is > uppercase
print *,'a space is the lowest printable character'
write(*,*) lle('abcd','abc') ! F d > space
write(*,*) lle('abc','abcd') ! T space < d
print *,'leading spaces matter, trailing spaces do not'
write(*,*) lle('abc','abc ') ! T trailing spaces
write(*,*) lle('abc',' abc') ! F leading spaces are significant
print *,'even null strings are padded and compared'
! If both strings are of zero length the result is true.
write(*,*) lle('','') ! T
write(*,*) lle('','a') ! T the null string is padded
write(*,*) lle('a','') ! F
print *,'elemental'
write(*,*) lle('abc',['abc','123']) ! [T,F] scalar and array
write(*,*) lle(['cba', '123'],'abc') ! [F,T]
! per the rules for elemental procedures arrays must be the same size
write(*,*) lle(['abc','123'],['cba','123']) ! [T,T] both arrays
end program demo_lle
結果
> the ASCII collating sequence for printable characters
> !"#$%&'()*+,-./012
> 3456789:;<=>?@ABCDE
> FGHIJKLMNOPQRSTUVWX
> YZ[\]^_`abcdefghijk
> lmnopqrstuvwxyz{|}~
> case matters
> F
> a space is the lowest printable character
> F
> T
> leading spaces matter, trailing spaces do not
> T
> F
> even null strings are padded and compared
> T
> T
> F
> elemental
> T F
> F T
> T T
標準#
FORTRAN 77
参照#
文字列に対して操作を実行し、引数の長さを返し、特定の引数を検索する関数
要素関数: adjustl(3)、adjustr(3)、index(3)、
非要素関数: len_trim(3)、len(3)、repeat(3)、trim(3)
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
llt#
名前#
llt(3) - [CHARACTER:COMPARE] ASCII辞書順比較（小なり）
概要#
result = llt(string_a, stringb)
elemental logical function llt(string_a, string_b)
character(len=*),intent(in) :: string_a
character(len=*),intent(in) :: string_b
特性#
string_a はデフォルトの文字型またはASCII文字です。
string_b はstring_aと同じ型とkindです。
結果はデフォルトの論理型です。
説明#
llt(3) は、2つの文字列がASCII文字コードとして解釈された場合に、一方の文字列がもう一方の文字列よりも辞書順で小さいかどうかを判定します。string_aとstring_bの長さが異なる場合、短い方の文字列には、長い方と同じ長さになるまでスペースが追加されたものとして比較されます。
一般的に、辞書順比較の組込み関数lge、lgt、lle、lltは、対応する組込み演算子.ge.、.gt.、.le.、.lt.とは異なります。後者はプロセッサの文字順序を使用しますが（一部のターゲットではASCIIではありません）、前者は常にASCII順序を使用します。
オプション#
- string_a
テストされる文字列
- string_b
string_aと比較する文字列
結果#
ASCII照合順序に基づいて、string*a < string_b の場合.true.を、それ以外の場合は.false.を返します。
両方の入力引数がヌル文字列の場合、常に.false.が返されます。
いずれかの文字列にASCII文字集合にない文字が含まれている場合、結果はプロセッサ依存です。
例#
サンプルプログラム
program demo_llt
implicit none
integer :: i
print *,'the ASCII collating sequence for printable characters'
write(*,'(1x,19a)')(char(i),i=32,126) ! ASCII order
! basics
print *,'case matters'
write(*,*) llt('abc','ABC') ! [F] lowercase is > uppercase
write(*,*) llt('abc','abc ') ! [F] trailing spaces
! If both strings are of zero length the result is false.
write(*,*) llt('','') ! [F]
write(*,*) llt('','a') ! [T] the null string is padded
write(*,*) llt('a','') ! [F]
print *,'elemental'
write(*,*) llt('abc',['abc','123']) ! [F F] scalar and array
write(*,*) llt(['cba', '123'],'abc') ! [F T]
write(*,*) llt(['abc','123'],['cba','123']) ! [T F] both arrays
end program demo_llt
結果
> the ASCII collating sequence for printable characters
> !"#$%&'()*+,-./012
> 3456789:;<=>?@ABCDE
> FGHIJKLMNOPQRSTUVWX
> YZ[\]^_`abcdefghijk
> lmnopqrstuvwxyz{|}~
> case matters
> F
> F
> F
> T
> F
> elemental
> F F
> F T
> T F
標準#
FORTRAN 77
参照#
文字列に対して操作を実行し、引数の長さを返し、特定の引数を検索する関数
非要素関数: len_trim(3)、len(3)、repeat(3)、trim(3)
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
adjustl#
名前#
adjustl(3) - [CHARACTER:WHITESPACE] 文字列の左詰め
概要#
result = adjustl(string)
elemental character(len=len(string),kind=KIND) function adjustl(string)
character(len=*,kind=KIND),intent(in) :: string
特性#
string は、任意のサポートされている種類の文字変数です。
戻り値は、string と同じ種類と長さの文字変数です。
説明#
adjustl(3) は、先頭のスペースを削除することで文字列を左詰めします。必要に応じて、文字列の最後にスペースが挿入されます。
オプション#
- string
左詰めする文字列
結果#
先頭のスペースが削除され、同じ数のスペースがstringの最後に挿入されたstringのコピー。
例#
サンプルプログラム
program demo_adjustl
implicit none
character(len=20) :: str = ' sample string'
character(len=:),allocatable :: astr
integer :: length
! basic use
write(*,'(a,"[",a,"]")') 'original: ',str
str=adjustl(str)
write(*,'(a,"[",a,"]")') 'adjusted: ',str
! a fixed-length string can be printed
! trimmed using trim(3f) or len_trim(3f)
write(*,'(a,"[",a,"]")') 'trimmed: ',trim(str)
length=len_trim(str)
write(*,'(a,"[",a,"]")') 'substring:',str(:length)
! note an allocatable string stays the same length too
! and is not trimmed by just an adjustl(3f) call.
astr=' allocatable string '
write(*,'(a,"[",a,"]")') 'original:',astr
astr = adjustl(astr)
write(*,'(a,"[",a,"]")') 'adjusted:',astr
! trim(3f) can be used to change the length
astr = trim(astr)
write(*,'(a,"[",a,"]")') 'trimmed: ',astr
end program demo_adjustl
結果
original: [ sample string ]
adjusted: [sample string ]
trimmed: [sample string]
substring:[sample string]
original:[ allocatable string ]
adjusted:[allocatable string ]
trimmed: [allocatable string]
標準#
Fortran 95
参照#
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
adjustr#
名前#
adjustr(3) - [CHARACTER:WHITESPACE] 文字列の右詰め
概要#
result = adjustr(string)
elemental character(len=len(string),kind=KIND) function adjustr(string)
character(len=*,kind=KIND),intent(in) :: string
特性#
string は文字変数です。
戻り値は、string と同じ種類と長さの文字変数です。
説明#
adjustr(3) は、末尾のスペースを削除することで文字列を右詰めします。元の長さを維持するために、必要に応じて文字列の先頭にスペースが挿入されます。
オプション#
- string
右詰めする文字列
結果#
末尾のスペースが削除され、同じ数のスペースがstringの先頭に挿入されます。
例#
サンプルプログラム
program demo_adjustr
implicit none
character(len=20) :: str
! print a short number line
write(*,'(a)')repeat('1234567890',2)
! basic usage
str = ' sample string '
write(*,'(a)') str
str = adjustr(str)
write(*,'(a)') str
!
! elemental
!
write(*,'(a)')repeat('1234567890',5)
write(*,'(a)')adjustr([character(len=50) :: &
' first ', &
' second ', &
' third ' ])
write(*,'(a)')repeat('1234567890',5)
end program demo_adjustr
結果
12345678901234567890
sample string
sample string
12345678901234567890123456789012345678901234567890
first
second
third
12345678901234567890123456789012345678901234567890
標準#
Fortran 95
参照#
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
len_trim#
名前#
len_trim(3) - [CHARACTER:WHITESPACE] 末尾の空白文字を除いた文字列の長さ
概要#
result = len_trim(string [,kind])
elemental integer(kind=KIND) function len_trim(string,KIND)
character(len=*),intent(in) :: string
integer(kind=KIND),intent(in),optional :: KIND
特性#
string は文字型です。
kind は、戻り値の種類を指定するスカラー整数定数式です。
戻り値は整数型で、KINDの種類です。KIND がない場合、戻り値はデフォルトの整数の種類になります。
説明#
len_trim(3) は、末尾の空白文字を無視した文字列の長さを返します。
オプション#
- string
長さを測定する入力文字列。
- kind
結果の種類パラメータを示します。
結果#
結果は、string の末尾の空白文字が削除された後の残りの文字数に等しくなります。
入力引数が長さ0またはすべて空白の場合、結果は0になります。
例#
サンプルプログラム
program demo_len_trim
implicit none
character(len=:),allocatable :: string
integer :: i
! basic usage
string=" how long is this string? "
write(*,*) string
write(*,*)'UNTRIMMED LENGTH=',len(string)
write(*,*)'TRIMMED LENGTH=',len_trim(string)
! print string, then print substring of string
string='xxxxx '
write(*,*)string,string,string
i=len_trim(string)
write(*,*)string(:i),string(:i),string(:i)
!
! elemental example
ELE:block
! an array of strings may be used
character(len=:),allocatable :: tablet(:)
tablet=[character(len=256) :: &
& ' how long is this string? ',&
& 'and this one?']
write(*,*)'UNTRIMMED LENGTH= ',len(tablet)
write(*,*)'TRIMMED LENGTH= ',len_trim(tablet)
write(*,*)'SUM TRIMMED LENGTH=',sum(len_trim(tablet))
endblock ELE
!
end program demo_len_trim
結果
how long is this string?
UNTRIMMED LENGTH= 30
TRIMMED LENGTH= 25
xxxxx xxxxx xxxxx
xxxxxxxxxxxxxxx
UNTRIMMED LENGTH= 256
TRIMMED LENGTH= 25 13
SUM TRIMMED LENGTH= 38
標準#
Fortran 95。kind引数はFortran 2003で追加されました。
参照#
文字列に対して操作を実行し、引数の長さを返し、特定の引数を検索する関数
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost
trim#
名前#
trim(3) - [CHARACTER:WHITESPACE] 文字列から末尾の空白文字を削除する
概要#
result = trim(string)
character(len=:,kind=KIND) function trim(string)
character(len=*,kind=KIND),intent(in) :: string
特性#
KIND は、文字型でサポートされている任意の種類にすることができます。
結果は、入力引数stringと同じ型と種類になります。
説明#
trim(3) は、文字列から末尾の空白文字を削除します。
オプション#
- string
トリムする文字列
結果#
結果は、末尾の空白が削除された文字列と同じです。
文字列が完全に空白で構成されているか、長さがゼロの場合、結果は長さゼロになります。
例#
サンプルプログラム
program demo_trim
implicit none
character(len=:), allocatable :: str, strs(:)
character(len=*),parameter :: brackets='( *("[",a,"]":,1x) )'
integer :: i
str=' trailing '
print brackets, str,trim(str) ! trims it
str=' leading'
print brackets, str,trim(str) ! no effect
str=' '
print brackets, str,trim(str) ! becomes zero length
print *, len(str), len(trim(' '))
! array elements are all the same length, so you often
! want to print them
strs=[character(len=10) :: "Z"," a b c","ABC",""]
write(*,*)'untrimmed:'
! everything prints as ten characters; nice for neat columns
print brackets, (strs(i), i=1,size(strs))
print brackets, (strs(i), i=size(strs),1,-1)
write(*,*)'trimmed:'
! everything prints trimmed
print brackets, (trim(strs(i)), i=1,size(strs))
print brackets, (trim(strs(i)), i=size(strs),1,-1)
end program demo_trim
結果
> [ trailing ] [ trailing]
> [ leading] [ leading]
> [ ] []
> 12 0
> untrimmed:
> [Z ] [ a b c ] [ABC ] [ ]
> [ ] [ABC ] [ a b c ] [Z ]
> trimmed:
> [Z] [ a b c] [ABC] []
> [] [ABC] [ a b c] [Z]
標準#
Fortran 95
参照#
文字列に対して操作を実行し、引数の長さを返し、特定の引数を検索する関数
非要素関数: len_trim(3)、len(3)、repeat(3)、trim(3)
fortran-lang 固有関数の説明 (ライセンス: MIT) @urbanjost