uutils Coreutils Documentation

uutils is an attempt at writing universal (as in cross-platform) CLI utilities in Rust. It is available for Linux, Windows, Mac and other platforms.

The API reference for uucore, the library of functions shared between various utils, is hosted at docs.rs.

uutils is licensed under the MIT License.

Useful links

• Releases
• Source Code
• Issues
• Discord

Note: This manual is automatically generated from the source code and is a work in progress.

Installation

This is a list of uutils packages in various distributions and package managers. Note that these are packaged by third-parties and the packages might contain patches.

You can also build uutils from source.

• Cargo
• Linux
  • Alpine
  • Arch
  • Debian
  • Fedora
  • Gentoo
  • Manjaro
  • NixOS
  • OpenMandriva Lx
  • RHEL/AlmaLinux/CENTOS Stream/Rocky Linux/EPEL 9
  • Ubuntu
  • AUR
• MacOS
  • Homebrew
  • MacPorts
• FreeBSD
• Windows
  • Winget
  • Scoop
  • MSYS2
• Alternative installers
  • Conda
  • Yocto

Cargo

# Linux
cargo install coreutils --features unix --locked
# MacOs
cargo install coreutils --features macos --locked
# Windows
cargo install coreutils --features windows --locked

Linux

Alpine

apk update uutils-coreutils

Note: Requires the edge repository.

Arch

pacman -S uutils-coreutils

Debian

apt install rust-coreutils
# To use it:
export PATH=/usr/lib/cargo/bin/coreutils:$PATH

Fedora

dnf install uutils-coreutils
# To use it:
export PATH=/usr/libexec/uutils-coreutils:$PATH

Gentoo

emerge -pv sys-apps/uutils-coreutils

Manjaro

pacman -S uutils-coreutils
# or
pamac install uutils-coreutils

NixOS

nix-env -iA nixos.uutils-coreutils

OpenMandriva Lx

dnf install uutils-coreutils

RHEL/AlmaLinux/CENTOS Stream/Rocky Linux/EPEL 9

# Install EPEL 9 - Specific For RHEL please check codeready-builder-for-rhel-9 First then install epel
dnf install https://dl.fedoraproject.org/pub/epel/epel-release-latest-9.noarch.rpm -y
# Install Core Utils
dnf install uutils-coreutils
# To use it:
export PATH=/usr/libexec/uutils-coreutils:$PATH

Ubuntu

apt install rust-coreutils
# To use it:
export PATH=/usr/lib/cargo/bin/coreutils:$PATH

AUR

AUR package

Rust rewrite of the GNU coreutils (main branch).

MacOS

Homebrew

brew install uutils-coreutils

MacPorts

port install coreutils-uutils

FreeBSD

pkg install rust-coreutils

Windows

Winget

winget install uutils.coreutils

Scoop

Scoop package

scoop install uutils-coreutils

MSYS2

MSYS2 package (Windows native)

MSYS2 package (Cygwin)

Alternative installers

Conda

Conda package

conda install -c conda-forge uutils-coreutils

Yocto

Yocto recipe

The uutils-coreutils recipe is provided as part of the meta-openembedded yocto layer. Clone poky and meta-openembedded, add meta-openembedded/meta-oe as layer in your build/conf/bblayers.conf file, and then either call bitbake uutils-coreutils, or use PREFERRED_PROVIDER_coreutils = "uutils-coreutils" in your build/conf/local.conf file and then build your usual yocto image.

Build from source

Requirements

• Rust (cargo, rustc)
• GNU Make (optional)

Rust Version

uutils follows Rust’s release channels and is tested against stable, beta and nightly.

Building

There are currently two methods to build the uutils binaries: either Cargo or GNU Make.

Building the full package, including all documentation, requires both Cargo and GNU Make on a Unix platform.

For either method, we first need to fetch the repository:

git clone https://github.com/uutils/coreutils
cd coreutils

Cargo

Building uutils using Cargo is easy because the process is the same as for every other Rust program:

cargo build --release

Replace --release with --profile=release-small to optimize binary size.

This command builds the most portable common core set of uutils into a multicall (BusyBox-type) binary, named ‘coreutils’, on most Rust-supported platforms.

Additional platform-specific uutils are often available. Building these expanded sets of uutils for a platform (on that platform) is as simple as specifying it as a feature:

cargo build --release --features macos
# or ...
cargo build --release --features windows
# or ...
cargo build --release --features unix

To build SELinux-specific features, including chcon and runcon, ensure that libselinux and libclang are installed on your system. Then, run the following command:

cargo build --release --features unix,feat_selinux

If you don’t want to build every utility available on your platform into the final binary, you can also specify which ones you want to build manually. For example:

cargo build --features "base32 cat echo rm" --no-default-features

If you want to build the utilities as individual binaries, that is also possible:

cargo build --release --bins --workspace --exclude coreutils --exclude uu_runcon --exclude uu_chcon

Each utility is contained in its own package within the main repository, named “uu_UTILNAME”. To build selected individual utilities, use the --package [aka -p] option. For example:

cargo build -p uu_base32 -p uu_cat -p uu_echo -p uu_rm

GNU Make

Building using make is a simple process as well.

To simply build all available utilities (with debug profile):

make

In release mode:

make PROFILE=release

To build all but a few of the available utilities:

make SKIP_UTILS='UTILITY_1 UTILITY_2'

To build only a few of the available utilities:

make UTILS='UTILITY_1 UTILITY_2'

Installation

Install with Cargo

Likewise, installing can simply be done using:

cargo install --path . --locked

This command will install uutils into Cargo’s bin folder (e.g. $HOME/.cargo/bin).

This does not install files necessary for shell completion or manpages. For manpages or shell completion to work, use GNU Make or see Manually install shell completions/Manually install manpages.

Install with GNU Make

To install all available utilities (PROFILE=release by default):

make install

To install using sudo switch -E must be used:

sudo -E make install

To install all but a few of the available utilities:

make SKIP_UTILS='UTILITY_1 UTILITY_2' install

To install only a few of the available utilities:

make UTILS='UTILITY_1 UTILITY_2' install

To install every program with a prefix (e.g. uu-echo uu-cat):

make PROG_PREFIX=uu- install

To install the multicall binary:

make MULTICALL=y install

Set install parent directory (default value is /usr/local):

# DESTDIR is also supported
make PREFIX=/my/path install

Installing with make installs shell completions for all installed utilities for bash, fish and zsh. Completions for elvish and powershell can also be generated; See Manually install shell completions.

To skip installation of completions and manpages:

make COMPLETIONS=n MANPAGES=n install

Manually install shell completions

The uudoc binary generates completions for the bash, elvish, fish, powershell and zsh shells to stdout.

Install uudoc by

cargo install --bin uudoc --features uudoc --path .

Then use the installed binary:

uudoc completion <utility> <shell>

So, to install completions for ls on bash to /usr/local/share/bash-completion/completions/ls, run:

uudoc completion ls bash > /usr/local/share/bash-completion/completions/ls.bash

Completion for prefixed cp with uu- on zsh is generated by

env PROG_PREFIX=uu- uudoc completion cp zsh

Manually install manpages

To generate manpages, the syntax is:

uudoc manpage <utility>

So, to install the manpage for ls to /usr/local/share/man/man1/ls.1 run:

uudoc manpage ls > /usr/local/share/man/man1/ls.1

Un-installation

Un-installation differs depending on how you have installed uutils. If you used Cargo to install, use Cargo to uninstall. If you used GNU Make to install, use Make to uninstall.

Uninstall with Cargo

To uninstall uutils:

cargo uninstall coreutils

Uninstall with GNU Make

To uninstall all utilities:

make uninstall

To uninstall every program with a set prefix:

make PROG_PREFIX=uu- uninstall

To uninstall the multicall binary:

make MULTICALL=y uninstall

To uninstall from a custom parent directory:

# DESTDIR is also supported
make PREFIX=/my/path uninstall

Platform support

uutils aims to be as “universal” as possible, meaning that we try to support many platforms. However, it is infeasible for us to guarantee that every platform works. Just like Rust itself, we therefore have multiple tiers of platform support, with different guarantees. We support two tiers of platforms:

• Tier 1: All applicable utils are compiled and tested in CI for these platforms.
• Tier 2: These platforms are supported but not actively tested. We do accept fixes for these platforms.

Note: The tiers are dictated by our CI. We would happily accept a job in the CI for testing more platforms, bumping those platforms to tier 1.

Platforms per tier

The platforms in tier 1 and the platforms that we test in CI are listed below.

The platforms in tier 2 are more vague, but include:

• untested variations of the platforms above,
• Redox OS,
• and BSDs such as NetBSD & DragonFlyBSD.

Utility compatibility per platform

Not all utils work on every platform. For instance, chgrp is not supported on Windows, because Windows does not have the concept of groups. Below is a full table detailing which utilities are supported for the tier 1 platforms.

Note that for some utilities, not all functionality is supported on each platform. This is documented per utility.

Contributing to coreutils

Hi! Welcome to uutils/coreutils!

Thanks for wanting to contribute to this project! This document explains everything you need to know to contribute. Before you start make sure to also check out these documents:

• Our community’s CODE_OF_CONDUCT.md.
• DEVELOPMENT.md for setting up your development environment.

Now follows a very important warning:

Warning

uutils is original code and cannot contain any code from GNU or other implementations. This means that we cannot accept any changes based on the GNU source code. To make sure that cannot happen, you cannot link to the GNU source code either. It is however possible to look at other implementations under a BSD or MIT license like Apple’s implementation or OpenBSD.

Finally, feel free to join our Discord!

Getting Oriented

uutils is a big project consisting of many parts. Here are the most important parts for getting started:

• src/uu: The code for all utilities
• src/uucore: Crate containing all the shared code between the utilities.
• tests/by-util: The tests for all utilities.
• src/bin/coreutils.rs: Code for the multicall binary.
• docs: the documentation for the website
• tests/uutests/: Crate implementing the various functions to test uutils commands.

Each utility is defined as a separate crate. The structure of each of these crates is as follows:

• Cargo.toml
• src/main.rs: contains only a single macro call
• src/<util name>.rs: the actual code for the utility
• locales/en-US.ftl: the util’s strings
• locales/fr-FR.ftl: French translation of the util’s strings

We have separated repositories for crates that we maintain but also publish for use by others:

• uutils-term-grid
• parse_datetime

Design Goals

We have the following goals with our development:

• Compatible: The utilities should be a drop-in replacement for the GNU coreutils.
• Cross-platform: All utilities should run on as many of the supported platforms as possible.
• Reliable: The utilities should never unexpectedly fail.
• Performant: Our utilities should be written in fast idiomatic Rust. We aim to match or exceed the performance of the GNU utilities.
• Well-tested: We should have a lot of tests to be able to guarantee reliability and compatibility.

How to Help

There are several ways to help and writing code is just one of them. Reporting issues and writing documentation are just as important as writing code.

Reporting Issues

We can’t fix bugs we don’t know about, so good issues are super helpful! Here are some tips for writing good issues:

• If you find a bug, make sure it’s still a problem on the main branch.
• Search through the existing issues to see whether it has already been reported.
• Make sure to include all relevant information, such as:
  • Which version or commit hash of uutils did you check?
  • Which version of GNU coreutils are you comparing with?
  • What platform are you on?
• Provide a way to reliably reproduce the issue.
• Be as specific as possible!
• Please provide the output with LANG=C, except for locale-related bugs.

Writing Documentation

There’s never enough documentation. If you come across any documentation that could be improved, feel free to submit a PR for it!

Writing Code

If you want to submit a PR, make sure that you’ve discussed the solution with the maintainers beforehand. We want to avoid situations where you put a lot of work into a fix that we can’t merge! If there’s no issue for what you’re trying to fix yet, make one before you start working on the PR.

Generally, we try to follow what GNU is doing in terms of options and behavior. It is recommended to look at the GNU coreutils manual (on the web, or locally using info <utility>). It is more in depth than the man pages and provides a good description of available features and their implementation details. But remember, you cannot look at the GNU source code!

Also remember that we can only merge PRs which pass our test suite, follow rustfmt, and do not have any warnings from clippy. See DEVELOPMENT.md for more information. Be sure to also read about our Rust style.

Our Rust Style

We want uutils to be written in idiomatic Rust, so here are some guidelines to follow. Some of these are aspirational, meaning that we don’t do them correctly everywhere in the code. If you find violations of the advice below, feel free to submit a patch!

Don’t panic!

The coreutils should be very reliable. This means that we should never panic!. Therefore, you should avoid using .unwrap() and panic!. Sometimes the use of unreachable! can be justified with a comment explaining why that code is unreachable.

Don’t exit

We want uutils to be embeddable in other programs. This means that no function in uutils should exit the program. Doing so would also lead to code with more confusing control flow. Avoid therefore std::process::exit and similar functions which exit the program early.

unsafe

uutils cannot be entirely safe, because we have to call out to libc and do syscalls. However, we still want to limit our use of unsafe. We generally only accept unsafe for FFI, with very few exceptions. Note that performance is very rarely a valid argument for using unsafe.

If you still need to write code with unsafe, make sure to read the Rustonomicon and annotate the calls with // SAFETY: comments explaining why the use of unsafe is sound.

Macros

Macros can be a great tool, but they are also usually hard to understand. They should be used sparingly. Make sure to explore simpler options before you reach for a solution involving macros.

str, OsStr & Path

Rust has many string-like types, and sometimes it’s hard to choose the right one. It’s tempting to use str (and String) for everything, but that is not always the right choice for uutils, because we need to support invalid UTF-8, just like the GNU coreutils. For example, paths on Linux might not be valid UTF-8! Whenever we are dealing with paths, we should therefore stick with OsStr and Path. Make sure that you only convert to str/String if you know that something is always valid UTF-8. If you need more operations on OsStr, you can use the bstr crate.

Doc-comments

We use rustdoc for our documentation, so it’s best to follow rustdoc’s guidelines. Make sure that your documentation is not just repeating the name of the function, but actually giving more useful information. Rustdoc recommends the following structure:

[short sentence explaining what it is]

[more detailed explanation]

[at least one code example that users can copy/paste to try it]

[even more advanced explanations if necessary]

Other comments

Comments should be written to explain the code, not to describe the code. Try to focus on explaining why the code is the way it is. If you feel like you have to describe the code, that’s usually a sign that you could improve the naming of variables and functions.

If you edit a piece of code, make sure to update any comments that need to change as a result. The only thing worse than having no comments is having outdated comments!

Git Etiquette

To ensure easy collaboration, we have guidelines for using Git and GitHub.

Commits

• Make small and atomic commits.
• Keep a clean history of commits.
• Write informative commit messages.
• Annotate your commit message with the component you’re editing. For example: cp: do not overwrite on with -i or uucore: add support for FreeBSD.
• Do not unnecessarily move items around in the code. This makes the changes much harder to review. If you do need to move things around, do that in a separate commit.

Commit messages

You can read this section in the Git book to learn how to write good commit messages.

In addition, here are a few examples for a summary line when committing to uutils:

• commit for a single utility

nohup: cleanup and refactor

• commit for a utility’s tests

tests/rm: test new feature

Beyond changes to an individual utility or its tests, other summary lines for non-utility modules include:

README: add help
uucore: add new modules
uutils: add new utility
gitignore: add temporary files

PRs

• Make the titles of PRs descriptive.
  • This means describing the problem you solve. For example, do not write Fix #1234, but ls: fix version sort order.
  • You can prefix the title with the utility the PR concerns.
• Keep PRs small and self-contained. A set of small PRs is much more likely to get merged quickly than one large PR.
• Make sure the CI passes (up to intermittently failing tests).
• You know your code best, that’s why it’s best if you can solve merge conflicts on your branch yourself.
  • It’s up to you whether you want to use git merge main or git rebase main.
  • Feel free to ask for help with merge conflicts.
• You do not need to ping maintainers to request a review immediately after submission. If you do not get a response to your patch within a few days, it is fine to request a review.
  • If after a week your patch has still not been reviewed, we recommend that you ping the maintainers on our Discord channel in #coreutils-chat.

Platforms

We take pride in supporting many operating systems and architectures. Any code you contribute must at least compile without warnings for all platforms in the CI. However, you can use #[cfg(...)] attributes to create platform dependent features.

Tip: For Windows, Microsoft provides some images (VMWare, Hyper-V, VirtualBox and Parallels) for development on their official download page.

Improving the GNU compatibility

Please make sure you have installed GNU utils and prerequisites and can execute commands described in Comparing with GNU section of DEVELOPMENT.md

The Python script ./util/remaining-gnu-error.py shows the list of failing tests in the CI.

To improve the GNU compatibility, the following process is recommended:

1. Identify a test (the smaller, the better) on a program that you understand or is easy to understand. You can use the ./util/remaining-gnu-error.py script to help with this decision.
2. Build both the GNU and Rust coreutils using: bash util/build-gnu.sh
3. Run the test with bash util/run-gnu-test.sh <your test>
4. Start to modify <your test> to understand what is wrong. Examples:
   1. Add set -v to have the bash verbose mode
   2. Add echo $? where needed
   3. When the variable fail is used in the test, echo $fail to see when the test started to fail
   4. Bump the content of the output (ex: cat err)
   5. …
5. Or, if the test is simple, extract the relevant information to create a new test case running both GNU & Rust implementation
6. Start to modify the Rust implementation to match the expected behavior
7. Add a test to make sure that we don’t regress (our test suite is super quick)

Code coverage

To generate code coverage report locally please follow Code coverage report section of DEVELOPMENT.md

Other implementations

The Coreutils have different implementations, with different levels of completions:

• GNU’s
• OpenBSD
• Busybox
• Toybox (Android)
• Mac OS
• V lang
• SerenityOS
• Initial Unix
• Perl Power Tools

However, when reimplementing the tools/options in Rust, don’t read their source codes when they are using reciprocal licenses (ex: GNU GPL, GNU LGPL, etc).

Licensing

uutils is distributed under the terms of the MIT License; see the LICENSE file for details. This is a permissive license, which allows the software to be used with few restrictions.

Copyrights in the uutils project are retained by their contributors, and no copyright assignment is required to contribute.

If you wish to add or change dependencies as part of a contribution to the project, a tool like cargo-license can be used to show their license details. The following types of license are acceptable:

• MIT License
• Dual- or tri-license with an MIT License option (“Apache-2.0 or MIT” is a popular combination)
• “MIT equivalent” license (2-clause BSD, 3-clause BSD, ISC)
• License less restrictive than the MIT License (CC0 1.0 Universal)
• Apache License version 2.0

Licenses we will not use:

• An ambiguous license, or no license
• Strongly reciprocal licenses (GNU GPL, GNU LGPL)

If you wish to add a reference but it doesn’t meet these requirements, please raise an issue to describe the dependency.

Setting up your local development environment

For contributing rules and best practices please refer to CONTRIBUTING.md

Before you start

For this guide we assume that you already have a GitHub account and have git and your favorite code editor or IDE installed and configured. Before you start working on coreutils, please follow these steps:

1. Fork the coreutils repository to your GitHub account. Tip: See this GitHub guide for more information on this step.
2. Clone that fork to your local development environment:

git clone https://github.com/YOUR-GITHUB-ACCOUNT/coreutils
cd coreutils

Tools

You will need the tools mentioned in this section to build and test your code changes locally. This section will explain how to install and configure these tools. We also have an extensive CI that uses these tools and will check your code before it can be merged. The next section Testing will explain how to run those checks locally to avoid waiting for the CI.

As an alternative to host installation of the tools, you can open the project with the provided development container configuration. For more information about development containers, see the Visual Studio Code Dev Containers documentation.

Rust toolchain

Install Rust

If you’re using rustup to install and manage your Rust toolchains, clippy and rustfmt are usually already installed. If you are using one of the alternative methods, please make sure to install them manually. See following sub-sections for their usage: clippy rustfmt.

Tip You might also need to add ‘llvm-tools’ component if you are going to generate code coverage reports locally:

rustup component add llvm-tools-preview

GNU utils and prerequisites

If you are developing on Linux, most likely you already have all/most GNU utilities and prerequisites installed.

