操作字符变量的基本过程

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中某个元素的字符数。

示例

示例程序

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) 是相关的例程，允许您处理前导和尾随空格。

执行字符字符串操作、返回参数长度和搜索某些参数的函数

• 元素级： adjustl(3)、adjustr(3)、index(3)、scan(3)、verify(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具有相同的种类类型参数。

描述

new_line(3) 返回换行符。

通常，当每个语句完成时，通过常规格式化 I/O 语句（如 WRITE() 和 PRINT()）生成换行符

   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

  任意字符，其种类用于确定表示换行符的输出字符。

结果

情况 (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

特性

• 指定为 ** 的种类可以是类型支持的任何种类

• string 是标量字符类型。

• ncopies 是标量整数。

• 结果是与string具有相同种类的字符类型的新标量

描述

repeat(3) 连接字符串的副本。

选项

• string

  要重复的输入字符串

• ncopies

  要创建的string副本的数量，大于或等于零 (0)。

结果

由ncopies个string副本构建的新字符串。

示例

示例程序

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

另请参阅

执行字符字符串操作的函数

• 元素级： adjustl(3)、adjustr(3)、index(3)、scan(3)、verify(3)

• 非元素级： 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的值。否则，返回单个默认字符。

描述

achar(3) 返回 ASCII 排序序列中位置为 i（通常称为 ADE 或 ASCII 十进制等效值）处的字符。

achar(3) 函数通常用于生成带内转义序列以控制终端属性，因为它可以轻松打印不可打印字符，例如转义和制表符。例如

   write(*,'(*(a))')achar(27),'[2J'

将在兼容 ANSI 的终端显示器上清除屏幕。

注意

ASCII 的 ADE（ASCII 十进制等效值）为

*-------*-------*-------*-------*-------*-------*-------*-------*
| 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。

  对于任何能够表示为默认字符的字符 C，achar(3) 的值应为 C。

• kind

  一个整数初始化表达式，指示结果的 kind 参数。

结果

假设 i 的值在范围 0 <= I <= 127 内，则结果是 ASCII 排序序列中位置 i 处的字符，前提是处理器能够以结果的字符 kind 表示该字符；否则，结果取决于处理器。

示例

示例程序

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 中添加

另请参见

char(3)，iachar(3)，ichar(3)

资源

• ANSI 转义序列

• 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

特性

• 指定为 ** 的种类可以是类型支持的任何种类

• i 是任何 kind 的整数

• kind 是一个整数初始化表达式，指示结果的 kind 参数。

• 返回值是一个字符，其 kind 由 kind 指定，如果 kind 不存在，则为默认字符 kind。

描述

给定一个表示指定 kind kind 关联的排序序列中位置 i 的数字代码，生成一个字符值。

请注意，achar(3) 是一个专门用于 ASCII 字符的类似函数，当仅处理 ASCII 时优先使用，它等效于 char(i,kind=selected_char_kind(“ascii”) )

ichar(3) 函数是 char(3) 的反函数，将字符转换为它们的排序序列值。

选项

• i

  一个在范围 0 <= I <= n-1 内的值，其中 n 是与指定的 kind 类型参数关联的排序序列中的字符数。

  对于 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

另请参见

achar(3)，iachar(3)，ichar(3)

执行字符字符串操作、返回参数长度和搜索某些参数的函数

• 元素级： adjustl(3)、adjustr(3)、index(3)、scan(3)、verify(3)

• 非元素级： 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。

注意

指定为 ** 的种类可以是类型支持的任何种类

描述

iachar(3) 返回 C 的第一个字符位置中 ASCII 字符的代码。

选项

• c

  要确定其 ASCII 代码的字符。

  一个常见的扩展是允许字符串，但除了第一个字符外，其余字符都被忽略。

• kind

  一个常量初始化表达式，指示结果的 kind 参数。

结果

结果是字符 c 在 ASCII 排序序列中的位置。它是非负的，并且小于或等于 127。

通过 ASCII，是指 c 位于 ISO/IEC 646:1991（国际参考版本）中指定的代码定义的排序序列中。

如果 c 不在 ASCII 排序序列中，则结果取决于处理器。

结果与 lge(3)、lgt(3)、lle(3) 和 llt(3) 比较函数一致。例如，如果 lle(C, D) 为真，则 iachar(C) <= iachar (D) 为真，其中 C 和 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

另请参见

achar(3)，char(3)，ichar(3)

特别是请参阅 ichar(3)，了解在数值和格式化字符串表示之间进行转换的讨论。

执行字符字符串操作、返回参数长度和搜索某些参数的函数

• 元素级： adjustl(3)、adjustr(3)、index(3)、scan(3)、verify(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 平台不同的值。

请参阅 iachar(3) 以专门使用 ASCII 字符集。

选项

• c

  要确定其代码的输入字符。其值应为处理器能够表示的字符。

• kind

  指示结果的 kind 参数。如果 kind 缺失，则返回值为默认整数 kind。

结果

返回正在查询的字符在系统默认字符集中的代码。

结果是 c 在与 c 的 kind 类型参数关联的处理器排序序列中的位置。

它是非负的，并且小于 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

另请参见

achar(3)，char(3)，iachar(3)

执行字符字符串操作、返回参数长度和搜索某些参数的函数

• 元素级：adjustl(3)，adjustr(3)，index(3)，

scan(3)，verify(3)

• 非元素级： len_trim(3)、len(3)、repeat(3)、trim(3)

fortran-lang 内在函数描述（许可证：MIT）@urbanjost

index

名称

index(3) - [CHARACTER:SEARCH] 字符串中子字符串的位置

概要

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 是任何 kind 的字符变量

• substring 是与 string 同一 kind 的字符变量

• back 是任何受支持 kind 的逻辑变量

• KIND 是标量整数常量表达式。

描述

index(3) 返回 string 中 substring 字符串最左边或最右边出现的起始位置，从 1 开始计数。如果 substring 不存在于 string 中，则返回零。

选项

• string

  要搜索匹配项的字符串

• substring

  要尝试在 string 中定位的字符串

• back

  如果存在 back 参数且为真，则返回值为最右边出现的起始位置，而不是最左边的。

• kind

  如果存在 kind，则 kind 类型参数为 kind 的值指定；否则，kind 类型参数为默认整数类型的 kind。

结果

结果是在 string 中找到的第一个子字符串 substring 的起始位置。

如果 substring 的长度大于 string，则结果为零。

如果未找到子字符串，则结果为零。

如果 **back** 为 .true.，则返回最大的起始位置（即最右侧匹配的位置）。否则，返回匹配的最小起始位置（即最左侧匹配的位置）。

返回的位置从左侧开始计算，其中 **string** 的第一个字符为位置一。

否则，如果未找到匹配项，则返回零。

示例

示例程序

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

另请参阅

执行字符字符串操作、返回参数长度和搜索某些参数的函数

• 元素级： adjustl(3)、adjustr(3)、index(3)、scan(3)、verify(3)

• 非元素级： len_trim(3)、len(3)、repeat(3)、trim(3)

fortran-lang 内置描述

scan

名称

scan(3) - [CHARACTER:SEARCH] 在字符串中搜索一组字符的存在

语法

    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 具有相同类型的 字符 字符串

• back 是一个 逻辑 类型

• kind 是一个标量 整数 常量表达式

• 结果是一个 整数，其类型由 kind 指定。如果未提供 kind，则结果为默认 整数。

描述

scan(3) 在 string 中扫描 set 中的任何字符。

如果 **back** 不存在或等于 .false.，则此函数返回 STRING 中最左侧字符的位置，该字符位于 set 中。如果 **back** 等于 .true.，则返回最右侧位置。如果在 string 中未找到 set 的任何字符，则结果为零。

选项

• string

  要扫描的字符串

• set

  将匹配的字符集

• back

  如果为 .true.，则返回匹配的最右侧字符的位置，而不是最左侧字符的位置。

• kind

  如果存在，则返回的值的类型与 kind 相同。否则，返回默认 整数 类型。

结果

如果 **back** 不存在或存在且值为 false，并且 **string** 包含至少一个位于 **set** 中的字符，则结果值为 string 中最左侧字符的位置，该字符位于 **set** 中。

如果 **back** 存在且值为 true，并且 **string** 包含至少一个位于 **set** 中的字符，则结果值为 string 中最右侧字符的位置，该字符位于 **set** 中。

如果 STRING 中没有字符位于 SET 中，或者 STRING 或 SET 的长度为零，则结果值为零。

示例

示例程序

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

另请参阅

执行字符字符串操作、返回参数长度和搜索某些参数的函数

• 元素： adjustl(3)，adjustr(3)，index(3)，verify(3)

• 非元素级： len_trim(3)、len(3)、repeat(3)、trim(3)

fortran-lang 内在函数描述（许可证：MIT）@urbanjost

verify

名称

verify(3) - [CHARACTER:SEARCH] 字符串中不属于给定字符集的字符的位置。

语法

    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 必须是常量 整数 初始化表达式，并且是 整数 类型的有效类型。

• back 应为逻辑类型。

• 如果存在，则返回的值的类型与 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

  表示结果的类型参数的 整数 初始化表达式。

结果

如果 string 中的所有字符都在 set 中找到，则结果为零。

如果 string 的长度为零，则始终返回零 (0)。

否则，如果找到不匹配的字符，则返回 string 中第一个或最后一个（如果 **back** 为 .false.）不匹配字符的位置，从字符串左侧的第一个位置开始。

示例

示例程序 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) - [CHARACTER:COMPARE] 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 具有相同的类型和类型

• 结果为默认逻辑类型

描述

lge(3) 确定一个字符串在词法上是否大于或等于另一个字符串，其中这两个字符串被解释为包含 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 比较的字符串

结果

如果 string*a == string_b，则返回 .true.，否则返回 *.false._，基于 ASCII 排序规则。

如果两个输入参数都是空字符串，则始终返回 .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

另请参阅

lgt(3)，lle(3)，llt(3)

执行字符字符串操作、返回参数长度和搜索某些参数的函数

• 元素级：adjustl(3)，adjustr(3)，index(3)，

scan(3)，verify(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 具有相同的类型和类型

• 结果为默认逻辑类型

描述

lgt(3) 确定一个字符串在词法上是否大于另一个字符串，其中这两个字符串被解释为包含 ASCII 字符代码。如果字符串 a 和字符串 b 的长度不同，则较短的字符串将被比较，就像在其后附加空格以形成与较长字符串长度相同的字符串。

通常，词法比较内在函数 lge、lgt、lle 和 llt 与相应的内在运算符 .ge.、.gt.、.le. 和 .lt. 不同，后者使用处理器的字符排序（在某些目标上不是 ASCII），而前者始终使用 ASCII 排序。

选项

• string_a

  要测试的字符串

• string_b

  要与 string_a 比较的字符串

结果

如果 string*a > string_b，则返回 .true.，否则返回 *.false._，基于 ASCII 排序。

如果两个输入参数都是空字符串，则返回 .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

另请参阅

lge(3)，lle(3)，llt(3)

执行字符字符串操作、返回参数长度和搜索某些参数的函数

• 元素级：adjustl(3)，adjustr(3)，index(3)，

scan(3)，verify(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 具有相同的类型和类型

• 结果为默认逻辑类型

描述

lle(3) 确定一个字符串在字典序上是否小于或等于另一个字符串，其中这两个字符串被解释为包含 ASCII 字符代码。

如果string_a 和string_b 的长度不同，则将较短的字符串视为在其末尾附加空格，以形成与较长字符串长度相同的字符串。

前导空格是有意义的。

通常，字典序比较内在函数lge、lgt、lle 和llt 与相应的内在运算符.ge.、.gt.、.le. 和 .lt.不同，后者使用处理器的字符排序（在某些目标上不是 ASCII），而lle(3) 始终使用 ASCII 排序。

选项

• string_a

  要测试的字符串

• string_b

  要与 string_a 比较的字符串

结果

• result 如果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

另请参阅

lge(3)，lgt(3)，llt(3)

执行字符字符串操作、返回参数长度和搜索某些参数的函数

• 元素级：adjustl(3)，adjustr(3)，index(3)，

scan(3)，verify(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 具有相同的类型和类型

• 结果为默认逻辑类型

描述

llt(3) 确定一个字符串在字典序上是否小于另一个字符串，其中这两个字符串被解释为包含 ASCII 字符代码。如果string_a 和string_b 的长度不同，则将较短的字符串视为在其末尾附加空格，以形成与较长字符串长度相同的字符串。

通常，词法比较内在函数 lge、lgt、lle 和 llt 与相应的内在运算符 .ge.、.gt.、.le. 和 .lt. 不同，后者使用处理器的字符排序（在某些目标上不是 ASCII），而前者始终使用 ASCII 排序。

选项

• string_a

  要测试的字符串

• string_b

  要与 string_a 比较的字符串

结果

如果 string*a <= string_b，则返回.true.，否则返回*.false._，基于 ASCII 排序规则。

如果两个输入参数都是空字符串，则始终返回.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

另请参阅

lge(3)，lgt(3)，lle(3))

执行字符字符串操作、返回参数长度和搜索某些参数的函数

• 元素级： adjustl(3)、adjustr(3)、index(3)、scan(3)、verify(3)

• 非元素级： 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

另请参阅

adjustr(3)，trim(3)

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

另请参阅

adjustl(3)，trim(3)

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 中任何尾随空格后剩余的字符数。

如果输入参数的长度为零或全部为空格，则结果为零。

示例

示例程序

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 添加。

另请参阅

执行字符字符串操作、返回参数长度和搜索某些参数的函数

• 元素级： adjustl(3)、adjustr(3)、index(3)、scan(3)、verify(3)

• 非元素：repeat(3)，len(3)，trim(3)

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

  要修剪的字符串

结果

结果与string 相同，只是删除了尾随空格。

如果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

另请参阅

执行字符字符串操作、返回参数长度和搜索某些参数的函数

• 元素级： adjustl(3)、adjustr(3)、index(3)、scan(3)、verify(3)

• 非元素级： len_trim(3)、len(3)、repeat(3)、trim(3)

fortran-lang 内在函数描述（许可证：MIT）@urbanjost