lua-fmt - GitLite

KO | EN

gitlite — search

#php #sql #react-native #ai-agents #artificial-intelligence #windows #security #data-science #animation #typescript

lua-fmt

(★ 40)

A fmtlib implement for Lua

파일 탐색기

ZIP 다운로드

- lua-fmt-0.1.0-1.rockspec
- lua-fmt-scm-1.rockspec
.gitignore
.travis.yml
lfmt.c
LICENSE
luaunit.lua
README.md
test.lua

# CDN으로 사용하기

jsDelivr

jsDelivr는 공개 GitHub 리포지토리를 별도 설정 없이 CDN으로 즉시 서빙합니다. 버전과 파일을 고르면 웹페이지에 바로 붙일 수 있는 링크와 예시 코드가 만들어집니다.

버전

파일

링크

예시

명령어 용어집

이 문서에서 사용된 명령어를 모아봤습니다. 낯선 명령어가 있다면 펼쳐서 확인해보세요.

🔍

`gcc`

설명 보기 ▼

C와 C++ 소스 파일들을 전처리, 컴파일하여 모으고 이어줍니다.
더 많은 정보: <https://gcc.gnu.org/onlinedocs/gcc/>.

gcc {{path/to/source1.c path/to/source2.c ...}} {{[-o|--output]}} {{path/to/output_executable}}

다수의 소스 파일을 실행 파일로 컴파일합니다:

gcc {{path/to/source.c}} -Wall {{[-o|--output]}} {{output_executable}}

일반적인 경고와 디버그 심볼을 출력합니다:

gcc {{path/to/source.c}} -Wall {{[-g|--debug]}} -Og {{[-o|--output]}} {{path/to/output_executable}}

다른 경로에 위치한 라이브러리들을 포함합니다:

# 프로젝트 배지

Build Status 바로가기
Coverage Status 바로가기

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

Lua-fmt is a fmt like simple C module for Lua to format string.

The format syntax is same with
[fmtlib](https://fmt.dev/latest/syntax.html), which is same with
Python's `format` routine.

## Install

The simplest way to install it is using Luarocks:

```shell
luarocks install --server=https://luarocks.org/dev lua-fmt
```

Or, just compile the single C file:

```shell
# Linux
gcc -o lfmt.so -O3 -fPIC -shared lfmt.c
# macOS
gcc -o lfmt.so -O3 -fPIC -shared -undefined dynamic_lookup lfmt.c
# Windows
cl /Fefmt.dll /LD /MT /O2 /DLUA_BUILD_AS_DLL /Ipath/to/lua/include lfmt.c path/to/lua/lib
```

# Example

```lua
local fmt = require "fmt"

-- automatic indexed argument
print(fmt("{} {} {}", 1,2, 3)) --> "1 2 3"

-- manual indexed argument
print(fmt("{2}, {1}", "World", "Hello")) --> "Hello, World"

-- named indexed argument
print(fmt("{name} is {type}", { name = "foo", type = "bar" })) --> "foo is bar"
print(fmt("{t.name} is {t.type}", {t = { name = "foo", type = "bar" }})) --> "foo is bar"

-- format specifier
print(fmt("{:b}", 42)) --> "101010"

```

## Document

Mostly same as [fmtlib](https://fmt.dev/latest/syntax.html).

Format strings contain “replacement fields” surrounded by curly braces
`{}`. Anything that is not contained in braces is considered literal
text, which is copied unchanged to the output. If you need to include
a brace character in the literal text, it can be escaped by doubling:
`{{` and `}}`.

The grammar for a replacement field is as follows:

```
replacement_field ::=  "{" [arg_id] [":" format_spec] "}"
arg_id            ::=  field_name accessor*
field_name        ::=  integer | identifier
accessor          ::=  "." field_name | "[" key_name "]"
key_name          ::=  field_name | <any chars except ']'>*
integer           ::=  digit+
digit             ::=  "0"..."9"
identifier        ::=  id_start id_continue*
id_start          ::=  "a"..."z" | "A"..."Z" | "_"
id_continue       ::=  id_start | digit
```

the mainly difference is the support of accessor, which is supported
by Python but not by fmtlib.

- - -

“Format specifications” are used within replacement fields contained
within a format string to define how individual values are presented.
Each formattable type may define how the format specification is to be
interpreted.

Most built-in types implement the following options for format
specifications, although some of the formatting options are only
supported by the numeric types.

The general form of a standard format specifier is:

```
format_spec ::=  [[fill]align][sign]["#"]["0"][width][grouping]["." precision][type]
fill        ::=  <a character other than '{' or '}'>
align       ::=  "<" | ">" | "^"
sign        ::=  "+" | "-" | " "
width       ::=  integer | "{" [arg_id] "}"
grouping    ::=  "_" | ","
precision   ::=  integer | "{" [arg_id] "}"
type        ::=  int_type | flt_type | str_type
int_type    ::=  "b" | "B" | "d" | "o" | "x" | "X" | "c"
flt_type    ::=  "e" | "E" | "f" | "F" | "g" | "G" | "%"
str_type    ::=  "p" | "s"
```

Differences (all exists in Python):
- add grouping support for int_type: `"{:_}"` e.g. `"10_000"`
- add `"%"` specifier for float type: `"{:%}"` e.g. `"100.0%"`

Lua type vs. type specifiers:
| Lua Type  | Type specifiers    |
| --------- | ------------------ |
| "integer" | `int_type` |
| "float"   | `flt_type` |
| Others    | `str_type` |