일반 텍스트 서식

F#은 , 및 sprintf관련 함수를 사용하여 printfprintfn일반 텍스트의 형식 검사 형식 지정을 지원합니다. 예를 들면 다음과 같습니다.

dotnet fsi

> printfn "Hello %s, %d + %d is %d" "world" 2 2 (2+2);;

는 출력을 제공합니다.

Hello world, 2 + 2 is 4

또한 F#을 사용하면 구조화된 값의 서식을 일반 텍스트로 지정할 수 있습니다. 예를 들어 출력을 행렬과 유사한 튜플 표시 형식으로 지정하는 다음 예제를 고려해 보세요.

dotnet fsi

> printfn "%A" [ for i in 1 .. 5 -> [ for j in 1 .. 5 -> (i, j) ] ];;

[[(1, 1); (1, 2); (1, 3); (1, 4); (1, 5)];
 [(2, 1); (2, 2); (2, 3); (2, 4); (2, 5)];
 [(3, 1); (3, 2); (3, 3); (3, 4); (3, 5)];
 [(4, 1); (4, 2); (4, 3); (4, 4); (4, 5)];
 [(5, 1); (5, 2); (5, 3); (5, 4); (5, 5)]]

구조화된 일반 텍스트 서식은 서식 문자열에 printf 서식을 %A 사용할 때 활성화됩니다. 또한 F# 대화형으로 값의 출력 서식을 지정할 때 활성화됩니다. 여기서 출력에는 추가 정보가 포함되며 추가로 사용자 지정할 수 있습니다. 일반 텍스트 서식은 디버깅, 로깅 및 기타 도구에서 암시적으로 발생하는 값을 포함하여 F# 공용 구조체 및 레코드 값에 대한 호출 x.ToString() 을 통해서도 관찰할 수 있습니다.

printf-format 문자열 확인

서식 문자열의 printf 형식 지정자와 일치하지 않는 인수와 함께 서식 함수를 사용하는 경우 printf 컴파일 시간 오류가 보고됩니다. 예를 들면 다음과 같습니다.

sprintf "Hello %s" (2+2)

는 출력을 제공합니다.

  sprintf "Hello %s" (2+2)
  ----------------------^

stdin(3,25): error FS0001: The type 'string' does not match the type 'int'

기술적으로 Fprintf# 컴파일러의 특수 규칙은 F# 컴파일러에서 형식 문자열로 전달된 문자열 리터럴을 검사 적용된 후속 인수가 사용된 형식 지정자와 일치하는 올바른 형식이 되도록 합니다.

에 대한 서식 지정자 printf

형식의 printf 형식 사양은 서식을 나타내는 표식 % 이 있는 문자열입니다. 형식 자리 표시자는 형식이 다음과 같이 해석되는 위치로 구성 %[flags][width][.precision][type] 됩니다.