To make sure, please check GNU coreutils README-prereq.

You will need these to run uutils against the GNU test suite locally.

For MacOS and Windows platform specific setup please check MacOS GNU utils and Windows GNU utils sections respectfully.

pre-commit hooks

A configuration for pre-commit is provided in the repository. It allows automatically checking every git commit you make to ensure it compiles, and passes clippy and rustfmt without warnings.

To use the provided hook:

1. Install pre-commit
2. Run pre-commit install while in the repository directory

Your git commits will then automatically be checked. If a check fails, an error message will explain why, and your commit will be canceled. You can then make the suggested changes, and run git commit ... again.

NOTE: On MacOS the pre-commit hooks are currently broken. There are workarounds involving switching to unstable nightly Rust and components.

clippy

cargo clippy --all-targets --all-features

The msrv key in the clippy configuration file clippy.toml is used to disable lints pertaining to newer features by specifying the minimum supported Rust version (MSRV).

rustfmt

cargo fmt --all

cargo-deny

This project uses cargo-deny to detect duplicate dependencies, checks licenses, etc. To run it locally, first install it and then run with:

cargo deny --all-features check all

Markdown linter

We use markdownlint to lint the Markdown files in the repository.

Spell checker

We use cspell as spell checker for all files in the project. If you are using VS Code, you can install the code spell checker extension to enable spell checking within your editor. Otherwise, you can install cspell separately.

If you want to make the spell checker ignore a word, you can add

#![allow(unused)]
fn main() {
// spell-checker:ignore word_to_ignore
}

at the top of the file.

Testing

This section explains how to run our CI checks locally. Testing can be done using either Cargo or make.

Testing with Cargo

Just like with building, we follow the standard procedure for testing using Cargo:

cargo test

By default, cargo test only runs the common programs. To run also platform specific tests, run:

cargo test --features unix

If you would prefer to test a select few utilities:

cargo test --features "chmod mv tail" --no-default-features

If you also want to test the core utilities:

cargo test  -p uucore -p coreutils
# or
cargo test --all-features -p uucore

Running the complete test suite might take a while. We use nextest in the CI and you might want to try it out locally. It can speed up the execution time of the whole test run significantly if the cpu has multiple cores.

cargo nextest run --features unix --no-fail-fast

To debug:

rust-gdb --args target/debug/coreutils ls
(gdb) b ls.rs:79
(gdb) run

Testing with GNU Make

To simply test all available utilities:

make test

To test all but a few of the available utilities:

make SKIP_UTILS='UTILITY_1 UTILITY_2' test

To test only a few of the available utilities:

make UTILS='UTILITY_1 UTILITY_2' test

To include tests for unimplemented behavior:

make UTILS='UTILITY_1 UTILITY_2' SPEC=y test

To run tests with nextest just use the nextest target. Note you’ll need to install nextest first. The nextest target accepts the same arguments like the default test target, so it’s possible to pass arguments to nextest run via CARGOFLAGS:

make CARGOFLAGS='--no-fail-fast' UTILS='UTILITY_1 UTILITY_2' nextest

Run Busybox Tests

This testing functionality is only available on *nix operating systems and requires make.

To run busybox tests for all utilities for which busybox has tests

make busytest

To run busybox tests for a few of the available utilities

make UTILS='UTILITY_1 UTILITY_2' busytest

To pass an argument like “-v” to the busybox test runtime

make UTILS='UTILITY_1 UTILITY_2' RUNTEST_ARGS='-v' busytest

Comparing with GNU

To run uutils against the GNU test suite locally, run the following commands:

bash util/build-gnu.sh
# Build uutils with release optimizations
env PROFILE=release bash util/build-gnu.sh
# Build uutils with SELinux
env SELINUX_ENABLED=1 bash util/build-gnu.sh
bash util/run-gnu-test.sh
# To run a single test:
bash util/run-gnu-test.sh tests/touch/not-owner.sh # for example
# To run several tests:
bash util/run-gnu-test.sh tests/touch/not-owner.sh tests/rm/no-give-up.sh # for example
# If this is a perl (.pl) test, to run in debug:
DEBUG=1 bash util/run-gnu-test.sh tests/misc/sm3sum.pl

Tip: First time you run bash util/build-gnu.sh command, it will provide instructions on how to checkout GNU coreutils repository at the correct release tag. Please follow those instructions and when done, run bash util/build-gnu.sh command again.

You also need to install quilt, a tool used to manage a stack of patches for modifying GNU tests.

On FreeBSD, you need to install packages for GNU coreutils and sed (used in shell scripts instead of system commands):

pkg install coreutils gsed

Code coverage report

Code coverage report can be generated using grcov.

To generate gcov-based coverage report

export CARGO_INCREMENTAL=0
export RUSTFLAGS="-Cinstrument-coverage -Ccodegen-units=1 -Copt-level=0 -Clink-dead-code -Coverflow-checks=off -Zpanic_abort_tests -Cpanic=abort"
export RUSTDOCFLAGS="-Cpanic=abort"
export RUSTUP_TOOLCHAIN="nightly"
cargo build <options...> # e.g., --features feat_os_unix
cargo test <options...> # e.g., --features feat_os_unix test_pathchk
grcov . -s . --binary-path ./target/debug/ -t html --branch --ignore-not-existing --ignore build.rs --excl-br-line "^\s*((debug_)?assert(_eq|_ne)?\#\[derive\()" -o ./target/debug/coverage/
# open target/debug/coverage/index.html in browser

if changes are not reflected in the report then run cargo clean and run the above commands.

Tips for setting up on Mac

C Compiler and linker

On MacOS you’ll need to install C compiler & linker:

xcode-select --install

MacOS GNU utils

On MacOS you will need to install Homebrew and use it to install the following Homebrew formulas:

brew install \
  coreutils \
  autoconf \
  gettext \
  texinfo \
  xz \
  automake \
  gnu-sed \
  m4 \
  bison \
  pre-commit \
  findutils

After installing these Homebrew formulas, please make sure to add the following lines to your zsh or bash rc file, i.e. ~/.profile or ~/.zshrc or ~/.bashrc … (assuming Homebrew is installed at default location /opt/homebrew):

eval "$(/opt/homebrew/bin/brew shellenv)"
export PATH="/opt/homebrew/opt/coreutils/libexec/gnubin:$PATH"
export PATH="/opt/homebrew/opt/bison/bin:$PATH"
export PATH="/opt/homebrew/opt/findutils/libexec/gnubin:$PATH"

Last step is to link Homebrew coreutils version of timeout to /usr/local/bin (as admin user):

sudo ln -s /opt/homebrew/bin/timeout /usr/local/bin/timeout

Do not forget to either source updated rc file or restart you terminal session to update environment variables.

Tips for setting up on Windows

MSVC build tools

On Windows you’ll need the MSVC build tools for Visual Studio 2013 or later.

If you are using rustup-init.exe to install Rust toolchain, it will guide you through the process of downloading and installing these prerequisites.

Otherwise please follow this guide.

Windows GNU utils

If you have used Git for Windows to install git on you Windows system you might already have some GNU core utilities installed as part of “GNU Bash” included in Git for Windows package, but it is not a complete package. This article provides instruction on how to add more to it.

Alternatively you can install Cygwin and/or use WSL2 to get access to all GNU core utilities on Windows.

Preparing a new release

1. Modify util/update-version.sh (FROM & TO) and run it
2. Submit a new PR with these changes and wait for it to be merged
3. Tag the new release git tag -a X.Y.Z and git push --tags
4. Once the CI is green, a new release will be automatically created in draft mode. Reuse this release and make sure that assets have been added.
5. Write the release notes (it takes time) following previous examples
6. Run util/publish.sh --do-it to publish the new release to crates.io

Contributor Covenant Code of Conduct

Our Pledge

We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socioeconomic status, nationality, personal appearance, race, religion, or sexual identity and orientation.

We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.

Our Standards

Examples of behavior that contributes to a positive environment for our community include:

• Demonstrating empathy and kindness toward other people
• Being respectful of differing opinions, viewpoints, and experiences
• Giving and gracefully accepting constructive feedback
• Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
• Focusing on what is best not just for us as individuals, but for the overall community

Examples of unacceptable behavior include:

• The use of sexualized language or imagery, and sexual attention or advances of any kind
• Trolling, insulting or derogatory comments, and personal or political attacks
• Public or private harassment
• Publishing others’ private information, such as a physical or email address, without their explicit permission
• Other conduct which could reasonably be considered inappropriate in a professional setting

Enforcement Responsibilities

Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.

Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.

Scope

This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.

Enforcement

Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at sylvestre@debian.org. All complaints will be reviewed and investigated promptly and fairly.

All community leaders are obligated to respect the privacy and security of the reporter of any incident.

Enforcement Guidelines

Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:

1. Correction

Community Impact: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.

Consequence: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.

2. Warning

Community Impact: A violation through a single incident or series of actions.

Consequence: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.

3. Temporary Ban

Community Impact: A serious violation of community standards, including sustained inappropriate behavior.

Consequence: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.

4. Permanent Ban

Community Impact: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior, harassment of an individual, or aggression toward or disparagement of classes of individuals.

Consequence: A permanent ban from any sort of public interaction within the community.

Attribution

This Code of Conduct is adapted from the Contributor Covenant, version 2.0, available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.

Community Impact Guidelines were inspired by Mozilla’s code of conduct enforcement ladder.

For answers to common questions about this code of conduct, see the FAQ at https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.

GNU Test Coverage

uutils is actively tested against the GNU coreutils test suite. The results below are automatically updated every day.

Coverage per category

Click on the categories to see the names of the tests. Green indicates a passing test, yellow indicates a skipped test and red means that the test either failed or resulted in an error.

Progress over time

Extensions over GNU

Though the main goal of the project is compatibility, uutils supports a few features that are not supported by GNU coreutils. We take care not to introduce features that are incompatible with the GNU coreutils. Below is a list of uutils extensions.

General

GNU coreutils provides two ways to define short options taking an argument:

$ ls -w 80
$ ls -w80

We support a third way:

$ ls -w=80

With GNU coreutils, --help usually prints the help message and --version prints the version. We also commonly provide short options: -h for help and -V for version.

coreutils

Our coreutils calls utility by coreutils utility-name and has --list to run against busybox test suite. Our coreutils is called as utility-name if its binary name ends with utility-name to support prefixed names. Longer name is prioritized e.g. sum with the prefix ck is called as cksum.

env

GNU env allows the empty string to be used as an environment variable name. This is unsupported by uutils, which will show a warning for any such assignment.

env has an additional -f/--file flag that can parse .env files and set variables accordingly. This feature is adopted from dotenv style packages.

cp

cp can display a progress bar when the -g/--progress flag is set.

mv

mv can display a progress bar when the -g/--progress flag is set.

rm

rm can display a progress bar when the -g/--progress flag is set.

more

We provide a simple implementation of more, which is not part of GNU coreutils. We do not aim for full compatibility with the more utility from util-linux. Features from more modern pagers (like less and bat) are therefore welcomed.

cut

cut can separate fields by whitespace (Space and Tab) with -w flag. This feature is adopted from FreeBSD.

fmt

fmt has additional flags for prefixes: -P/--skip-prefix, -x/--exact-prefix, and -X/--exact-skip-prefix. With -m/--preserve-headers, an attempt is made to detect and preserve mail headers in the input. -q/--quick breaks lines more quickly. And -T/--tab-width defines the number of spaces representing a tab when determining the line length.

printf

printf uses arbitrary precision decimal numbers to parse and format floating point numbers. GNU coreutils uses long double, whose actual size may be double precision 64-bit float (e.g 32-bit arm), extended precision 80-bit float (x86(-64)), or quadruple precision 128-bit float (e.g. arm64).

Practically, this means that printing a number with high precision will remain exact:

printf "%.48f\n" 0.1
0.100000000000000000000000000000000000000000000000 << uutils on all platforms
0.100000000000000000001355252715606880542509316001 << GNU coreutils on x86(-64)
0.100000000000000000000000000000000004814824860968 << GNU coreutils on arm64
0.100000000000000005551115123125782702118158340454 << GNU coreutils on armv7 (32-bit)

Hexadecimal floats

For hexadecimal float format (%a), POSIX only states that one hexadecimal number should be present left of the decimal point (0xh.hhhhp±d [1]), but does not say how many bits should be included (between 1 and 4). On x86(-64), the first digit always includes 4 bits, so its value is always between 0x8 and 0xf, while on other architectures, only 1 bit is included, so the value is always 0x1.

However, the first digit will of course be 0x0 if the number is zero. Also, rounding numbers may cause the first digit to be 0x1 on x86(-64) (e.g. 0xf.fffffffp-5 rounds to 0x1.00p-1), or 0x2 on other architectures.

We chose to replicate x86-64 behavior on all platforms.

Additionally, the default precision of the hexadecimal float format (%a without any specifier) is expected to be “sufficient for exact representation of the value” [1]. This is not possible in uutils as we store arbitrary precision numbers that may be periodic in hexadecimal form (0.1 = 0xc.ccc...p-7), so we revert to the number of digits that would be required to exactly print an extended precision 80-bit float, emulating GNU coreutils behavior on x86(-64). An 80-bit float has 64 bits in its integer and fractional part, so 16 hexadecimal digits are printed in total (1 digit before the decimal point, 15 after).

Practically, this means that the default hexadecimal floating point output is identical to x86(-64) GNU coreutils:

printf "%a\n" 0.1
0xc.ccccccccccccccdp-7 << uutils on all platforms
0xc.ccccccccccccccdp-7 << GNU coreutils on x86-64
0x1.999999999999999999999999999ap-4 << GNU coreutils on arm64
0x1.999999999999ap-4   << GNU coreutils on armv7 (32-bit)

We can print an arbitrary number of digits if a larger precision is requested, and the leading digit will still be in the 0x8-0xf range:

printf "%.32a\n" 0.1
0xc.cccccccccccccccccccccccccccccccdp-7 << uutils on all platforms
0xc.ccccccccccccccd00000000000000000p-7 << GNU coreutils on x86-64
0x1.999999999999999999999999999a0000p-4 << GNU coreutils on arm64
0x1.999999999999a0000000000000000000p-4 << GNU coreutils on armv7 (32-bit)

Note: The architecture-specific behavior on non-x86(-64) platforms may change in the future.

seq

Unlike GNU coreutils, seq always uses arbitrary precision decimal numbers, no matter the parameters (integers, decimal numbers, positive or negative increments, format specified, etc.), so its output will be more correct than GNU coreutils for some inputs (e.g. small fractional increments where GNU coreutils uses long double).

The only limitation is that the position of the decimal point is stored in a i64, so values smaller than 10**(-263) will underflow to 0, and some values larger than 10(2**63) may overflow to infinity.

See also comments under printf for formatting precision and differences.

seq provides -t/--terminator to set the terminator character.

sort

When sorting with -g/--general-numeric-sort, arbitrary precision decimal numbers are parsed and compared, unlike GNU coreutils that uses platform-specific long double floating point numbers.

Extremely large or small values can still overflow or underflow to infinity or zero, see note in seq.

ls

GNU ls provides two ways to use a long listing format: -l and --format=long. We support a third way: --long.

GNU ls --sort=VALUE only supports special non-default sort orders. We support --sort=name, which makes it possible to override an earlier value.

du

du allows birth and creation as values for the --time argument to show the creation time. It also provides a -v/--verbose flag.

id

id has three additional flags:

• -P displays the id as a password file entry
• -p makes the output human-readable
• -A displays the process audit user ID

uptime

Similar to the proc-ps implementation and unlike GNU/Coreutils, uptime provides:

• -s/--since to show since when the system is up
• -p/--pretty to display uptime in a pretty-printed format

base32/base64/basenc

Just like on macOS, base32/base64/basenc provides -D to decode data.

unexpand

GNU unexpand provides --first-only to convert only leading sequences of blanks. We support a second way: -f like busybox.

With -U/--no-utf8, you can interpret input files as 8-bit ASCII rather than UTF-8.

expand

expand also offers the -U/--no-utf8 option to interpret input files as 8-bit ASCII instead of UTF-8.

install

install offers FreeBSD’s -U unprivileged option to not change the owner, the group, or the file flags of the destination.

Multi-call binary

uutils includes a multi-call binary from which the utils can be invoked. This reduces the binary size of the binary and can be useful for portability.

The first argument of the multi-call binary is the util to run, after which the regular arguments to the util can be passed.

coreutils [util] [util options]

The --help flag will print a list of available utils.

Example

coreutils ls -l

arch

arch

Affiche l’architecture de la machine

Options

Détermine le nom de l’architecture pour la machine actuelle.

Examples

Affiche la documentation de la commande originale :

tldr uname

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

b2sum

b2sum [OPTION]... [FICHIER]...

Afficher le BLAKE2b et la taille de chaque fichier

Options

--binary, -b

--check, -c

ck-common-help-check

--warn, -w

ck-common-help-warn

--status

ck-common-help-status

--quiet

ck-common-help-quiet

--ignore-missing

ck-common-help-ignore-missing

--strict

ck-common-help-strict

--length, -l

ck-common-help-length

--tag

ck-common-help-tag

--text, -t

ck-common-help-text

--zero, -z

ck-common-help-zero

Examples

Calcule la somme de contrôle BLAKE2 d’un fichier :

b2sum {{chemin/vers/fichier}}

Calcule les sommes de contrôle BLAKE2 pour plusieurs fichiers :

b2sum {{chemin/vers/fichier1 chemin/vers/fichier2 ...}} > {{chemin/vers/fichier}}.b2

Calcule la somme de contrôle BLAKE2 depuis stdin :

{{commande}} | b2sum

Lis un fichier contenant des sommes de contrôle BLAKE2 et des noms de fichier et vérifie que tous les fichiers ont des sommes de contrôle correspondantes :

b2sum --check {{chemin/vers/fichier}}.b2

Affiche un message uniquement pour les fichiers manquants ou lorsque la vérification échoue :

b2sum --check --quiet {{chemin/vers/fichier}}.b2

N’affiche un message que pour les fichiers pour lesquels la vérification a échoué, en ignorant les fichiers manquants :

b2sum --ignore-missing --check --quiet {{chemin/vers/fichier}}.b2

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

base32

base32 [OPTION]... [FICHIER]

encode/décode des données et les affiche sur la sortie standard Sans FICHIER spécifié, ou quand FICHIER = ‘-’, lis l’entrée standard.

Les données sont encodées comme décrit pour l’alphabet base32 dans le RFC 4648. Lors du décodage, l’entrée peut contenir des sauts de ligne en plus des octets de l’alphabet base32 formel. Utilisez –ignore-garbage pour tenter de récupérer tout autre octet non-alphabétique dans encodé le flux.

Options

--decode, -d, -D

base-common-help-decode

--ignore-garbage, -i

base-common-help-ignore-garbage

--wrap=<COLS>, -w <COLS>

base-common-help-wrap

Examples

Encode un fichier :

base32 {{chemin/vers/fichier}}

Envelopper la sortie codée à une largeur spécifique (0 désactive l’enveloppement) :

base32 {{[-w|--wrap]}} {{0|76|...}} {{chemin/vers/fichier}}

Décode un fichier :

base32 {{[-d|--decode]}} {{chemin/vers/fichier}}

Encode depuis stdin :

{{commande}} | base32

Décode depuis stdin :

