Anúncios incomodam? Ir Sem anúncios Hoje 

Julia Code Formatter

DesenvolvedorTexto

[iotools_julia_code_formatter]

Guia

Julia Code Formatter

Paste any Julia (.jl) source and get instantly reformatted output following the conventions used by the wider Julia scientific-computing community. The tool runs entirely in your browser — no Julia runtime, no server round-trip — so even confidential research or proprietary code can be cleaned up safely.

The formatter mirrors the default style of JuliaFormatter.jl: four-space indentation, consistent spacing around binary operators, tight type annotations such as x::Int e T <: Real, preserved juxtaposition multiplication like 2π, and a configurable soft line-length warning at 92 characters.

Como usar

Paste your Julia code into the Julia Code textarea, or click Tente um exemplo to load a sample module.
Escolha um Estilo de Indentação — four spaces is the JuliaFormatter default, two spaces and tabs are also available.
Ajuste o Comprimento da Linha slider if your team uses a width other than 92 characters. Long lines are reported but never broken automatically, so the result stays syntactically equivalent.
Alternar spacing around binary operators, tight type-annotation spacing, preserve commentse, e collapse multiple blank lines to taste.
Clique Formatar. Copy the result with the clipboard button or download it as a .jl arquivo.

Características

JuliaFormatter default style – four-space indentation, blank-line conventions, and consistent operator spacing out of the box.
Block-aware indentation – correctly handles function, if/elseif/else, for, while, try/catch/finally, let, begin, do, module, struct, quote, macroe, e abstract type/primitive type declarations.
Unicode-aware tokenizer – recognises Greek-letter and other Unicode identifiers such as π, α, θe, e Δ.
Juxtaposition multiplication preserved – numeric coefficients written as 2π ou 0.5x stay tight, while explicit 2 * π stays spaced.
Tight type annotations – x::Int, T <: Reale, e Vector{<:Shape} remain compact.
Comments and strings respected – line comments (#), nestable block comments (#=…=#), triple-quoted strings, prefixed strings (r"…", raw"…"), char literals, and string interpolation are left intact.
Soft line-length report – exceeding lines are counted so you can refactor manually without the formatter breaking semantics.
Copiar e baixar com um clique as formatted.jl.
100% do lado do cliente – nothing leaves your browser.

ANUNCIADO Remover?

 Perguntas frequentes

What style guide does the JuliaFormatter default follow?

The JuliaFormatter.jl default style is the most widely adopted convention in the Julia community. It uses four-space indentation, surrounds most binary operators with single spaces, keeps type annotations and subtype operators tight (e.g. x::Int, T<:Real), preserves juxtaposition multiplication such as 2π, and targets a soft line width of about 92 characters. Several Julia-organisation packages bundle this style as the baseline for contributions.
Why does Julia allow numbers and identifiers to be written together without an operator?

Julia treats a numeric literal immediately followed by an identifier or parenthesised expression as implicit multiplication — a feature called juxtaposition. So 2π means 2 * π, 0.5x means 0.5 * xe, e 3(a + b) means 3 * (a + b). The numeric literal must come first; the reverse (π2) is not valid because Julia cannot tell whether it is a multiplication or part of an identifier name. Style-wise, the convention is to keep juxtaposition tight without an inserted space.
How are Julia block structures different from C-style languages?

Julia uses keyword-delimited blocks instead of curly braces. Almost every block opener — function, if, for, while, let, begin, try, do, module, struct, macro, quotee, e abstract type/primitive type — is closed by a matching end token. Continuers like elseif, else, catche, e finally sit at the same indentation as the opener but introduce a new body at the next deeper level. This makes Julia code visually closer to Ruby or Lua than to Java or C.
What is the difference between a regular string and a non-standard (prefixed) string literal in Julia?

In Julia a regular double-quoted string like "hello" is processed by the standard String constructor with backslash escape sequences. A prefixed string such as r"\d+" ou raw"C:\path" calls a non-standard string macro — r for regular expressions, raw for unescaped content, b for byte arrays, and many others including user-defined ones. Inside a non-standard literal the contents are passed verbatim, so backslashes are not consumed by the lexer. Triple-quoted variants ("""…""") span multiple lines and trim a common leading indentation.