형식 지정자	형식(들)	설명
%b	bool (System.Boolean)	형식이 truefalse
%s	string (System.String)	이스케이프되지 않은 콘텐츠로 형식이 지정됨
%c	char (System.Char)	문자 리터럴로 서식 지정
%d, %i	기본 정수 형식	10진수 정수로 형식이 지정되고, 기본 정수 형식이 서명된 경우 서명됩니다
%u	기본 정수 형식	부호 없는 10진수 정수로 서식 지정
%x, %X	기본 정수 형식	부호 없는 16진수 형식(각각 16진수의 경우 a-f 또는 A-F)
%o	기본 정수 형식	부호 없는 8진수로 서식 지정
%B	기본 정수 형식	부호 없는 이진 번호로 형식이 지정됨
%e, %E	기본 부동 소수점 형식	d가 10진수인 폼 [-]d.dddde[sign]ddd 을 갖는 부호 있는 값으로 서식이 지정되고, dddd는 하나 이상의 10진수이고, ddd는 정확히 3진수이고, 기호는 +-
%f, %F	기본 부동 소수점 형식	하나 이상의 10진수인 폼 [-]dddd.dddd이 있는 dddd 부명 값으로 서식이 지정됩니다. 소수점 앞의 자릿수는 숫자의 크기에 따라 달라지고 소수점 뒤의 자릿수는 요청된 전체 자릿수에 따라 달라집니다.
%g, %G	기본 부동 소수점 형식	지정된 값과 정밀도에 대해 더 간결하게 인쇄된 %f 부가 값 또는 %e 형식으로 사용하여 서식을 지정합니다.
%M	a decimal (System.Decimal) 값	에 대한 형식 지정자를 사용하여 "G" 서식 지정 System.Decimal.ToString(format)
%O	어떤 값	개체를 boxing하고 메서드를 호출하여 서식 지정 System.Object.ToString()
%A	어떤 값	기본 레이아웃 설정과 함께 구조화된 일반 텍스트 서식을 사용하여 서식 지정
%a	어떤 값	컨텍스트 매개 변수와 값을 허용하는 서식 함수와 인쇄할 특정 값의 두 인수가 필요합니다.
%t	어떤 값	하나의 인수가 필요합니다. 적절한 텍스트를 출력하거나 반환하는 컨텍스트 매개 변수를 수락하는 서식 함수
%%	(없음)	인수가 필요하지 않으며 일반 백분율 기호를 인쇄합니다. %

기본 정수 형식은 (), (), (), int16 (System.UInt16System.Int16), int32uint16 (System.Int32), uint32 (System.UInt32), int64 (System.Int64), uint64 (System.IntPtrSystem.UInt64) nativeint 및 unativeint (System.UIntPtr)입니다.byteSystem.SBytesbyteSystem.Byte 기본 부동 소수점 형식은 (), (System.Single) 및 decimal (System.Decimal)입니다 float . float32System.Double

선택적 너비는 결과의 최소 너비를 나타내는 정수입니다. 예를 들어 %6d 정수는 6자 이상을 채울 공백으로 접두사를 지정하여 인쇄합니다. width이 *면 해당 너비를 지정하기 위해 추가 정수 인수를 사용합니다.

유효한 플래그는 다음과 같습니다.

Flag	효과
0	필요한 너비를 만회하기 위해 공백 대신 0을 추가합니다.
-	지정된 너비 내의 결과를 왼쪽 맞춤
+	+ 숫자가 양수이면 문자를 추가합니다(음수의 기호와 - 일치).
공백 문자	숫자가 양수이면 (음수의 '-' 기호와 일치하도록) 추가 공간을 추가합니다.

printf # 플래그가 잘못되었으며 사용하는 경우 컴파일 시간 오류가 보고됩니다.

값은 고정 문화권을 사용하여 형식이 지정됩니다. 문화권 설정은 결과 %O 및 서식에 영향을 미치는 경우를 제외하고 서식과 %A 관련이 없습니다printf. 자세한 내용은 구조적 일반 텍스트 서식을 참조 하세요.

%A 서식

%A 형식 지정자는 사람이 읽을 수 있는 방식으로 값의 서식을 지정하는 데 사용되며 진단 정보를 보고하는 데 유용할 수도 있습니다.

기본값

지정자를 사용하여 일반 텍스트의 %A 서식을 지정할 때 F# 숫자 값은 접미사와 고정 문화권으로 서식이 지정됩니다. 부동 소수점 값은 10개의 부동 소수점 정밀도 위치를 사용하여 서식이 지정됩니다. 예를 들면 다음과 같습니다.

printfn "%A" (1L, 3n, 5u, 7, 4.03f, 5.000000001, 5.0000000001)

생성

(1L, 3n, 5u, 7, 4.03000021f, 5.000000001, 5.0)

지정자를 %A 사용하는 경우 문자열은 따옴표를 사용하여 형식이 지정됩니다. 이스케이프 코드는 추가되지 않고 대신 원시 문자가 인쇄됩니다. 예를 들면 다음과 같습니다.