{{commande}} | base32 {{[-d|--decode]}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

base64

base64 [OPTION]... [FICHIER]

encode/décode des données et les affiche sur la sortie standard Sans FICHIER spécifié, ou quand FICHIER = ‘-’, lis l’entrée standard.

Les données sont encodées comme décrit pour l’alphabet base64 dans le RFC 3548. Lors du décodage, l’entrée peut contenir des sauts de ligne en plus des octets de l’alphabet base64 formel. Utilisez –ignore-garbage pour tenter de récupérer tout autre octet non-alphabétiques dans encodé le flux.

Options

--decode, -d, -D

base-common-help-decode

--ignore-garbage, -i

base-common-help-ignore-garbage

--wrap=<COLS>, -w <COLS>

base-common-help-wrap

Examples

Encode un fichier :

base64 {{chemin/vers/fichier}}

Envelopper la sortie codée à une largeur spécifique (0 désactive l’enveloppement) :

base64 {{[-w|--wrap]}} {{0|76|...}} {{chemin/vers/fichier}}

Décode un fichier :

base64 {{[-d|--decode]}} {{chemin/vers/fichier}}

Encode depuis stdin :

{{commande}} | base64

Décode depuis stdin :

{{commande}} | base64 {{[-d|--decode]}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

basename

basename [-z] NOM [SUFFIXE]
basename OPTION... NOM...

Affiche NOM sans les composants de répertoire précédents Si spécifié, supprime également un SUFFIXE final

Options

--multiple, -a

prend en charge plusieurs arguments et traite chacun comme un NOM

--suffix=<SUFFIX>, -s <SUFFIX>

supprime un SUFFIXE final ; implique -a

--zero, -z

termine chaque ligne de sortie avec NUL, pas nouvelle ligne

Examples

N’afficher que le nom du fichier depuis un chemin :

basename {{chemin/vers/fichier}}

N’afficher que le nom du dernier répertoire depuis un chemin :

basename {{chemin/vers/répertoire/}}

N’afficher que le nom du fichier depuis un chemin, en ôtant un préfixe donné :

basename {{chemin/vers/fichier}} {{suffixe}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

basenc

basenc [OPTION]... [FICHIER]

Encode/décode des données et les affiche sur la sortie standard Sans FICHIER spécifié, ou lorsque FICHIER = ‘-’, lis l’entrée standard.

Lors du décodage, l’entrée peut contenir des sauts de ligne en plus des octets de l’alphabet formel. Utilisez –ignore-garbage pour tenter de récupérer tout autre octet non-alphabétique encodé dans le flux.

Options

--decode, -d, -D

base-common-help-decode

--ignore-garbage, -i

base-common-help-ignore-garbage

--wrap=<COLS>, -w <COLS>

base-common-help-wrap

--base64

identique au programme ‘base64’

--base64url

base64 sécurisé pour fichiers et URLs

--base32

identique au programme ‘base32’

--base32hex

base32 avec alphabet hexadécimal étendu

--base16

encodage hexadécimal

--base2lsbf

chaîne de bits avec le bit de poids faible (lsb) en premier

--base2msbf

chaîne de bits avec le bit de poids fort (msb) en premier

--z85

encodage de type ascii85 ;
lors de l’encodage, la longueur d’entrée doit être un multiple de 4 ;
lors du décodage, la longueur d’entrée doit être un multiple de 5

--base58

encodage base58 visuellement non ambigu

Examples

Encode a file with base64 encoding:

basenc --base64 {{path/to/file}}

Decode a file with base64 encoding:

basenc {{[-d|--decode]}} --base64 {{path/to/file}}

Encode from stdin with base32 encoding with 42 columns:

{{command}} | basenc --base32 {{[-w|--wrap]}} 42

Encode from stdin with base32 encoding:

{{command}} | basenc --base32

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

cat

cat [OPTION]... [FICHIER]...

Concaténer les FICHIER(s), ou l’entrée standard, vers la sortie standard Si aucun FICHIER, ou quand FICHIER est -, lire l’entrée standard.

Options

--show-all, -A

équivalent à -vET

--number-nonblank, -b

numéroter les lignes de sortie non vides, remplace -n

-e

équivalent à -vE

--show-ends, -E

afficher $ à la fin de chaque ligne

--number, -n

numéroter toutes les lignes de sortie

--squeeze-blank, -s

supprimer les lignes vides répétées en sortie

-t

équivalent à -vT

--show-tabs, -T

afficher les caractères TAB comme ^I

--show-nonprinting, -v

utiliser la notation ^ et M-, sauf pour LF (\n) et TAB (\t)

-u

(ignoré)

Examples

Affiche le contenu d’un fichier sur la sortie standard :

cat {{chemin/vers/fichier}}

Concatène le contenu de plusieurs fichiers vers le fichier de destination :

cat {{chemin/vers/fichier1 chemin/vers/fichier2 ...}} > {{chemin/vers/fichier_de_destination}}

Ajoute le contenu d’un ficher à la fin du fichier de destination :

cat {{chemin/vers/fichier1 chemin/vers/fichier2 ...}} >> {{chemin/vers/fichier_de_destination}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

chcon

chcon [OPTION]... CONTEXTE FICHIER...
chcon [OPTION]... [-u UTILISATEUR] [-r RÔLE] [-l PLAGE] [-t TYPE] FICHIER...
chcon [OPTION]... --reference=RFICHIER FICHIER...

Changer le contexte de sécurité SELinux de chaque FICHIER vers CONTEXTE. Avec –reference, changer le contexte de sécurité de chaque FICHIER vers celui de RFICHIER.

Options

--dereference

Affecter la cible de chaque lien symbolique (par défaut), plutôt que le lien symbolique lui-même.

--no-dereference, -h

Affecter les liens symboliques au lieu de tout fichier référencé.

--help

help

--preserve-root

Échouer lors de l’opération récursive sur ‘/’.

--no-preserve-root

Ne pas traiter ‘/’ spécialement (par défaut).

--reference=<RFILE>

Utiliser le contexte de sécurité de RFICHIER, plutôt que de spécifier une valeur CONTEXTE.

--user=<USER>, -u <USER>

Définir l’utilisateur UTILISATEUR dans le contexte de sécurité cible.

--role=<ROLE>, -r <ROLE>

Définir le rôle RÔLE dans le contexte de sécurité cible.

--type=<TYPE>, -t <TYPE>

Définir le type TYPE dans le contexte de sécurité cible.

--range=<RANGE>, -l <RANGE>

Définir la plage PLAGE dans le contexte de sécurité cible.

--recursive, -R

Opérer sur les fichiers et répertoires de manière récursive.

-H

Si un argument de ligne de commande est un lien symbolique vers un répertoire, le traverser. Valide uniquement quand -R est spécifié.

-L

Traverser chaque lien symbolique vers un répertoire rencontré. Valide uniquement quand -R est spécifié.

-P

Ne traverser aucun lien symbolique (par défaut). Valide uniquement quand -R est spécifié.

--verbose, -v

Afficher un diagnostic pour chaque fichier traité.

Examples

Affiche le contexte de sécurité d’un fichier :

ls {{[-lZ|-l --context]}} {{chemin/vers/fichier}}

Change le contexte de sécurité d’un fichier cible, en utilisant un fichier de référence :

chcon --reference {{fichier_référence}} {{fichier_cible}}

Change le contexte de sécurité SELinux complet d’un fichier :

chcon {{utilisateur}}:{{role}}:{{type}}:{{range/level}} {{fichier}}

Change seulement la partie utilisateur du contexte de sécurité SELinux :

chcon {{[-u|--user]}} {{utilisateur}} {{fichier}}

Change seulement la partie role du contexte de sécurité SELinux :

chcon {{[-r|--role]}} {{role}} {{fichier}}

Change seulement la partie type du contexte de sécurité SELinux :

chcon {{[-t|--type]}} {{type}} {{fichier}}

Change seulement la partie plage/niveau du contexte de sécurité SELinux :

chcon {{[-l|--range]}} {{plage/niveau}} {{fichier}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

chgrp

chgrp [OPTION]... GROUPE FICHIER...
chgrp [OPTION]... --reference=RFICHIER FICHIER...

Changer le groupe de chaque FICHIER vers GROUPE.

Options

--help

Afficher les informations d’aide.

--changes, -c

comme verbeux mais rapporter seulement lors d’un changement

--silent, -f

--quiet

supprimer la plupart des messages d’erreur

--verbose, -v

afficher un diagnostic pour chaque fichier traité

--preserve-root

échouer à opérer récursivement sur ‘/’

--no-preserve-root

ne pas traiter ‘/’ spécialement (par défaut)

--reference=<RFILE>

utiliser le groupe de RFICHIER plutôt que spécifier les valeurs de GROUPE

--from=<GROUP>

changer le groupe seulement si son groupe actuel correspond à GROUPE

--recursive, -R

opérer sur les fichiers et répertoires récursivement

-H

if a command line argument is a symbolic link to a directory, traverse it

-L

traverse every symbolic link to a directory encountered

-P

do not traverse any symbolic links (default)

--dereference

affect the referent of each symbolic link (this is the default), rather than the symbolic link itself

--no-dereference, -h

affect symbolic links instead of any referenced file (useful only on systems that can change the ownership of a symlink)

Examples

Change le groupe propriétaire d’un fichier/répertoire :

chgrp {{groupe}} {{chemin/vers/fichier_ou_répertoire}}

Change récursivement le groupe propriétaire d’un répertoire et de son contenu :

chgrp {{[-R|--recursive]}} {{groupe}} {{chemin/vers/répertoire}}

Change le groupe propriétaire d’un lien symbolique :

chgrp {{[-h|--no-dereference]}} {{groupe}} {{chemin/vers/lien_symbolique}}

Modifie le groupe propriétaire d’un fichier/répertoire pour qu’il corresponde à un fichier de référence :

chgrp --reference {{chemin/vers/fichier_référence}} {{chemin/vers/fichier_ou_répertoire}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

chmod

chmod [OPTION]... MODE[,MODE]... FICHIER...
chmod [OPTION]... MODE-OCTAL FICHIER...
chmod [OPTION]... --reference=RFICHIER FICHIER...

Changer le mode de chaque FICHIER vers MODE. Avec –reference, changer le mode de chaque FICHIER vers celui de RFICHIER.

Options

--help

Afficher les informations d’aide.

--changes, -c

comme verbeux mais rapporter seulement lors d’un changement

--quiet, --silent, -f

supprimer la plupart des messages d’erreur

--verbose, -v

afficher un diagnostic pour chaque fichier traité

--no-preserve-root

ne pas traiter ‘/’ spécialement (par défaut)

--preserve-root

échouer à opérer récursivement sur ‘/’

--recursive, -R

changer les fichiers et répertoires récursivement

--reference

utiliser le mode de RFICHIER au lieu des valeurs de MODE

-H

if a command line argument is a symbolic link to a directory, traverse it

-L

traverse every symbolic link to a directory encountered

-P

do not traverse any symbolic links (default)

--dereference

affect the referent of each symbolic link (this is the default), rather than the symbolic link itself

--no-dereference, -h

affect symbolic links instead of any referenced file (useful only on systems that can change the ownership of a symlink)

Chaque MODE est de la forme [ugoa]*(-+=)+|[-+=]?[0-7]+.

Examples

Donne les droits d’e[x]écution à l’[u]tilisateur auquel le fichier appartient :

chmod u+x {{chemin/vers/fichier}}

Donne à l’[u]tilisateur les droits de lecture [r] et d’écriture [w] sur un fichier/répertoire :

chmod u+rw {{chemin/vers/fichier_ou_répertoire}}

Enlève les droits d’e[x]écution pour le [g]roupe :

chmod g-x {{chemin/vers/fichier}}

Donne à tous [a] les utilisateurs les droits de lecture [r] et d’e[x]écution :

chmod a+rx {{chemin/vers/fichier}}

Donne aux autres [o] utilisateurs (qui sont dans un autre groupe) les mêmes droits que ceux du [g]roupe propriétaire :

chmod o=g {{chemin/vers/fichier}}

Retire tous les droits aux autres [o] utilisateurs :

chmod o= {{chemin/vers/fichier}}

Modifie les permissions récursivement en donnant aux membres du [g]roupe et aux autres [o] utilisateurs le droit d’écriture [w] :

chmod {{[-R|--recursive]}} g+w,o+w {{chemin/vers/répertoire}}

Donne récursivement à tous [a] les utilisateurs les droits de lecture [r] de fichiers et d’e[X]écution de sous-répertoires à l’intérieur d’un répertoire :

chmod {{[-R|--recursive]}} a+rX {{chemin/vers/répertoire}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

chown

chown [OPTION]... [PROPRIÉTAIRE][:[GROUPE]] FICHIER...
chown [OPTION]... --reference=RFICHIER FICHIER...

Changer le propriétaire et le groupe des fichiers

Options

--help

Afficher les informations d’aide.

--changes, -c

comme verbeux mais rapporter seulement lors d’un changement

--from=<CURRENT_OWNER:CURRENT_GROUP>

changer le propriétaire et/ou le groupe de chaque fichier seulement si son
propriétaire et/ou groupe actuel correspondent à ceux spécifiés ici.
L’un ou l’autre peut être omis, auquel cas une correspondance n’est pas requise
pour l’attribut omis

--preserve-root

échouer à opérer récursivement sur ‘/’

--no-preserve-root

ne pas traiter ‘/’ spécialement (par défaut)

--quiet

supprimer la plupart des messages d’erreur

--recursive, -R

opérer sur les fichiers et répertoires récursivement

--reference=<RFILE>

utiliser le propriétaire et groupe de RFICHIER plutôt que spécifier les valeurs PROPRIÉTAIRE:GROUPE

--silent, -f

--verbose, -v

afficher un diagnostic pour chaque fichier traité

-H

if a command line argument is a symbolic link to a directory, traverse it

-L

traverse every symbolic link to a directory encountered

-P

do not traverse any symbolic links (default)

--dereference

affect the referent of each symbolic link (this is the default), rather than the symbolic link itself

--no-dereference, -h

affect symbolic links instead of any referenced file (useful only on systems that can change the ownership of a symlink)

Examples

Modifie le propriétaire d’un fichier/dossier :

chown {{utilisateur}} {{chemin/vers/fichier_ou_dossier}}

Modifie l’utilisateur et le groupe propriétaire d’un fichier/dossier :

chown {{utilisateur}}:{{groupe}} {{chemin/vers/fichier_ou_dossier}}

Modifie le propriétaire et le groupe pour qu’ils aient tous les deux le nom utilisateur :

chown {{utilisateur}}: {{chemin/vers/fichier_ou_dossier}}

Modifie récursivement le propriétaire d’un dossier et de son contenu :

chown {{[-R|--recursive]}} {{utilisateur}} {{chemin/vers/dossier}}

Modifie le propriétaire d’un lien symbolique :

chown {{[-h|--no-dereference]}} {{utilisateur}} {{chemin/vers/lien_symbolique}}

Modifie le propriétaire d’un fichier / dossier pour correspondre à un fichier de référence :

chown --reference {{chemin/vers/fichier_de_référence}} {{chemin/vers/fichier_ou_dossier}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

chroot

chroot [OPTION]... NOUVRACINE [COMMANDE [ARG]...]

Exécuter COMMANDE avec le répertoire racine défini à NOUVRACINE.

Options

--groups=<GROUP1,GROUP2...>

Liste de groupes séparés par des virgules vers lesquels basculer

--userspec=<USER:GROUP>

Utilisateur et groupe séparés par deux-points vers lesquels basculer.

--skip-chdir

Utiliser cette option pour ne pas changer le répertoire de travail vers / après avoir changé le répertoire racine vers nouvracine, c.-à-d., à l’intérieur du chroot.

Examples

Exécute la commande en tant que nouveau répertoire racine :

chroot {{chemin/vers/nouveau/répertoire/racine}} {{command}}

Spécifie l’utilisateur et le groupe (ID ou nom) à utiliser :

chroot --userspec={{utilisateur:groupe}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

cksum

cksum [OPTION]... [FICHIER]...

Afficher le CRC et la taille de chaque fichier

Options

--algorithm=<ALGORITHM>, -a <ALGORITHM>

ck-common-help-algorithm

--untagged

ck-common-help-untagged

--tag

ck-common-help-tag-default

--length, -l

ck-common-help-length

--raw

ck-common-help-raw

--check, -c

ck-common-help-check

--warn, -w

ck-common-help-warn

--status

ck-common-help-status

--quiet

ck-common-help-quiet

--ignore-missing

ck-common-help-ignore-missing

--strict

ck-common-help-strict

--base64

ck-common-help-base64

--text, -t

--binary, -b

--zero, -z

ck-common-help-zero

--debug

ck-common-help-debug

DIGEST détermine l’algorithme de condensé et le format de sortie par défaut :

• sysv : (équivalent à sum -s)
• bsd : (équivalent à sum -r)
• crc : (équivalent à cksum)
• crc32b : (disponible uniquement via cksum)
• md5 : (équivalent à md5sum)
• sha1 : (équivalent à sha1sum)
• sha224 : (équivalent à sha224sum)
• sha256 : (équivalent à sha256sum)
• sha384 : (équivalent à sha384sum)
• sha512 : (équivalent à sha512sum)
• blake2b : (équivalent à b2sum)
• sm3 : (disponible uniquement via cksum)

Examples

Display a 32-bit checksum, size in bytes and filename:

cksum {{path/to/file}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

comm

comm [OPTION]... FICHIER1 FICHIER2

Comparer deux fichiers triés ligne par ligne.

Lorsque FICHIER1 ou FICHIER2 (pas les deux) est -, lire l’entrée standard.

Sans options, produit une sortie à trois colonnes. La colonne un contient les lignes uniques à FICHIER1, la colonne deux contient les lignes uniques à FICHIER2, et la colonne trois contient les lignes communes aux deux fichiers.

Options

-1

supprimer la colonne 1 (lignes uniques à FICHIER1)

-2

supprimer la colonne 2 (lignes uniques à FICHIER2)

-3

supprimer la colonne 3 (lignes qui apparaissent dans les deux fichiers)

--output-delimiter=<STR>

séparer les colonnes avec STR

--zero-terminated, -z

le délimiteur de ligne est NUL, pas nouvelle ligne

--total

afficher un résumé

--check-order

vérifier que l’entrée est correctement triée, même si toutes les lignes d’entrée sont appariables

--nocheck-order

ne pas vérifier que l’entrée est correctement triée

Examples

Produce three tab-separated columns: lines only in first file, lines only in second file, and common lines:

comm {{file1}} {{file2}}

Print only lines common to both files:

comm -12 {{file1}} {{file2}}

Print only lines common to both files, reading one file from stdin:

cat {{file1}} | comm -12 - {{file2}}

Get lines only found in first file, saving the result to a third file:

comm -23 {{file1}} {{file2}} > {{file1_only}}

Print lines only found in second file, when the files aren’t sorted:

comm -13 <(sort {{file1}}) <(sort {{file2}})

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

cp

cp [OPTION]... [-T] SOURCE DEST
cp [OPTION]... SOURCE... RÉPERTOIRE
cp [OPTION]... -t RÉPERTOIRE SOURCE...

Copier SOURCE vers DEST, ou plusieurs SOURCE(s) vers RÉPERTOIRE.

Options

--target-directory=<target-directory>, -t <target-directory>

copier tous les arguments SOURCE dans le répertoire cible

--no-target-directory, -T

Traiter DEST comme un fichier régulier et non comme un répertoire

--interactive, -i

demander avant d’écraser les fichiers

--link, -l

créer des liens durs au lieu de copier

--no-clobber, -n

ne pas écraser un fichier qui existe déjà

--recursive, -R, -r

copier les répertoires récursivement

--strip-trailing-slashes

supprimer les barres obliques finales de chaque argument SOURCE

--debug

expliquer comment un fichier est copié. Implique -v

--verbose, -v

indiquer explicitement ce qui est fait

--symbolic-link, -s

créer des liens symboliques au lieu de copier

--force, -f

si un fichier de destination existant ne peut pas être ouvert, le supprimer et réessayer (cette option est ignorée lorsque l’option -n est également utilisée). Actuellement non implémenté pour Windows.

--remove-destination

supprimer chaque fichier de destination existant avant de tenter de l’ouvrir (contraste avec –force). Sur Windows, ne fonctionne actuellement que pour les fichiers inscriptibles.

--backup=<CONTROL>

make a backup of each existing destination file

-b

like –backup but does not accept an argument

--suffix=<SUFFIX>, -S <SUFFIX>

override the usual backup suffix

--update

move only when the SOURCE file is newer than the destination file or when the destination file is missing

-u

like –update but does not accept an argument

--reflink=<WHEN>

contrôler les copies clone/CoW. Voir ci-dessous

--attributes-only

Ne pas copier les données du fichier, juste les attributs

--preserve=<ATTR_LIST>

Préserver les attributs spécifiés (par défaut : mode, propriété (unix uniquement), horodatages), si possible attributs supplémentaires : contexte, liens, xattr, all

--preserve-default-attributes, -p

identique à –preserve=mode,ownership(unix uniquement),timestamps

--no-preserve=<ATTR_LIST>

ne pas préserver les attributs spécifiés

--parents

utiliser le nom complet du fichier source sous RÉPERTOIRE

--no-dereference, -P

ne jamais suivre les liens symboliques dans SOURCE

--dereference, -L

toujours suivre les liens symboliques dans SOURCE

-H

suivre les liens symboliques de la ligne de commande dans SOURCE

--archive, -a

Identique à -dR –preserve=all

-d

identique à –no-dereference –preserve=links

--one-file-system, -x

rester sur ce système de fichiers

--sparse=<WHEN>

contrôler la création de fichiers épars. Voir ci-dessous

-Z

définir le contexte de sécurité SELinux du fichier de destination au type par défaut

--context=<CTX>

comme -Z, ou si CTX est spécifié, définir le contexte de sécurité SELinux ou SMACK à CTX

--progress, -g

Afficher une barre de progression. Note : cette fonctionnalité n’est pas supportée par GNU coreutils.

--copy-contents

Non implémenté : copier le contenu des fichiers spéciaux lors de la récursion

Ne pas copier un non-répertoire qui a une destination existante avec le même horodatage de modification ou plus récent ; à la place, ignorer silencieusement le fichier sans échec. Si les horodatages sont préservés, la comparaison est faite avec l’horodatage source tronqué aux résolutions du système de fichiers de destination et des appels système utilisés pour mettre à jour les horodatages ; cela évite le travail en double si plusieurs commandes cp -pu sont exécutées avec la même source et destination. Cette option est ignorée si l’option -n ou –no-clobber est également spécifiée. De plus, si –preserve=links est également spécifié (comme avec cp -au par exemple), cela aura la priorité ; par conséquent, selon l’ordre dans lequel les fichiers sont traités depuis la source, les fichiers plus récents dans la destination peuvent être remplacés, pour refléter les liens durs dans la source. ce qui donne plus de contrôle sur les fichiers existants dans la destination qui sont remplacés, et sa valeur peut être l’une des suivantes :

• all C’est l’opération par défaut lorsqu’une option –update n’est pas spécifiée, et entraîne le remplacement de tous les fichiers existants dans la destination.
• none Cela est similaire à l’option –no-clobber, en ce sens qu’aucun fichier dans la destination n’est remplacé, mais ignorer un fichier n’induit pas d’échec.
• older C’est l’opération par défaut lorsque –update est spécifié, et entraîne le remplacement des fichiers s’ils sont plus anciens que le fichier source correspondant.

Examples

Copier un fichier vers un autre emplacement :

cp {{chemin/vers/fichier_source.ext}} {{chemin/vers/fichier_cible.ext}}

Copier un fichier vers un autre répertoire en conservant le nom du fichier :

cp {{chemin/vers/fichier_source.ext}} {{chemin/vers/répertoire_parent_cible}}

Copier récursivement le contenu d’un répertoire vers un autre emplacement (si la destination existe, le répertoire est copié à l’intérieur) :

cp -R {{chemin/vers/répertoire_source}} {{chemin/vers/répertoire_cible}}

Copier un répertoire récursivement, en mode verbeux (affiche les fichiers au fur et à mesure de leur copie) :

cp -vR {{chemin/vers/répertoire_source}} {{chemin/vers/répertoire_cible}}

Copier les fichiers texte vers un autre emplacement, en mode interactif (demande confirmation avant d’écraser) :

cp -i {{*.txt}} {{chemin/vers/répertoire_cible}}

Déréférencer les liens symboliques avant de copier :

cp -L {{link}} {{chemin/vers/répertoire_cible}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

csplit

csplit [OPTION]... FICHIER MOTIF...

Diviser un fichier en sections déterminées par des lignes de contexte

Options

--suffix-format=<FORMAT>, -b <FORMAT>

utiliser le FORMAT sprintf au lieu de %02d

--prefix=<PREFIX>, -f <PREFIX>

utiliser PRÉFIXE au lieu de ‘xx’

--keep-files, -k

ne pas supprimer les fichiers de sortie en cas d’erreurs

--suppress-matched

supprimer les lignes correspondant au MOTIF

--digits=<DIGITS>, -n <DIGITS>

utiliser le nombre spécifié de chiffres au lieu de 2

--quiet, --silent, -q, -s

ne pas afficher le nombre d’octets des fichiers de sortie

--elide-empty-files, -z

supprimer les fichiers de sortie vides

Sortir les morceaux de FICHIER séparés par MOTIF(S) dans les fichiers ‘xx00’, ‘xx01’, …, et sortir le nombre d’octets de chaque morceau sur la sortie standard.

Examples

Split a file in two parts, starting the second one at line 10:

csplit {{path/to/file}} 10

Split a file in three parts, starting the latter parts in lines 7 and 23:

csplit {{path/to/file}} 7 23

Start a new part at every 5th line (will fail if number of lines is not divisible by 5):

csplit {{path/to/file}} 5 {*}

Start a new part at every 5th line, ignoring exact-division error:

csplit {{[-k|--keep-files]}} {{path/to/file}} 5 {*}

Split a file above line 5 and use a custom prefix for the output files (default is xx):

csplit {{path/to/file}} 5 {{[-f|--prefix]}} {{prefix}}

Split a file above the first line matching a regex pattern:

csplit {{path/to/file}} /{{regex}}/

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

cut

cut OPTION... [FICHIER]...

Affiche les colonnes d’octets ou de champs spécifiées de chaque ligne de stdin ou des fichiers d’entrée

Options

--bytes=<LIST>, -b <LIST>

filtrer les colonnes d’octets depuis la source d’entrée

--characters=<LIST>, -c <LIST>

alias pour le mode caractère

--delimiter=<DELIM>, -d <DELIM>

spécifier le caractère délimiteur qui sépare les champs dans la source d’entrée. Par défaut Tab.

-w <WHITESPACE>

Utiliser tout nombre d’espaces (Espace, Tab) pour séparer les champs dans la source d’entrée (extension FreeBSD).

--fields=<LIST>, -f <LIST>

filtrer les colonnes de champs depuis la source d’entrée

--complement

inverser le filtre - au lieu d’afficher seulement les colonnes filtrées, afficher toutes sauf ces colonnes

--only-delimited, -s

en mode champ, afficher seulement les lignes qui contiennent le délimiteur

--zero-terminated, -z

au lieu de filtrer les colonnes basées sur la ligne, filtrer les colonnes basées sur \0 (caractère NULL)

--output-delimiter=<NEW_DELIM>

en mode champ, remplacer le délimiteur dans les lignes de sortie avec l’argument de cette option

-n

(ignored)

Chaque appel doit spécifier un mode (quoi utiliser pour les colonnes), une séquence (quelles colonnes afficher), et fournir une source de données

Spécifier un mode

Utilisez –bytes (-b) ou –characters (-c) pour spécifier le mode octet

Utilisez –fields (-f) pour spécifier le mode champ, où chaque ligne est divisée en champs identifiés par un caractère délimiteur. Par exemple pour un CSV typique vous pourriez utiliser ceci en combinaison avec la définition de la virgule comme délimiteur

Spécifier une séquence

Une séquence est un groupe de 1 ou plusieurs nombres ou plages inclusives séparés par des virgules.

cut -f 2,5-7 quelque_fichier.txt

affichera les 2ème, 5ème, 6ème, et 7ème champs pour chaque ligne source

Les plages peuvent s’étendre jusqu’à la fin de la ligne en excluant le second nombre

cut -f 3- quelque_fichier.txt

affichera le 3ème champ et tous les champs suivants pour chaque ligne source

Le premier nombre d’une plage peut être exclu, et ceci est effectivement identique à utiliser 1 comme premier nombre : cela fait commencer la plage à la première colonne. Les plages peuvent aussi afficher une seule colonne

cut -f 1,3-5 quelque_fichier.txt

affichera les 1er, 3ème, 4ème, et 5ème champs pour chaque ligne source

L’option –complement, quand utilisée, inverse l’effet de la séquence

cut –complement -f 4-6 quelque_fichier.txt

affichera tous les champs sauf les 4ème, 5ème, et 6ème

Spécifier une source de données

Si aucun argument de fichier source n’est spécifié, stdin est utilisé comme source de lignes à afficher

Si des arguments de fichier source sont spécifiés, stdin est ignoré et tous les fichiers sont lus consécutivement si un fichier source n’est pas lu avec succès, un avertissement sera affiché sur stderr, et le code de statut final sera 1, mais cut continuera à lire les fichiers sources suivants

Pour afficher les colonnes depuis STDIN et un argument de fichier, utilisez - (tiret) comme argument de fichier source pour représenter stdin.

Options du Mode Champ

Les champs dans chaque ligne sont identifiés par un délimiteur (séparateur)

Définir le délimiteur

Définissez le délimiteur qui sépare les champs dans le fichier en utilisant l’option –delimiter (-d). Définir le délimiteur est optionnel. Si non défini, un délimiteur par défaut de Tab sera utilisé.

Si l’option -w est fournie, les champs seront séparés par tout nombre de caractères d’espacement (Espace et Tab). Le délimiteur de sortie sera un Tab sauf si explicitement spécifié. Seulement une des options -d ou -w peut être spécifiée. Ceci est une extension adoptée de FreeBSD.

Filtrage optionnel basé sur le délimiteur

Si le drapeau –only-delimited (-s) est fourni, seules les lignes qui contiennent le délimiteur seront affichées

Remplacer le délimiteur

Si l’option –output-delimiter est fournie, l’argument utilisé pour elle remplacera le caractère délimiteur dans chaque ligne affichée. Ceci est utile pour transformer les données tabulaires - par ex. pour convertir un CSV en TSV (fichier séparé par tabulations)

Fins de ligne

Quand l’option –zero-terminated (-z) est utilisée, cut voit \0 (null) comme le caractère de ‘fin de ligne’ (à la fois pour lire les lignes et séparer les lignes affichées) au lieu de \n (nouvelle ligne). Ceci est utile pour les données tabulaires où certaines cellules peuvent contenir des nouvelles lignes

echo ‘ab\0cd’ | cut -z -c 1

donnera comme résultat ‘a\0c\0’

Examples

Print the fifth character on each line:

{{command}} | cut {{[-c|--characters]}} 5

Print the fifth to tenth character of each line of the specified file:

cut {{[-c|--characters]}} 5-10 {{path/to/file}}

Split each line in a file by a delimiter into fields and print fields two and six (default delimiter is TAB):

cut {{[-f|--fields]}} 2,6 {{path/to/file}}

Split each line by the specified delimiter and print all from the second field onward:

{{command}} | cut {{[-d|--delimiter]}} "{{delimiter}}" {{[-f|--fields]}} 2-

Use space as a delimiter and print only the first 3 fields:

{{command}} | cut {{[-d|--delimiter]}} " " {{[-f|--fields]}} -3

Only print lines that contain the delimiter:

{{command}} | cut {{[-d|--delimiter]}} "{{:}}" {{[-f|--fields]}} {{1}} {{[-s|--only-delimited]}}

Print specific fields of lines that use NUL to terminate lines instead of newlines:

{{find . -print0}} | cut {{[-z|--zero-terminated]}} {{[-d|--delimiter]}} "{{/}}" {{[-f|--fields]}} {{2}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

date

[OPTION]... [+FORMAT]
date [-u|--utc|--universal] [MMDDhhmm[[CC]YY][.ss]]

FORMAT contrôle la sortie. Les séquences interprétées sont :
| Séquence | Description                                                    | Exemple                |
| -------- | -------------------------------------------------------------- | ---------------------- |
| %%       | un % littéral                                                  | %                      |
| %a       | nom abrégé du jour de la semaine selon la locale             | dim                    |
| %A       | nom complet du jour de la semaine selon la locale            | dimanche               |
| %b       | nom abrégé du mois selon la locale                            | jan                    |
| %B       | nom complet du mois selon la locale                           | janvier                |
| %c       | date et heure selon la locale                                 | jeu 3 mar 23:05:25 2005|
| %C       | siècle ; comme %Y, sauf qu'on omet les deux derniers chiffres | 20                     |
| %d       | jour du mois                                                   | 01                     |
| %D       | date ; identique à %m/%d/%y                                    | 12/31/99               |
| %e       | jour du mois, rempli avec des espaces ; identique à %_d       | 3                      |
| %F       | date complète ; identique à %Y-%m-%d                          | 2005-03-03             |
| %g       | deux derniers chiffres de l'année du numéro de semaine ISO (voir %G) | 05                     |
| %G       | année du numéro de semaine ISO (voir %V) ; normalement utile seulement avec %V | 2005                   |
| %h       | identique à %b                                                 | jan                    |
| %H       | heure (00..23)                                                 | 23                     |
| %I       | heure (01..12)                                                 | 11                     |
| %j       | jour de l'année (001..366)                                     | 062                    |
| %k       | heure, remplie avec des espaces ( 0..23) ; identique à %_H    |  3                     |
| %l       | heure, remplie avec des espaces ( 1..12) ; identique à %_I    |  9                     |
| %m       | mois (01..12)                                                  | 03                     |
| %M       | minute (00..59)                                                | 30                     |
| %n       | une nouvelle ligne                                             | \\n                     |
| %N       | nanosecondes (000000000..999999999)                            | 123456789              |
| %p       | équivalent locale de AM ou PM ; vide si inconnu               | PM                     |
| %P       | comme %p, mais en minuscules                                   | pm                     |
| %q       | trimestre de l'année (1..4)                                   | 1                      |
| %r       | heure sur 12 heures selon la locale                           | 11:11:04 PM            |
| %R       | heure sur 24 heures et minute ; identique à %H:%M             | 23:30                  |
| %s       | secondes depuis 1970-01-01 00:00:00 UTC                       | 1615432800             |
| %S       | seconde (00..60)                                               | 30                     |
| %t       | une tabulation                                                 | \\t                     |
| %T       | heure ; identique à %H:%M:%S                                   | 23:30:30               |
| %u       | jour de la semaine (1..7) ; 1 est lundi                       | 4                      |
| %U       | numéro de semaine de l'année, avec dimanche comme premier jour de la semaine (00..53) | 10                     |
| %V       | numéro de semaine ISO, avec lundi comme premier jour de la semaine (01..53) | 12                     |
| %w       | jour de la semaine (0..6) ; 0 est dimanche                    | 4                      |
| %W       | numéro de semaine de l'année, avec lundi comme premier jour de la semaine (00..53) | 11                     |
| %x       | représentation de la date selon la locale                     | 03/03/2005             |
| %X       | représentation de l'heure selon la locale                     | 23:30:30               |
| %y       | deux derniers chiffres de l'année (00..99)                    | 05                     |
| %Y       | année                                                          | 2005                   |
| %z       | fuseau horaire numérique +hhmm                                | -0400                  |
| %:z      | fuseau horaire numérique +hh:mm                               | -04:00                 |
| %::z     | fuseau horaire numérique +hh:mm:ss                            | -04:00:00              |
| %:::z    | fuseau horaire numérique avec : à la précision nécessaire     | -04, +05:30            |
| %Z       | abréviation alphabétique du fuseau horaire                    | EDT                    |

Par défaut, date remplit les champs numériques avec des zéros.
Les indicateurs optionnels suivants peuvent suivre '%' :
* `-` (tiret) ne pas remplir le champ
* `_` (soulignement) remplir avec des espaces
* `0` (zéro) remplir avec des zéros
* `^` utiliser des majuscules si possible
* `#` utiliser l'inverse si possible
Après tout indicateur vient une largeur de champ optionnelle, comme nombre décimal ;
puis un modificateur optionnel, qui est soit
* `E` pour utiliser les représentations alternatives de la locale si disponibles, ou
* `O` pour utiliser les symboles numériques alternatifs de la locale si disponibles.
Exemples :
  Convertir les secondes depuis l'époque (1970-01-01 UTC) en date

  date --date='@2147483647'

  Montrer l'heure sur la côte ouest des États-Unis (utiliser tzselect(1) pour trouver TZ)

  TZ='America/Los_Angeles' date

afficher ou définir la date système

Options

--date=<STRING>, -d <STRING>

afficher l’heure décrite par CHAÎNE, pas ‘maintenant’

--file=<DATEFILE>, -f <DATEFILE>

comme –date ; une fois pour chaque ligne de FICHIER_DATE

--iso-8601=<FMT>, -I <FMT>

afficher la date/heure au format ISO 8601.
FMT=‘date’ pour la date seulement (par défaut),
‘hours’, ‘minutes’, ‘seconds’, ou ‘ns’
pour la date et l’heure à la précision indiquée.
Exemple : 2006-08-14T02:34:56-06:00

--resolution

Affiche la résolution disponible des horodatages
Exemple : 0.000000001

--rfc-email, -R

afficher la date et l’heure au format RFC 5322.
Exemple : Mon, 14 Aug 2006 02:34:56 -0600

--rfc-3339=<FMT>

afficher la date/heure au format RFC 3339.
FMT=‘date’, ‘seconds’, ou ‘ns’
pour la date et l’heure à la précision indiquée.
Exemple : 2006-08-14 02:34:56-06:00

--debug

annoter la date analysée et avertir des usages douteux sur stderr

--reference=<FILE>, -r <FILE>

afficher l’heure de dernière modification du FICHIER

--set=<STRING>, -s <STRING>

définir l’heure décrite par CHAÎNE

--universal, --utc, -u

afficher ou définir le Temps Universel Coordonné (UTC)

Examples

Display the current date using the default locale’s format:

date +%c

Display the current date in UTC, using the ISO 8601 format:

date {{[-u|--utc]}} +%Y-%m-%dT%H:%M:%S%Z

Display the current date as a Unix timestamp (seconds since the Unix epoch):

date +%s

Convert a date specified as a Unix timestamp to the default format:

date {{[-d|--date]}} @{{1473305798}}

Convert a given date to the Unix timestamp format:

date {{[-d|--date]}} "{{2018-09-01 00:00}}" +%s {{[-u|--utc]}}

Display the current date using the RFC-3339 format (YYYY-MM-DD hh:mm:ss TZ):

date --rfc-3339 s

Set the current date using the format MMDDhhmmYYYY.ss (YYYY and .ss are optional):

date {{093023592021.59}}

Display the current ISO week number:

date +%V

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

dd

dd [OPÉRANDE]...
dd OPTION

Copier, et optionnellement convertir, une ressource du système de fichiers

Options

Opérandes

• bs=OCTETS : lire et écrire jusqu’à OCTETS octets à la fois (par défaut : 512) ; remplace ibs et obs.

• cbs=OCTETS : la ‘taille de bloc de conversion’ en octets. S’applique aux opérations conv=block et conv=unblock.

• conv=CONVS : une liste séparée par des virgules d’options de conversion ou (pour des raisons historiques) d’indicateurs de fichier.

• count=N : arrêter la lecture de l’entrée après N opérations de lecture de taille ibs plutôt que de continuer jusqu’à EOF. Voir iflag=count_bytes si l’arrêt après N octets est préféré

• ibs=N : la taille du tampon utilisé pour les lectures (par défaut : 512)

• if=FICHIER : le fichier utilisé pour l’entrée. Quand non spécifié, stdin est utilisé à la place

• iflag=INDICATEURS : une liste séparée par des virgules d’indicateurs d’entrée qui spécifient comment la source d’entrée est traitée. INDICATEURS peut être n’importe lequel des indicateurs d’entrée ou indicateurs généraux spécifiés ci-dessous.

• skip=N (ou iseek=N) : ignorer N enregistrements de taille ibs dans l’entrée avant de commencer les opérations de copie/conversion. Voir iflag=seek_bytes si la recherche de N octets est préférée.

• obs=N : la taille du tampon utilisé pour les écritures (par défaut : 512)

• of=FICHIER : le fichier utilisé pour la sortie. Quand non spécifié, stdout est utilisé à la place

• oflag=INDICATEURS : liste séparée par des virgules d’indicateurs de sortie qui spécifient comment la source de sortie est traitée. INDICATEURS peut être n’importe lequel des indicateurs de sortie ou indicateurs généraux spécifiés ci-dessous

• seek=N (ou oseek=N) : recherche N enregistrements de taille obs dans la sortie avant de commencer les opérations de copie/conversion. Voir oflag=seek_bytes si la recherche de N octets est préférée

• status=NIVEAU : contrôle si les statistiques de volume et de performance sont écrites sur stderr.

  Quand non spécifié, dd affichera les statistiques à la fin. Un exemple est ci-dessous.

    6+0 enregistrements en entrée
    16+0 enregistrements en sortie
    8192 octets (8.2 kB, 8.0 KiB) copiés, 0.00057009 s,
    14.4 MB/s
  
  Les deux premières lignes sont les statistiques de 'volume' et la dernière ligne est les
  statistiques de 'performance'.
  Les statistiques de volume indiquent le nombre de lectures complètes et partielles de taille ibs,
  ou d'écritures de taille obs qui ont eu lieu pendant la copie. Le format des statistiques de
  volume est <complètes>+<partielles>. Si des enregistrements ont été tronqués (voir
  conv=block), les statistiques de volume contiendront le nombre d'enregistrements tronqués.
  
  Les valeurs possibles de NIVEAU sont :
  - progress : Afficher les statistiques de performance périodiques pendant la copie.
  - noxfer : Afficher les statistiques de volume finales, mais pas les statistiques de performance.
  - none : N'afficher aucune statistique.
  
  L'affichage des statistiques de performance est aussi déclenché par le signal INFO (quand supporté),
  ou le signal USR1. Définir la variable d'environnement POSIXLY_CORRECT à n'importe quelle valeur
  (y compris une valeur vide) fera ignorer le signal USR1.
  
  

Options de conversion

• ascii : convertir d’EBCDIC vers ASCII. C’est l’inverse de l’option ebcdic. Implique conv=unblock.

• ebcdic : convertir d’ASCII vers EBCDIC. C’est l’inverse de l’option ascii. Implique conv=block.

• ibm : convertir d’ASCII vers EBCDIC, en appliquant les conventions pour [, ] et ~ spécifiées dans POSIX. Implique conv=block.

• ucase : convertir de minuscules vers majuscules.

• lcase : convertir de majuscules vers minuscules.

• block : pour chaque nouvelle ligne inférieure à la taille indiquée par cbs=OCTETS, supprimer la nouvelle ligne et remplir avec des espaces jusqu’à cbs. Les lignes plus longues que cbs sont tronquées.

• unblock : pour chaque bloc d’entrée de la taille indiquée par cbs=OCTETS, supprimer les espaces de fin à droite et remplacer par un caractère de nouvelle ligne.

• sparse : tente de rechercher la sortie quand un bloc de taille obs ne contient que des zéros.

• swab : échange chaque paire d’octets adjacents. Si un nombre impair d’octets est présent, l’octet final est omis.

• sync : remplit chaque bloc de taille ibs avec des zéros. Si block ou unblock est spécifié, remplit avec des espaces à la place.

• excl : le fichier de sortie doit être créé. Échoue si le fichier de sortie est déjà présent.

• nocreat : le fichier de sortie ne sera pas créé. Échoue si le fichier de sortie n’est pas déjà présent.

• notrunc : le fichier de sortie ne sera pas tronqué. Si cette option n’est pas présente, la sortie sera tronquée à l’ouverture.

• noerror : toutes les erreurs de lecture seront ignorées. Si cette option n’est pas présente, dd n’ignorera que Error::Interrupted.

• fdatasync : les données seront écrites avant la fin.

• fsync : les données et les métadonnées seront écrites avant la fin.

Indicateurs d’entrée

• count_bytes : une valeur pour count=N sera interprétée comme des octets.
• skip_bytes : une valeur pour skip=N sera interprétée comme des octets.
• fullblock : attendre ibs octets de chaque lecture. les lectures de longueur zéro sont toujours considérées comme EOF.

Indicateurs de sortie

• append : ouvrir le fichier en mode ajout. Considérez définir conv=notrunc aussi.
• seek_bytes : une valeur pour seek=N sera interprétée comme des octets.

Indicateurs généraux

• direct : utiliser les E/S directes pour les données.
• directory : échouer sauf si l’entrée donnée (si utilisée comme iflag) ou la sortie (si utilisée comme oflag) est un répertoire.
• dsync : utiliser les E/S synchronisées pour les données.
• sync : utiliser les E/S synchronisées pour les données et les métadonnées.
• nonblock : utiliser les E/S non-bloquantes.
• noatime : ne pas mettre à jour l’heure d’accès.
• nocache : demander au système d’exploitation de supprimer le cache.
• noctty : ne pas assigner un tty de contrôle.
• nofollow : ne pas suivre les liens système.

Examples

Make a bootable USB drive from an isohybrid file (such as archlinux-xxx.iso) and show the progress:

dd if={{path/to/file.iso}} of={{/dev/usb_drive}} status=progress

Clone a drive to another drive with 4 MiB block size and flush writes before the command terminates:

dd bs=4194304 conv=fsync if={{/dev/source_drive}} of={{/dev/dest_drive}}

Generate a file with a specific number of random bytes by using kernel random driver:

dd bs={{100}} count={{1}} if=/dev/urandom of={{path/to/random_file}}

Benchmark the sequential write performance of a disk:

dd bs={{1024}} count={{1000000}} if=/dev/zero of={{path/to/file_1GB}}

Create a system backup, save it into an IMG file (can be restored later by swapping if and of), and show the progress:

dd if={{/dev/drive_device}} of={{path/to/file.img}} status=progress

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

df

df [OPTION]... [FICHIER]...

afficher des informations sur le système de fichiers sur lequel chaque FICHIER réside, ou tous les systèmes de fichiers par défaut.

Options

--help

afficher les informations d’aide.

--all, -a

inclure les systèmes de fichiers factices

--block-size=<SIZE>, -B <SIZE>

mettre les tailles à l’échelle par TAILLE avant de les afficher ; par ex. ‘-BM’ affiche les tailles en unités de 1 048 576 octets

--total

produire un total général

--human-readable, -h

afficher les tailles dans un format lisible par l’homme (par ex., 1K 234M 2G)

--si, -H

pareillement, mais utiliser les puissances de 1000 pas 1024

--inodes, -i

lister les informations d’inode au lieu de l’utilisation des blocs

-k

comme –block-size=1K

--local, -l

limiter l’affichage aux systèmes de fichiers locaux

--no-sync

ne pas invoquer sync avant d’obtenir les informations d’utilisation (par défaut)

--output=<FIELD_LIST>

utiliser le format de sortie défini par LISTE_CHAMPS, ou afficher tous les champs si LISTE_CHAMPS est omise.

--portability, -P

utiliser le format de sortie POSIX

--sync

invoquer sync avant d’obtenir les informations d’utilisation (non-windows seulement)

--type=<TYPE>, -t <TYPE>

limiter l’affichage aux systèmes de fichiers de type TYPE

--print-type, -T

afficher le type de système de fichiers

--exclude-type=<TYPE>, -x <TYPE>

limiter l’affichage aux systèmes de fichiers pas de type TYPE

Les valeurs affichées sont en unités de la première TAILLE disponible de –block-size, et des variables d’environnement DF_BLOCK_SIZE, BLOCK_SIZE et BLOCKSIZE. Sinon, les unités par défaut sont 1024 octets (ou 512 si POSIXLY_CORRECT est défini).

TAILLE est un entier et une unité optionnelle (exemple : 10M est 1010241024). Les unités sont K, M, G, T, P, E, Z, Y (puissances de 1024) ou KB, MB,… (puissances de 1000).

Examples

Afficher tous les systèmes de fichiers et leur utilisation d’espace disque :

df

Afficher tous les systèmes de fichiers et leur utilisation d’espace disque dans un format plus facilement :

df -h

Afficher le système de fichiers et son utilisation d’espace disque rattaché au chemin donné :

df {{chemin/vers/fichier_ou_dossier}}

Afficher des statistiques sur le nombre d’inodes disponibles :

df -i

Afficher les systèmes de fichiers sauf ceux de types spécifiques :

df -x {{squashfs}} -x {{tmpfs}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

dir

Options

--help

ls-help-print-help

--format

ls-help-set-display-format

-C

ls-help-display-files-columns

--long, -l

ls-help-display-detailed-info

-x

ls-help-list-entries-rows

--tabsize=<COLS>, -T <COLS>

ls-help-assume-tab-stops

-m

ls-help-list-entries-commas

--zero

ls-help-list-entries-nul

--dired, -D

ls-help-generate-dired-output

--hyperlink=<WHEN>

ls-help-hyperlink-filenames

-1

ls-help-list-one-file-per-line

-o

ls-help-long-format-no-group

-g

ls-help-long-no-owner

--numeric-uid-gid, -n

ls-help-long-numeric-uid-gid

--quoting-style

ls-help-set-quoting-style

--literal, -N

ls-help-literal-quoting-style

--escape, -b

ls-help-escape-quoting-style

--quote-name, -Q

ls-help-c-quoting-style

--hide-control-chars, -q

ls-help-replace-control-chars

--show-control-chars

ls-help-show-control-chars

--time=<field>

ls-help-show-time-field

-c

ls-help-time-change

-u

ls-help-time-access

--hide=<PATTERN>

ls-help-hide-pattern

--ignore=<PATTERN>, -I <PATTERN>

ls-help-ignore-pattern

--ignore-backups, -B

ls-help-ignore-backups

--sort=<field>

ls-help-sort-by-field

-S

ls-help-sort-by-size

-t

ls-help-sort-by-time

-v

ls-help-sort-by-version

-X

ls-help-sort-by-extension

-U

ls-help-sort-none

--dereference, -L

ls-help-dereference-all

--dereference-command-line-symlink-to-dir

ls-help-dereference-dir-args

--dereference-command-line, -H

ls-help-dereference-args

--no-group, -G

ls-help-no-group

--author

ls-help-author

--all, -a

ls-help-all-files

--almost-all, -A

ls-help-almost-all

-f

ls-help-unsorted-all

--directory, -d

ls-help-directory

--human-readable, -h

ls-help-human-readable

--kibibytes, -k

ls-help-kibibytes

--si

ls-help-si

--block-size=<BLOCK_SIZE>

ls-help-block-size

--inode, -i

ls-help-print-inode

--reverse, -r

ls-help-reverse-sort

--recursive, -R

ls-help-recursive

--width=<COLS>, -w <COLS>

ls-help-terminal-width

--size, -s

ls-help-allocation-size

--color

ls-help-color-output

--indicator-style

ls-help-indicator-style

--classify=<when>, -F <when>

ls-help-classify

--file-type

ls-help-file-type

-p

ls-help-slash-directories

--time-style=<TIME_STYLE>

ls-help-time-style

--full-time

ls-help-full-time

--context, -Z

ls-help-context

--group-directories-first

ls-help-group-directories-first

Examples

Affiche la documentation de la commande originale :

tldr ls

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

dircolors

dircolors [OPTION]... [FICHIER]

Afficher les commandes pour définir la variable d’environnement LS_COLORS.

Options

--sh, --bourne-shell, -b

afficher le code Bourne shell pour définir LS_COLORS

--csh, --c-shell, -c

afficher le code C shell pour définir LS_COLORS

--print-database, -p

afficher la base de données de configuration

--print-ls-colors

afficher les couleurs entièrement échappées pour l’affichage

Si FICHIER est spécifié, le lire pour déterminer quelles couleurs utiliser pour quels types de fichiers et extensions. Sinon, une base de données précompilée est utilisée. Pour les détails sur le format de ces fichiers, exécutez ‘dircolors –print-database’

Examples

Output commands to set $LS_COLOR using default colors:

dircolors

Display each filetype with the color they would appear in ls:

dircolors --print-ls-colors

Output commands to set $LS_COLOR using colors from a file:

dircolors {{path/to/file}}

Output commands for Bourne shell:

dircolors {{[-b|--bourne-shell]}}

Output commands for C shell:

dircolors {{[-c|--c-shell]}}

View the default colors for file types and extensions:

dircolors {{[-p|--print-database]}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

dirname

dirname [OPTION] NOM...

Supprimer le dernier composant du nom de fichier

Options

--zero, -z

dirname-zero-help

Afficher chaque NOM avec son dernier composant non-slash et les slashes finaux supprimés ; si NOM ne contient pas de ‘/’, afficher ‘.’ (signifiant le répertoire courant).

Examples

Calculate the parent directory of a given path:

dirname {{path/to/file_or_directory}}

Calculate the parent directory of multiple paths:

dirname {{path/to/file_or_directory1 path/to/file_or_directory2 ...}}

Delimit output with a NUL character instead of a newline (useful when combining with xargs):

dirname {{[-z|--zero]}} {{path/to/file_or_directory1 path/to/file_or_directory2 ...}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

du

du [OPTION]... [FICHIER]...
du [OPTION]... --files0-from=F

Estimer l’utilisation de l’espace disque des fichiers

Options

--help

Afficher les informations d’aide.

--all, -a

afficher les comptes pour tous les fichiers, pas seulement les répertoires

--apparent-size, -A

afficher les tailles apparentes, plutôt que l’utilisation du disque bien que la taille apparente soit généralement plus petite, elle peut être plus grande en raison de trous dans les fichiers (‘sparse’), la fragmentation interne, les blocs indirects, etc.

--block-size=<SIZE>, -B <SIZE>

mettre à l’échelle les tailles par TAILLE avant de les afficher. Par ex., ‘-BM’ affiche les tailles en unités de 1 048 576 octets. Voir le format TAILLE ci-dessous.

--bytes, -b

équivalent à ‘–apparent-size –block-size=1’

--total, -c

produire un total général

--max-depth=<N>, -d <N>

afficher le total pour un répertoire (ou fichier, avec –all) seulement s’il est à N niveaux ou moins sous l’argument de ligne de commande ; –max-depth=0 est identique à –summarize

--human-readable, -h

afficher les tailles dans un format lisible par l’homme (p. ex., 1K 234M 2G)

--inodes

lister les informations d’utilisation des inodes au lieu de l’utilisation des blocs comme –block-size=1K

-k

comme –block-size=1K

--count-links, -l

compter les tailles plusieurs fois si liées en dur

--dereference, -L

suivre tous les liens symboliques

--dereference-args, -D, -H

suivre seulement les liens symboliques qui sont listés sur la ligne de commande

--no-dereference, -P

ne pas suivre les liens symboliques (c’est le défaut)

-m

comme –block-size=1M

--null, -0

terminer chaque ligne de sortie avec un octet 0 plutôt qu’une nouvelle ligne

--separate-dirs, -S

ne pas inclure la taille des sous-répertoires

--summarize, -s

afficher seulement un total pour chaque argument

--si

comme -h, mais utiliser les puissances de 1000 et non 1024

--one-file-system, -x

ignorer les répertoires sur des systèmes de fichiers différents

--threshold=<SIZE>, -t <SIZE>

exclure les entrées plus petites que TAILLE si positive, ou les entrées plus grandes que TAILLE si négative

--verbose, -v

mode verbeux (option non présente dans GNU/Coreutils)

--exclude=<PATTERN>

exclure les fichiers qui correspondent au MOTIF

--exclude-from=<FILE>, -X <FILE>

exclure les fichiers qui correspondent à n’importe quel motif dans FICHIER

--files0-from=<FILE>

résumer l’utilisation du périphérique des noms de fichiers terminés par NUL spécifiés dans le fichier F ; si F est -, alors lire les noms depuis l’entrée standard

--time=<WORD>

montrer l’heure de la dernière modification de n’importe quel fichier dans le répertoire, ou n’importe lequel de ses sous-répertoires. Si MOT est donné, montrer l’heure comme MOT au lieu de l’heure de modification : atime, access, use, ctime, status, birth ou creation

--time-style=<STYLE>

montrer les heures en utilisant le style STYLE : full-iso, long-iso, iso, +FORMAT FORMAT est interprété comme ‘date’

Les valeurs affichées sont en unités de la première TAILLE disponible de –block-size, et des variables d’environnement DU_BLOCK_SIZE, BLOCK_SIZE et BLOCKSIZE. Sinon, les unités par défaut sont 1024 octets (ou 512 si POSIXLY_CORRECT est défini).

TAILLE est un entier et une unité optionnelle (exemple : 10M est 1010241024). Les unités sont K, M, G, T, P, E, Z, Y (puissances de 1024) ou KB, MB,… (puissances de 1000).

MOTIF permet des exclusions avancées. Par exemple, les syntaxes suivantes sont supportées : ? correspondra à un seul caractère

• correspondra à zéro ou plusieurs caractères {a,b} correspondra à a ou b

Examples

Liste les tailles d’un répertoire et de ses sous-répertoires, dans l’unité donnée (o/Kio/Mio) :

du -{{b|k|m}} {{chemin/vers/répertoire}}

Liste les tailles d’un répertoire et de ses sous-répertoires, sous une forme lisible par l’homme (c’est-à-dire en sélectionnant automatiquement l’unité appropriée pour chaque taille) :

du {{[-h|--human-readable]}} {{chemin/vers/répertoire}}

Affiche la taille d’un répertoire unique, en unités lisibles par l’homme :

du {{[-sh|--summarize --human-readable]}} {{chemin/vers/répertoire}}

Liste les tailles, en unités lisibles par l’homme, d’un répertoire et de tous les fichiers et répertoires qu’il contient :

du {{[-ah|--all --human-readable]}} {{chemin/vers/répertoire}}

Liste les tailles, en unités lisibles par l’homme, d’un répertoire et de ses sous-répertoires, jusqu’à N niveaux de profondeur :

du {{[-h|--human-readable]}} {{[-d|--max-depth]}} N {{chemin/vers/répertoire}}

Liste la taille, en unités lisible par l’homme, de tous les fichiers .jpg dans les sous-répertoires du répertoire courant, et affiche un total cumulatif à la fin :

du {{[-ch|--total --human-readable]}} {{*/*.jpg}}

Liste tous les fichiers et répertoires (y compris les fichiers cachés) dépassant un certain seuil (utile pour déterminer ce qui occupe réellement l’espace) :

du {{[-ah|--all --human-readable]}} {{[-t|--threshold]}} {{1G|1024M|1048576K}} .[^.]* *

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

echo

echo [OPTIONS]... [CHAÎNE]...

Affiche une ligne de texte

Options

-n

ne pas afficher la nouvelle ligne finale

-e

activer l’interprétation des séquences d’échappement

-E

désactiver l’interprétation des séquences d’échappement (par défaut)

Affiche la ou les CHAÎNE(s) sur la sortie standard.

Si -e est activé, les séquences suivantes sont reconnues :

• \ barre oblique inverse
• \a alerte (BEL)
• \b retour arrière
• \c ne produit aucune sortie supplémentaire
• \e échappement
• \f saut de page
• \n nouvelle ligne
• \r retour chariot
• \t tabulation horizontale
• \v tabulation verticale
• \0NNN octet avec valeur octale NNN (1 à 3 chiffres)
• \xHH octet avec valeur hexadécimale HH (1 à 2 chiffres)

Examples

Affiche un message (les guillemets sont facultatifs) :

echo "{{Hello World}}"

Affiche un message avec des variables d’environnement :

echo "{{Ma variable PATH est $PATH}}"

Affiche un message sans retour à la ligne :

echo -n "{{Hello World}}"

Ajoute un message à un fichier :

echo "{{Hello World}}" >> {{fichier.txt}}

Active l’interprétation des spécificateurs d’échappement :

echo -e "{{Colonne 1\tColonne 2}}"

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

env

env [OPTION]... [-] [NOM=VALEUR]... [COMMANDE [ARG]...]

Définir chaque NOM à VALEUR dans l’environnement et exécuter COMMANDE

Options

--ignore-environment, -i

commencer avec un environnement vide

--chdir=<DIR>, -C <DIR>

changer le répertoire de travail vers RÉP

--null, -0

terminer chaque ligne de sortie avec un octet 0 plutôt qu’un retour à la ligne (valide uniquement lors de l’affichage de l’environnement)

--file=<PATH>, -f <PATH>

lire et définir les variables à partir d’un fichier de configuration de style “.env” (avant toute suppression et/ou définition)

--unset=<NAME>, -u <NAME>

supprimer la variable de l’environnement

--debug, -v

afficher des informations détaillées pour chaque étape de traitement

--split-string=<S>, -S <S>

traiter et diviser S en arguments séparés ; utilisé pour passer plusieurs arguments sur les lignes shebang

--argv0=<a>, -a <a>

Remplacer le zéroième argument passé à la commande en cours d’exécution. Sans cette option, une valeur par défaut de command est utilisée.

--ignore-signal=<SIG>

définir la gestion du/des signal/signaux SIG pour ne rien faire

--default-signal=<SIG>

reset handling of SIG signal(s) to the default action

--block-signal=<SIG>

block delivery of SIG signal(s) while running COMMAND

--list-signal-handling

list signal handling changes requested by preceding options

Un simple - implique -i. Si aucune COMMANDE, afficher l’environnement résultant.

Examples

Affiche l’environnement :

env

Exécute le programme donné. Souvent utilisé dans les scripts après le shebang (#!) pour consulter le chemin vers le programme :

env {{programme}}

Exécute le programme donné, avec un environnement vide :

env -i {{programme}}

Supprime une variable d’environnement et execute le programme donné :

env -u {{variable}} {{programme}}

Définit ou modifie une variable d’environnement et execute le programme donné :

env {{variable}}={{valeur}} {{programme}}

Définit ou modifie plusieurs variables d’environnement et execute le programme donné :

env {{variable1}}={{valeur}} {{variable2}}={{valeur}} {{variable3}}={{valeur}} {{programme}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

expand

expand [OPTION]... [FICHIER]...

Convertir les tabulations de chaque FICHIER en espaces, en écrivant vers la sortie standard. Sans FICHIER, ou quand FICHIER est -, lire l’entrée standard.

Options

--initial, -i

ne pas convertir les tabulations après les caractères non-blancs

--tabs=<N, LIST>, -t <N, LIST>

avoir des tabulations espacées de N caractères, pas 8 ou utiliser une liste séparée par des virgules de positions de tabulation explicites

--no-utf8, -U

interpréter le fichier d’entrée comme ASCII 8 bits plutôt que UTF-8

Examples

Convert tabs in each file to spaces, writing to stdout:

expand {{path/to/file}}

Convert tabs to spaces, reading from stdin:

expand

Do not convert tabs after non blanks:

expand {{[-i|--initial]}} {{path/to/file}}

Have tabs a certain number of characters apart, not 8:

expand {{[-t|--tabs]}} {{number}} {{path/to/file}}

Use a comma separated list of explicit tab positions:

expand {{[-t|--tabs]}} {{1,4,6}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

expr

expr [EXPRESSION]
expr [OPTIONS]

Afficher la valeur de EXPRESSION sur la sortie standard

Options

--version

afficher les informations de version et quitter

--help

afficher cette aide et quitter

Afficher la valeur de EXPRESSION sur la sortie standard. Une ligne vide ci-dessous sépare les groupes de précédence croissante.

EXPRESSION peut être :

• ARG1 | ARG2: ARG1 s’il n’est ni nul ni 0, sinon ARG2
• ARG1 & ARG2: ARG1 si aucun argument n’est nul ou 0, sinon 0
• ARG1 < ARG2: ARG1 est inférieur à ARG2
• ARG1 <= ARG2: ARG1 est inférieur ou égal à ARG2
• ARG1 = ARG2: ARG1 est égal à ARG2
• ARG1 != ARG2: ARG1 est différent de ARG2
• ARG1 >= ARG2: ARG1 est supérieur ou égal à ARG2
• ARG1 > ARG2: ARG1 est supérieur à ARG2
• ARG1 + ARG2: somme arithmétique de ARG1 et ARG2
• ARG1 - ARG2: différence arithmétique de ARG1 et ARG2
• ARG1 * ARG2: produit arithmétique de ARG1 et ARG2
• ARG1 / ARG2: quotient arithmétique de ARG1 divisé par ARG2
• ARG1 % ARG2: reste arithmétique de ARG1 divisé par ARG2
• STRING : REGEXP: correspondance de motif ancré de REGEXP dans STRING
• match STRING REGEXP: identique à STRING : REGEXP
• substr STRING POS LENGTH: sous-chaîne de STRING, POS compté à partir de 1
• index STRING CHARS: index dans STRING où l’un des CHARS est trouvé, ou 0
• length STRING: longueur de STRING
• • TOKEN: interpréter TOKEN comme une chaîne, même si c’est un mot-clé comme match ou un opérateur comme /
• ( EXPRESSION ): valeur de EXPRESSION

Attention : de nombreux opérateurs doivent être échappés ou mis entre guillemets pour les shells. Les comparaisons sont arithmétiques si les deux ARG sont des nombres, sinon lexicographiques. Les correspondances de motifs retournent la chaîne correspondant entre ( et ) ou null ; si ( et ) ne sont pas utilisés, elles retournent le nombre de caractères correspondants ou 0.

Le statut de sortie est 0 si EXPRESSION n’est ni nulle ni 0, 1 si EXPRESSION est nulle ou 0, 2 si EXPRESSION est syntaxiquement invalide, et 3 si une erreur s’est produite.

Variables d’environnement :

• EXPR_DEBUG_TOKENS=1: afficher les jetons de l’expression
• EXPR_DEBUG_RPN=1: afficher l’expression représentée en notation polonaise inverse
• EXPR_DEBUG_SYA_STEP=1: afficher chaque étape de l’analyseur
• EXPR_DEBUG_AST=1: afficher l’arbre de syntaxe abstraite représentant l’expression

Examples

Get the length of a specific string:

expr length "{{string}}"

Get the substring of a string with a specific length:

expr substr "{{string}}" {{from}} {{length}}

Match a specific substring against an anchored pattern:

expr match "{{string}}" '{{pattern}}'

Get the first char position from a specific set in a string:

expr index "{{string}}" "{{chars}}"

Calculate a specific mathematic expression:

expr {{expression1}} {{+|-|*|/|%}} {{expression2}}

Get the first expression if its value is non-zero and not null otherwise get the second one:

expr {{expression1}} \| {{expression2}}

Get the first expression if both expressions are non-zero and not null otherwise get zero:

expr {{expression1}} \& {{expression2}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

factor

factor [OPTION]... [NOMBRE]...

Afficher les facteurs premiers du/des NOMBRE(s) donné(s). Si aucun n’est spécifié, lire depuis l’entrée standard.

Options

--exponents, -h

Afficher les facteurs sous la forme p^e

--help

Afficher les informations d’aide.

Examples

Display the prime-factorization of a number:

factor {{number}}

Take the input from stdin if no argument is specified:

echo {{number}} | factor

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

false

Retourne immédiatement avec le code de sortie 1. Lorsqu’il est invoqué avec l’une des options reconnues, il tente d’afficher l’aide ou la version. Toute erreur d’entrée/sortie pendant cette opération est signalée, mais le programme retourne également 1.

Options

--help

Afficher l’aide

--version

false-version-text

Examples

Return a non-zero exit code:

false

Make a command always exit with 1:

{{command}} && false

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

fmt

[OPTION]... [FICHIER]...

Reformate les paragraphes depuis l’entrée (ou l’entrée standard) vers la sortie standard.

Options

--crown-margin, -c

fmt-crown-margin-help

--tagged-paragraph, -t

fmt-tagged-paragraph-help

--preserve-headers, -m

fmt-preserve-headers-help

--split-only, -s

fmt-split-only-help

--uniform-spacing, -u

fmt-uniform-spacing-help

--prefix=<PREFIX>, -p <PREFIX>

fmt-prefix-help

--skip-prefix=<PSKIP>, -P <PSKIP>

fmt-skip-prefix-help

--exact-prefix, -x

fmt-exact-prefix-help

--exact-skip-prefix, -X

fmt-exact-skip-prefix-help

--width=<WIDTH>, -w <WIDTH>

fmt-width-help

--goal=<GOAL>, -g <GOAL>

fmt-goal-help

--quick, -q

fmt-quick-help

--tab-width=<TABWIDTH>, -T <TABWIDTH>

fmt-tab-width-help

Examples

Reformat a file:

fmt {{path/to/file}}

Reformat a file producing output lines of (at most) n characters:

fmt {{[-w|--width]}} {{n}} {{path/to/file}}

Reformat a file without joining lines shorter than the given width together:

fmt {{[-s|--split-only]}} {{path/to/file}}

Reformat a file with uniform spacing (1 space between words and 2 spaces between paragraphs):

fmt {{[-u|--uniform-spacing]}} {{path/to/file}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

fold

fold [OPTION]... [FICHIER]...

Écrit chaque fichier (ou l’entrée standard si aucun fichier n’est donné) sur la sortie standard en coupant les lignes trop longues

Options

--bytes, -b

fold-bytes-help

--characters, -c

fold-characters-help

--spaces, -s

fold-spaces-help

--width=<WIDTH>, -w <WIDTH>

fold-width-help

Examples

Wrap each line to default width (80 characters):

fold {{path/to/file}}

Wrap each line to width “30”:

fold -w30 {{path/to/file}}

Wrap each line to width “5” and break the line at spaces (puts each space separated word in a new line, words with length > 5 are wrapped):

fold -w5 -s {{path/to/file}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

groups

groups [OPTION]... [NOM_UTILISATEUR]...

Affiche les groupes d’appartenance pour chaque NOM_UTILISATEUR ou, s’il n’est pas précisé, pour le processus courant (ce qui peut différer si la base de données des groupes a changé).

Options

Examples

Print group memberships for the current user:

groups

Print group memberships for a list of users:

groups {{username1 username2 ...}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

head

head [DRAPEAU]... [FICHIER]...

Affiche les 10 premières lignes de chaque FICHIER sur la sortie standard. Avec plus d’un FICHIER, précède chacun d’un en-tête donnant le nom du fichier. Sans FICHIER, ou quand FICHIER est -, lit l’entrée standard.

Les arguments obligatoires pour les drapeaux longs sont obligatoires pour les drapeaux courts aussi.

Options

--bytes=<[-]NUM>, -c <[-]NUM>

affiche les premiers NUM octets de chaque fichier ;
avec le préfixe ‘-’, affiche tout sauf les derniers
NUM octets de chaque fichier

--lines=<[-]NUM>, -n <[-]NUM>

affiche les premières NUM lignes au lieu des 10 premières ;
avec le préfixe ‘-’, affiche tout sauf les dernières
NUM lignes de chaque fichier

--quiet, --silent, -q

n’affiche jamais les en-têtes donnant les noms de fichiers

--verbose, -v

affiche toujours les en-têtes donnant les noms de fichiers

--presume-input-pipe

--zero-terminated, -z

le délimiteur de ligne est NUL, pas nouvelle ligne

Examples

Affiche les premières lignes d’un fichier :

head -n {{nombre}} {{chemin/vers/fichier}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

hostid

hostid [OPTIONS]

Afficher l’identifiant numérique (en hexadécimal) de l’hôte actuel

Options

Examples

Display the numeric identifier for the current host in hexadecimal:

hostid

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

hostname

hostname [OPTION]... [NOM_HÔTE]

Afficher ou définir le nom d’hôte du système.

Options

--domain, -d

Afficher le nom du domaine DNS si possible

--ip-address, -i

Afficher la ou les adresses réseau de l’hôte

--fqdn, -f

Afficher le FQDN (nom de domaine pleinement qualifié) (par défaut)

--short, -s

Afficher le nom d’hôte court (la partie avant le premier point) si possible

Examples

Show current host name:

hostname

Show the network address of the host name:

hostname {{[-i|--ip-address]}}

Show the FQDN (Fully Qualified Domain Name):

hostname {{[-f|--fqdn]}}

Set current host name:

hostname {{new_hostname}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

id

id [OPTION]... [UTILISATEUR]...

Affiche les informations d’utilisateur et de groupe pour chaque UTILISATEUR spécifié, ou (si UTILISATEUR est omis) pour l’utilisateur actuel.

Options

--ignore, -a

ignore, pour compatibilité avec d’autres versions

-A

Affiche l’ID utilisateur d’audit du processus et autres propriétés d’audit,
ce qui nécessite des privilèges (non disponible sous Linux).

--user, -u

Affiche uniquement l’ID utilisateur effectif sous forme de nombre.

--group, -g

Affiche uniquement l’ID de groupe effectif sous forme de nombre

--groups, -G

Affiche uniquement les différents ID de groupe sous forme de nombres séparés par des espaces,
dans un ordre quelconque.

-p

Rend la sortie lisible par l’humain. Chaque affichage est sur une ligne séparée.

--name, -n

Affiche le nom de l’ID utilisateur ou groupe pour les options -G, -g et -u
au lieu du nombre.
Si certains ID numériques ne peuvent pas être convertis en
noms, le nombre sera affiché comme d’habitude.

-P

Affiche l’id comme une entrée de fichier de mots de passe.

--real, -r

Affiche l’ID réel pour les options -G, -g et -u au lieu de
l’ID effectif.

--zero, -z

délimite les entrées avec des caractères NUL, pas des espaces ;
non autorisé dans le format par défaut

--context, -Z

id-context-help-enabled

L’utilitaire id affiche les noms d’utilisateur et de groupe ainsi que leurs ID numériques du processus appelant, vers la sortie standard. Si les ID réels et effectifs sont différents, les deux sont affichés, sinon seul l’ID réel est affiché.

Si un utilisateur (nom de connexion ou ID utilisateur) est spécifié, les ID utilisateur et groupe de cet utilisateur sont affichés. Dans ce cas, les ID réels et effectifs sont supposés être identiques.

Examples

Display current user’s ID (UID), group ID (GID), and groups to which they belong:

id

Display the current user identity:

id {{[-un|--user --name]}}

Display the current user identity as a number:

id {{[-u|--user]}}

Display the current primary group identity:

id {{[-gn|--group --name]}}

Display the current primary group identity as a number:

id {{[-g|--group]}}

Display all groups the current user belongs to:

id {{[-Gn|--groups --name]}}

Display an arbitrary user’s ID (UID), group ID (GID), and groups to which they belong:

id {{username}}

Skip name lookup and specify the UID number explicitly:

id +{{uid_number}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

install

install [OPTION]... [FICHIER]...

Copier SOURCE vers DEST ou plusieurs SOURCE(s) vers le RÉPERTOIRE existant, tout en définissant les modes de permission et propriétaire/groupe

Options

--backup=<CONTROL>

make a backup of each existing destination file

-b

like –backup but does not accept an argument

-c

ignoré

--compare, -C

comparer chaque paire de fichiers source et destination, et dans certains cas, ne pas modifier la destination du tout

--directory, -d

traiter tous les arguments comme des noms de répertoires. créer tous les composants des répertoires spécifiés

-D

créer tous les composants principaux de DEST sauf le dernier, puis copier SOURCE vers DEST

--group=<GROUP>, -g <GROUP>

définir la propriété du groupe, au lieu du groupe actuel du processus

--mode=<MODE>, -m <MODE>

définir le mode de permission (comme dans chmod), au lieu de rwxr-xr-x

--owner=<OWNER>, -o <OWNER>

définir la propriété (super-utilisateur uniquement)

--preserve-timestamps, -p

appliquer les temps d’accès/modification des fichiers SOURCE aux fichiers de destination correspondants

--strip, -s

supprimer les tables de symboles (aucune action Windows)

--strip-program=<PROGRAM>

programme utilisé pour supprimer les binaires (aucune action Windows)

--suffix=<SUFFIX>, -S <SUFFIX>

override the usual backup suffix

--target-directory=<DIRECTORY>, -t <DIRECTORY>

déplacer tous les arguments SOURCE dans RÉPERTOIRE

--no-target-directory, -T

traiter DEST comme un fichier normal

--verbose, -v

expliquer ce qui est fait

--preserve-context, -P

préserver le contexte de sécurité

-Z

définir le contexte de sécurité SELinux du fichier de destination et de chaque répertoire créé au type par défaut

--context=<CONTEXT>

définir le contexte de sécurité des fichiers et répertoires

--unprivileged, -U

do not require elevated privileges to change the owner, the group, or the file flags of the destination

Examples

Copie des fichiers vers une destination :

install {{chemin/fichier/source}} {{chemin/repertoire/destination}}

Copie des fichiers vers une destination en mettant à jour leur propriétaire :

install --owner {{utilisateur}} {{chemin/fichier/source}} {{chemin/repertoire/destination}}

Copie des fichiers vers une destination en mettant à jour leur groupe d’appartenance :

install --group {{utilisateur}} {{chemin/fichier/source}} {{chemin/repertoire/destination}}

Copie des fichiers vers une destination en mettant à jour leur mode :

install --mode {{+x}} {{chemin/fichier/source}} {{chemin/repertoire/destination}}

Copie des fichiers en mettant à jour leur dates d’accès et de modification à partir de leurs sources respectives :

install --preserve-timestamps {{chemin/fichier/source}} {{chemin/repertoire/destination}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

join

join [OPTION]... FICHIER1 FICHIER2

Pour chaque paire de lignes d’entrée avec des champs de jointure identiques, écrire une ligne sur la sortie standard. Le champ de jointure par défaut est le premier, délimité par des espaces.

Quand FILE1 ou FILE2 (mais pas les deux) est -, lire l’entrée standard.

Options

-a <FILENUM>

afficher aussi les lignes non appariables du fichier NUMÉRO_FICHIER, où
NUMÉRO_FICHIER est 1 ou 2, correspondant à FICHIER1 ou FICHIER2

-v <FILENUM>

comme -a NUMÉRO_FICHIER, mais supprimer les lignes de sortie jointes

-e <EMPTY>

remplacer les champs d’entrée manquants par VIDE

--ignore-case, -i

ignorer les différences de casse lors de la comparaison des champs

-j <FIELD>

équivalent à ‘-1 CHAMP -2 CHAMP’

-o <FORMAT>

obéir au FORMAT lors de la construction de la ligne de sortie

-t <CHAR>

utiliser CHAR comme séparateur de champ d’entrée et de sortie

-1 <FIELD>

joindre sur ce CHAMP du fichier 1

-2 <FIELD>

joindre sur ce CHAMP du fichier 2

--check-order

vérifier que l’entrée est correctement triée, même si toutes les lignes d’entrée sont appariables

--nocheck-order

ne pas vérifier que l’entrée est correctement triée

--header

traiter la première ligne de chaque fichier comme des en-têtes de champs, les imprimer sans essayer de les apparier

--zero-terminated, -z

le délimiteur de ligne est NUL, pas de nouvelle ligne

Examples

Join two files on the first (default) field:

join {{path/to/file1}} {{path/to/file2}}

Join two files using a comma (instead of a space) as the field separator:

join -t ',' {{path/to/file1}} {{path/to/file2}}

Join field3 of file1 with field1 of file2:

join -1 {{3}} -2 {{1}} {{path/to/file1}} {{path/to/file2}}

Produce a line for each unpairable line for file1:

join -a {{1}} {{path/to/file1}} {{path/to/file2}}

Join a file from stdin:

cat {{path/to/file1}} | join - {{path/to/file2}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

kill

kill [OPTIONS]... PID...

Envoyer un signal aux processus ou lister les informations sur les signaux.

Options

--list, -l

Liste les signaux

--table, -t

Liste le tableau des signaux

--signal=<signal>, -s <signal>

Envoie le signal donné au lieu de SIGTERM

Examples

Termine un processus avec le signal SIGTERM (terminaison) par défaut :

kill {{identifiant_processus}}

Liste les noms des signaux disponibles (à utiliser sans leurs préfixes SIG) :

kill -l

Termine un processus avec le signal SIGHUP (“raccrocher”). Beaucoup de daemons se rafraîchissent au lieu de terminer :

kill -{{1|HUP}} {{identifiant_processus}}

Termine un processus avec le signal SIGINT (“interruption”). Généralement initié par l’utilisateur appuyant sur <Ctrl c> :

kill -{{2|INT}} {{identifiant_processus}}

Demande au système d’exploitation de mettre fin à un processus immédiatement (sans possibilité d’intercepter le signal) :

kill -{{9|KILL}} {{identifiant_processus}}

Demande au système d’exploitation de suspendre un processus jusqu’à recevoir le signal SIGCONT (“continue”) :

kill -{{17|STOP}} {{identifiant_processus}}

Envoie le signal SIGUSR1 à tous les processus dans le groupe avec l’identifiant indiqué :

kill -{{SIGUSR1}} -{{identifiant_groupe}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

link

link FILE1 FILE2

Appelle la fonction link pour créer un lien nommé FILE2 vers un FILE1 existant.

Options

Examples

Create a hard link from a new file to an existing file:

link {{path/to/existing_file}} {{path/to/new_file}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

ln

ln [OPTION]... [-T] CIBLE NOM_LIEN
ln [OPTION]... CIBLE
ln [OPTION]... CIBLE... RÉPERTOIRE
ln [OPTION]... -t RÉPERTOIRE CIBLE...

Créer des liens entre fichiers.

Options

--backup=<CONTROL>

make a backup of each existing destination file

-b

like –backup but does not accept an argument

--force, -f

supprimer les fichiers de destination existants

--interactive, -i

demander avant de supprimer les fichiers de destination existants

--no-dereference, -n

traiter NOM_LIEN comme un fichier normal s’il s’agit d’un
lien symbolique vers un répertoire

--logical, -L

suivre les CIBLEs qui sont des liens symboliques

--physical, -P

créer des liens physiques directement vers les liens symboliques

--symbolic, -s

créer des liens symboliques au lieu de liens physiques

--suffix=<SUFFIX>, -S <SUFFIX>

override the usual backup suffix

--target-directory=<DIRECTORY>, -t <DIRECTORY>

spécifier le RÉPERTOIRE dans lequel créer les liens

--no-target-directory, -T

toujours traiter NOM_LIEN comme un fichier normal

--relative, -r

créer des liens symboliques relatifs à l’emplacement du lien

--verbose, -v

afficher le nom de chaque fichier lié

Dans la 1ère forme, créer un lien vers CIBLE avec le nom NOM_LIEN. Dans la 2ème forme, créer un lien vers CIBLE dans le répertoire courant. Dans les 3ème et 4ème formes, créer des liens vers chaque CIBLE dans RÉPERTOIRE. Créer des liens physiques par défaut, des liens symboliques avec –symbolic. Par défaut, chaque destination (nom du nouveau lien) ne doit pas déjà exister. Lors de la création de liens physiques, chaque CIBLE doit exister. Les liens symboliques peuvent contenir du texte arbitraire ; s’ils sont résolus plus tard, un lien relatif est interprété en relation avec son répertoire parent.

Examples

Crée un lien symbolique vers un fichier ou un répertoire :

ln {{[-s|--symbolic]}} {{/chemin/vers/fichier_ou_repertoire}} {{chemin/vers/lien_symbolique}}

Modifie la cible d’un lien symbolique existant :

ln {{[-sf|--symbolic --force]}} {{/chemin/vers/nouveau_fichier}} {{chemin/vers/lien_symbolique}}

Crée un lien dur vers un fichier :

ln {{/chemin/vers/fichier}} {{chemin/vers/lien_dur}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

logname

logname

Afficher le nom de connexion de l’utilisateur

Options

Examples

Display the currently logged in user’s name:

logname

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

ls

ls [OPTION]... [FICHIER]...

Lister le contenu des répertoires. Ignorer les fichiers et répertoires commençant par un ‘.’ par défaut

Options

--help

Afficher les informations d’aide.

--format

Définir le format d’affichage.

-C

Afficher les fichiers en colonnes.

--long, -l

Afficher des informations détaillées.

-x

Lister les entrées en lignes au lieu de colonnes.

--tabsize=<COLS>, -T <COLS>

Supposer des arrêts de tabulation à chaque COLS au lieu de 8

-m

Lister les entrées séparées par des virgules.

--zero

Lister les entrées séparées par des caractères NUL ASCII.

--dired, -D

générer une sortie conçue pour le mode dired (Directory Editor) d’Emacs

--hyperlink=<WHEN>

créer des hyperliens pour les noms de fichiers QUAND

-1

Lister un fichier par ligne.

-o

Format long sans informations de groupe.
Identique à –format=long avec –no-group.

-g

Format long sans informations de propriétaire.

--numeric-uid-gid, -n

-l avec des UID et GID numériques.

--quoting-style

Définir le style de citation.

--literal, -N

Utiliser le style de citation littéral. Équivalent à --quoting-style=literal

--escape, -b

Utiliser le style de citation d’échappement. Équivalent à --quoting-style=escape

--quote-name, -Q

Utiliser le style de citation C. Équivalent à --quoting-style=c

--hide-control-chars, -q

Remplacer les caractères de contrôle par ‘?’ s’ils ne sont pas échappés.

--show-control-chars

Afficher les caractères de contrôle ‘tels quels’ s’ils ne sont pas échappés.

--time=<field>

Afficher l’heure dans :
heure d’accès (-u) : atime, access, use ;
heure de changement (-t) : ctime, status.
heure de modification : mtime, modification.
heure de création : birth, creation ;

-c

Si le format de liste long (par ex., -l, -o) est utilisé, afficher
l’heure de changement de statut (le ‘ctime’ dans l’inode) au lieu de l’heure
de modification. Lors du tri explicite par heure (–sort=time ou -t) ou lors
de l’absence de format de liste long, trier selon l’heure de changement de statut.

-u

Si le format de liste long (par ex., -l, -o) est utilisé, afficher
l’heure d’accès au statut au lieu de l’heure de modification. Lors du tri
explicite par heure (–sort=time ou -t) ou lors de l’absence de format de
liste long, trier selon l’heure d’accès.

--hide=<PATTERN>

ne pas lister les entrées implicites correspondant au MOTIF shell (surchargé par -a ou -A)

--ignore=<PATTERN>, -I <PATTERN>

ne pas lister les entrées implicites correspondant au MOTIF shell

--ignore-backups, -B

Ignorer les entrées qui se terminent par ~.

--sort=<field>

Trier par : name, none (-U), time (-t), size (-S), extension (-X) ou width

-S

Trier par taille de fichier, le plus grand en premier.

-t

Trier par heure de modification (le ‘mtime’ dans l’inode), le plus récent en premier.

-v

Tri naturel des numéros (de version) dans les noms de fichiers.

-X

Trier alphabétiquement par extension d’entrée.

-U

Ne pas trier ; lister les fichiers dans l’ordre où ils sont stockés dans le
répertoire. Ceci est particulièrement utile lors de l’affichage de très grands répertoires,
car ne pas trier peut être sensiblement plus rapide.

--dereference, -L

Lors de l’affichage d’informations de fichier pour un lien symbolique, afficher les informations pour le
fichier référencé par le lien plutôt que le lien lui-même.

--dereference-command-line-symlink-to-dir

Ne pas suivre les liens symboliques sauf quand ils pointent vers des répertoires et sont
donnés comme arguments de ligne de commande.

--dereference-command-line, -H

Ne pas suivre les liens symboliques sauf quand ils sont donnés comme arguments de ligne de commande.

--no-group, -G

Ne pas afficher le groupe en format long.

--author

Afficher l’auteur en format long. Sur les plateformes supportées,
l’auteur correspond toujours au propriétaire du fichier.

--all, -a

Ne pas ignorer les fichiers cachés (fichiers dont les noms commencent par ‘.’).

--almost-all, -A

Dans un répertoire, ne pas ignorer tous les noms de fichiers qui commencent par ‘.’,
ignorer seulement ‘.’ et ‘..’.

-f

Liste tous les fichiers dans l’ordre du répertoire, non triés. Équivalent à -aU. Désactive –color sauf si spécifié explicitement.

--directory, -d

Lister seulement les noms des répertoires, plutôt que le contenu des répertoires.
Ceci ne suivra pas les liens symboliques à moins qu’une des options
--dereference-command-line (-H), --dereference (-L), ou
--dereference-command-line-symlink-to-dir soit spécifiée.

--human-readable, -h

Afficher les tailles de fichiers lisibles par l’homme (par ex. 1K 234M 56G).

--kibibytes, -k

par défaut aux blocs de 1024 octets pour l’utilisation du système de fichiers ; utilisé seulement avec -s et par
totaux de répertoire

--si

Afficher les tailles de fichiers lisibles par l’homme utilisant des puissances de 1000 au lieu de 1024.

--block-size=<BLOCK_SIZE>

dimensionner les tailles par BLOCK_SIZE lors de l’affichage

--inode, -i

afficher le numéro d’index de chaque fichier

--reverse, -r

Inverser quelle que soit la méthode de tri, par ex., lister les fichiers en ordre
alphabétique inverse, le plus jeune en premier, le plus petit en premier, ou autre.

--recursive, -R

Lister le contenu de tous les répertoires récursivement.

--width=<COLS>, -w <COLS>

Supposer que le terminal a COLS colonnes de largeur.

--size, -s

afficher la taille allouée de chaque fichier, en blocs

--color

Colorier la sortie basée sur le type de fichier.

--indicator-style

Ajouter un indicateur avec le style WORD aux noms d’entrée :
none (par défaut), slash (-p), file-type (–file-type), classify (-F)

--classify=<when>, -F <when>

Ajouter un caractère à chaque nom de fichier indiquant le type de fichier. Aussi, pour
les fichiers réguliers qui sont exécutables, ajouter ‘*’. Les indicateurs de type de fichier sont
‘/’ pour les répertoires, ‘@’ pour les liens symboliques, ‘|’ pour les FIFOs, ‘=’ pour les sockets,
‘>’ pour les portes, et rien pour les fichiers réguliers. when peut être omis, ou un de :
none - Ne pas classifier. C’est la valeur par défaut.
auto - Classifier seulement si la sortie standard est un terminal.
always - Toujours classifier.
Spécifier –classify et aucun when est équivalent à –classify=always. Ceci ne
suivra pas les liens symboliques listés sur la ligne de commande à moins que les
options –dereference-command-line (-H), –dereference (-L), ou
–dereference-command-line-symlink-to-dir soient spécifiées.

--file-type

Identique à –classify, mais ne pas ajouter ‘*’

-p

Ajouter l’indicateur / aux répertoires.

--time-style=<TIME_STYLE>

format de date/heure avec -l ; voir TIME_STYLE ci-dessous

--full-time

comme -l –time-style=full-iso

--context, -Z

afficher tout contexte de sécurité de chaque fichier

--group-directories-first

grouper les répertoires avant les fichiers ; peut être augmenté avec
une option –sort, mais toute utilisation de –sort=none (-U) désactive le groupement

L’argument TIME_STYLE peut être full-iso, long-iso, iso, locale ou +FORMAT. FORMAT est interprété comme dans date. De plus, la variable d’environnement TIME_STYLE définit le style par défaut à utiliser.

Examples

Liste les fichiers, un par ligne :

ls -1

Liste tous les fichiers, ainsi que les fichiers cachés :

ls {{[-a|--all]}}

Liste tous les fichiers, avec les noms de répertoires suivis d’un / :

ls {{[-F|--classify]}}

Liste tous les fichiers avec un format détaillé (permissions, propriétaire, taille et date de modification) :

ls {{[-la|-l --all]}}

Liste les fichiers avec un format détaillé en utilisant des préfixes d’unités (KiB, MiB, GiB) :

ls {{[-lh|-l --human-readable]}}

Liste les fichiers avec un format détaillé en triant par taille décroissante :

ls {{[-lSR|-lS --recursive]}}

Liste avec un format détaillé tous les fichiers en triant par date de modification (les plus anciennes en premier) :

ls {{[-ltr|-lt --reverse]}}

Liste uniquement les répertoires :

ls {{[-d|--directory]}} */

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

md5sum

md5sum [OPTION]... [FICHIER]...

Afficher le MD5 et la taille de chaque fichier

Options

--binary, -b

--check, -c

ck-common-help-check

--warn, -w

ck-common-help-warn

--status

ck-common-help-status

--quiet

ck-common-help-quiet

--ignore-missing

ck-common-help-ignore-missing

--strict

ck-common-help-strict

--tag

ck-common-help-tag

--text, -t

ck-common-help-text

--zero, -z

ck-common-help-zero

Examples

Calculate the MD5 checksum for one or more files:

md5sum {{path/to/file1 path/to/file2 ...}}

Calculate and save the list of MD5 checksums to a file:

md5sum {{path/to/file1 path/to/file2 ...}} > {{path/to/file.md5}}

Calculate an MD5 checksum from stdin:

{{command}} | md5sum

Read a file of MD5 checksums and filenames and verify all files have matching checksums:

md5sum {{[-c|--check]}} {{path/to/file.md5}}

Only show a message for missing files or when verification fails:

md5sum {{[-c|--check]}} --quiet {{path/to/file.md5}}

Only show a message when verification fails, ignoring missing files:

md5sum --ignore-missing {{[-c|--check]}} --quiet {{path/to/file.md5}}

Check a known MD5 checksum of a file:

echo {{known_md5_checksum_of_the_file}} {{path/to/file}} | md5sum {{[-c|--check]}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

mkdir

mkdir [OPTION]... RÉPERTOIRE...

Créer les RÉPERTOIRE(s) donnés s’ils n’existent pas

Options

--mode, -m

définir le mode de fichier (non implémenté sur Windows)

--parents, -p

créer les répertoires parents si nécessaire

--verbose, -v

afficher un message pour chaque répertoire créé

-Z

définir le contexte de sécurité SELinux de chaque répertoire créé au type par défaut

--context=<CTX>

comme -Z, ou si CTX est spécifié, définir le contexte de sécurité SELinux ou SMACK à CTX

Chaque MODE est de la forme [ugoa]*(-+=)+|[-+=]?[0-7]+.

Examples

Crée plusieurs répertoires dans le répertoire actuel :

mkdir {{répertoire_1 répertoire_2 ...}}

Crée des répertoires récursivement (utile pour créer des répertoires imbriqués) :

mkdir {{[-p|--parents]}} {{chemin/vers/répertoire}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

mkfifo

mkfifo [OPTION]... NOM...

Créer un FIFO avec le nom donné.

Options

--mode=<MODE>, -m <MODE>

permissions de fichier pour le fifo

-Z

définir le contexte de sécurité SELinux au type par défaut

--context=<CTX>

comme -Z, ou si CTX est spécifié, définir le contexte de sécurité SELinux ou SMACK à CTX

Examples

Create a named pipe at a given path:

mkfifo {{path/to/pipe}}

Send data through a named pipe and send the command to the background:

echo "{{Hello World}}" > {{path/to/pipe}} &

Receive data through a named pipe:

cat {{path/to/pipe}}

Share your terminal session in real-time:

mkfifo {{path/to/pipe}}; script {{[-f|--flush]}} {{path/to/pipe}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

mknod

mknod [OPTION]... NOM TYPE [MAJEUR MINEUR]

Créer le fichier spécial NOM du TYPE donné.

Options

--mode=<MODE>, -m <MODE>

définir les bits de permission de fichier à MODE, pas a=rw - umask

nom du nouveau fichier

type du nouveau fichier (b, c, u ou p)

type de fichier majeur

type de fichier mineur

-Z

définir le contexte de sécurité SELinux de chaque répertoire créé au type par défaut

--context=<CTX>

comme -Z, ou si CTX est spécifié, définir le contexte de sécurité SELinux ou SMACK à CTX

Les arguments obligatoires pour les options longues le sont aussi pour les options courtes. -m, –mode=MODE définir les bits de permission de fichier à MODE, pas a=rw - umask

MAJEUR et MINEUR doivent tous deux être spécifiés quand TYPE est b, c, ou u, et ils doivent être omis quand TYPE est p. Si MAJEUR ou MINEUR commence par 0x ou 0X, il est interprété comme hexadécimal ; sinon, s’il commence par 0, comme octal ; sinon, comme décimal. TYPE peut être :

• b créer un fichier spécial bloc (mis en mémoire tampon)
• c, u créer un fichier spécial caractère (non mis en mémoire tampon)
• p créer un FIFO

NOTE : votre shell peut avoir sa propre version de mknod, qui remplace généralement la version décrite ici. Veuillez vous référer à la documentation de votre shell pour les détails sur les options qu’il supporte.

Examples

Create a block device:

sudo mknod {{path/to/device_file}} b {{major_device_number}} {{minor_device_number}}

Create a character device:

sudo mknod {{path/to/device_file}} c {{major_device_number}} {{minor_device_number}}

Create a FIFO (queue) device:

sudo mknod {{path/to/device_file}} p

Create a device file with default SELinux security context:

sudo mknod {{[-Z|--context]}} {{path/to/device_file}} {{type}} {{major_device_number}} {{minor_device_number}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

mktemp

mktemp [OPTION]... [MODÈLE]

Créer un fichier ou répertoire temporaire.

Options

--directory, -d

Créer un répertoire au lieu d’un fichier

--dry-run, -u

ne rien créer ; afficher seulement un nom (dangereux)

--quiet, -q

Échouer silencieusement si une erreur se produit.

--suffix=<SUFFIX>

ajouter SUFFIXE au MODÈLE ; SUFFIXE ne doit pas contenir un séparateur de chemin. Cette option est implicite si MODÈLE ne se termine pas par X.

-p <DIR>

forme courte de –tmpdir

--tmpdir=<DIR>

interpréter MODÈLE relativement à RÉP ; si RÉP n’est pas spécifié, utiliser $TMPDIR ($TMP sur windows) si défini, sinon /tmp. Avec cette option, MODÈLE ne doit pas être un nom absolu ; contrairement à -t, MODÈLE peut contenir des barres obliques, mais mktemp ne crée que le composant final

-t

Générer un modèle (en utilisant le préfixe fourni et TMPDIR (TMP sur windows) si défini) pour créer un modèle de nom de fichier [obsolète]

Examples

Crée un fichier temporaire vide et affiche son chemin d’accès absolu :

mktemp

Utilise un répertoire personnalisé si $TMPDIR n’est pas défini (la valeur par défaut dépend de la plateforme, mais est habituellement /tmp) :

mktemp -p {{/chemin/vers/reptemp}}

Utilise un modèle de chemin personnalisé (les X sont remplacés par des caractères alphanumériques aléatoires) :

mktemp {{/tmp/exemple.XXXXXXXX}}

Utilise un modèle de nom de fichier personnalisé :

mktemp -t {{exemple.XXXXXXXX}}

Crée un répertoire temporaire vide et affiche son chemin d’accès absolu :

mktemp -d

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

more

more [OPTIONS] FICHIER...

Afficher le contenu d’un fichier texte

Options

--silent, -d

Afficher l’aide au lieu de sonner la cloche lorsqu’une touche illégale est pressée

--logical, -l

Ne pas faire de pause après une ligne contenant un ^L (saut de page)

--exit-on-eof, -e

Quitter à la fin du fichier

--no-pause, -f

Compter les lignes logiques plutôt que les lignes d’écran

--print-over, -p

Ne pas défiler, effacer l’écran et afficher le texte

--clean-print, -c

Ne pas défiler, afficher le texte et nettoyer les fins de ligne

--squeeze, -s

Compresser plusieurs lignes vides en une seule

--plain, -u

Supprimer le soulignement

--lines=<number>, -n <number>

Le nombre de lignes par écran complet

--number

Identique à l’argument de l’option –lines

--from-line=<number>, -F <number>

Commencer l’affichage de chaque fichier au numéro de ligne

--pattern=<pattern>, -P <pattern>

La chaîne à rechercher dans chaque fichier avant de commencer à l’afficher

Chemin vers les fichiers à lire

Examples

Open a file:

more {{path/to/file}}

Display a specific line:

more +{{line_number}} {{path/to/file}}

Go to the next page:

<Space>

Search for a string (press <n> to go to the next match):

</>{{something}}<Enter>

Exit:

<q>

Display help about interactive commands:

<h>

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

mv

mv [OPTION]... [-T] SOURCE DEST
mv [OPTION]... SOURCE... RÉPERTOIRE
mv [OPTION]... -t RÉPERTOIRE SOURCE...

Déplacer SOURCE vers DEST, ou plusieurs SOURCE(s) vers RÉPERTOIRE.

Options

--force, -f

ne pas demander avant d’écraser

--interactive, -i

demander avant d’écraser

--no-clobber, -n

ne pas écraser un fichier existant

--strip-trailing-slashes

supprimer toutes les barres obliques de fin de chaque argument SOURCE

--backup=<CONTROL>

make a backup of each existing destination file

-b

like –backup but does not accept an argument

--suffix=<SUFFIX>, -S <SUFFIX>

override the usual backup suffix

--update

move only when the SOURCE file is newer than the destination file or when the destination file is missing

-u

like –update but does not accept an argument

--target-directory=<DIRECTORY>, -t <DIRECTORY>

déplacer tous les arguments SOURCE dans RÉPERTOIRE

--no-target-directory, -T

traiter DEST comme un fichier normal

--verbose, -v

expliquer ce qui est fait

--progress, -g

Afficher une barre de progression.
Note : cette fonctionnalité n’est pas supportée par GNU coreutils.

-Z

défini le contexte de sécurité SELinux du fichier de destination au type par défaut

--context=<CTX>

comme -Z, sauf si CTX est spécifié auquel cas le contexte de sécurité SELinux est défini sur CTX

--debug

expliquer comment un fichier est copié. Implique -v

Lors de la spécification de plus d’une option parmi -i, -f, -n, seule la dernière prend effet.

Ne pas déplacer un non-répertoire qui a une destination existante avec un horodatage de modification identique ou plus récent ; au lieu de cela, ignorer silencieusement le fichier sans échouer. Si le déplacement traverse les limites du système de fichiers, la comparaison est avec l’horodatage source tronqué aux résolutions du système de fichiers de destination et des appels système utilisés pour mettre à jour les horodatages ; cela évite le travail en double si plusieurs commandes mv -u sont exécutées avec la même source et destination. Cette option est ignorée si l’option -n ou –no-clobber est également spécifiée, qui donne plus de contrôle sur quels fichiers existants dans la destination sont remplacés, et sa valeur peut être une des suivantes :

• all C’est l’opération par défaut quand une option –update n’est pas spécifiée, et résulte en tous les fichiers existants dans la destination étant remplacés.
• none C’est similaire à l’option –no-clobber, en ce que aucun fichier dans la destination n’est remplacé, mais aussi ignorer un fichier n’induit pas un échec.
• older C’est l’opération par défaut quand –update est spécifié, et résulte en des fichiers étant remplacés s’ils sont plus anciens que le fichier source correspondant.

Examples

Rename a file or directory when the target is not an existing directory:

mv {{path/to/source}} {{path/to/target}}

Move a file or directory into an existing directory:

mv {{path/to/source}} {{path/to/existing_directory}}

Move multiple files into an existing directory, keeping the filenames unchanged:

mv {{path/to/source1 path/to/source2 ...}} {{path/to/existing_directory}}

Do not prompt for confirmation before overwriting existing files:

mv {{[-f|--force]}} {{path/to/source}} {{path/to/target}}

Prompt for confirmation interactively before overwriting existing files, regardless of file permissions:

mv {{[-i|--interactive]}} {{path/to/source}} {{path/to/target}}

Do not overwrite existing files at the target:

mv {{[-n|--no-clobber]}} {{path/to/source}} {{path/to/target}}

Move files in verbose mode, showing files after they are moved:

mv {{[-v|--verbose]}} {{path/to/source}} {{path/to/target}}

Specify target directory so that you can use external tools to gather movable files:

{{find /var/log -type f -name '*.log' -print0}} | {{xargs -0}} mv {{[-t|--target-directory]}} {{path/to/target_directory}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

nice

nice [OPTION] [COMMANDE [ARG]...]

Exécute COMMANDE avec une priorité ajustée, ce qui affecte l’ordonnancement des processus. Sans COMMANDE, affiche la priorité actuelle. Les valeurs de priorité vont de -20 (plus favorable au processus) à 19 (moins favorable au processus).

Options

--adjustment, -n

ajoute N à la priorité (par défaut 10)

Examples

Print the current niceness value:

nice

Increment the current niceness value by 10:

nice nice

Launch a program with lowered priority:

nice -{{niceness_value}} {{command}}

Launch a program with heightened priority:

sudo nice --{{niceness_value}} {{command}}

Define the priority with an explicit option:

nice {{[-n|--adjustment]}} {{niceness_value}} {{command}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

nl

nl [OPTION]... [FICHIER]...

Numéroter les lignes des fichiers

Options

--help

Afficher les informations d’aide.

--body-numbering=<STYLE>, -b <STYLE>

utiliser STYLE pour numéroter les lignes du corps

--section-delimiter=<CC>, -d <CC>

utiliser CC pour séparer les pages logiques

--footer-numbering=<STYLE>, -f <STYLE>

utiliser STYLE pour numéroter les lignes de pied de page

--header-numbering=<STYLE>, -h <STYLE>

utiliser STYLE pour numéroter les lignes d’en-tête

--line-increment=<NUMBER>, -i <NUMBER>

incrément du numéro de ligne à chaque ligne

--join-blank-lines=<NUMBER>, -l <NUMBER>

groupe de NUMBER lignes vides comptées comme une seule

--number-format=<FORMAT>, -n <FORMAT>

insérer les numéros de ligne selon FORMAT

--no-renumber, -p

ne pas remettre à zéro les numéros de ligne aux pages logiques

--number-separator=<STRING>, -s <STRING>

ajouter STRING après le numéro de ligne (éventuel)

--starting-line-number=<NUMBER>, -v <NUMBER>

premier numéro de ligne sur chaque page logique

--number-width=<NUMBER>, -w <NUMBER>

utiliser NUMBER colonnes pour les numéros de ligne

STYLE est l’un des suivants :

• a numéroter toutes les lignes
• t numéroter seulement les lignes non vides
• n ne numéroter aucune ligne
• pBRE numéroter seulement les lignes qui contiennent une correspondance pour l’expression régulière de base, BRE

FORMAT est l’un des suivants :

• ln justifié à gauche, sans zéros en tête
• rn justifié à droite, sans zéros en tête
• rz justifié à droite, avec zéros en tête

Examples

Number non-blank lines in a file:

nl {{path/to/file}}

Read from stdin:

{{command}} | nl -

Number [a]ll [b]ody lines including blank lines or do [n]ot number [b]ody lines:

nl -b {{a|n}} {{path/to/file}}

Number only the [b]ody lines that match a basic regex (BRE) [p]attern:

nl -b p'FooBar[0-9]' {{path/to/file}}

Use a specific [i]ncrement for line numbering:

nl -i {{increment}} {{path/to/file}}

Specify the line numbering format to [r]ight or [l]eft justified, keeping leading [z]eros or [n]ot:

nl -n {{rz|ln|rn}}

Specify the line numbering’s [w]idth (6 by default):

nl -w {{col_width}} {{path/to/file}}

Use a specific string to [s]eparate the line numbers from the lines (TAB by default):

nl -s {{separator}} {{path/to/file}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

nohup

nohup COMMANDE [ARG]...
nohup OPTION

Exécuter COMMANDE en ignorant les signaux de raccrochage.

Options

Si l’entrée standard est un terminal, elle sera remplacée par /dev/null. Si la sortie standard est un terminal, elle sera ajoutée à nohup.out à la place, ou $HOME/nohup.out, si l’ouverture de nohup.out a échoué. Si l’erreur standard est un terminal, elle sera redirigée vers la sortie standard.

Examples

Run a process that can live beyond the terminal:

nohup {{command}} {{argument1 argument2 ...}}

Launch nohup in background mode:

nohup {{command}} {{argument1 argument2 ...}} &

Run a shell script that can live beyond the terminal:

nohup {{path/to/script.sh}} &

Run a process and write the output to a specific file:

nohup {{command}} {{argument1 argument2 ...}} > {{path/to/output_file}} &

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

nproc

nproc [OPTIONS]...

Affiche le nombre de cœurs disponibles pour le processus actuel. Si les variables d’environnement OMP_NUM_THREADS ou OMP_THREAD_LIMIT sont définies, elles détermineront respectivement la valeur minimale et maximale retournée.

Options

--all

affiche le nombre de cœurs disponibles pour le système

--ignore=<N>

ignore jusqu’à N cœurs

Examples

Display the number of available processing units:

nproc

Display the number of installed processing units, including any inactive ones:

nproc --all

If possible, subtract a given number of units from the returned value:

nproc --ignore {{count}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

numfmt

numfmt [OPTION]... [NOMBRE]...

Convertir les nombres vers/depuis des chaînes lisibles par l’homme

Options

--debug

print warnings about invalid input

--delimiter=<X>, -d <X>

utiliser X au lieu d’espaces pour le délimiteur de champ

--field=<FIELDS>

remplacer les nombres dans ces champs d’entrée ; voir FIELDS ci-dessous

--format=<FORMAT>

utiliser le FORMAT à virgule flottante de style printf ; voir FORMAT ci-dessous pour les détails

--from=<UNIT>

mettre automatiquement à l’échelle les nombres d’entrée vers les UNITÉs ; voir UNIT ci-dessous

--from-unit=<N>

spécifier la taille de l’unité d’entrée

--to=<UNIT>

mettre automatiquement à l’échelle les nombres de sortie vers les UNITÉs ; voir UNIT ci-dessous

--to-unit=<N>

la taille de l’unité de sortie

--padding=<N>

remplir la sortie à N caractères ; N positif alignera à droite ; N négatif alignera à gauche ; le remplissage est ignoré si la sortie est plus large que N ; la valeur par défaut est de remplir automatiquement si un espace est trouvé

--header=<N>

imprimer (sans convertir) les N premières lignes d’en-tête ; N vaut 1 par défaut si non spécifié

--round=<METHOD>

utiliser METHOD pour l’arrondi lors de la mise à l’échelle

--suffix=<SUFFIX>

imprimer SUFFIX après chaque nombre formaté, et accepter les entrées se terminant optionnellement par SUFFIX

--unit-separator=<STRING>

use STRING to separate the number from any unit when printing; by default, no separator is used

--invalid=<INVALID>

définir le mode d’échec pour les entrées invalides

--zero-terminated, -z

le délimiteur de ligne est NUL, pas retour à la ligne

Options d’UNITÉ :

• none : aucune mise à l’échelle automatique n’est effectuée ; les suffixes déclencheront une erreur

• auto : accepter un suffixe optionnel d’une/deux lettres :

  1K = 1000, 1Ki = 1024, 1M = 1000000, 1Mi = 1048576,

• si : accepter un suffixe optionnel d’une lettre :

  1K = 1000, 1M = 1000000, …

• iec : accepter un suffixe optionnel d’une lettre :

  1K = 1024, 1M = 1048576, …

• iec-i : accepter un suffixe optionnel de deux lettres :

  1Ki = 1024, 1Mi = 1048576, …

• FIELDS supporte les plages de champs de style cut(1) :

  N N-ième champ, compté à partir de 1 N- du N-ième champ jusqu’à la fin de la ligne N-M du N-ième au M-ième champ (inclus) -M du premier au M-ième champ (inclus)

  • tous les champs

Plusieurs champs/plages peuvent être séparés par des virgules

FORMAT doit être adapté pour imprimer un argument à virgule flottante %f. Une guillemet optionnelle (%’f) activera –grouping (si supporté par la locale actuelle). Une valeur de largeur optionnelle (%10f) remplira la sortie. Un zéro optionnel (%010f) remplira le nombre de zéros. Des valeurs négatives optionnelles (%-10f) aligneront à gauche. Une précision optionnelle (%.1f) remplacera la précision déterminée par l’entrée.

Examples

Convert 1.5K (SI Units) to 1500:

numfmt --from si 1.5K

Convert 1500 to 1.5K (SI Units):

numfmt --to si 1500

Convert 1.5K (IEC Units) to 1536:

numfmt --from iec 1.5K

Use appropriate conversion based on the suffix:

numfmt --from auto {{1.5Ki}}

Convert 5th field (1-indexed) to IEC Units without converting header:

ls -l | numfmt --header=1 --field 5 --to iec

Convert to IEC units, pad with 5 characters, left aligned:

du {{[-s|--summarize]}} * | numfmt --to iec --format "%-5f"

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

od

od [OPTION]... [--] [NOMFICHIER]...
od [-abcdDefFhHiIlLoOsxX] [NOMFICHIER] [[+][0x]DÉCALAGE[.][b]]
od --traditional [OPTION]... [NOMFICHIER] [[+][0x]DÉCALAGE[.][b] [[+][0x]ÉTIQUETTE[.][b]]]

Afficher les fichiers en format octal et autres formats

Options

--help

Afficher les informations d’aide.

--address-radix=<RADIX>, -A <RADIX>

Sélectionner la base dans laquelle les décalages de fichier sont imprimés.

--skip-bytes=<BYTES>, -j <BYTES>

Ignorer les octets d’entrée avant le formatage et l’écriture.

--read-bytes=<BYTES>, -N <BYTES>

limiter le dump à OCTETS octets d’entrée

--endian=<big|little>

ordre des octets à utiliser pour les formats multi-octets

--strings=<BYTES>, -S <BYTES>

afficher les chaînes d’au moins OCTETS caractères graphiques. 3 est supposé quand OCTETS n’est pas spécifié.

-a

caractères nommés, ignorant le bit d’ordre supérieur

-b

octets octaux

-c

caractères ASCII ou échappements antislash

-d

unités décimales non signées 2-octets

-D

unités décimales non signées 4-octets

-o

unités octales 2-octets

-I

unités décimales 8-octets

-L

unités décimales 8-octets

-i

unités décimales 4-octets

-l

unités décimales 8-octets

-x

unités hexadécimales 2-octets

-h

unités hexadécimales 2-octets

-O

unités octales 4-octets

-s

unités décimales 2-octets

-X

unités hexadécimales 4-octets

-H

unités hexadécimales 4-octets

-e

unités virgule flottante double précision (64-bits)

-f

unités virgule flottante double précision (32-bits)

-F

unités virgule flottante double précision (64-bits)

--format=<TYPE>, -t <TYPE>

sélectionner le(s) format(s) de sortie

--output-duplicates, -v

ne pas utiliser * pour marquer la suppression de ligne

--width=<BYTES>, -w <BYTES>

sortir OCTETS octets par ligne de sortie. 32 est impliqué quand OCTETS n’est pas
spécifié.

--traditional

mode de compatibilité avec une entrée, décalage et étiquette.

Affiche les données dans divers formats lisibles par l’homme. Si plusieurs formats sont spécifiés, la sortie contiendra tous les formats dans l’ordre où ils apparaissent sur la ligne de commande. Chaque format sera imprimé sur une nouvelle ligne. Seule la ligne contenant le premier format sera préfixée avec le décalage.

Si aucun nom de fichier n’est spécifié, ou si c’est “-”, stdin sera utilisé. Après un “–”, aucune autre option ne sera reconnue. Cela permet d’avoir des noms de fichiers commençant par “-”.

Si un nom de fichier est un nombre valide qui peut être utilisé comme décalage dans la deuxième forme, vous pouvez le forcer à être reconnu comme un nom de fichier si vous incluez une option comme “-j0”, qui n’est valide que dans la première forme.

RADIX est l’un de o,d,x,n pour octal, décimal, hexadécimal ou aucun.

OCTETS est décimal par défaut, octal si préfixé par “0”, ou hexadécimal si préfixé par “0x”. Les suffixes b, KB, K, MB, M, GB, G multiplieront le nombre par 512, 1000, 1024, 1000^2, 1024^2, 1000^3, 1024^3, 1000^2, 1024^2.

DÉCALAGE et ÉTIQUETTE sont octaux par défaut, hexadécimaux si préfixés par “0x” ou décimaux si un suffixe “.” est ajouté. Le suffixe “b” multipliera par 512.

TYPE contient une ou plusieurs spécifications de format constituées de : a pour ASCII imprimable 7-bits c pour caractères utf-8 ou octal pour caractères non définis d[TAILLE] pour décimal signé f[TAILLE] pour virgule flottante o[TAILLE] pour octal u[TAILLE] pour décimal non signé x[TAILLE] pour hexadécimal TAILLE est le nombre d’octets qui peut être le nombre 1, 2, 4, 8 ou 16, ou C, S, I, L pour 1, 2, 4, 8 octets pour les types entiers, ou F, D, L pour 4, 8, 16 octets pour les virgules flottantes. Toute spécification de type peut avoir un suffixe “z”, qui ajoutera un dump ASCII à la fin de la ligne.

Si une erreur s’est produite, un message de diagnostic sera imprimé sur stderr, et le code de sortie sera non-zéro.

Examples

Display file using default settings: octal format, 8 bytes per line, byte offsets in octal, and duplicate lines replaced with *:

od {{path/to/file}}

Display file in verbose mode, i.e. without replacing duplicate lines with *:

od {{[-v|--output-duplicates]}} {{path/to/file}}

Display file in hexadecimal format (2-byte units), with byte offsets in decimal format:

od {{[-t|--format]}} {{x}} {{[-A|--address-radix]}} {{d}} {{[-v|--output-duplicates]}} {{path/to/file}}

Display file in hexadecimal format (1-byte units), and 4 bytes per line:

od {{[-t|--format]}} {{x1}} {{[-w|--width=]}}4 {{[-v|--output-duplicates]}} {{path/to/file}}

Display file in hexadecimal format along with its character representation, and do not print byte offsets:

od {{[-t|--format]}} {{xz}} {{[-A|--address-radix]}} {{n}} {{[-v|--output-duplicates]}} {{path/to/file}}

Read only 100 bytes of a file starting from the 500th byte:

od {{[-N|--read-bytes]}} 100 {{[-j|--skip-bytes]}} 500 {{[-v|--output-duplicates]}} {{path/to/file}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

paste

paste [OPTIONS] [FICHIER]...

Écrire les lignes composées des lignes correspondantes séquentiellement de chaque FICHIER, séparées par des TABs, vers la sortie standard.

Options

--serial, -s

coller un fichier à la fois au lieu d’en parallèle

--delimiters=<LIST>, -d <LIST>

réutiliser les caractères de LISTE au lieu des TABs

--zero-terminated, -z

le délimiteur de ligne est NUL, pas une nouvelle ligne

Examples

Join all the lines into a single line, using TAB as delimiter:

paste {{[-s|--serial]}} {{path/to/file}}

Join all the lines into a single line, using the specified delimiter:

paste {{[-s|--serial]}} {{[-d|--delimiters]}} {{delimiter}} {{path/to/file}}

Merge two files side by side, each in its column, using TAB as delimiter:

paste {{path/to/file1}} {{path/to/file2}}

Merge two files side by side, each in its column, using the specified delimiter:

paste {{[-d|--delimiters]}} {{delimiter}} {{path/to/file1}} {{path/to/file2}}

Merge two files, with lines added alternatively:

paste {{[-d|--delimiters]}} '\n' {{path/to/file1}} {{path/to/file2}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

pathchk

pathchk [OPTION]... NOM...

Vérifier si les noms de fichiers sont valides ou portables

Options

-p

vérifier pour la plupart des systèmes POSIX

-P

vérifier les noms vides et les “-” en début

--portability

vérifier pour tous les systèmes POSIX (équivalent à -p -P)

Examples

Check pathnames for validity in the current system:

pathchk {{path1 path2 ...}}

Check pathnames for validity on a wider range of POSIX compliant systems:

pathchk -p {{path1 path2 ...}}

Check pathnames for validity on all POSIX compliant systems:

pathchk {{[-p -P|--portability]}} {{path1 path2 ...}}

Only check for empty pathnames or leading dashes (-):

pathchk -P {{path1 path2 ...}}

The examples are provided by the tldr-pages project under the CC BY 4.0 License.

Please note that, as uutils is a work in progress, some examples might fail.

pinky