printfn "%A" ("abc", "a\tb\nc\"d")

생성

("abc", "a      b
c"d")

.NET 값

지정자를 사용하여 일반 텍스트의 %A 서식을 지정할 때 F# .NET이 아닌 개체는 지정된 System.Globalization.CultureInfo.CurrentCulture .NET 및 System.Globalization.CultureInfo.CurrentUICulture.NET의 기본 설정을 사용하여 x.ToString() 서식이 지정됩니다. 예를 들면 다음과 같습니다.

open System.Globalization

let date = System.DateTime(1999, 12, 31)

CultureInfo.CurrentCulture <- CultureInfo.GetCultureInfo("de-DE")
printfn "Culture 1: %A" date

CultureInfo.CurrentCulture <- CultureInfo.GetCultureInfo("en-US")
printfn "Culture 2: %A" date

생성

Culture 1: 31.12.1999 00:00:00
Culture 2: 12/31/1999 12:00:00 AM

구조적 값

지정자를 사용하여 일반 텍스트의 서식을 %A 지정할 때 블록 들여쓰기는 F# 목록 및 튜플에 사용됩니다. 위의 예에도 이러한 열이 포함되어 있습니다. 다차원 배열을 포함하여 배열 구조도 사용됩니다. 1차원 배열은 구문으로 [| ... |] 표시됩니다. 예를 들면 다음과 같습니다.

printfn "%A" [| for i in 1 .. 20 -> (i, i*i) |]

생성

[|(1, 1); (2, 4); (3, 9); (4, 16); (5, 25); (6, 36); (7, 49); (8, 64); (9, 81);
  (10, 100); (11, 121); (12, 144); (13, 169); (14, 196); (15, 225); (16, 256);
  (17, 289); (18, 324); (19, 361); (20, 400)|]

기본 인쇄 너비는 80입니다. 서식 지정자의 인쇄 너비를 사용하여 이 너비를 사용자 지정할 수 있습니다. 예를 들면 다음과 같습니다.

printfn "%10A" [| for i in 1 .. 5 -> (i, i*i) |]

printfn "%20A" [| for i in 1 .. 5 -> (i, i*i) |]

printfn "%50A" [| for i in 1 .. 5 -> (i, i*i) |]

생성

[|(1, 1);
  (2, 4);
  (3, 9);
  (4, 16);
  (5, 25)|]
[|(1, 1); (2, 4);
  (3, 9); (4, 16);
  (5, 25)|]
[|(1, 1); (2, 4); (3, 9); (4, 16); (5, 25)|]

인쇄 너비를 0으로 지정하면 인쇄 너비가 사용되지 않습니다. 출력에 포함된 문자열에 줄 바꿈이 포함된 경우를 제외하고 한 줄의 텍스트가 발생합니다. 예를 들면 다음과 같습니다.

printfn "%0A" [| for i in 1 .. 5 -> (i, i*i) |]

printfn "%0A" [| for i in 1 .. 5 -> "abc\ndef" |]

생성

[|(1, 1); (2, 4); (3, 9); (4, 16); (5, 25)|]
[|"abc
def"; "abc
def"; "abc
def"; "abc
def"; "abc
def"|]

깊이 제한은 4로 seq { ...}표시되는 시퀀스(IEnumerable) 값에 사용됩니다. 목록 및 배열 값에는 깊이 제한이 100으로 사용됩니다. 예를 들면 다음과 같습니다.

printfn "%A" (seq { for i in 1 .. 10 -> (i, i*i) })

생성

seq [(1, 1); (2, 4); (3, 9); (4, 16); ...]

블록 들여쓰기는 공용 레코드 및 공용 구조체 값의 구조에도 사용됩니다. 예를 들면 다음과 같습니다.

type R = { X : int list; Y : string list }

printfn "%A" { X =  [ 1;2;3 ]; Y = ["one"; "two"; "three"] }

생성

{ X = [1; 2; 3]
  Y = ["one"; "two"; "three"] }

사용되는 경우 %+A 리플렉션을 사용하여 레코드 및 공용 구조체의 프라이빗 구조도 표시됩니다. 예를 들면 다음과 같습니다.

type internal R =
    { X : int list; Y : string list }
    override _.ToString() = "R"

let internal data = { X = [ 1;2;3 ]; Y = ["one"; "two"; "three"] }

printfn "external view:\n%A" data

printfn "internal view:\n%+A" data

생성

external view:
R

internal view:
{ X = [1; 2; 3]
  Y = ["one"; "two"; "three"] }

큰 값, 순환 값 또는 깊이 중첩된 값

구조화된 큰 값은 최대 전체 개체 노드 수인 10000으로 형식이 지정됩니다. 깊이가 100인 깊이로 중첩된 값의 서식이 지정됩니다. 두 경우 ... 모두 일부 출력을 제외하는 데 사용됩니다. 예를 들면 다음과 같습니다.

type Tree =
    | Tip
    | Node of Tree * Tree

let rec make n =
    if n = 0 then
        Tip
    else
        Node(Tip, make (n-1))

printfn "%A" (make 1000)

는 일부 파트가 제외된 큰 출력을 생성합니다.

Node(Tip, Node(Tip, ....Node (..., ...)...))

주기는 개체 그래프에서 검색되며 ... 주기가 검색되는 위치에서 사용됩니다. 예를 들면 다음과 같습니다.

type R = { mutable Links: R list }
let r = { Links = [] }
r.Links <- [r]
printfn "%A" r

생성

{ Links = [...] }

지연, null 및 함수 값

값이 아직 평가되지 않은 경우 지연 값은 텍스트로 인쇄되거나 동일한 텍스트로 Value is not created 인쇄됩니다.

값의 정적 형식이 허용되는 표현인 공용 구조체 형식 null 으로 null 결정되지 않는 한 Null 값은 인쇄됩니다.

F# 함수 값은 내부적으로 생성된 클로저 이름으로 인쇄됩니다(예 <fun:it@43-7>: .).

를 사용하여 일반 텍스트 서식 사용자 지정 StructuredFormatDisplay

지정자를 %A 사용하는 경우 형식 선언에 StructuredFormatDisplay 대한 특성의 존재가 적용됩니다. 서로게이트 텍스트와 속성을 지정하여 값을 표시하는 데 사용할 수 있습니다. 예시:

[<StructuredFormatDisplay("Counts({Clicks})")>]
type Counts = { Clicks:int list}

printfn "%20A" {Clicks=[0..20]}

생성

Counts([0; 1; 2; 3;
        4; 5; 6; 7;
        8; 9; 10; 11;
        12; 13; 14;
        15; 16; 17;
        18; 19; 20])

재정의하여 일반 텍스트 서식 사용자 지정 ToString

기본 구현 ToString 은 F# 프로그래밍에서 관찰할 수 있습니다. 종종 기본 결과는 프로그래머 쪽 정보 표시 또는 사용자 출력에 사용하기에 적합하지 않으며, 따라서 기본 구현을 재정의하는 것이 일반적입니다.

기본적으로 F# 레코드 및 공용 구조체 형식은 사용하는 구현을 사용하여 구현sprintf "%+A"을 재정의 ToString 합니다. 예를 들면 다음과 같습니다.

type Counts = { Clicks:int list }

printfn "%s" ({Clicks=[0..10]}.ToString())

생성

{ Clicks = [0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10] }

클래스 형식의 ToString 경우 기본 구현이 제공되지 않으며 형식의 이름을 보고하는 .NET 기본값이 사용됩니다. 예를 들면 다음과 같습니다.

type MyClassType(clicks: int list) =
   member _.Clicks = clicks

let data = [ MyClassType([1..5]); MyClassType([1..5]) ]
printfn "Default structured print gives this:\n%A" data
printfn "Default ToString gives:\n%s" (data.ToString())

생성

Default structured print gives this:
[MyClassType; MyClassType]
Default ToString gives:
[MyClassType; MyClassType]

재정 ToString 의를 추가하면 더 나은 서식을 제공할 수 있습니다.

type MyClassType(clicks: int list) =
   member _.Clicks = clicks
   override _.ToString() = sprintf "MyClassType(%0A)" clicks

let data = [ MyClassType([1..5]); MyClassType([1..5]) ]
printfn "Now structured print gives this:\n%A" data
printfn "Now ToString gives:\n%s" (data.ToString())

생성

Now structured print gives this:
[MyClassType([1; 2; 3; 4; 5]); MyClassType([1; 2; 3; 4; 5])]
Now ToString gives:
[MyClassType([1; 2; 3; 4; 5]); MyClassType([1; 2; 3; 4; 5])]

및 를 StructuredFormatDisplay 사용하여 일반 텍스트 서식 사용자 지정 ToString

지정자에 대해 %A 일관된 서식 지정 및 %O 서식 지정을 수행하려면 재정의 StructuredFormatDisplay 와 사용을 ToString결합합니다. 예를 들면 다음과 같습니다.

[<StructuredFormatDisplay("{DisplayText}")>]
type MyRecord =
    {
        a: int
    }
    member this.DisplayText = this.ToString()

    override _.ToString() = "Custom ToString"

다음 정의 평가

let myRec = { a = 10 }
let myTuple = (myRec, myRec)
let s1 = sprintf $"{myRec}"
let s2 = sprintf $"{myTuple}"
let s3 = sprintf $"%A{myTuple}"
let s4 = sprintf $"{[myRec; myRec]}"
let s5 = sprintf $"%A{[myRec; myRec]}"

은 텍스트를 제공합니다.

val myRec: MyRecord = Custom ToString
val myTuple: MyRecord * MyRecord = (Custom ToString, Custom ToString)
val s1: string = "Custom ToString"
val s2: string = "(Custom ToString, Custom ToString)"
val s3: string = "(Custom ToString, Custom ToString)"
val s4: string = "[Custom ToString; Custom ToString]"
val s5: string = "[Custom ToString; Custom ToString]"

지원 DisplayText 속성을 사용하면 StructuredFormatDisplay 구조화된 인쇄 중에 구조적 레코드 형식이 무시되고 모든 상황에서 재정의 ToString() 가 선호된다는 사실을 myRec 의미합니다.

.NET 형식 사양이 System.IFormattable 있는 상태에서 추가 사용자 지정을 위해 인터페이스 구현을 추가할 수 있습니다.

F# 대화형 구조적 인쇄

F# 대화형(dotnet fsi)은 구조화된 일반 텍스트 서식의 확장 버전을 사용하여 값을 보고하고 추가 사용자 지정 기능을 허용합니다. 자세한 내용은 F# 대화형을 참조 하세요.

디버그 디스플레이 사용자 지정

.NET용 디버거는 다음과 같은 DebuggerDisplayDebuggerTypeProxy특성의 사용을 존중하며, 이러한 특성은 디버거 검사 창에서 개체의 구조화된 표시에 영향을 줍니다. F# 컴파일러는 구분된 공용 구조체 및 레코드 형식에 대해 이러한 특성을 자동으로 생성하지만 클래스, 인터페이스 또는 구조체 형식은 생성하지 않았습니다.

이러한 특성은 F# 일반 텍스트 서식에서 무시되지만 F# 형식을 디버깅할 때 표시를 개선하기 위해 이러한 메서드를 구현하는 것이 유용할 수 있습니다.

참고 항목

• 문자열
• 레코드
• 구별된 공용 구조체
• F# Interactive