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

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

# Unix like
cargo install coreutils --features unix --locked
# Windows
cargo install coreutils --features windows --locked

Linux

Alpine

apk update uutils-coreutils

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)

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.

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 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.

Platforms per tier

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

Operating system	Tested targets
Linux	`x86_64-unknown-linux-gnu` `x86_64-unknown-linux-musl` `arm-unknown-linux-gnueabihf` `i686-unknown-linux-gnu` `aarch64-unknown-linux-gnu`
macOS	`x86_64-apple-darwin`
Windows	`i686-pc-windows-msvc` `x86_64-pc-windows-gnu` `x86_64-pc-windows-msvc`
FreeBSD	`x86_64-unknown-freebsd`
OpenBSD	`x86_64-unknown-openbsd`
Android	`x86_64-linux-android`
wasm32	`wasm32-wasip1`

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.

util	Linux	macOS	Windows	FreeBSD	Android
arch	✓		✓	✓	✓
b2sum	✓	✓	✓	✓	✓
base32	✓		✓	✓	✓
base64	✓		✓	✓	✓
basename	✓		✓	✓	✓
basenc	✓		✓	✓	✓
cat	✓		✓	✓	✓
chcon	✓
chgrp	✓			✓	✓
chmod	✓			✓	✓
chown	✓			✓	✓
chroot	✓			✓	✓
cksum	✓	✓	✓	✓	✓
comm	✓		✓	✓	✓
cp	✓		✓	✓	✓
csplit	✓		✓	✓	✓
cut	✓		✓	✓	✓
date	✓		✓	✓	✓
dd	✓		✓	✓	✓
df	✓		✓	✓	✓
dir	✓		✓	✓	✓
dircolors	✓		✓	✓	✓
dirname	✓		✓	✓	✓
du	✓		✓	✓	✓
echo	✓		✓	✓	✓
env	✓		✓	✓	✓
expand	✓		✓	✓	✓
expr	✓		✓	✓	✓
factor	✓		✓	✓	✓
false	✓		✓	✓	✓
fmt	✓		✓	✓	✓
fold	✓		✓	✓	✓
groups	✓			✓	✓
head	✓		✓	✓	✓
hostid	✓			✓
hostname	✓		✓	✓	✓
id	✓			✓	✓
install	✓			✓	✓
join	✓		✓	✓	✓
kill	✓			✓	✓
link	✓		✓	✓	✓
ln	✓		✓	✓	✓
logname	✓			✓	✓
ls	✓		✓	✓	✓
md5sum	✓	✓	✓	✓	✓
mkdir	✓		✓	✓	✓
mkfifo	✓			✓	✓
mknod	✓			✓	✓
mktemp	✓		✓	✓	✓
more	✓		✓	✓	✓
mv	✓		✓	✓	✓
nice	✓			✓	✓
nl	✓		✓	✓	✓
nohup	✓			✓	✓
nproc	✓		✓	✓	✓
numfmt	✓		✓	✓	✓
od	✓		✓	✓	✓
paste	✓		✓	✓	✓
pathchk	✓		✓	✓	✓
pinky	✓			✓
pr	✓		✓	✓	✓
printenv	✓		✓	✓	✓
printf	✓		✓	✓	✓
ptx	✓		✓	✓	✓
pwd	✓		✓	✓	✓
readlink	✓		✓	✓	✓
realpath	✓		✓	✓	✓
rm	✓		✓	✓	✓
rmdir	✓		✓	✓	✓
runcon	✓
seq	✓		✓	✓	✓
sha1sum	✓	✓	✓	✓	✓
sha224sum	✓	✓	✓	✓	✓
sha256sum	✓	✓	✓	✓	✓
sha384sum	✓	✓	✓	✓	✓
sha512sum	✓	✓	✓	✓	✓
shred	✓		✓	✓	✓
shuf	✓		✓	✓	✓
sleep	✓		✓	✓	✓
sort	✓		✓	✓	✓
split	✓		✓	✓	✓
stat	✓			✓	✓
stdbuf	✓			✓	✓
stty	✓			✓	✓
sum	✓	✓	✓	✓	✓
sync	✓		✓	✓	✓
tac	✓		✓	✓	✓
tail	✓		✓	✓	✓
tee	✓		✓	✓	✓
test	✓		✓	✓	✓
timeout	✓			✓	✓
touch	✓		✓	✓	✓
tr	✓		✓	✓	✓
true	✓		✓	✓	✓
truncate	✓		✓	✓	✓
tsort	✓		✓	✓	✓
tty	✓			✓	✓
uname	✓		✓	✓	✓
unexpand	✓		✓	✓	✓
uniq	✓		✓	✓	✓
unlink	✓		✓	✓	✓
uptime	✓			✓
users	✓			✓
vdir	✓		✓	✓	✓
wc	✓		✓	✓	✓
who	✓			✓
whoami	✓		✓	✓	✓
yes	✓		✓	✓	✓

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:

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:

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:

Confirm the bug is in coreutils; some tools (e.g., find, sed) are maintained in separate repositories under the uutils project.
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 println!, .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.

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:

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.
Build both the GNU and Rust coreutils using: bash util/build-gnu.sh
Run the test with bash util/run-gnu-test.sh <your test>
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. …
Or, if the test is simple, extract the relevant information to create a new test case running both GNU & Rust implementation
Start to modify the Rust implementation to match the expected behavior
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:

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:

Fork the coreutils repository to your GitHub account. Tip: See this GitHub guide for more information on this step.
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:

Install pre-commit
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

Modify util/update-version.sh (FROM & TO) and run it
Submit a new PR with these changes and wait for it to be merged
Tag the new release git tag -a X.Y.Z and git push --tags
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.
Write the release notes (it takes time) following previous examples
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

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

arch

Mostrar la arquitectura de la máquina

Options

Determinar el nombre de la arquitectura para la máquina actual.

Examples

Vea la documentación del comando original:

tldr uname

b2sum

v(uutils coreutils) 0.8.0

b2sum [OPTIONS] [FILE]...

Print or check the BLAKE2b checksums

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

Calcula la suma de comprobación BLAKE2 para uno o más archivos:

b2sum {{ruta/al/archivo1 ruta/al/archivo2 ...}}

Calcula y guarda la lista de sumas de comprobación BLAKE2 en un archivo:

b2sum {{ruta/al/archivo1 ruta/al/archivo2 ...}} > {{ruta/al/archivo}}.b2

Calcula una suma de comprobación BLAKE2 desde stdin:

{{comando}} | b2sum

Lee un archivo de sumas de comprobación BLAKE2 y nombres de archivo y verifica que todos los archivos tengan sumas de comprobación coincidentes:

b2sum {{[-c|--check]}} {{path/to/file}}.b2

Muestra solo un mensaje para los archivos que faltan o cuando falla la verificación:

b2sum {{[-c|--check]}} --quiet {{ruta/al/archivo}}.b2

Muestra solo un mensaje cuando falle la verificación, ignorando los archivos que faltan:

b2sum --ignore-missing {{[-c|--check]}} --quiet {{ruta/al/archivo}}.b2

Comprueba una suma de comprobación BLAKE2 conocida de un archivo:

echo {{suma_de_comprobación_blake2_conocida_del_archivo}} {{ruta/al/archivo}} | b2sum {{[-c|--check]}}

base32

v(uutils coreutils) 0.8.0

base32 [OPCIÓN]... [ARCHIVO]

codificar/decodificar datos y mostrar a salida estándar Sin ARCHIVO, o cuando ARCHIVO es -, leer entrada estándar.

Los datos se codifican como se describe para el alfabeto base32 en RFC 4648. Al decodificar, la entrada puede contener nuevas líneas además de los bytes del alfabeto base32 formal. Use –ignore-garbage para intentar recuperarse de cualquier otro byte no alfabético en el flujo codificado.

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

Codifica un archivo:

base32 {{ruta/al/archivo}}

Ajuste la salida codificada en un ancho específico (0 deshabilita el ajuste):

base32 {{[-w|--wrap]}} {{0|76|...}} {{ruta/al/archivo}}

Decodifica un archivo:

base32 {{[-d|--decode]}} {{ruta/al/archivo}}

Codifica stdin:

{{comando}} | base32

Decodifica stdin:

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

base64

v(uutils coreutils) 0.8.0

base64 [OPCIÓN]... [ARCHIVO]

codificar/decodificar datos y mostrar a salida estándar Sin ARCHIVO, o cuando ARCHIVO es -, leer entrada estándar.

Los datos se codifican como se describe para el alfabeto base64 en RFC 3548. Al decodificar, la entrada puede contener nuevas líneas además de los bytes del alfabeto base64 formal. Use –ignore-garbage para intentar recuperarse de cualquier otro byte no alfabético en el flujo codificado.

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

Codifica un archivo:

base64 {{ruta/al/archivo}}

Ajusta la salida codificada en un ancho específico (0 deshabilita el ajuste):

base64 {{[-w|--wrap]}} {{0|76|...}} {{ruta/al/archivo}}

Decodifica un archivo:

base64 {{[-d|--decode]}} {{ruta/al/archivo}}

Codifica stdin:

{{comando}} | base64

Decodifica stdin:

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

basename

v(uutils coreutils) 0.8.0

basename [-z] NOMBRE [SUFIJO]
basename OPCIÓN... NOMBRE...

Mostrar NOMBRE eliminando cualquier componente de directorio inicial Si se especifica, también eliminar un SUFIJO final

Options

--multiple, -a: admitir múltiples argumentos y tratar cada uno como un NOMBRE

--suffix=<SUFFIX>, -s <SUFFIX>: eliminar un SUFIJO final; implica -a
--zero, -z: terminar cada línea de salida con NUL, no con nueva línea

Examples

Imprime el nombre de un fichero a partir de su ruta:

basename {{ruta/al/archivo}}

Imprime el componente terminal de la ruta de un directorio:

basename {{ruta/al/directorio}}

Imprime el nombre de un fichero sin un sufijo:

basename {{ruta/al/archivo}} {{sufijo}}

basenc

v(uutils coreutils) 0.8.0

basenc [OPCIÓN]... [ARCHIVO]

Codificar/decodificar datos y mostrar a salida estándar Sin ARCHIVO, o cuando ARCHIVO es -, leer entrada estándar.

Al decodificar, la entrada puede contener nuevas líneas además de los bytes del alfabeto formal. Use –ignore-garbage para intentar recuperarse de cualquier otro byte no alfabético en el flujo codificado.

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: igual que el programa ‘base64’
--base64url: base64 seguro para archivos y url
--base32: igual que el programa ‘base32’
--base32hex: base32 de alfabeto hex extendido
--base16: codificación hex
--base2lsbf: cadena de bits con bit menos significativo (lsb) primero
--base2msbf: cadena de bits con bit más significativo (msb) primero
--z85: codificación similar a ascii85;
al codificar, la longitud de entrada debe ser múltiplo de 4;
al decodificar, la longitud de entrada debe ser múltiplo de 5
--base58: codificación en base58 visualmente no ambigua

Examples

Codifica un archivo con codificación base64:

basenc --base64 {{ruta/al/archivo}}

Descifra un archivo con codificación base64:

basenc {{[-d|--decode]}} --base64 {{ruta/al/archivo}}

Codifica desde stdin con codificación base32 con 42 columnas:

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

Codifica desde stdin con codificación base32:

{{comando}} | basenc --base32

cat

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

cat [OPCIÓN]... [ARCHIVO]...

Concatenar ARCHIVO(s), o entrada estándar, a salida estándar Sin ARCHIVO, o cuando ARCHIVO es -, leer entrada estándar.

Options


--show-all, -A: equivalente a -vET
--number-nonblank, -b: número de líneas de salida no vacías, sobrescribe -n
-e: equivalente a -vE
--show-ends, -E: exhibe $ al final de cada línea
--number, -n: enumera todas las líneas de salida
--squeeze-blank, -s: suprime líneas de salida vacías repetidas
-t: equivalente a -vT
--show-tabs, -T: exhibe caracteres TAB en ^I
--show-nonprinting, -v: utilice ^ y notación M- excepto para LF (\n) y TAB (\t)
-u: (ignorado)

Examples

Imprime el contenido de un fichero a stdout:

cat {{ruta/al/archivo}}

Concatena varios archivos en un archivo de salida:

cat {{ruta/al/archivo1 ruta/al/archivo2 ...}} > {{ruta/al/archivo_salida}}

Añade el contenido de varios archivos a un archivo de salida:

cat {{ruta/al/archivo1 ruta/al/archivo2 ...}} >> {{ruta/al/archivo_salida}}

Copia el contenido de un archivo en un archivo de salida sin almacenamiento en el búfer:

cat -u {{/dev/tty12}} > {{/dev/tty13}}

Copia stdin en un archivo:

cat - > {{ruta/al/archivo}}

chcon

v(uutils coreutils) 0.8.0

chcon [OPCIÓN]... CONTEXTO ARCHIVO...
chcon [OPCIÓN]... [-u USUARIO] [-r ROL] [-l RANGO] [-t TIPO] ARCHIVO...
chcon [OPCIÓN]... --reference=RARCHIVO ARCHIVO...

Cambiar el contexto de seguridad SELinux de cada ARCHIVO a CONTEXTO. Con –reference, cambiar el contexto de seguridad de cada ARCHIVO al de RARCHIVO.

Options

--dereference: Afectar el referente de cada enlace simbólico (esto es por defecto), en lugar del enlace simbólico mismo.
--no-dereference, -h: Afectar enlaces simbólicos en lugar de cualquier archivo referenciado.
--help: help
--preserve-root: Fallar al operar recursivamente en ‘/’.
--no-preserve-root: No tratar ‘/’ especialmente (por defecto).
--reference=<RFILE>: Usar contexto de seguridad de RARCHIVO, en lugar de especificar un valor CONTEXTO.
--user=<USER>, -u <USER>: Establecer usuario USUARIO en el contexto de seguridad destino.
--role=<ROLE>, -r <ROLE>: Establecer rol ROL en el contexto de seguridad destino.
--type=<TYPE>, -t <TYPE>: Establecer tipo TIPO en el contexto de seguridad destino.
--range=<RANGE>, -l <RANGE>: Establecer rango RANGO en el contexto de seguridad destino.
--recursive, -R: Operar en archivos y directorios recursivamente.
-H: Si un argumento de línea de comandos es un enlace simbólico a un directorio, atravesarlo. Solo válido cuando se especifica -R.
-L: Atravesar cada enlace simbólico a un directorio encontrado. Solo válido cuando se especifica -R.
-P: No atravesar ningún enlace simbólico (por defecto). Solo válido cuando se especifica -R.
--verbose, -v: Mostrar un diagnóstico para cada archivo procesado.

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

View security context of a file:

ls {{[-lZ|-l --context]}} {{path/to/file}}

Change the security context of a target file, using a reference file:

chcon --reference {{reference_file}} {{target_file}}

Change the full SELinux security context of a file:

chcon {{user}}:{{role}}:{{type}}:{{range/level}} {{filename}}

Change only the user part of SELinux security context:

chcon {{[-u|--user]}} {{user}} {{filename}}

Change only the role part of SELinux security context:

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

Change only the type part of SELinux security context:

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

Change only the range/level part of SELinux security context:

chcon {{[-l|--range]}} {{range/level}} {{filename}}

chgrp

v(uutils coreutils) 0.8.0

chgrp [OPCIÓN]... GRUPO ARCHIVO...
chgrp [OPCIÓN]... --reference=RARCHIVO ARCHIVO...

Cambiar el grupo de cada ARCHIVO a GRUPO.

Options

--help: Mostrar información de ayuda.
--changes, -c: como verbose pero reportar solo cuando se hace un cambio
--silent, -f
--quiet: suprimir la mayoría de mensajes de error
--verbose, -v: mostrar un diagnóstico para cada archivo procesado
--preserve-root: fallar al operar recursivamente en ‘/’
--no-preserve-root: no tratar ‘/’ especialmente (por defecto)
--reference=<RFILE>: usar el grupo de RARCHIVO en lugar de especificar valores GRUPO
--from=<GROUP>: cambiar el grupo solo si su grupo actual coincide con GRUPO
--recursive, -R: operar en archivos y directorios recursivamente
-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

Cambia el grupo propietario de un archivo/directorio:

chgrp {{grupo}} {{ruta/al/archivo_o_directorio}}

Cambia recursivamente el grupo propietario de un directorio y su contenido:

chgrp {{[-R|--recursive]}} {{grupo}} {{ruta/al/directorio}}

Cambia el grupo propietario de un enlace simbólico:

chgrp {{[-h|--no-dereference]}} {{grupo}} {{ruta/al/symlink}}

Cambia el grupo propietario de un archivo/directorio para que coincida con un archivo de referencia:

chgrp --reference {{ruta/al/archivo_de_referencia}} {{ruta/al/archivo_o_directorio}}

chmod

v(uutils coreutils) 0.8.0

chmod [OPCIÓN]... MODO[,MODO]... ARCHIVO...
chmod [OPCIÓN]... MODO-OCTAL ARCHIVO...
chmod [OPCIÓN]... --reference=RARCHIVO ARCHIVO...

Cambiar el modo de cada ARCHIVO a MODO. Con –reference, cambiar el modo de cada ARCHIVO al de RARCHIVO.

Options

--help: Mostrar información de ayuda.
--changes, -c: como verbose pero reportar solo cuando se hace un cambio
--quiet, --silent, -f: suprimir la mayoría de mensajes de error
--verbose, -v: mostrar un diagnóstico para cada archivo procesado
--no-preserve-root: no tratar ‘/’ especialmente (por defecto)
--preserve-root: fallar al operar recursivamente en ‘/’
--recursive, -R: cambiar archivos y directorios recursivamente
--reference: usar el modo de RARCHIVO en lugar de valores MODO


-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)

Cada MODO tiene la forma [ugoa]*(-+=)+|[-+=]?[0-7]+.

Examples

Otorga al [u]suario que es propietario del archivo permiso para [x] ejecutarlo:

chmod u+x {{ruta/al/archivo}}

Otorga al [u]suario derechos para leer (r) y escribir (w) un archivo o directorio:

chmod u+rw {{ruta/al/archivo_o_directorio}}

Elimina los derechos de ejecución del [g]rupo:

chmod g-x {{ruta/al/archivo}}

Otorga a todos los usuarios (a) derechos para leer y ejecutar:

chmod a+rx {{ruta/al/archivo}}

Otorga a [o]tros (que no están en el grupo del propietario) los mismos derechos que los del [g]rupo:

chmod o=g {{ruta/al/archivo}}

Quita todos los derechos a [o]tros:

chmod o= {{ruta/al/archivo}}

Otorga al [g]rupo y a [o]tros el derecho para escribir (w) un directorio y su contenido:

chmod {{[-R|--recursive]}} g+w,o+w {{ruta/al/directorio}}

Concede de forma recursiva [a] todos los usuarios permisos de lectu[r]a a los archivos y permisos de e[X]ecución a los subdirectorios dentro de un directorio:

chmod {{[-R|--recursive]}} a+rX {{ruta/al/directorio}}

chown

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

chown [OPCIÓN]... [PROPIETARIO][:[GRUPO]] ARCHIVO...
chown [OPCIÓN]... --reference=RARCHIVO ARCHIVO...

Cambiar propietario y grupo de archivo

Options

--help: Mostrar información de ayuda.
--changes, -c: como verbose pero reportar solo cuando se hace un cambio
--from=<CURRENT_OWNER:CURRENT_GROUP>: cambiar el propietario y/o grupo de cada archivo solo si su
propietario y/o grupo actual coinciden con los especificados aquí.
Cualquiera puede ser omitido, en cuyo caso no se requiere una coincidencia
para el atributo omitido
--preserve-root: fallar al operar recursivamente en ‘/’
--no-preserve-root: no tratar ‘/’ especialmente (por defecto)
--quiet: suprimir la mayoría de mensajes de error
--recursive, -R: operar en archivos y directorios recursivamente
--reference=<RFILE>: usar el propietario y grupo de RARCHIVO en lugar de especificar valores PROPIETARIO:GRUPO
--silent, -f
--verbose, -v: mostrar un diagnóstico para cada archivo procesado
-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

Cambia el usuario propietario de un archivo/directorio:

chown {{usuario}} {{ruta/al/archivo_o_directorio}}

Cambia el usuario y grupo propietario de un archivo/directorio:

chown {{usuario}}:{{grupo}} {{ruta/al/archivo_o_directorio}}

Cambia el usuario propietario y el grupo para que ambos sean usuario:

chown {{usuario}}: {{ruta/al/archivo_o_directorio}}

Cambia recursivamente el propietario de un directorio y su contenido:

chown {{[-R|--recursive]}} {{usuario}} {{ruta/al/directorio}}

Cambia el propietario de un enlace simbólico:

chown {{[-h|--no-dereference]}} {{usuario}} {{ruta/al/enlace_simbólico}}

Cambia el propietario de un archivo/directorio para que coincida con un archivo de referencia:

chown --reference {{ruta/al/archivo_de_referencia}} {{ruta/al/archivo_o_directorio}}

chroot

v(uutils coreutils) 0.8.0

chroot [OPCIÓN]... NUEVARAIZ [COMANDO [ARG]...]

Ejecutar COMANDO con directorio raíz establecido a NUEVARAIZ.

Options


--groups=<GROUP1,GROUP2...>: Lista separada por comas de grupos a los cuales cambiar
--userspec=<USER:GROUP>: Usuario y grupo separados por dos puntos a los cuales cambiar.
--skip-chdir: Use esta opción para no cambiar el directorio de trabajo a / después de cambiar el directorio raíz a nuevaraiz, es decir, dentro del chroot.

Examples

Ejecuta un comando como nuevo directorio raíz:

sudo chroot {{ruta/al/nuevo/root}} {{comando}}

Utiliza un usuario y grupo específicos:

sudo chroot --userspec {{nombre_usuario_o_id:nombre_grupo_o_id}}

cksum

v(uutils coreutils) 0.8.0

cksum [OPCIONES] [ARCHIVO]...

Mostrar CRC y tamaño para cada archivo

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 determina el algoritmo de resumen y formato de salida por defecto:

sysv: (equivalente a sum -s)
bsd: (equivalente a sum -r)
crc: (equivalente a cksum)
crc32b: (solo disponible a través de cksum)
md5: (equivalente a md5sum)
sha1: (equivalente a sha1sum)
sha224: (equivalente a sha224sum)
sha256: (equivalente a sha256sum)
sha384: (equivalente a sha384sum)
sha512: (equivalente a sha512sum)
blake2b: (equivalente a b2sum)
sm3: (solo disponible a través de cksum)

Examples

Muestra una suma de comprobación de 32 bits, el tamaño en bytes y el nombre del archivo:

cksum {{ruta/al/archivo}}

comm

v(uutils coreutils) 0.8.0

comm [OPCIÓN]... ARCHIVO1 ARCHIVO2

Comparar dos archivos ordenados línea por línea.

Cuando ARCHIVO1 o ARCHIVO2 (no ambos) es -, leer entrada estándar.

Sin opciones, producir salida de tres columnas. La columna uno contiene líneas únicas a ARCHIVO1, la columna dos contiene líneas únicas a ARCHIVO2, y la columna tres contiene líneas comunes a ambos archivos.

Options

-1: suprimir columna 1 (líneas únicas a ARCHIVO1)
-2: suprimir columna 2 (líneas únicas a ARCHIVO2)
-3: suprimir columna 3 (líneas que aparecen en ambos archivos)
--output-delimiter=<STR>: separar columnas con STR
--zero-terminated, -z: el delimitador de línea es NUL, no nueva línea


--total: mostrar un resumen
--check-order: verificar que la entrada esté correctamente ordenada, incluso si todas las líneas de entrada son emparejables
--nocheck-order: no verificar que la entrada esté correctamente ordenada

Examples

Produce tres columnas separadas por tabuladores: líneas solo en el primer archivo, líneas solo en el segundo archivo y líneas comunes:

comm {{fichero1}} {{fichero2}}

Imprime solo las líneas comunes a ambos archivos:

comm -12 {{fichero1}} {{fichero2}}

Imprime solo las líneas comunes a ambos archivos, leyendo un archivo desde stdin:

cat {{fichero1}} | comm -12 - {{fichero2}}

Obtiene las líneas que solo se encuentran en el primer fichero, guardando el resultado en un tercer fichero:

comm -23 {{fichero1}} {{fichero2}} > {{solo_fichero1}}

Imprime las líneas solo encontradas en el segundo fichero, cuando los ficheros no están ordenados:

comm -13 <(sort {{fichero1}}) <(sort {{fichero2}})

cp

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

cp [OPCIÓN]... [-T] ORIGEN DESTINO
cp [OPCIÓN]... ORIGEN... DIRECTORIO
cp [OPCIÓN]... -t DIRECTORIO ORIGEN...

Copiar ORIGEN a DESTINO, o múltiples ORIGEN(es) a DIRECTORIO.

Options

--target-directory=<target-directory>, -t <target-directory>: copiar todos los argumentos ORIGEN al directorio destino
--no-target-directory, -T: Tratar DESTINO como un archivo regular y no un directorio
--interactive, -i: preguntar antes de sobreescribir archivos
--link, -l: enlazar archivos duros en lugar de copiar
--no-clobber, -n: no sobreescribir un archivo que ya existe
--recursive, -R, -r: copiar directorios recursivamente
--strip-trailing-slashes: eliminar cualquier barra final de cada argumento ORIGEN
--debug: explicar cómo se copia un archivo. Implica -v
--verbose, -v: declarar explícitamente lo que se está haciendo
--symbolic-link, -s: hacer enlaces simbólicos en lugar de copiar
--force, -f: si un archivo de destino existente no se puede abrir, eliminarlo e intentar de nuevo (esta opción se ignora cuando también se usa la opción -n). Actualmente no implementado para Windows.
--remove-destination: eliminar cada archivo de destino existente antes de intentar abrirlo (contraste con –force). En Windows, actualmente solo funciona para archivos escribibles.
--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>: controlar copias clone/CoW. Ver abajo
--attributes-only: No copiar los datos del archivo, solo los atributos
--preserve=<ATTR_LIST>: Preservar los atributos especificados (por defecto: modo, propiedad (solo unix), marcas de tiempo), si es posible atributos adicionales: context, links, xattr, all
--preserve-default-attributes, -p: igual que –preserve=mode,ownership(solo unix),timestamps
--no-preserve=<ATTR_LIST>: no preservar los atributos especificados
--parents: usar nombre completo del archivo origen bajo DIRECTORIO
--no-dereference, -P: nunca seguir enlaces simbólicos en ORIGEN
--dereference, -L: siempre seguir enlaces simbólicos en ORIGEN
-H: seguir enlaces simbólicos de línea de comandos en ORIGEN
--archive, -a: Igual que -dR –preserve=all
-d: igual que –no-dereference –preserve=links
--one-file-system, -x: permanecer en este sistema de archivos
--sparse=<WHEN>: controlar creación de archivos dispersos. Ver abajo
-Z: establecer contexto de seguridad SELinux del archivo destino al tipo por defecto
--context=<CTX>: como -Z, o si se especifica CTX entonces establecer el contexto de seguridad SELinux o SMACK a CTX
--progress, -g: Mostrar una barra de progreso. Nota: esta característica no está soportada por GNU coreutils.
--copy-contents: NoImplementado: copiar contenidos de archivos especiales cuando recursivo

No copiar un no-directorio que tiene un destino existente con la misma o más nueva marca de tiempo de modificación; en su lugar, omitir silenciosamente el archivo sin fallar. Si se están preservando las marcas de tiempo, la comparación es con la marca de tiempo de origen truncada a las resoluciones del sistema de archivos de destino y de las llamadas del sistema usadas para actualizar marcas de tiempo; esto evita trabajo duplicado si varios comandos cp -pu se ejecutan con el mismo origen y destino. Esta opción se ignora si también se especifica la opción -n o –no-clobber. También, si –preserve=links también se especifica (como con cp -au por ejemplo), eso tendrá precedencia; consecuentemente, dependiendo del orden en que se procesen los archivos del origen, archivos más nuevos en el destino pueden ser reemplazados, para reflejar enlaces duros en el origen. lo cual da más control sobre qué archivos existentes en el destino son reemplazados, y su valor puede ser uno de los siguientes:

all Esta es la operación por defecto cuando no se especifica una opción –update, y resulta en que todos los archivos existentes en el destino sean reemplazados.
none Esto es similar a la opción –no-clobber, en que ningún archivo en el destino es reemplazado, pero también omitir un archivo no induce un fallo.
older Esta es la operación por defecto cuando se especifica –update, y resulta en que los archivos sean reemplazados si son más antiguos que el archivo origen correspondiente.

Examples

Copia un archivo a otra ubicación:

cp {{ruta/al/archivo_de_origen.ext}} {{ruta/al/archivo_destino.ext}}

Copia un archivo en otro directorio, manteniendo el nombre del archivo:

cp {{ruta/al/archivo_de_origen.ext}} {{ruta/al/directorio_destino}}

Copia recursivamente el contenido de un directorio a otra ubicación (si el destino existe, el directorio se copia dentro de él):

cp {{[-r|--recursive]}} {{ruta/al/directorio_de_origen}} {{ruta/al/directorio_de_destino}}

Copia un directorio de forma recursiva, en modo detallado (muestra los archivos a medida que se copian):

cp {{[-vr|--verbose --recursive]}} {{ruta/al/directorio_de_origen}} {{ruta/al/directorio_de_destino}}

Copia varios archivos a la vez en un directorio:

cp {{[-t|--target-directory]}} {{ruta/al/directorio_de_destino}} {{ruta/al/archivo1 ruta/al/archivo2 ...}}

Copia archivos de texto a otra ubicación, en modo interactivo (pregunta al usuario antes de sobrescribir):

cp {{[-i|--interactive]}} {{*.txt}} {{ruta/al/directorio_de_objetivo}}

Sigue los enlaces simbólicos antes de copiar:

cp {{[-L|--dereference]}} {{enlace}} {{ruta/al/directorio_de_destino}}

Utiliza el primer argumento como directorio de destino (útil para xargs ... | cp -t <DEST_DIR>):

cp {{[-t|--target-directory]}} {{ruta/al/directorio_de_destino}} {{ruta/al/archivo_o_directorio1 ruta/al/archivo_o_directorio2 ...}}

csplit

v(uutils coreutils) 0.8.0

csplit [OPCIÓN]... ARCHIVO PATRÓN...

Dividir un archivo en secciones determinadas por líneas de contexto

Options

--suffix-format=<FORMAT>, -b <FORMAT>: usar FORMATO sprintf en lugar de %02d
--prefix=<PREFIX>, -f <PREFIX>: usar PREFIJO en lugar de ‘xx’
--keep-files, -k: no eliminar archivos de salida cuando hay errores
--suppress-matched: suprimir las líneas que coinciden con PATRÓN
--digits=<DIGITS>, -n <DIGITS>: usar el número especificado de dígitos en lugar de 2
--quiet, --silent, -q, -s: no mostrar el número de bytes de los archivos de salida
--elide-empty-files, -z: eliminar archivos de salida vacíos

Dividir piezas de ARCHIVO separadas por PATRÓN(ES) en archivos ‘xx00’, ‘xx01’, …, y mostrar el número de bytes de cada pieza en la salida estándar.

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

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}}/

cut

v(uutils coreutils) 0.8.0

cut OPCIÓN... [ARCHIVO]...

Muestra columnas de byte o campo especificadas de cada línea de stdin o los archivos de entrada

Options

--bytes=<LIST>, -b <LIST>: filtrar columnas de byte de la fuente de entrada
--characters=<LIST>, -c <LIST>: alias para modo carácter
--delimiter=<DELIM>, -d <DELIM>: especificar el carácter delimitador que separa campos en la fuente de entrada. Por defecto Tab.
-w <WHITESPACE>: Usar cualquier número de espacios en blanco (Espacio, Tab) para separar campos en la fuente de entrada (extensión FreeBSD).
--fields=<LIST>, -f <LIST>: filtrar columnas de campo de la fuente de entrada
--complement: invertir el filtro - en lugar de mostrar solo las columnas filtradas, mostrar todas excepto esas columnas
--only-delimited, -s: en modo campo, solo mostrar líneas que contienen el delimitador
--zero-terminated, -z: en lugar de filtrar columnas basado en línea, filtrar columnas basado en \0 (carácter NULL)
--output-delimiter=<NEW_DELIM>: en modo campo, reemplazar el delimitador en líneas de salida con el argumento de esta opción

-n: (ignored)

Cada llamada debe especificar un modo (qué usar para columnas), una secuencia (qué columnas mostrar), y proporcionar una fuente de datos

Especificar un modo

Use –bytes (-b) o –characters (-c) para especificar modo byte

Use –fields (-f) para especificar modo campo, donde cada línea se divide en campos identificados por un carácter delimitador. Por ejemplo, para un CSV típico podría usar esto en combinación con establecer coma como delimitador

Especificar una secuencia

Una secuencia es un grupo de 1 o más números o rangos inclusivos separados por comas.

cut -f 2,5-7 algun_archivo.txt

mostrará el 2º, 5º, 6º y 7º campo para cada línea fuente

Los rangos pueden extenderse hasta el final de la fila excluyendo el segundo número

cut -f 3- algun_archivo.txt

mostrará el 3er campo y todos los campos después para cada línea fuente

El primer número de un rango puede ser excluido, y esto es efectivamente lo mismo que usar 1 como el primer número: hace que el rango comience en la primera columna. Los rangos también pueden mostrar una sola columna

cut -f 1,3-5 algun_archivo.txt

mostrará el 1º, 3º, 4º y 5º campo para cada línea fuente

La opción –complement, cuando se usa, invierte el efecto de la secuencia

cut –complement -f 4-6 algun_archivo.txt

mostrará todos los campos excepto el 4º, 5º y 6º

Especificar una fuente de datos

Si no se especifican argumentos de archivo fuente, stdin se usa como la fuente de líneas a mostrar

Si se especifican argumentos de archivo fuente, stdin se ignora y todos los archivos se leen consecutivamente si un archivo fuente no se lee exitosamente, se mostrará una advertencia a stderr, y el código de estado eventual será 1, pero cut continuará leyendo a través de los archivos fuente procedentes

Para mostrar columnas tanto de STDIN como de un argumento de archivo, use - (guión) como argumento de archivo fuente para representar stdin.

Opciones de Modo Campo

Los campos en cada línea son identificados por un delimitador (separador)

Establecer el delimitador

Establezca el delimitador que separa campos en el archivo usando la opción –delimiter (-d). Establecer el delimitador es opcional. Si no se establece, se usará un delimitador por defecto de Tab.

Si se proporciona la opción -w, los campos serán separados por cualquier número de caracteres de espacio en blanco (Espacio y Tab). El delimitador de salida será un Tab a menos que se especifique explícitamente. Solo una de las opciones -d o -w puede ser especificada. Esta es una extensión adoptada de FreeBSD.

Opcionalmente Filtrar basado en delimitador

Si se proporciona la bandera –only-delimited (-s), solo las líneas que contienen el delimitador serán mostradas

Reemplazar el delimitador

Si se proporciona la opción –output-delimiter, el argumento usado para ella reemplazará el carácter delimitador en cada línea mostrada. Esto es útil para transformar datos tabulares - ej. para convertir un CSV a un TSV (archivo separado por tabs)

Finales de línea

Cuando se usa la opción –zero-terminated (-z), cut ve \0 (null) como el carácter de ‘final de línea’ (tanto para propósitos de leer líneas como separar líneas mostradas) en lugar de \n (nueva línea). Esto es útil para datos tabulares donde algunas de las celdas pueden contener nuevas líneas

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

resultará en ‘a\0c\0’

Examples

Imprime un rango específico de caracteres/campos de cada línea:

{{comando}} | cut --{{characters|field}} {{1|1,10|1-10|1-|-10}}

Imprime un rango de campos de cada línea con un [d]elimitador específico:

{{comando}} | cut --delimiter "{{,}}" --fields {{1}}

Imprime un rango de [c]aracteres de cada línea del archivo específico:

cut --characters {{1}} {{ruta/al/archivo}}

Imprime [c]ampos específicos de líneas terminadas en NUL (por ejemplo, como en find . -print0) en lugar de nuevas líneas:

{{comando}} | cut --zero-terminated --fields {{1}}

date

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

date [OPCIÓN]... [+FORMATO]...
date [OPCIÓN]... [MMDDhhmm[[CC]AA][.ss]]

FORMATO controla la salida. Las secuencias interpretadas son:
| Secuencia | Descripción                                                       | Ejemplo                |
| --------- | ----------------------------------------------------------------- | ---------------------- |
| %%        | un % literal                                                      | %                      |
| %a        | nombre abreviado del día de la semana según la configuración regional | dom                    |
| %A        | nombre completo del día de la semana según la configuración regional | domingo                |
| %b        | nombre abreviado del mes según la configuración regional         | ene                    |
| %B        | nombre completo del mes según la configuración regional          | enero                  |
| %c        | fecha y hora según la configuración regional                     | jue 3 mar 23:05:25 2005|
| %C        | siglo; como %Y, pero omite los dos últimos dígitos               | 20                     |
| %d        | día del mes                                                       | 01                     |
| %D        | fecha; igual que %m/%d/%y                                         | 12/31/99               |
| %e        | día del mes, rellenado con espacios; igual que %_d               | 3                      |
| %F        | fecha completa; igual que %Y-%m-%d                                | 2005-03-03             |
| %g        | dos últimos dígitos del año del número de semana ISO (ver %G)    | 05                     |
| %G        | año del número de semana ISO (ver %V); normalmente útil solo con %V | 2005                   |
| %h        | igual que %b                                                      | ene                    |
| %H        | hora (00..23)                                                     | 23                     |
| %I        | hora (01..12)                                                     | 11                     |
| %j        | día del año (001..366)                                            | 062                    |
| %k        | hora, rellenada con espacios ( 0..23); igual que %_H             |  3                     |
| %l        | hora, rellenada con espacios ( 1..12); igual que %_I             |  9                     |
| %m        | mes (01..12)                                                      | 03                     |
| %M        | minuto (00..59)                                                   | 30                     |
| %n        | una nueva línea                                                   | \\n                     |
| %N        | nanosegundos (000000000..999999999)                               | 123456789              |
| %p        | equivalente regional de AM o PM; vacío si es desconocido         | PM                     |
| %P        | como %p, pero en minúsculas                                       | pm                     |
| %q        | trimestre del año (1..4)                                          | 1                      |
| %r        | hora en formato de 12 horas según la configuración regional      | 11:11:04 PM            |
| %R        | hora de 24 horas y minuto; igual que %H:%M                       | 23:30                  |
| %s        | segundos desde 1970-01-01 00:00:00 UTC                           | 1615432800             |
| %S        | segundo (00..60)                                                  | 30                     |
| %t        | una tabulación                                                    | \\t                     |
| %T        | hora; igual que %H:%M:%S                                          | 23:30:30               |
| %u        | día de la semana (1..7); 1 es lunes                              | 4                      |
| %U        | número de semana del año, con domingo como primer día de la semana (00..53) | 10                     |
| %V        | número de semana ISO, con lunes como primer día de la semana (01..53) | 12                     |
| %w        | día de la semana (0..6); 0 es domingo                            | 4                      |
| %W        | número de semana del año, con lunes como primer día de la semana (00..53) | 11                     |
| %x        | representación de fecha según la configuración regional          | 03/03/2005             |
| %X        | representación de hora según la configuración regional           | 23:30:30               |
| %y        | dos últimos dígitos del año (00..99)                             | 05                     |
| %Y        | año                                                               | 2005                   |
| %z        | zona horaria numérica +hhmm                                       | -0400                  |
| %:z       | zona horaria numérica +hh:mm                                      | -04:00                 |
| %::z      | zona horaria numérica +hh:mm:ss                                   | -04:00:00              |
| %:::z     | zona horaria numérica con : hasta la precisión necesaria         | -04, +05:30            |
| %Z        | abreviatura alfabética de zona horaria                           | EDT                    |

Por defecto, date rellena los campos numéricos con ceros.
Las siguientes banderas opcionales pueden seguir a '%':
* `-` (guión) no rellenar el campo
* `_` (guión bajo) rellenar con espacios
* `0` (cero) rellenar con ceros
* `^` usar mayúsculas si es posible
* `#` usar el caso opuesto si es posible
Después de cualquier bandera viene un ancho de campo opcional, como número decimal;
luego un modificador opcional, que es
* `E` para usar las representaciones alternativas de la configuración regional si están disponibles, o
* `O` para usar los símbolos numéricos alternativos de la configuración regional si están disponibles.
Ejemplos:
  Convertir segundos desde la época (1970-01-01 UTC) a una fecha

  date --date='@2147483647'

  Mostrar la hora en la costa oeste de EE.UU. (usar tzselect(1) para encontrar TZ)

  TZ='America/Los_Angeles' date

Mostrar o establecer la fecha y hora del sistema

Options

--date=<STRING>, -d <STRING>: mostrar la hora descrita por CADENA, no ‘ahora’
--file=<DATEFILE>, -f <DATEFILE>: como –date; una vez por cada línea de ARCHIVOFECHA
--iso-8601=<FMT>, -I <FMT>: mostrar fecha/hora en formato ISO 8601.
FMT=‘date’ solo para fecha (por defecto),
‘hours’, ‘minutes’, ‘seconds’, o ‘ns’
para fecha y hora con la precisión indicada.
Ejemplo: 2006-08-14T02:34:56-06:00
--resolution: salida de resolución de sellos horarios disponibles
Ejemplo: 0.000000001
--rfc-email, -R: mostrar fecha y hora en formato RFC 5322.
Ejemplo: Mon, 14 Aug 2006 02:34:56 -0600
--rfc-3339=<FMT>: mostrar fecha/hora en formato RFC 3339.
FMT=‘date’, ‘seconds’, o ‘ns’
para fecha y hora con la precisión indicada.
Ejemplo: 2006-08-14 02:34:56-06:00
--debug: anotar la fecha analizada y advertir sobre uso cuestionable en stderr
--reference=<FILE>, -r <FILE>: mostrar la hora de última modificación de ARCHIVO
--set=<STRING>, -s <STRING>: establecer la hora descrita por CADENA
--universal, --utc, -u: mostrar o establecer el Tiempo Universal Coordinado (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

dd

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

dd [OPERANDO]...
dd OPCIÓN

Copiar, y opcionalmente convertir, un recurso del sistema de archivos

Options

Operandos

bs=BYTES : leer y escribir hasta BYTES bytes a la vez (predeterminado: 512); sobrescribe ibs y obs.
cbs=BYTES : el ‘tamaño de bloque de conversión’ en bytes. Se aplica a las operaciones conv=block y conv=unblock.
conv=CONVS : una lista separada por comas de opciones de conversión o (por razones de compatibilidad) indicadores de archivo.
count=N : dejar de leer entrada tras N operaciones de lectura de tamaño ibs en lugar de continuar hasta EOF. Ver iflag=count_bytes si se prefiere detenerse tras N bytes
ibs=N : el tamaño del búfer usado para lecturas (predeterminado: 512)
if=ARCHIVO : el archivo usado para entrada. Cuando no se especifica, se usa stdin
iflag=INDICADORES : una lista separada por comas de indicadores de entrada que especifican cómo se trata la fuente de entrada. INDICADORES puede ser cualquiera de los indicadores de entrada o indicadores generales especificados abajo.
skip=N (o iseek=N) : omiten N registros de tamaño ibs en la entrada antes de comenzar las operaciones de copia/conversión. Consulte iflag=seek_bytes si se prefiere buscar N bytes.
obs=N : el tamaño del búfer usado para escrituras (predeterminado: 512)
of=ARCHIVO : el archivo usado para salida. Cuando no se especifica, se usa stdout
oflag=INDICADORES : lista separada por comas de indicadores de salida que especifican cómo se trata el origen de salida. INDICADORES puede ser cualquiera de los indicadores de salida o indicadores generales especificados abajo
seek=N (o oseek=N) : busca N registros de tamaño obs en la salida antes de comenzar las operaciones de copia/conversión. Consulte oflag=seek_bytes si se prefiere buscar N bytes

status=NIVEL : controla si las estadísticas de volumen y rendimiento se escriben en stderr.

Cuando no se especifica, dd imprimirá estadísticas al completarse. Un ejemplo está abajo.

  6+0 records in
  16+0 records out
  8192 bytes (8.2 kB, 8.0 KiB) copied, 0.00057009 s,
  14.4 MB/s

Las primeras dos líneas son las estadísticas de 'volumen' y la línea final
son las estadísticas de 'rendimiento'.
Las estadísticas de volumen indican el número de lecturas completas y
parciales de tamaño ibs, o escrituras de tamaño obs que tuvieron lugar
durante la copia. El formato de las estadísticas de volumen es
<completas>+<parciales>. Si los registros han sido truncados (consulte
conv=block), las estadísticas de volumen contendrán el número de registros
truncados.

Los valores posibles de NIVEL son:
- progress : Declarar estadísticas de rendimiento periódicas conforme avanza la copia.
- noxfer : Declarar estadísticas de volumen finales, pero no estadísticas de rendimiento.
- none : No declarar estadísticas.

La impresión de estadísticas de rendimiento también se activa con la señal INFO
(donde sea soportada), o la señal USR1. Establecer la variable de entorno
POSIXLY_CORRECT a cualquier valor (incluyendo un valor vacío) causará que la
señal USR1 sea ignorada.

Opciones de Conversión

ascii : convertir de EBCDIC a ASCII. Esto es lo inverso de la opción ebcdic. Implica conv=unblock.
ebcdic : convertir de ASCII a EBCDIC. Esto es lo inverso de la opción ascii. Implica conv=block.
ibm : convertir de ASCII a EBCDIC, aplicando las convenciones para [, ] y ~ especificadas en POSIX. Implica conv=block.
ucase : convertir de minúsculas a mayúsculas.
lcase : convierte de mayúsculas a minúsculas.
block : para cada nueva línea menor que el tamaño indicado por cbs=BYTES, eliminar la línea nueva y rellenar con espacios hasta cbs. Las líneas más largas que cbs son truncadas.
unblock : para cada bloque de entrada del tamaño indicado por cbs=BYTES, eliminar los espacios finales derechos y reemplazar con un carácter de nueva línea.
sparse : intenta buscar en la salida cuando un bloque de tamaño obs consiste solo de ceros.
swab : intercambia cada par adyacente de bytes. Si hay un número impar de bytes, el byte final se omite.
sync : rellenar cada bloque de lado ibs con ceros. Si se especifica block o unblock, rellenar con espacios en su lugar.
excl : el archivo de salida debe ser creado. Fallar si el archivo de salida ya está presente.
nocreat : el archivo de salida no será creado. Fallar si el archivo de salida no está ya presente.
notrunc : el archivo de salida no será truncado. Si esta opción no está presente, la salida será truncada cuando se abra.
noerror : todos los errores de lectura serán ignorados. Si esta opción no está presente, dd solo ignorará Error::Interrupted.
fdatasync : los datos se escribirán antes de terminar.
fsync : los datos y metadatos se escribirán antes de terminar.

Indicadores de entrada

count_bytes : un valor para count=N será interpretado como bytes.
skip_bytes : un valor para skip=N será interpretado como bytes.
fullblock : esperar ibs bytes de cada lectura. Las lecturas de longitud cero aún se consideran EOF.

Indicadores de salida

append : abrir archivo en modo de adición. Considere establecer conv=notrunc también.
seek_bytes : un valor para seek=N será interpretado como bytes.

Indicadores Generales

direct : usar E/S directa para datos.
directory : fallar a menos que la entrada dada (si se usa como iflag) o salida (si se usa como oflag) sea un directorio.
dsync : usar E/S sincronizada para datos.
sync : usar E/S sincronizada para datos y metadatos.
nonblock : usar E/S no bloqueante.
noatime : no actualizar el tiempo de acceso.
nocache : solicitar que el SO descarte la caché.
noctty : no asignar un tty controlador.
nofollow : no seguir enlaces del sistema.

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

df

v(uutils coreutils) 0.8.0

df [OPCIÓN]... [ARCHIVO]...

Mostrar información sobre el sistema de archivos en el que reside cada ARCHIVO, o todos los sistemas de archivos por defecto.

Options

--help: Mostrar información de ayuda.
--all, -a: incluir sistemas de archivos ficticios
--block-size=<SIZE>, -B <SIZE>: escalar tamaños por TAMAÑO antes de mostrarlos; ej. ‘-BM’ muestra tamaños en unidades de 1,048,576 bytes
--total: producir un gran total
--human-readable, -h: mostrar tamaños en formato legible por humanos (ej., 1K 234M 2G)
--si, -H: igualmente, pero usar potencias de 1000 no 1024
--inodes, -i: listar información de inodo en lugar de uso de bloque
-k: como –block-size=1K
--local, -l: limitar listado a sistemas de archivos locales
--no-sync: no invocar sync antes de obtener información de uso (por defecto)
--output=<FIELD_LIST>: usar formato de salida definido por LISTA_CAMPO, o mostrar todos los campos si LISTA_CAMPO se omite.
--portability, -P: usar el formato de salida POSIX
--sync: invocar sync antes de obtener información de uso (solo no-windows)
--type=<TYPE>, -t <TYPE>: limitar listado a sistemas de archivos de tipo TIPO
--print-type, -T: mostrar tipo de sistema de archivos
--exclude-type=<TYPE>, -x <TYPE>: limitar listado a sistemas de archivos no de tipo TIPO

Los valores mostrados están en unidades del primer TAMAÑO disponible de –block-size, y las variables de entorno DF_BLOCK_SIZE, BLOCK_SIZE y BLOCKSIZE. De otra manera, las unidades por defecto son 1024 bytes (o 512 si POSIXLY_CORRECT está establecido).

TAMAÑO es un entero y unidad opcional (ejemplo: 10M es 1010241024). Las unidades son K, M, G, T, P, E, Z, Y (potencias de 1024) o KB, MB,… (potencias de 1000).

Examples

Muestra todos los sistemas de ficheros y su uso de disco usando unidades de 512 bytes:

df

Muestra el sistema de archivos y su uso del disco que contiene el archivo o directorio dado:

df {{ruta/al/archivo_o_directorio}}

Utiliza unidades de 1024 bytes en las columnas de cifras de espacio:

df -k

Muestra la información de forma portátil (formato POSIX):

df -P

dir

v(uutils coreutils) 0.8.0

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

Vea la documentación del comando original:

tldr ls

dircolors

v(uutils coreutils) 0.8.0

dircolors [OPCIÓN]... [ARCHIVO]

Mostrar comandos para establecer la variable de entorno LS_COLORS.

Options

--sh, --bourne-shell, -b: mostrar código de shell Bourne para establecer LS_COLORS
--csh, --c-shell, -c: mostrar código de shell C para establecer LS_COLORS
--print-database, -p: imprimir el número de bytes
--print-ls-colors: mostrar colores completamente escapados para visualización

Si se especifica ARCHIVO, leerlo para determinar qué colores usar para qué tipos de archivo y extensiones. De lo contrario, se usa una base de datos precompilada. Para detalles sobre el formato de estos archivos, ejecute ‘dircolors –print-database’

Examples

Comandos de salida para establecer $LS_COLOR usando los colores por defecto:

dircolors

Muestra cada tipo de fichero con el color con el que aparecerían en ls:

dircolors --print-ls-colors

Comandos de salida para establecer $LS_COLOR utilizando los colores de un archivo:

dircolors {{ruta/al/archivo}}

Comandos de salida para el intérprete de comandos Bourne:

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

Comandos de salida para el intérprete de comandos C:

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

Visualiza los colores predeterminados según los tipos de archivo y extensiones:

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

dirname

v(uutils coreutils) 0.8.0

dirname [OPCIÓN] NOMBRE...

Quitar el último componente del nombre de archivo

Options

--zero, -z: dirname-zero-help

Mostrar cada NOMBRE eliminando su último componente que no sea barra y las barras finales; si NOMBRE no contiene /, mostrar ‘.’ (indicando el directorio actual).

Examples

Calcula el directorio padre de una ruta dada:

dirname {{ruta/al/archivo_o_directorio}}

Calcula el directorio padre de múltiples rutas:

dirname {{ruta/al/archivo_o_directorio1 ruta/al/archivo_o_directorio2 ...}}

Delimita la salida con un carácter NUL en lugar de una nueva línea (útil cuando se combina con xargs):

dirname {{[-z|--zero]}} {{ruta/al/archivo_o_directorio1 ruta/al/archivo_o_directorio2 ...}}

du

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

du [OPCIÓN]... [ARCHIVO]...
du [OPCIÓN]... --files0-from=F

Estimar uso de espacio de archivos

Options

--help: Mostrar información de ayuda.
--all, -a: escribir conteos para todos los archivos, no solo directorios
--apparent-size, -A: mostrar tamaños aparentes, en lugar de uso de disco aunque el tamaño aparente es usualmente menor, puede ser mayor debido a agujeros en archivos (‘dispersos’), fragmentación interna, bloques indirectos, y similares
--block-size=<SIZE>, -B <SIZE>: escalar tamaños por TAMAÑO antes de mostrarlos. Ej., ‘-BM’ muestra tamaños en unidades de 1,048,576 bytes. Ver formato TAMAÑO abajo.
--bytes, -b: equivalente a ‘–apparent-size –block-size=1’
--total, -c: producir un gran total
--max-depth=<N>, -d <N>: mostrar el total para un directorio (o archivo, con –all) solo si está N o menos niveles debajo del argumento de línea de comandos; –max-depth=0 es lo mismo que –summarize
--human-readable, -h: mostrar tamaños en formato legible por humanos (ej., 1K 234M 2G)
--inodes: listar información de uso de inodo en lugar de uso de bloque como –block-size=1K
-k: como –block-size=1K
--count-links, -l: contar tamaños muchas veces si están enlazados duros
--dereference, -L: seguir todos los enlaces simbólicos
--dereference-args, -D, -H: seguir solo enlaces simbólicos que están listados en la línea de comandos
--no-dereference, -P: no seguir ningún enlace simbólico (esto es por defecto)
-m: como –block-size=1M
--null, -0: terminar cada línea de salida con byte 0 en lugar de nueva línea
--separate-dirs, -S: no incluir tamaño de subdirectorios
--summarize, -s: mostrar solo un total para cada argumento
--si: como -h, pero usar potencias de 1000 no 1024
--one-file-system, -x: omitir directorios en diferentes sistemas de archivos
--threshold=<SIZE>, -t <SIZE>: excluir entradas menores que TAMAÑO si es positivo, o entradas mayores que TAMAÑO si es negativo
--verbose, -v: modo detallado (opción no presente en GNU/Coreutils)
--exclude=<PATTERN>: excluir archivos que coinciden con PATRÓN
--exclude-from=<FILE>, -X <FILE>: excluir archivos que coinciden con cualquier patrón en ARCHIVO
--files0-from=<FILE>: resumir uso de dispositivo de los nombres de archivo terminados en NUL especificados en archivo F; si F es -, entonces leer nombres de entrada estándar
--time=<WORD>: mostrar tiempo de la última modificación de cualquier archivo en el directorio, o cualquiera de sus subdirectorios. Si se da PALABRA, mostrar tiempo como PALABRA en lugar de tiempo de modificación: atime, access, use, ctime, status, birth o creation
--time-style=<STYLE>: mostrar tiempos usando estilo ESTILO: full-iso, long-iso, iso, +FORMATO FORMATO se interpreta como ‘date’

Los valores mostrados están en unidades del primer TAMAÑO disponible de –block-size, y las variables de entorno DU_BLOCK_SIZE, BLOCK_SIZE y BLOCKSIZE. De otra manera, las unidades por defecto son 1024 bytes (o 512 si POSIXLY_CORRECT está establecido).

TAMAÑO es un entero y unidad opcional (ejemplo: 10M es 1010241024). Las unidades son K, M, G, T, P, E, Z, Y (potencias de 1024) o KB, MB,… (potencias de 1000).

PATRÓN permite algunas exclusiones avanzadas. Por ejemplo, las siguientes sintaxis están soportadas: ? coincidirá solo con un carácter

coincidirá con cero o más caracteres {a,b} coincidirá con a o b

Examples

Lista los tamaños de un directorio y sus subdirectorios, en la unidad dada (B/KiB/MiB):

du -{{b|k|m}} {{ruta/al/directorio}}

Lista los tamaños de un directorio y sus subdirectorios, de forma legible (es decir, seleccionando automáticamente la unidad adecuada para cada tamaño):

du {{[-h|--human-readable]}} {{ruta/al/directorio}}

Muestra el tamaño de un único directorio, en unidades legibles:

du {{[-sh|--summarize --human-readable]}} {{ruta/al/directorio}}

Lista los tamaños legibles de un directorio y de todos los archivos y directorios que contiene:

du -ah {{ruta/al/directorio}}

Lista los tamaños legibles de un directorio y sus subdirectorios, hasta N niveles de profundidad:

du {{[-h|--human-readable]}} --max-depth=N {{ruta/al/directorio}}

Lista el tamaño legible de todos los archivos .jpg en los subdirectorios del directorio actual y muestra un total acumulado al final:

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

Lista todos los archivos y directorios (incluidos los ocultos) por encima de un determinado tamaño (útil para investigar qué está ocupando realmente el espacio):

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

echo

v(uutils coreutils) 0.8.0

echo [OPCIONES]... [CADENA]...

Mostrar una línea de texto

Options

-n: no mostrar la nueva línea final
-e: habilitar interpretación de secuencias de escape con barra invertida
-E: deshabilitar interpretación de secuencias de escape con barra invertida (por defecto)

Mostrar la(s) CADENA(s) en salida estándar.

Si -e está activo, se reconocen las siguientes secuencias:

\ barra invertida
\a alerta (BEL)
\b retroceso
\c no producir más salida
\e escape
\f avance de página
\n nueva línea
\r retorno de carro
\t tabulación horizontal
\v tabulación vertical
\0NNN byte con valor octal NNN (1 a 3 dígitos)
\xHH byte con valor hexadecimal HH (1 a 2 dígitos)

Examples

Imprime un mensaje de texto. Nota: las comillas son opcionales:

echo "{{Hola Mundo}}"

Imprime un mensaje con variables de ambiente:

echo "{{Mi ruta es $PATH}}"

Imprime un mensaje sin la nueva línea:

echo -n "{{Hola Mundo}}"

Añade un mensaje al final del archivo:

echo "{{Hola Mundo}}" >> {{archivo.txt}}

Habilita la interpretación de escapes de backslash (caracteres especiales):

echo -e "{{Column 1\tColumn 2}}"

Imprime el estado de salida del último comando ejecutado (Nota: En Windows Command Prompt y PowerShell los equivalentes son echo %errorlevel% y $lastexitcode respectivamente):

echo $?

env

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

env [OPCIÓN]... [-] [NOMBRE=VALOR]... [COMANDO [ARG]...]

Establecer cada NOMBRE a VALOR en el entorno y ejecutar COMANDO

Options

--ignore-environment, -i: comenzar con un entorno vacío
--chdir=<DIR>, -C <DIR>: cambiar directorio de trabajo a DIR
--null, -0: terminar cada línea de salida con un byte 0 en lugar de nueva línea (solo válido al mostrar el entorno)
--file=<PATH>, -f <PATH>: leer y establecer variables de un archivo de configuración estilo “.env” (antes de cualquier unset y/o set)
--unset=<NAME>, -u <NAME>: eliminar variable del entorno
--debug, -v: mostrar información detallada para cada paso de procesamiento
--split-string=<S>, -S <S>: procesar y dividir S en argumentos separados; usado para pasar múltiples argumentos en líneas shebang
--argv0=<a>, -a <a>: Anular el argumento cero pasado al comando siendo ejecutado. Sin esta opción se usa un valor por defecto de command.

--ignore-signal=<SIG>: establecer manejo de señal(es) SIG a no hacer nada
--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 - implica -i. Si no hay COMANDO, mostrar el entorno resultante.

Examples

Muestra el entorno:

env

Ejecuta un programa. A menudo se utiliza en scripts después del shebang (#!) para buscar la ruta al programa:

env {{program}}

Limpia el entorno y ejecuta un programa:

env {{[-i|--ignore-environment]}} {{program}}

Elimina variable del entorno y ejecuta un programa:

env {{[-u|--unset]}} {{variable}} {{program}}

Establece una variable y ejecuta un programa:

env {{variable}}={{value}} {{program}}

Establece una o más variables y ejecuta un programa:

env {{variable1=value variable2=value variable3=value ...}} {{program}}

Ejecuta un programa con un nombre diferente:

env {{[-a|--argv0]}} {{custom_name}} {{program}}

expand

v(uutils coreutils) 0.8.0

expand [OPCIÓN]... [ARCHIVO]...

Convertir tabulaciones en cada ARCHIVO a espacios, escribiendo a la salida estándar. Sin ARCHIVO, o cuando ARCHIVO es -, leer la entrada estándar.

Options

--initial, -i: no convertir tabulaciones después de caracteres que no sean espacios en blanco
--tabs=<N, LIST>, -t <N, LIST>: tener tabulaciones separadas por N caracteres, no 8, o usar lista separada por comas de posiciones de tabulación explícitas
--no-utf8, -U: interpretar archivo de entrada como ASCII de 8-bit en lugar de 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}}

expr

v(uutils coreutils) 0.8.0

expr [EXPRESIÓN]
expr [OPCIONES]

Imprimir el valor de EXPRESIÓN en la salida estándar

Options

--version: mostrar información de versión y salir
--help: mostrar esta ayuda y salir

Imprimir el valor de EXPRESIÓN en la salida estándar. Una línea en blanco abajo separa grupos de precedencia creciente.

EXPRESIÓN puede ser:

ARG1 | ARG2: ARG1 si no es nulo ni 0, de lo contrario ARG2
ARG1 & ARG2: ARG1 si ningún argumento es nulo o 0, de lo contrario 0
ARG1 < ARG2: ARG1 es menor que ARG2
ARG1 <= ARG2: ARG1 es menor o igual que ARG2
ARG1 = ARG2: ARG1 es igual a ARG2
ARG1 != ARG2: ARG1 es distinto de ARG2
ARG1 >= ARG2: ARG1 es mayor o igual que ARG2
ARG1 > ARG2: ARG1 es mayor que ARG2
ARG1 + ARG2: suma aritmética de ARG1 y ARG2
ARG1 - ARG2: diferencia aritmética de ARG1 y ARG2
ARG1 * ARG2: producto aritmético de ARG1 y ARG2
ARG1 / ARG2: cociente aritmético de ARG1 dividido por ARG2
ARG1 % ARG2: resto aritmético de ARG1 dividido por ARG2
CADENA : REGEXP: coincidencia de patrón anclado de REGEXP en CADENA
match CADENA REGEXP: igual que CADENA : REGEXP
substr CADENA POS LONGITUD: subcadena de CADENA, POS contado desde 1
index CADENA CARACTERES: índice en CADENA donde se encuentra cualquier CARACTERES, o 0
length CADENA: longitud de CADENA
- TOKEN: interpretar TOKEN como una cadena, incluso si es una palabra clave como match o un operador como /
( EXPRESIÓN ): valor de EXPRESIÓN

Tenga cuidado que muchos operadores necesitan ser escapados o entrecomillados para los shells. Las comparaciones son aritméticas si ambos ARGs son números, de lo contrario lexicográficas. Las coincidencias de patrón devuelven la cadena coincidente entre ( y ) o nulo; si ( y ) no se usan, devuelven el número de caracteres coincidentes o 0.

El estado de salida es 0 si EXPRESIÓN no es nula ni 0, 1 si EXPRESIÓN es nula o 0, 2 si EXPRESIÓN es sintácticamente inválida, y 3 si ocurrió un error.

Variables de entorno:

EXPR_DEBUG_TOKENS=1: volcar tokens de la expresión
EXPR_DEBUG_RPN=1: volcar expresión representada en notación polaca inversa
EXPR_DEBUG_SYA_STEP=1: volcar cada paso del analizador
EXPR_DEBUG_AST=1: volcar expresión representada como árbol de sintaxis abstracta

Examples

Obtiene la longitud de una cadena específica:

expr length "{{cadena}}"

Obtiene la subcadena de una cadena con una longitud específica:

expr substr "{{cadena}}" {{desde}} {{longitud}}

Empareja una subcadena específica frente a un patrón:

expr match "{{cadena}}" '{{patrón}}'

Obtiene la primera posición de un caracter de un conjunto específico en una cadena:

expr index "{{cadena}}" "{{caracteres}}"

Calcula una expresión matemática específica:

expr {{expresión1}} {{+|-|*|/|%}} {{expresión2}}

Obtiene la primera expresión si su valor no es cero y no nulo, de otro modo, obtiene el segundo:

expr {{expresión1}} \| {{expresión2}}

Obtiene la primera expresión si ambas expresiones no son cero y no nulas de otro modo obtiene cero:

expr {{expresión1}} \& {{expresión2}}

factor

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

factor [OPCIÓN]... [NÚMERO]...

Imprimir los factores primos de los NÚMERO(s) dados. Si no se especifica ninguno, leer de la entrada estándar.

Options


--exponents, -h: Imprimir factores en la forma p^e
--help: Imprimir información de ayuda.

Examples

Muestra la factorización primaria de un número:

factor {{número}}

Toma la entrada de stdin si no se especifica ningún argumento:

echo {{número}} | factor

false

v(uutils coreutils) 0.8.0

Devuelve falso, un estado de salida sin éxito.

Inmediatamente devuelve el estado de salida 1. Cuando se invoca con una de las opciones reconocidas, intentará escribir el texto de ayuda o versión. Cualquier error de E/S durante esta operación es diagnosticado, sin embargo el programa también devolverá 1.

Options

--help: Mostrar información de ayuda
--version: false-version-text

Examples

Devuelve un código de salida distinto de cero:

false

Hace que un comando siempre salga con 1:

{{command}} && false

fmt

v(uutils coreutils) 0.8.0

[OPCIÓN]... [ARCHIVO]...

Reformatear párrafos de entrada (o entrada estándar) a stdout.

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

Reformatea un archivo:

fmt {{ruta/al/archivo}}

Reformatea un archivo produciendo líneas de salida de (como máximo) n caracteres:

fmt {{[-w|--width]}} {{n}} {{ruta/al/archivo}}

Reformatea un archivo sin unir las líneas más cortas respecto al ancho dado:

fmt {{[-s|--split-only]}} {{ruta/al/archivo}}

Reformatea un archivo con espaciado uniforme (1 espacio entre palabras y 2 espacios entre párrafos):

fmt {{[-u|--uniform-spacing]}} {{ruta/al/archivo}}

fold

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

fold [OPCIÓN]... [ARCHIVO]...

Escribe cada archivo (o entrada estándar si no se proporcionan archivos) a la salida estándar mientras corta líneas largas

Options

--bytes, -b: fold-bytes-help
--characters, -c: fold-characters-help
--spaces, -s: fold-spaces-help
--width=<WIDTH>, -w <WIDTH>: fold-width-help

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

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}}

groups

v(uutils coreutils) 0.8.0

groups [OPCIÓN]... [NOMBREUSUARIO]...

Mostrar membresías de grupo para cada NOMBREUSUARIO o, si no se especifica NOMBREUSUARIO, para el proceso actual (que puede diferir si la base de datos de grupos ha cambiado).

Options

Examples

Muestra los grupos a los que pertenece el usuario actual:

groups

Imprime la pertenencia a grupos de una lista de usuarios:

groups {{nombredeusuario1 nombredeusuario2 ...}}

head

v(uutils coreutils) 0.8.0

head [OPCIÓN]... [ARCHIVO]...

Mostrar las primeras 10 líneas de cada ARCHIVO a salida estándar. Con más de un ARCHIVO, preceder cada uno con un encabezado que muestre el nombre del archivo. Sin ARCHIVO, o cuando ARCHIVO es -, leer entrada estándar.

Los argumentos obligatorios para las opciones largas también son obligatorios para las opciones cortas.

Options

--bytes=<[-]NUM>, -c <[-]NUM>: mostrar los primeros NÚM bytes de cada archivo;
con el ‘-’ inicial, mostrar todos excepto los últimos
NÚM bytes de cada archivo
--lines=<[-]NUM>, -n <[-]NUM>: mostrar las primeras NÚM líneas en lugar de las primeras 10;
con el ‘-’ inicial, mostrar todas excepto las últimas
NÚM líneas de cada archivo
--quiet, --silent, -q: nunca mostrar encabezados con nombres de archivo
--verbose, -v: siempre mostrar encabezados con nombres de archivo
--presume-input-pipe
--zero-terminated, -z: el delimitador de línea es NUL, no nueva línea

Examples

Output the first few lines of a file:

head -n {{count}} {{path/to/file}}

hostid

v(uutils coreutils) 0.8.0

hostid [opciones]

Imprimir el identificador numérico (en hexadecimal) para el host actual

Options

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Display the numeric identifier for the current host in hexadecimal:

hostid

hostname

v(uutils coreutils) 0.8.0

hostname [OPCIÓN]... [NOMBRE_HOST]

Mostrar o establecer el nombre del host del sistema.

Options

--domain, -d: Mostrar el nombre del dominio DNS si es posible
--ip-address, -i: Mostrar la(s) dirección(es) de red del host
--fqdn, -f: Mostrar el FQDN (Nombre de Dominio Completamente Calificado) (predeterminado)
--short, -s: Mostrar el nombre de host corto (la porción antes del primer punto) si es posible

Examples

Muestra el nombre actual del host:

hostname

Muestra la dirección de red correspondiente al nombre del host:

hostname {{[-i|--ip-address]}}

Muestra el FQDN (nombre de dominio completamente calificado):

hostname {{[-f|--fqdn]}}

Establece el nombre del host:

hostname {{nuevo_nombre}}

id

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

id [OPCIÓN]... [USUARIO]...

Mostrar información de usuario y grupo para cada USUARIO especificado, o (cuando se omite USUARIO) para el usuario actual.

Options

--ignore, -a: se descarta, para compatibilidad con otras versiones
-A: Mostrar el ID de usuario de auditoría del proceso y otras propiedades de auditoría del proceso,
lo cual requiere privilegio (no disponible en Linux).
--user, -u: Mostrar solo el ID de usuario efectivo como un número.
--group, -g: Mostrar solo el ID de grupo efectivo como un número
--groups, -G: Mostrar solo los diferentes IDs de grupo como números separados por espacios en blanco,
en ningún orden particular.
-p: Hacer la salida legible por humanos. Cada muestra está en una línea separada.
--name, -n: Mostrar el nombre del ID de usuario o grupo para las opciones -G, -g y -u
en lugar del número.
Si cualquiera de los números de ID no se puede mapear a
nombres, el número se mostrará como usual.
-P: Mostrar el id como una entrada de archivo de contraseña.
--real, -r: Mostrar el ID real para las opciones -G, -g y -u en lugar del
ID efectivo.
--zero, -z: delimitar entradas con caracteres NUL, no espacios en blanco;
no permitido en formato por defecto
--context, -Z: id-context-help-enabled

La utilidad id muestra los nombres de usuario y grupo e IDs numéricos, del proceso que llama, a la salida estándar. Si los IDs reales y efectivos son diferentes, ambos se muestran, de otra manera solo se muestra el ID real.

Si se especifica un usuario (nombre de login o ID de usuario), se muestran los IDs de usuario y grupo de ese usuario. En este caso, se asume que los IDs reales y efectivos son los mismos.

Examples

Muestra la ID del usuario actual (UID), la ID del grupo (GID) y los grupos a los que pertenece:

id

Muestra la identidad del usuario actual:

id {{[-un|--user --name]}}

Muestra la identidad del usuario actual como un número:

id {{[-u|--user]}}

Muestra la identidad del grupo primario actual:

id {{[-gn|--group --name]}}

Muestra la identidad del grupo primario actual como un número:

id {{[-g|--group]}}

Muestra el ID (UID) de un usuario arbitrario, el ID de grupo (GID) y los grupos a los que pertenece:

id {{usuario}}

install

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

install [OPCIÓN]... [ARCHIVO]...

Copiar FUENTE a DEST o múltiples FUENTE(s) al DIRECTORIO existente, mientras se establecen los modos de permisos y propietario/grupo

Options

--backup=<CONTROL>: make a backup of each existing destination file
-b: like –backup but does not accept an argument
-c: ignorado
--compare, -C: comparar cada par de archivos fuente y destino, y en algunos casos, no modificar el destino en absoluto
--directory, -d: tratar todos los argumentos como nombres de directorio. crear todos los componentes de los directorios especificados
-D: crear todos los componentes principales de DEST excepto el último, luego copiar FUENTE a DEST
--group=<GROUP>, -g <GROUP>: establecer propiedad del grupo, en lugar del grupo actual del proceso
--mode=<MODE>, -m <MODE>: establecer modo de permisos (como en chmod), en lugar de rwxr-xr-x
--owner=<OWNER>, -o <OWNER>: establecer propiedad (solo super-usuario)
--preserve-timestamps, -p: aplicar tiempos de acceso/modificación de archivos FUENTE a los archivos destino correspondientes
--strip, -s: quitar tablas de símbolos (sin acción en Windows)
--strip-program=<PROGRAM>: programa usado para quitar símbolos de binarios (sin acción en Windows)
--suffix=<SUFFIX>, -S <SUFFIX>: override the usual backup suffix
--target-directory=<DIRECTORY>, -t <DIRECTORY>: mover todos los argumentos FUENTE al DIRECTORIO
--no-target-directory, -T: tratar DEST como un archivo normal
--verbose, -v: explicar qué se está haciendo
--preserve-context, -P: preservar contexto de seguridad
-Z: establecer contexto de seguridad SELinux de archivo destino y cada directorio creado a tipo predeterminado
--context=<CONTEXT>: establecer contexto de seguridad de archivos y directorios

--unprivileged, -U: do not require elevated privileges to change the owner, the group, or the file flags of the destination

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Copy files to the destination:

install {{path/to/source_file1 path/to/source_file2 ...}} {{path/to/destination}}

Copy files to the destination, setting their ownership:

install {{[-o|--owner]}} {{user}} {{path/to/source_file1 path/to/source_file2 ...}} {{path/to/destination}}

Copy files to the destination, setting their group ownership:

install {{[-g|--group]}} {{user}} {{path/to/source_file1 path/to/source_file2 ...}} {{path/to/destination}}

Copy files to the destination, setting their mode:

install {{[-m|--mode]}} {{+x}} {{path/to/source_file1 path/to/source_file2 ...}} {{path/to/destination}}

Copy files and apply access/modification times of source to the destination:

install {{[-p|--preserve-timestamps]}} {{path/to/source_file1 path/to/source_file2 ...}} {{path/to/destination}}

Copy files and create the directories at the destination if they don’t exist:

install -D {{path/to/source_file1 path/to/source_file2 ...}} {{path/to/destination}}

join

v(uutils coreutils) 0.8.0

join [OPCIÓN]... ARCHIVO1 ARCHIVO2

Para cada par de líneas de entrada con campos de unión idénticos, escribir una línea a la salida estándar. El campo de unión predeterminado es el primero, delimitado por espacios en blanco.

Cuando FILE1 o FILE2 (no ambos) es -, leer entrada estándar.

Options

-a <FILENUM>: también imprimir líneas no emparejables del archivo NUMARCHIVO, donde
NUMARCHIVO es 1 o 2, correspondiente a ARCHIVO1 o ARCHIVO2
-v <FILENUM>: como -a NUMARCHIVO, pero suprimir líneas de salida unidas
-e <EMPTY>: reemplazar campos de entrada faltantes con VACÍO
--ignore-case, -i: ignorar diferencias de mayúsculas/minúsculas al comparar campos
-j <FIELD>: equivalente a ‘-1 CAMPO -2 CAMPO’
-o <FORMAT>: obedecer FORMATO mientras se construye la línea de salida
-t <CHAR>: usar CARÁCTER como separador de campo de entrada y salida
-1 <FIELD>: unir en este CAMPO del archivo 1
-2 <FIELD>: unir en este CAMPO del archivo 2
--check-order: verificar que la entrada esté correctamente ordenada, incluso si todas las líneas de entrada son emparejables
--nocheck-order: no verificar que la entrada esté correctamente ordenada
--header: tratar la primera línea en cada archivo como cabeceras de campo, imprimirlas sin intentar emparejarlas
--zero-terminated, -z: el delimitador de línea es NUL, no nueva línea

Examples

Une dos archivos en el primer campo (por defecto):

join {{ruta/al/archivo1}} {{ruta/al/archivo2}}

Une dos archivos utilizando una coma (en lugar de un espacio) como separador de campos:

join -t ',' {{ruta/al/archivo1}} {{ruta/al/archivo2}}

Une el campo3 del archivo1 con el campo1 del archivo2:

join -1 {{3}} -2 {{1}} {{ruta/al/fichero1}} {{ruta/al/archivo2}}

Produce una línea por cada línea no emparejable del fichero1:

join -a {{1}} {{ruta/al/fichero1}} {{ruta/al/archivo2}}

Une un fichero desde stdin:

cat {{ruta/al/archivo1}} | join - {{ruta/al/archivo2}}

kill

v(uutils coreutils) 0.8.0

kill [OPCIONES]... PID...

Enviar señal a procesos o listar información sobre señales.

Options

--list, -l: Lista señales
--table, -t: Lista tabla de señales
--signal=<signal>, -s <signal>: Envía la señal dada en lugar de SIGTERM

Examples

Termina un programa usando la señal SIGTERM (terminar) predeterminada:

kill {{identificador_del_proceso}}

Lista todas las señales disponibles (para utilizarlas sin el prefijo SIG):

kill -l

Termina un programa usando la señal SIGHUP (hang up/colgar). Muchos programas residentes (daemons) se recargarán en lugar de terminar:

kill {{[-1|-HUP]}} {{identificador_del_proceso}}

Termina un programa usando la señal SIGINT (interrumpir). Esto es normalmente iniciado por el usuario al presionar <Ctrl c>:

kill {{[-2|-INT]}} {{identificador_del_proceso}}

Señala al sistema operativo terminar inmediatamente un programa (el cual no tiene oportunidad de capturar la señal):

kill {{[-9|-KILL]}} {{identificador_del_proceso}}

Señala al sistema operativo pausar un programa hasta que la señal SIGCONT (continuar) sea recibida:

kill {{[-19|-STOP]}} {{identificador_del_proceso}}

Envía una señal SIGUSR1 a todos los procesos con un GID (id de grupo) dado:

kill -SIGUSR1 -{{identificador_de_grupo}}

link

v(uutils coreutils) 0.8.0

link ARCHIVO1 ARCHIVO2

Llamar la función link para crear un enlace llamado ARCHIVO2 a un ARCHIVO1 existente.

Options

Examples

Crea un enlace duro de un archivo nuevo a un archivo existente:

link {{ruta/al/archivo_existente}} {{ruta/al/archivo_nuevo}}

ln

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

ln [OPCIÓN]... [-T] DESTINO NOMBRE_ENLACE
ln [OPCIÓN]... DESTINO
ln [OPCIÓN]... DESTINO... DIRECTORIO
ln [OPCIÓN]... -t DIRECTORIO DESTINO...

Crear enlaces entre archivos.

Options

--backup=<CONTROL>: make a backup of each existing destination file
-b: like –backup but does not accept an argument
--force, -f: eliminar archivos destino existentes
--interactive, -i: preguntar si eliminar archivos destino existentes
--no-dereference, -n: tratar NOMBRE_ENLACE como un archivo normal si es un
enlace simbólico a un directorio
--logical, -L: seguir DESTINOs que son enlaces simbólicos
--physical, -P: hacer enlaces duros directamente a enlaces simbólicos
--symbolic, -s: hacer enlaces simbólicos en lugar de enlaces duros
--suffix=<SUFFIX>, -S <SUFFIX>: override the usual backup suffix
--target-directory=<DIRECTORY>, -t <DIRECTORY>: especificar el DIRECTORIO en el cual crear los enlaces
--no-target-directory, -T: tratar NOMBRE_ENLACE como un archivo normal siempre
--relative, -r: crear enlaces simbólicos relativos a la ubicación del enlace
--verbose, -v: mostrar nombre de cada archivo enlazado

En la 1a forma, crear un enlace a DESTINO con el nombre NOMBRE_ENLACE. En la 2a forma, crear un enlace a DESTINO en el directorio actual. En las 3a y 4a formas, crear enlaces a cada DESTINO en DIRECTORIO. Crear enlaces duros por defecto, enlaces simbólicos con –symbolic. Por defecto, cada destino (nombre del nuevo enlace) no debería existir ya. Al crear enlaces duros, cada DESTINO debe existir. Los enlaces simbólicos pueden contener texto arbitrario; si se resuelve posteriormente, un enlace relativo se interpreta en relación a su directorio padre.

Examples

Crea un enlace simbólico a un archivo o directorio:

ln {{[-s|--symbolic]}} {{/ruta/al/archivo_o_directorio}} {{ruta/al/enlace_simbólico}}

Sobrescribe un enlace simbólico existente para que apunte a un archivo distinto:

ln {{[-sf|--symbolic --force]}} {{/ruta/al/nuevo_archivo}} {{ruta/al/enlace_simbólico}}

Crea un enlace duro a un archivo:

ln {{/ruta/al/archivo}} {{ruta/al/enlace_duro}}

logname

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

logname

Imprimir el nombre de inicio de sesión del usuario

Options

Examples

Muestra el nombre del usuario que ha iniciado sesión actualmente:

logname

ls

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

ls [OPCIÓN]... [ARCHIVO]...

Listar contenido de directorios. Ignorar archivos y directorios que empiecen por ‘.’ de forma predeterminada

Options

--help: Mostrar información de ayuda.
--format: Establecer el formato de visualización.
-C: Mostrar los archivos en columnas.
--long, -l: Mostrar información detallada.
-x: Listar entradas en filas en lugar de columnas.
--tabsize=<COLS>, -T <COLS>: Asumir paradas de tabulación en cada COLS en lugar de 8
-m: Listar entradas separadas por comas.
--zero: Listar entradas separadas por caracteres NUL ASCII.
--dired, -D: generar salida diseñada para el modo dired (Directory Editor) de Emacs
--hyperlink=<WHEN>: crear hiperenlaces en nombres de archivo CUANDO
-1: Listar un archivo por línea.
-o: Formato largo sin información de grupo.
Idéntico a –format=long con –no-group.
-g: Formato largo sin información de propietario.
--numeric-uid-gid, -n: -l con UIDs y GIDs numéricos.
--quoting-style: Establecer estilo de comillas.
--literal, -N: Usar estilo de comillas literal. Equivalente a --quoting-style=literal
--escape, -b: Usar estilo de comillas de escape. Equivalente a --quoting-style=escape
--quote-name, -Q: Usar estilo de comillas C. Equivalente a --quoting-style=c
--hide-control-chars, -q: Reemplazar caracteres de control con ‘?’ si no están escapados.
--show-control-chars: Mostrar caracteres de control ‘tal como están’ si no están escapados.
--time=<field>: Mostrar tiempo en :
tiempo de acceso (-u): atime, access, use;
tiempo de cambio (-t): ctime, status.
tiempo de modificación: mtime, modification.
tiempo de creación: birth, creation;
-c: Si se está usando el formato de listado largo (p. ej., -l, -o), mostrar el
tiempo de cambio de estado (el ‘ctime’ en el inode) en lugar del tiempo de
modificación. Cuando se ordene explícitamente por tiempo (–sort=time o -t) o cuando
no se use un formato de listado largo, ordenar según el tiempo de cambio de estado.
-u: Si se está usando el formato de listado largo (p. ej., -l, -o), mostrar el
tiempo de acceso de estado en lugar del tiempo de modificación. Cuando se ordene
explícitamente por tiempo (–sort=time o -t) o cuando no se use un formato de
listado largo, ordenar según el tiempo de acceso.
--hide=<PATTERN>: no listar entradas implícitas que coincidan con el PATRÓN shell (anulado por -a o -A)
--ignore=<PATTERN>, -I <PATTERN>: no listar entradas implícitas que coincidan con el PATRÓN shell
--ignore-backups, -B: Ignorar entradas que terminen con ~.
--sort=<field>: Ordenar por : name, none (-U), time (-t), size (-S), extension (-X) o width
-S: Ordenar por tamaño de archivo, el más grande primero.
-t: Ordenar por tiempo de modificación (el ‘mtime’ en el inode), el más nuevo primero.
-v: Ordenación natural de números (de versión) en los nombres de archivo.
-X: Ordenar alfabéticamente por extensión de entrada.
-U: No ordenar; listar los archivos en cualquier orden en que estén almacenados en el
directorio. Esto es especialmente útil al listar directorios muy grandes,
ya que no ordenar puede ser notablemente más rápido.
--dereference, -L: Al mostrar información de archivo para un enlace simbólico, mostrar información para el
archivo al que se refiere el enlace en lugar del enlace mismo.
--dereference-command-line-symlink-to-dir: No seguir enlaces simbólicos excepto cuando enlacen a directorios y sean
dados como argumentos de línea de comandos.
--dereference-command-line, -H: No seguir enlaces simbólicos excepto cuando sean dados como argumentos de línea de comandos.
--no-group, -G: No mostrar grupo en formato largo.
--author: Mostrar autor en formato largo. En las plataformas soportadas,
el autor siempre coincide con el propietario del archivo.
--all, -a: No ignorar archivos ocultos (archivos con nombres que empiecen por ‘.’).
--almost-all, -A: En un directorio, no ignorar todos los nombres de archivo que empiecen por ‘.’,
solo ignorar ‘.’ y ‘..’.
-f: Listado de todos los archivos dentro del directorio ordenado, no ordenado. Equivalente a -aU. Inhabilita –color a no ser que se especifique explícitamente.
--directory, -d: Solo listar los nombres de directorios, en lugar de listar contenido de directorios.
Esto no seguirá enlaces simbólicos a menos que se especifique una de las opciones
--dereference-command-line (-H), --dereference (-L), o
--dereference-command-line-symlink-to-dir.
--human-readable, -h: Mostrar tamaños de archivo legibles por humanos (p. ej. 1K 234M 56G).
--kibibytes, -k: predeterminado a bloques de 1024 bytes para uso del sistema de archivos; usado solo con -s y por
totales de directorio
--si: Mostrar tamaños de archivo legibles por humanos usando potencias de 1000 en lugar de 1024.
--block-size=<BLOCK_SIZE>: escalar tamaños por BLOCK_SIZE al mostrarlos
--inode, -i: mostrar el número de índice de cada archivo
--reverse, -r: Invertir cualquier método de ordenación, p. ej., listar archivos en orden
alfabético inverso, el más joven primero, el más pequeño primero, o lo que sea.
--recursive, -R: Listar el contenido de todos los directorios recursivamente.
--width=<COLS>, -w <COLS>: Asumir que el terminal tiene COLS columnas de ancho.
--size, -s: mostrar el tamaño asignado de cada archivo, en bloques
--color: Colorear salida basada en tipo de archivo.
--indicator-style: Añadir indicador con estilo WORD a nombres de entrada:
none (predeterminado), slash (-p), file-type (–file-type), classify (-F)
--classify=<when>, -F <when>: Añadir un carácter a cada nombre de archivo indicando el tipo de archivo. También, para
archivos regulares que son ejecutables, añadir ‘*’. Los indicadores de tipo de archivo son
‘/’ para directorios, ‘@’ para enlaces simbólicos, ‘|’ para FIFOs, ‘=’ para sockets,
‘>’ para puertas, y nada para archivos regulares. when puede omitirse, o uno de:
none - No clasificar. Este es el predeterminado.
auto - Solo clasificar si salida estándar es un terminal.
always - Siempre clasificar.
Especificar –classify y ningún when es equivalente a –classify=always. Esto no
seguirá enlaces simbólicos listados en la línea de comandos a menos que se especifiquen
las opciones –dereference-command-line (-H), –dereference (-L), o
–dereference-command-line-symlink-to-dir.
--file-type: Igual que –classify, pero no añadir ‘*’
-p: Añadir indicador / a directorios.
--time-style=<TIME_STYLE>: formato de fecha/hora con -l; ver TIME_STYLE abajo
--full-time: como -l –time-style=full-iso
--context, -Z: mostrar cualquier contexto de seguridad de cada archivo
--group-directories-first: agrupar directorios antes que archivos; puede aumentarse con
una opción –sort, pero cualquier uso de –sort=none (-U) deshabilita la agrupación

El argumento TIME_STYLE puede ser full-iso, long-iso, iso, locale o +FORMATO. FORMATO se interpreta como en date. También la variable de entorno TIME_STYLE establece el estilo predeterminado a usar.

Examples

Lista un archivo por línea:

ls -1

Lista todos los archivos, incluyendo archivos ocultos:

ls {{[-a|--all]}}

Lista todos los archivos, añadiendo / al final de los nombres de directorios:

ls {{[-F|--classify]}}

Lista todos los archivos en formato largo (permisos, propietarios, tamaño y fecha de última modificación):

ls {{[-la|-l --all]}}

Lista en formato largo y tamaño legible por humanos (i.e., KiB, MiB, GiB, etc.):

ls {{[-lh|-l --human-readable]}}

Lista recursivamente en formato largo y ordena los tamaños de mayor a menor:

ls {{[-lSR|-lS --recursive]}}

Lista todos los archivos en formato largo y ordenados por fecha de modificación (archivos más viejos en primer lugar):

ls {{[-ltr|-lt --reverse]}}

Lista solamente directorios:

ls {{[-d|--directory]}} */

md5sum

v(uutils coreutils) 0.8.0

md5sum [OPTIONS] [FILE]...

Print or check the MD5 checksums

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

Calcula la suma de comprobación MD5 de uno o más archivos:

md5sum {{ruta/al/archivo1 ruta/al/archivo2 ...}}

Calcula y guarda la lista de sumas de comprobación MD5 en un archivo:

md5sum {{ruta/al/archivo1 ruta/al/archivo2 ...}} > {{ruta/al/archivo.md5}}

Calcula una suma de comprobación MD5 a partir de stdin:

{{comando}} | md5sum

Lee un archivo de sumas de comprobación MD5 y nombres de archivo y verifica que todos los archivos tengan sumas de comprobación coincidentes:

md5sum {{[-c|--check]}} {{ruta/al/archivo.md5}}

Muestra un mensaje solo para los archivos que faltan o cuando falla la verificación:

md5sum {{[-c|--check]}} --quiet {{ruta/al/archivo.md5}}

Muestra un mensaje solo cuando falla la verificación, ignorando los archivos que faltan:

md5sum --ignore-missing {{[-c|--check]}} --quiet {{ruta/al/archivo.md5}}

Comprueba la suma de comprobación MD5 conocida de un archivo:

echo {{suma_de_comprobación_md5_conocida_del_archivo}} {{ruta/al/archivo}} | md5sum {{[-c|--check]}}

mkdir

v(uutils coreutils) 0.8.0

mkdir [OPCIÓN]... DIRECTORIO...

Crear el/los DIRECTORIO(s) dado(s) si no existen

Options

--mode, -m: establecer modo de archivo (no implementado en windows)
--parents, -p: crear directorios padre según sea necesario
--verbose, -v: mostrar un mensaje para cada directorio mostrado
-Z: establecer el contexto de seguridad SELinux de cada directorio creado al tipo por defecto
--context=<CTX>: como -Z, o si se especifica CTX entonces establecer el contexto de seguridad SELinux o SMACK a CTX

Cada MODO tiene la forma [ugoa]*(-+=)+|[-+=]?[0-7]+.

Examples

Crea los directorios especificados:

mkdir {{ruta/al/directorio1 ruta/al/directorio2 ...}}

Crea directorios recursivamente y sus padres si es necesario:

mkdir {{[-p|--parents]}} {{ruta/al/directorio}}

Crea directorios con permisos específicos:

mkdir {{[-m|--mode]}} {{rwxrw-r--}} {{ruta/al/directorio1 ruta/al/directorio2 ...}}

mkfifo

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

mkfifo [OPCIÓN]... NOMBRE...

Crear un FIFO con el nombre dado.

Options

--mode=<MODE>, -m <MODE>: permisos de archivo para el fifo
-Z: establecer el contexto de seguridad SELinux al tipo predeterminado
--context=<CTX>: como -Z, o si se especifica CTX entonces establecer el contexto de seguridad SELinux o SMACK a CTX

Examples

Crea un pipe nombrado en una ruta específica:

mkfifo {{ruta/al/pipe}}

Envía datos a través de un pipe nombrado ejecutando el comando en segundo plano:

echo "{{Hola Mundo}}" > {{ruta/al/pipe}} &

Recibe datos a través de un pipe nombrado:

cat {{ruta/al/pipe}}

Comparte tu sesión de la terminal en tiempo real:

mkfifo {{ruta/al/pipe}}; script -f {{ruta/al/pipe}}

mknod

v(uutils coreutils) 0.8.0

mknod [OPCIÓN]... NOMBRE TIPO [MAYOR MENOR]

Crear el archivo especial NOMBRE del TIPO dado.

Options

--mode=<MODE>, -m <MODE>: establecer los bits de permisos de archivo a MODO, no a=rw - umask
: nombre del nuevo archivo
: tipo del nuevo archivo (b, c, u o p)
: tipo de archivo mayor
: tipo de archivo menor
-Z: establecer el contexto de seguridad SELinux de cada directorio creado al tipo predeterminado
--context=<CTX>: como -Z, o si se especifica CTX entonces establecer el contexto de seguridad SELinux o SMACK a CTX

Los argumentos obligatorios para las opciones largas son obligatorios también para las opciones cortas. -m, –mode=MODO establecer los bits de permisos de archivo a MODO, no a=rw - umask

Tanto MAYOR como MENOR deben especificarse cuando TIPO es b, c, o u, y deben omitirse cuando TIPO es p. Si MAYOR o MENOR comienza con 0x o 0X, se interpreta como hexadecimal; de lo contrario, si comienza con 0, como octal; de lo contrario, como decimal. TIPO puede ser:

b crear un archivo especial de bloque (con búfer)
c, u crear un archivo especial de carácter (sin búfer)
p crear un FIFO

NOTA: su shell puede tener su propia versión de mknod, que generalmente reemplaza la versión descrita aquí. Por favor consulte la documentación de su shell para detalles sobre las opciones que soporta.

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

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}}

mktemp

v(uutils coreutils) 0.8.0

mktemp [OPCIÓN]... [PLANTILLA]

Crear un archivo o directorio temporal.

Options

--directory, -d: Crear un directorio en lugar de un archivo
--dry-run, -u: no crear nada; simplemente imprimir un nombre (inseguro)
--quiet, -q: Fallar silenciosamente si ocurre un error.
--suffix=<SUFFIX>: agregar SUFIJO a PLANTILLA; SUFIJO no debe contener un separador de ruta. Esta opción está implícita si PLANTILLA no termina con X.
-p <DIR>: forma corta de –tmpdir
--tmpdir=<DIR>: interpretar PLANTILLA relativa a DIR; si DIR no se especifica, usar $TMPDIR ($TMP en windows) si está establecido, de lo contrario /tmp. Con esta opción, PLANTILLA no debe ser un nombre absoluto; a diferencia de -t, PLANTILLA puede contener barras, pero mktemp crea solo el componente final
-t: Generar una plantilla (usando el prefijo suministrado y TMPDIR (TMP en windows) si está establecido) para crear una plantilla de nombre de archivo [obsoleto]

Examples

Create an empty temporary file and print its absolute path:

mktemp

Use a custom directory if $TMPDIR is not set (the default is platform-dependent, but usually /tmp):

mktemp -p /{{path/to/temporary_directory}}

Use a custom path template (Xs are replaced with random alphanumeric characters):

mktemp {{/tmp/example.XXXXXXXX}}

Use a custom file name template:

mktemp -t {{example.XXXXXXXX}}

Create an empty temporary directory and print its absolute path:

mktemp -d

v(uutils coreutils) 0.8.0

more [OPCIONES] ARCHIVO...

Mostrar el contenido de un archivo de texto

Options

--silent, -d: Mostrar ayuda en lugar de sonar campana cuando se presiona una tecla ilegal
--logical, -l: No pausar después de cualquier línea que contenga un ^L (alimentación de formulario)
--exit-on-eof, -e: Salir al Final-Del-Archivo
--no-pause, -f: Contar líneas lógicas, en lugar de líneas de pantalla
--print-over, -p: No desplazar, limpiar pantalla y mostrar texto
--clean-print, -c: No desplazar, mostrar texto y limpiar finales de línea
--squeeze, -s: Comprimir múltiples líneas en blanco en una
--plain, -u: Suprimir subrayado
--lines=<number>, -n <number>: El número de líneas por pantalla completa
--number: Igual que el argumento de la opción –lines
--from-line=<number>, -F <number>: Comenzar a mostrar cada archivo en el número de línea
--pattern=<pattern>, -P <pattern>: La cadena a buscar en cada archivo antes de comenzar a mostrarlo
: Ruta a los archivos a leer

Examples

Abre un archivo:

more {{ruta/al/archivo}}

Abre un archivo y muestra su contenido desde una línea específica:

more +{{número_de_línea}} {{ruta/al/archivo}}

Avanza a la siguiente página:

<Espacio>

Busca una cadena de caracteres (presione n para ir a la siguiente coincidencia):

/{{cadena}}

Sal del programa:

Muestra ayuda sobre comandos interactivos:

mv

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

mv [OPCIÓN]... [-T] ORIGEN DESTINO
mv [OPCIÓN]... ORIGEN... DIRECTORIO
mv [OPCIÓN]... -t DIRECTORIO ORIGEN...

Mover ORIGEN a DESTINO, o múltiples ORIGEN(es) a DIRECTORIO.

Options

--force, -f: no avisar antes de sobreescribir
--interactive, -i: avisar antes de anular
--no-clobber, -n: no sobreescribir un archivo existente
--strip-trailing-slashes: eliminar cualquier barra final de cada argumento ORIGEN
--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>: mover todos los argumentos ORIGEN al DIRECTORIO
--no-target-directory, -T: tratar DESTINO como un archivo normal
--verbose, -v: explicar lo que se está haciendo
--progress, -g: Mostrar una barra de progreso.
Nota: esta característica no está soportada por GNU coreutils.
-Z: establecer contexto de seguridad SELinux del archivo destino al tipo predeterminado
--context=<CTX>: como -Z, o si CTX está especificado entonces establezca el contexto de seguridad SELinux a CTX

--debug: explicar cómo se copia un archivo. Implica -v

Al especificar más de una de -i, -f, -n, solo la final tendrá efecto.

No mover un no-directorio que tiene un destino existente con la misma o más nueva marca de tiempo de modificación; en su lugar, omitir silenciosamente el archivo sin fallar. Si el movimiento cruza límites de sistema de archivos, la comparación es con la marca de tiempo de origen truncada a las resoluciones del sistema de archivos de destino y de las llamadas del sistema usadas para actualizar marcas de tiempo; esto evita trabajo duplicado si varios comandos mv -u se ejecutan con el mismo origen y destino. Esta opción se ignora si también se especifica la opción -n o –no-clobber. lo cual da más control sobre qué archivos existentes en el destino son reemplazados, y su valor puede ser uno de los siguientes:

all Esta es la operación por defecto cuando no se especifica una opción –update, y resulta en que todos los archivos existentes en el destino sean reemplazados.
none Esto es similar a la opción –no-clobber, en que ningún archivo en el destino es reemplazado, pero también omitir un archivo no induce un fallo.
older Esta es la operación por defecto cuando se especifica –update, y resulta en que los archivos sean reemplazados si son más antiguos que el archivo origen correspondiente.

Examples

Cambia el nombre de un archivo o directorio cuando el destino no es un directorio existente:

mv {{ruta/a/origen}} {{ruta/a/destino}}

Mueve un archivo o directorio a un directorio existente:

mv {{ruta/a/origen}} {{ruta/al/directorio_existente}}

Mueve varios archivos a un directorio existente, manteniendo los nombres de archivo sin cambios:

mv {{ruta/a/origen1 ruta/a/origen2 ...}} {{ruta/al/directorio_existente}}

No pedir confirmación antes de sobrescribir los archivos existentes:

mv {{[-f|--force]}} {{ruta/a/origen}} {{ruta/a/destino}}

Pedir confirmación interactivamente antes de sobrescribir archivos existentes, independientemente de los permisos de los archivos:

mv {{[-i|--interactive]}} {{ruta/a/origen}} {{ruta/a/destino}}

No sobrescribir los archivos existentes en el destino:

mv {{[-n|--no-clobber]}} {{ruta/a/origen}} {{ruta/a/destino}}

Mueve archivos en modo verboso, mostrando los archivos después de moverlos:

mv {{[-v|--verbose]}} {{ruta/a/origen}} {{ruta/a/destino}}

Especifica el directorio de destino para poder utilizar herramientas externas para recopilar archivos movibles:

{{find /var/log -type f -name '*.log' -print0}} | {{xargs -0}} mv {{[-t|--target-directory]}} {{ruta/al/directorio_destino}}

nice

v(uutils coreutils) 0.8.0

nice [OPCIÓN] [COMANDO [ARG]...]

Ejecutar COMANDO con una prioridad ajustada, que afecta la programación de procesos. Sin COMANDO, imprimir la prioridad actual. Los valores de prioridad van desde -20 (más favorable al proceso) hasta 19 (menos favorable al proceso).

Options

--adjustment, -n: agregar N a la prioridad (predeterminado es 10)

Examples

Inicia un programa con la prioridad modificada:

nice -{{valor_de_niceness}} {{comando}}

Defina la prioridad con una opción explícita:

nice {{[-n|--adjustment]}} {{valor_de_niceness}} {{comando}}

nl

v(uutils coreutils) 0.8.0

nl [OPCIÓN]... [ARCHIVO]...

Numerar líneas de archivos

Options

--help: Imprimir información de ayuda.

--body-numbering=<STYLE>, -b <STYLE>: usar ESTILO para numerar líneas del cuerpo
--section-delimiter=<CC>, -d <CC>: usar CC para separar páginas lógicas
--footer-numbering=<STYLE>, -f <STYLE>: usar ESTILO para numerar líneas del pie
--header-numbering=<STYLE>, -h <STYLE>: usar ESTILO para numerar líneas del encabezado
--line-increment=<NUMBER>, -i <NUMBER>: incremento del número de línea en cada línea
--join-blank-lines=<NUMBER>, -l <NUMBER>: grupo de NÚMERO líneas vacías contadas como una
--number-format=<FORMAT>, -n <FORMAT>: insertar números de línea según FORMATO
--no-renumber, -p: no reiniciar números de línea en páginas lógicas
--number-separator=<STRING>, -s <STRING>: agregar CADENA después del número de línea (posible)
--starting-line-number=<NUMBER>, -v <NUMBER>: primer número de línea en cada página lógica
--number-width=<NUMBER>, -w <NUMBER>: usar NÚMERO columnas para números de línea

ESTILO es uno de:

a numerar todas las líneas
t numerar solo líneas no vacías
n no numerar líneas
pBRE numerar solo líneas que contengan una coincidencia para la expresión regular básica, BRE

FORMATO es uno de:

ln justificado a la izquierda, sin ceros a la izquierda
rn justificado a la derecha, sin ceros a la izquierda
rz justificado a la derecha, con ceros a la izquierda

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

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}}

nohup

v(uutils coreutils) 0.8.0

nohup COMANDO [ARG]...
nohup OPCIÓN

Ejecutar COMANDO ignorando señales de desconexión.

Options

Si la entrada estándar es terminal, será reemplazada con /dev/null. Si la salida estándar es terminal, será anexada a nohup.out en su lugar, o $HOME/nohup.out, si falló abrir nohup.out. Si el error estándar es terminal, será redirigido a stdout.

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

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}} &

nproc

v(uutils coreutils) 0.8.0

nproc [OPCIONES]...

Imprimir el número de núcleos disponibles para el proceso actual. Si las variables de entorno OMP_NUM_THREADS u OMP_THREAD_LIMIT están establecidas, entonces determinarán el valor mínimo y máximo devuelto respectivamente.

Options

--all: imprimir el número de núcleos disponibles para el sistema
--ignore=<N>: ignorar hasta N núcleos

Examples

Muestra el número de unidades de procesamiento disponibles:

nproc

Muestra el número de unidades de procesamiento instaladas, incluidas las inactivas:

nproc --all

Si es posible, resta un número determinado de unidades del valor devuelto:

nproc --ignore {{conteo}}

numfmt

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

numfmt [OPCIÓN]... [NÚMERO]...

Convertir números desde/hacia cadenas legibles por humanos

Options

--debug: print warnings about invalid input
--grouping: use locale-defined grouping of digits, for example 1,000,000 (which means it has no effect in the C/POSIX locale)
--delimiter=<X>, -d <X>: usar X en lugar de espacio en blanco para delimitador de campo
--field=<FIELDS>: reemplazar los números en estos campos de entrada; ver CAMPOS abajo
--format=<FORMAT>: usar FORMATO de punto flotante estilo printf; ver FORMATO abajo para detalles
--from=<UNIT>: escalar automáticamente números de entrada a UNIDADes; ver UNIDAD abajo
--from-unit=<N>: especificar el tamaño de unidad de entrada
--to=<UNIT>: escalar automáticamente números de salida a UNIDADes; ver UNIDAD abajo
--to-unit=<N>: el tamaño de unidad de salida
--padding=<N>: rellenar la salida a N caracteres; N positivo alineará a la derecha; N negativo alineará a la izquierda; el relleno se ignora si la salida es más ancha que N; el predeterminado es rellenar automáticamente si se encuentra un espacio en blanco
--header=<N>: imprimir (sin convertir) las primeras N líneas de encabezado; N predeterminado es 1 si no se especifica
--round=<METHOD>: usar MÉTODO para redondear al escalar
--suffix=<SUFFIX>: imprimir SUFIJO después de cada número formateado, y aceptar entradas que terminen opcionalmente con SUFIJO
--unit-separator=<STRING>: use STRING to separate the number from any unit when printing; by default, no separator is used
--invalid=<INVALID>: establecer el modo de fallo para entrada no válida
--zero-terminated, -z: el delimitador de línea es NUL, no nueva línea

Opciones de UNIDAD:

none: no se hace escalado automático; los sufijos activarán un error
auto: aceptar sufijo opcional de una/dos letras:

1K = 1000, 1Ki = 1024, 1M = 1000000, 1Mi = 1048576,
si: aceptar sufijo opcional de una letra:

1K = 1000, 1M = 1000000, …
iec: aceptar sufijo opcional de una letra:

1K = 1024, 1M = 1048576, …
iec-i: aceptar sufijo opcional de dos letras:

1Ki = 1024, 1Mi = 1048576, …
CAMPOS soporta rangos de campo estilo cut(1):

N N-ésimo campo, contado desde 1 N- desde el N-ésimo campo, hasta el final de la línea N-M desde el N-ésimo hasta el M-ésimo campo (inclusive) -M desde el primero hasta el M-ésimo campo (inclusive)
- todos los campos

Múltiples campos/rangos pueden separarse con comas

FORMATO debe ser adecuado para imprimir un argumento de punto flotante %f. Comilla opcional (%’f) habilitará –grouping (si es soportado por la configuración regional actual). Valor de ancho opcional (%10f) rellenará la salida. Ancho cero opcional (%010f) rellenará el número con ceros. Valores negativos opcionales (%-10f) alinearán a la izquierda. Precisión opcional (%.1f) sobrescribirá la precisión determinada por la entrada.

Examples

Convierte 1.5K (Unidades SI) a 1500:

numfmt --from si 1.5K

Convierte el 5º campo (1-indexado) a Unidades IEC sin convertir la cabecera:

ls -l | numfmt --header=1 --field 5 --to iec

Convierte a unidades IEC, los rellena con 5 caracteres, alineado a la izquierda:

du {{[-s|--summarize]}} * | numfmt --to iec --format "%-5f"

od

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

od [OPCIÓN]... [--] [NOMBRE_ARCHIVO]...
od [-abcdDefFhHiIlLoOsxX] [NOMBRE_ARCHIVO] [[+][0x]DESPLAZAMIENTO[.][b]]
od --traditional [OPCIÓN]... [NOMBRE_ARCHIVO] [[+][0x]DESPLAZAMIENTO[.][b] [[+][0x]ETIQUETA[.][b]]]

Volcar archivos en octal y otros formatos

Options

--help: Imprimir información de ayuda.
--address-radix=<RADIX>, -A <RADIX>: Seleccionar la base en la que se imprimen los desplazamientos de archivo.
--skip-bytes=<BYTES>, -j <BYTES>: Saltar bytes de entrada antes de formatear y escribir.
--read-bytes=<BYTES>, -N <BYTES>: limitar volcado a BYTES bytes de entrada
--endian=<big|little>: orden de bytes a usar para formatos multi-byte
--strings=<BYTES>, -S <BYTES>: cadenas de salida de al menos BYTES de caracteres gráficos. Se asume 3 cuando BYTES no está especificado.
-a: caracteres nombrados, ignorando bit de orden superior
-b: bytes octales
-c: caracteres ASCII o escapes con barra invertida
-d: unidades decimales sin signo de 2-bytes
-D: unidades decimales sin signo de 4-bytes
-o: 2-byte de unidades octales
-I: 8-byte de unidades decimales
-L: 8-byte de unidades decimales
-i: 4-byte de unidades decimales
-l: 8-byte de unidades decimales
-x: 2-byte de unidades hexadecimales
-h: 2-byte de unidades hexadecimales
-O: 4-byte de unidades octales
-s: 2-byte de unidades decimales
-X: 4-byte de unidades hexadecimales
-H: 4-byte de unidades hexadecimales
-e: unidades de coma flotante de precisión doble (64-bit)
-f: unidades de coma flotante de precisión doble (32-bit)
-F: unidades de coma flotante de precisión doble (64-bit)
--format=<TYPE>, -t <TYPE>: seleccionar formato o formatos de salida
--output-duplicates, -v: no usar * para marcar supresión de líneas
--width=<BYTES>, -w <BYTES>: imprimir BYTES bytes por línea de salida. Se implica 32 cuando no se
especifica BYTES.
--traditional: modo de compatibilidad con una entrada, desplazamiento y etiqueta.

Exhibe datos en varios formatos legibles por humanos. Si se especifican múltiples formatos, la salida contendrá todos los formatos en el orden que aparecen en la línea de comandos. Cada formato se imprimirá en una nueva línea. Solo la línea que contiene el primer formato será prefijada con el desplazamiento.

Si no se especifica nombre de archivo, o es “-”, se usará stdin. Tras un “–”, no se reconocerán más opciones. Esto permite nombres de archivo que empiecen con “-”.

Si un nombre de archivo es un número válido que puede usarse como desplazamiento en la segunda forma, puede forzar que se reconozca como nombre de archivo si incluye una opción como “-j0”, que solo es válida en la primera forma.

RADIX es uno de o,d,x,n para octal, decimal, hexadecimal o ninguno.

BYTES es decimal por defecto, octal si tiene prefijo “0”, o hexadecimal si tiene prefijo “0x”. Los sufijos b, KB, K, MB, M, GB, G, multiplicarán el número con 512, 1000, 1024, 1000^2, 1024^2, 1000^3, 1024^3, 1000^2, 1024^2.

DESPLAZAMIENTO y ETIQUETA son octal por defecto, hexadecimal si tienen prefijo “0x” o decimal si se agrega un sufijo “.”. El sufijo “b” multiplicará con 512.

TIPO contiene una o más especificaciones de formato que consisten en: a para ASCII imprimible de 7-bits c para caracteres utf-8 u octal para caracteres indefinidos d[TAMAÑO] para decimal con signo f[TAMAÑO] para punto flotante o[TAMAÑO] para octal u[TAMAÑO] para decimal sin signo x[TAMAÑO] para hexadecimal TAMAÑO es el número de bytes que puede ser el número 1, 2, 4, 8 o 16, o C, S, I, L para 1, 2, 4, 8 bytes para tipos enteros, o F, D, L para 4, 8, 16 bytes para punto flotante. Cualquier especificación de tipo puede tener un sufijo “z”, que agregará un volcado ASCII al final de la línea.

Si ocurrió un error, se imprimirá un mensaje de diagnóstico en stderr, y el código de salida será distinto de cero.

Examples

Muestra el archivo con la configuración predeterminada: formato octal, 8 bytes por línea, desplazamientos de bytes en octal y líneas duplicadas sustituidas por *:

od {{ruta/al/archivo}}

Muestra el archivo en modo detallado, es decir, sin sustituir las líneas duplicadas por *:

od {{[-v|--output-duplicates]}} {{ruta/al/archivo}}

Muestra el archivo en formato hexadecimal (unidades de 2 bytes), con desplazamientos de bytes en formato decimal:

od {{[-t|--format]}} {{x}} {{[-A|--address-radix]}} {{d}} {{[-v|--output-duplicates]}} {{ruta/al/archivo}}

Muestra el archivo en formato hexadecimal (unidades de 1 byte) y 4 bytes por línea:

od {{[-t|--format]}} {{x1}} {{[-w|--width=]}}4 {{[-v|--output-duplicates]}} {{ruta/al/archivo}}

Muestra el archivo en formato hexadecimal junto con su representación en caracteres y no imprime las compensaciones de bytes:

od {{[-t|--format]}} {{xz}} {{[-A|--address-radix]}} {{n}} {{[-v|--output-duplicates]}} {{ruta/al/archivo}}

Lee solo 100 bytes de un archivo a partir del byte 500:

od {{[-N|--read-bytes]}} 100 {{[-j|--skip-bytes]}} 500 {{[-v|--output-duplicates]}} {{ruta/al/archivo}}

paste

v(uutils coreutils) 0.8.0

paste [OPCIONES] [ARCHIVO]...

Escribir líneas consistentes de las líneas correspondientes secuencialmente de cada ARCHIVO, separadas por TABs, a salida estándar.

Options

--serial, -s: pegar un archivo a la vez en lugar de en paralelo
--delimiters=<LIST>, -d <LIST>: reutilizar caracteres de LISTA en lugar de TABs

--zero-terminated, -z: el delimitador de línea es NUL, no nueva línea

Examples

Une todas las líneas en una sola línea, utilizando TAB como delimitador:

paste {{[-s|--serial]}} {{ruta/al/archivo}}

Une todas las líneas en una sola línea, utilizando el delimitador especificado:

paste {{[-s|--serial]}} {{[-d|--delimiters]}} {{delimitador}} {{ruta/al/archivo}}

Combina dos archivos uno al lado del otro, cada uno en su columna, utilizando TAB como delimitador:

paste {{ruta/al/archivo1}} {{ruta/al/archivo2}}

Combina dos archivos uno al lado del otro, cada uno en su columna, utilizando el delimitador especificado:

paste {{[-d|--delimiters]}} {{delimitador}} {{ruta/al/archivo1}} {{ruta/al/archivo2}}

Combina dos archivos, con líneas añadidas alternativamente:

paste {{[-d|--delimiters]}} '\n' {{ruta/al/archivo1}} {{ruta/al/archivo2}}

pathchk

v(uutils coreutils) 0.8.0

pathchk [OPCIÓN]... NOMBRE...

Verificar si los nombres de archivo son válidos o portables

Options

-p: verificar para la mayoría de sistemas POSIX
-P: verificar nombres vacíos y “-” inicial
--portability: verificar para todos los sistemas POSIX (equivalente a -p -P)

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

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 ...}}

pinky

v(uutils coreutils) 0.8.0

pinky [OPCIÓN]... [USUARIO]...

Muestra información breve del usuario en sistemas basados en Unix

Options

-l: producir salida de formato largo para los USUARIOs especificados
-b: omitir el directorio de inicio y shell del usuario en formato largo
-h: omitir el archivo de proyecto del usuario en formato largo
-p: omitir el archivo de plan del usuario en formato largo
-s: hacer salida de formato corto, este es el predeterminado
-f: omitir la línea de encabezados de columna en formato corto
-w: omitir el nombre completo del usuario en formato corto
-i: omitir el nombre completo del usuario y host remoto en formato corto
-q: omitir el nombre completo del usuario, host remoto y tiempo inactivo en formato corto

--lookup: intenta canonizar nombres de host por medio de DNS
--help: Imprimir información de ayuda

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Display details about the current user:

pinky

Display details for a specific user:

pinky {{user}}

Display details in the long format:

pinky {{user}} -l

Omit the user’s home directory and shell in long format:

pinky {{user}} -lb

Omit the user’s project file in long format:

pinky {{user}} -lh

Omit the column headings in short format:

pinky {{user}} -f

pr

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

pr [OPCIÓN]... [ARCHIVO]...

paginar o hacer columnas de ARCHIVO(s) para impresión

Options

--pages=<FIRST_PAGE[:LAST_PAGE]>: Comenzar y detener impresión con página PRIMERA_PÁGINA[:ÚLTIMA_PÁGINA]
--header=<STRING>, -h <STRING>: Usar la cadena encabezado para reemplazar el nombre del archivo
en la línea de encabezado.
--date-format=<FORMAT>, -D <FORMAT>: Utilice el FORMATO ‘date’-stile para la fecha de cabecera.
--double-space, -d: Producir salida con doble espaciado. Se emite un carácter
extra siguiendo cada encontrada en la entrada.
--number-lines=<[char][width]>, -n <[char][width]>: Proporcionar numeración de línea de dígitos de ancho. El predeterminado para ancho,
si no se especifica, es 5. El número ocupa las primeras posiciones de columna de ancho
de cada columna de texto o cada línea de salida -m. Si se proporciona char
(cualquier carácter que no sea dígito), se anexa al número de línea
para separarlo de lo que sigue. El predeterminado para char es un .
Los números de línea más largos que columnas de ancho se truncan.
--first-line-number=<NUMBER>, -N <NUMBER>: comenzar a contar con NÚMERO en la primera línea de la primera página impresa
--omit-header, -t: No escribir ni el encabezado identificador de cinco líneas ni el remolque de cinco líneas
usualmente suministrado para cada página. Dejar de escribir después de la última línea
de cada archivo sin espaciar hasta el final de la página.
--omit-pagination, -T: omit page headers and trailers, eliminate any pagination
by form feeds set in input files
--length=<PAGE_LENGTH>, -l <PAGE_LENGTH>: Sobrescribir el predeterminado de 66 líneas (número predeterminado de líneas de texto 56,
y con -F 63) y restablecer la longitud de página a líneas. Si líneas no es
mayor que la suma de ambas profundidades de encabezado y remolque (en líneas),
la utilidad pr suprimirá tanto el encabezado como el remolque, como si la opción -t
estuviera en efecto.
--no-file-warnings, -r: omitir advertencia cuando un archivo no se puede abrir
--form-feed, -F: Usar un para páginas nuevas, en lugar del comportamiento predeterminado que
usa una secuencia de s.
--width=<width>, -w <width>: Establecer el ancho de la línea a posiciones de columna de ancho para salida
de texto de múltiples columnas solamente. Si la opción -w no se especifica y la opción -s
no se especifica, el ancho predeterminado será 72. Si la opción -w no se especifica
y la opción -s se especifica, el ancho predeterminado será 512.
--page-width=<width>, -W <width>: establecer ancho de página a PAGE_WIDTH (72) caracteres siempre,
truncar líneas, excepto si se establece la opción -J, sin interferencia
con -S o -s
--across, -a: Modificar el efecto de la opción - columna para que las columnas se llenen
a través de la página en orden round-robin (por ejemplo, cuando columna es 2, la
primera línea de entrada encabeza la columna 1, la segunda encabeza la columna 2,
la tercera es la segunda línea en la columna 1, y así sucesivamente).
-b
--column=<column>: Producir salida multicolumna que se organiza en columna columnas
(el predeterminado será 1) y se escribe hacia abajo en cada columna en el orden en que
se recibe el texto del archivo de entrada. Esta opción no debe usarse con -m.
Las opciones -e e -i se asumirán para salida de texto multicolumna. Si
las columnas de texto se producen o no con longitudes verticales idénticas no se especifica,
pero una columna de texto nunca debe exceder la longitud de la página (ver opción -l).
Cuando se usa con -t, usar el número mínimo de líneas para escribir la salida.
--separator=<char>, -s <char>: Separar columnas de texto por el carácter único char en lugar del
número apropiado de s (predeterminado para char es el carácter ).
--sep-string=<string>, -S <string>: separar columnas por STRING,
sin -S: Separador predeterminado con -J y
de otra manera (igual que -S" "), sin efecto en opciones de columna
--merge, -m: Combinar archivos. La salida estándar se formateará para que la utilidad pr
escriba una línea de cada archivo especificado por un operando de archivo, lado a lado
en columnas de texto de anchos fijos iguales, en términos del número de posiciones de columna.
Las implementaciones deben soportar la combinación de al menos nueve operandos de archivo.
--indent=<margin>, -o <margin>: Cada línea de salida será precedida por desplazamiento s. Si la opción -o
no se especifica, el desplazamiento predeterminado será cero. El espacio tomado está
además del ancho de línea de salida (consulte la opción -w abajo).
-J: combinar líneas completas, desactiva truncamiento de línea -W, sin
alineación de columna, –sep-string[=STRING] establece separadores
--help: Imprimir información de ayuda

--expand-tabs=<[CHAR][WIDTH]>, -e <[CHAR][WIDTH]>: expand input CHARs (TABs) to tab WIDTH (8)

Si no se proporcionan ARCHIVO(s), o si ARCHIVO es -, leer entrada estándar.

Al crear salida multicolumna, las columnas serán de ancho igual. Al usar la opción ‘-s’ para separar columnas, el separador predeterminado es un solo carácter de tabulación. Al usar la opción ‘-S’ para separar columnas, el separador predeterminado es un solo carácter de espacio.

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Print multiple files with a default header and footer:

pr {{path/to/file1 path/to/file2 ...}}

Print with a custom centered header:

pr {{[-h|--header]}} "{{header}}" {{path/to/file1 path/to/file2 ...}}

Print with numbered lines and a custom date format:

pr {{[-n|--number-lines]}} {{[-D|--date-format]}} "{{format}}" {{path/to/file1 path/to/file2 ...}}

Print all files together, one in each column, without a header or footer:

pr {{[-m|--merge]}} {{[-T|--omit-pagination]}} {{path/to/file1 path/to/file2 ...}}

Print, beginning at page 2 up to page 5, with a given page length (including header and footer):

pr +2:5 {{[-l|--length]}} {{page_length}} {{path/to/file1 path/to/file2 ...}}

Print with an offset for each line and a truncating custom page width:

pr {{[-o|--indent]}} {{offset}} {{[-W|--page_width]}} {{width}} {{path/to/file1 path/to/file2 ...}}

printenv

v(uutils coreutils) 0.8.0

printenv [OPCIÓN]... [VARIABLE]...

Mostrar los valores de las VARIABLE(s) de entorno especificadas, o (sin VARIABLE) mostrar pares nombre y valor para todas ellas.

Options

--null, -0: terminar cada línea de salida con byte 0 en lugar de nueva línea

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Display key-value pairs of all environment variables:

printenv

Display the value of a specific variable:

printenv {{HOME}}

Display the value of a variable and end with NUL instead of newline:

printenv {{[-0|--null]}} {{HOME}}

printf

v(uutils coreutils) 0.8.0

printf FORMATO [ARGUMENTO]...
printf OPCIÓN

Imprimir salida basada en la cadena de formato y argumentos siguientes.

Options

--help: Imprimir información de ayuda
--version: Imprimir información de versión

plantilla de cadena anónima básica:

imprime cadena de formato al menos una vez, repitiendo mientras queden argumentos la salida imprime literales escapados en la cadena de formato como literales de carácter la salida reemplaza campos anónimos con el siguiente argumento sin usar, formateado según el campo.

Imprime el , reemplazando secuencias de caracteres escapados con literales de carácter y secuencias de campo de sustitución con argumentos pasados

literalmente, con la excepción de las siguientes secuencias de caracteres escapados, y las secuencias de sustitución descritas más abajo.

SECUENCIAS DE ESCAPE

Las siguientes secuencias de escape, organizadas aquí en orden alfabético, imprimirán el literal de carácter correspondiente:

" comilla doble
\ barra invertida
\a alerta (BEL)
\b retroceso
\c Fin-de-Entrada
\e escape
\f alimentación de formulario
\n nueva línea
\r retorno de carro
\t tabulación horizontal
\v tabulación vertical
\NNN byte con valor expresado en valor octal NNN (1 a 3 dígitos) valores mayores que 256 serán tratados
\xHH byte con valor expresado en valor hexadecimal NN (1 a 2 dígitos)
\uHHHH carácter Unicode (IEC 10646) con valor expresado en valor hexadecimal HHHH (4 dígitos)
\uHHHH carácter Unicode con valor expresado en valor hexadecimal HHHH (8 dígitos)
%% un solo %

SUSTITUCIONES

REFERENCIA RÁPIDA DE SUSTITUCIÓN

Campos

%s: cadena
%b: cadena analizada para literales segundo parámetro es longitud máxima
%c: carácter sin segundo parámetro
%i o %d: entero de 64-bit
%u: entero sin signo de 64 bit
%x o %X: entero sin signo de 64-bit como hex
%o: entero sin signo de 64-bit como octal segundo parámetro es ancho mínimo, entero salida bajo ese ancho se rellena con ceros iniciales
%q: ARGUMENTO se imprime en un formato que puede reutilizarse como entrada de shell, escapando caracteres no imprimibles con la sintaxis $‘’ propuesta por POSIX.
%f o %F: valor de punto flotante decimal
%e o %E: valor de punto flotante en notación científica
%g o %G: el más corto de valor de punto flotante decimal o SciNote interpretado especialmente. segundo parámetro es -lugares máximos después del punto decimal para salida de punto flotante -número máximo de dígitos significativos para salida de notación científica

parametrizando campos

ejemplos:

printf ‘%4.3i’ 7

Tiene un primer parámetro de 4 y un segundo parámetro de 3 y resultará en ’ 007’

printf ‘%.1s’ abcde

No tiene primer parámetro y un segundo parámetro de 1 y resultará en ‘a’

printf ‘%4c’ q

Tiene un primer parámetro de 4 y sin segundo parámetro y resultará en ’ q’

El primer parámetro de un campo es el ancho mínimo para rellenar la salida si la salida es menor que este valor absoluto de este ancho, se rellenará con espacios iniciales, o, si el argumento es negativo, con espacios finales. el predeterminado es cero.

El segundo parámetro de un campo es particular al tipo de campo de salida. los predeterminados se pueden encontrar en la ayuda de sustitución completa abajo

prefijos especiales para argumentos numéricos

0: (ej. 010) interpretar argumento como octal (solo campos de salida enteros)
0x: (ej. 0xABC) interpretar argumento como hex (solo campos de salida numéricos)
': (ej. 'a) interpretar argumento como una constante de carácter

CÓMO USAR SUSTITUCIONES

Las sustituciones se usan para pasar argumento(s) adicional(es) a la cadena FORMAT, para ser formateados de una manera particular. Ej.

printf ‘la letra %X viene antes de la letra %X’ 10 11

imprimirá

la letra A viene antes de la letra B

porque el campo de sustitución %X significa ‘tomar un argumento entero y escribirlo como un número hexadecimal’

Pasar más argumentos que los que están en la cadena de formato causará que la cadena de formato se repita para las sustituciones restantes

printf ‘está a %i F en %s \n’ 22 Portland 25 Boston 27 New York

imprimirá

está a 22 F en Portland está a 25 F en Boston está a 27 F en Boston

Si una cadena de formato se imprime pero quedan menos argumentos que campos de sustitución, los campos de sustitución sin un argumento usarán cadenas vacías por defecto, o para campos numéricos el valor 0

SUSTITUCIONES DISPONIBLES

Este programa, como printf de GNU coreutils, interpreta un subconjunto modificado de la especificación printf C POSIX, una referencia rápida a sustituciones está abajo.

SUSTITUCIONES DE CADENA

Todos los campos de cadena tienen un parámetro de ‘ancho máximo’ %.3s significa ‘imprimir no más de tres caracteres de la entrada original’

%s: cadena
%b: cadena escapada - la cadena será verificada para cualquier literal escapado de la lista de literales escapados arriba, y traducirlos a caracteres literales. ej. \n será transformado en un carácter de nueva línea. Una regla especial sobre el modo %b es que los literales octales se interpretan diferente En argumentos pasados por %b, los literales interpretados como octal deben estar en la forma \0NNN en lugar de \NNN. (Aunque, por razones de compatibilidad, los literales octales en la forma \NNN aún serán interpretados y no lanzarán una advertencia, tendrá problemas si usa esto para un literal cuyo código comience con cero, ya que será visto como en forma \0NNN.)
%q: cadena escapada - la cadena en un formato que puede reutilizarse como entrada por la mayoría de shells. Los caracteres no imprimibles son escapados con la sintaxis POSIX propuesta ‘$’‘’’, y los meta-caracteres de shell son entrecomillados apropiadamente. Esto es un formato equivalente a la salida ls –quoting=shell-escape.

SUSTITUCIONES DE CARÁCTER

El campo de carácter no tiene un parámetro secundario.

%c: un solo carácter

SUSTITUCIONES DE ENTERO

Todos los campos enteros tienen un parámetro ‘rellenar con cero’ %.4i significa un entero que si es menor de 4 dígitos en longitud, se rellena con ceros iniciales hasta que sea de 4 dígitos de longitud.

%d o %i: entero de 64-bit
%u: entero sin signo de 64-bit
%x o %X: entero sin signo de 64-bit impreso en Hexadecimal (base 16) %X en lugar de %x significa usar letras mayúsculas para ‘a’ hasta ‘f’
%o: entero sin signo de 64-bit impreso en octal (base 8)

SUSTITUCIONES DE PUNTO FLOTANTE

Todos los campos de punto flotante tienen un parámetro ‘lugares decimales máximos / dígitos significativos máximos’ %.10f significa un punto flotante decimal con 7 lugares decimales después de 0 %.10e significa un número en notación científica con 10 dígitos significativos %.10g significa el mismo comportamiento para decimal y Sci. Note, respectivamente, y proporciona la más corta de cada salida.

Como con GNU coreutils, el valor después del punto decimal es estas salidas se analiza como un double primero antes de ser renderizado a texto. Para ambas implementaciones no espere precisión significativa más allá del 18º lugar decimal. Al usar un número de lugares decimales que es 18 o mayor, puede esperar variación en salida entre printf de GNU coreutils y este printf en el 18º lugar decimal de +/- 1

%f: valor de punto flotante presentado en decimal, truncado y mostrado a 6 lugares decimales por defecto. No hay paridad de comportamiento pasado-double con printf de Coreutils, los valores no son estimados o ajustados más allá de valores de entrada.
%e o %E: valor de punto flotante presentado en notación científica 7 dígitos significativos por defecto %E significa usar E mayúscula para la mantisa.
%g o %G: valor de punto flotante presentado en la más corta de notación decimal y científica se comporta diferente de %f y %E, por favor vea especificación printf posix para detalles completos, algunos ejemplos de comportamiento diferente: Sci Note tiene 6 dígitos significativos por defecto Los ceros finales son removidos En lugar de ser truncado, el dígito después del último es redondeado

Como otro comportamiento en esta utilidad, las decisiones de diseño del comportamiento de punto flotante en esta utilidad están seleccionadas para reproducir exactamente el comportamiento del printf de GNU coreutils desde un punto de vista de entradas y salidas.

USANDO PARÁMETROS

La mayoría de campos de sustitución pueden parametrizarse usando hasta 2 números que pueden pasarse al campo, entre el signo % y la letra del campo.

El 1er parámetro siempre indica el ancho mínimo de salida, es útil para crear salida columnar. Cualquier salida que sería menor que este ancho mínimo se rellena con espacios iniciales El 2do parámetro es precedido por un punto. No tiene que usar parámetros

FORMAS ESPECIALES DE ENTRADA

Para entrada numérica, las siguientes formas adicionales de entrada son aceptadas además de decimal:

Octal (solo con entero): si el argumento comienza con un 0 los caracteres siguientes serán interpretados como octal (base 8) para campos enteros

Hexadecimal: si el argumento comienza con 0x los caracteres siguientes serán interpretados serán interpretados como hex (base 16) para cualquier campo numérico para campos float, la entrada hexadecimal resulta en un límite de precisión (al convertir entrada después del punto decimal) de 10^-15

Constante de Carácter: si el argumento comienza con un carácter de comilla simple, el primer byte del siguiente carácter será interpretado como un entero sin signo de 8-bit. Si hay bytes adicionales, lanzarán un error (a menos que la variable de entorno POSIXLY_CORRECT esté establecida)

Examples

Imprime un mensaje de texto:

printf "{{%s\n}}" "{{Hola mundo}}"

Imprime un número entero en negrita azul:

printf "{{\e[1;34m%.3d\e[0m\n}}" {{42}}

Imprime un número flotante con el signo del euro Unicode:

printf "{{\u20AC %.2f\n}}" {{123.4}}

Imprime un mensaje de texto compuesto con variables de entorno:

printf "{{var1: %s\tvar2: %s\n}}" "{{$VAR1}}" "{{$VAR2}}"

Almacena un mensaje formateado en una variable (no funciona en Zsh):

printf -v {{myvar}} {{"Esto es %s = %d\n" "un año" 2016}}

Imprime un número hexadecimal, octal y científico:

printf "{{hex=%x octal=%o scientific=%e\n}}" 0x{{FF}} 0{{377}} {{100000}}

ptx

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

ptx [OPCIÓN]... [ENTRADA]...
ptx -G [OPCIÓN]... [ENTRADA [SALIDA]]

Producir un índice permutado del contenido del archivo Generar un índice permutado, incluyendo contexto, de las palabras en los archivos de entrada. Los argumentos obligatorios para opciones largas son obligatorios también para opciones cortas. Sin ARCHIVO, o cuando ARCHIVO es -, leer entrada estándar. El predeterminado es ‘-F /’.

Options


--auto-reference, -A: generar referencias automáticamente
--traditional, -G: comportarse más como ‘ptx’ de System V
--flag-truncation=<STRING>, -F <STRING>: usar CADENA para marcar truncamientos de línea
--macro-name=<STRING>, -M <STRING>: nombre de macro a usar en lugar de ‘xx’
--format
-O: generar salida como directivas roff
-T: generar salida como directivas TeX
--right-side-refs, -R: poner referencias a la derecha, no contadas en -w
--sentence-regexp=<REGEXP>, -S <REGEXP>: para final de líneas o final de oraciones
--word-regexp=<REGEXP>, -W <REGEXP>: usar REGEXP para coincidir con cada palabra clave
--break-file=<FILE>, -b <FILE>: caracteres de corte de palabra en este ARCHIVO
--ignore-case, -f: doblar minúsculas a mayúsculas para ordenar
--gap-size=<NUMBER>, -g <NUMBER>: tamaño de espacio en columnas entre campos de salida
--ignore-file=<FILE>, -i <FILE>: leer lista de palabras a ignorar de ARCHIVO
--only-file=<FILE>, -o <FILE>: leer solo lista de palabras de este ARCHIVO
--references=<FILE>, -r <FILE>: el primer campo de cada línea es una referencia
--typeset-mode, -t: change the default width from 72 to 100
--width=<NUMBER>, -w <NUMBER>: ancho de salida en columnas, referencia excluida

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Generate a permuted index where the first field of each line is an index reference:

ptx {{[-r|--references]}} {{path/to/file}}

Generate a permuted index with automatically generated index references:

ptx {{[-A|--auto-reference]}} {{path/to/file}}

Generate a permuted index with a fixed width:

ptx {{[-w|--width]}} {{width_in_columns}} {{path/to/file}}

Generate a permuted index with a list of filtered words:

ptx {{[-o|--only-file]}} {{path/to/filter}} {{path/to/file}}

Generate a permuted index with SYSV-style behaviors:

ptx {{[-G|--traditional]}} {{path/to/file}}

pwd

v(uutils coreutils) 0.8.0

pwd [OPCIÓN]...

Mostrar el nombre completo del directorio de trabajo actual.

Options

--logical, -L: usar PWD del entorno, incluso si contiene enlaces simbólicos
--physical, -P: evitar todos los enlaces simbólicos

Examples

Muestra el directorio actual:

pwd

Muestra el directorio actual y resuelve todos los enlaces simbólicos (es decir, muestra la ruta “física”):

pwd {{[-P|--physical]}}

Muestra la ayuda:

pwd --help

readlink

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

readlink [OPCIÓN]... [ARCHIVO]...

Imprimir valor de un enlace simbólico o nombre de archivo canónico.

Options

--canonicalize, -f: canonicalizar siguiendo cada enlace simbólico en cada componente del nombre dado recursivamente; todos excepto el último componente deben existir
--canonicalize-existing, -e: canonicalizar siguiendo cada enlace simbólico en cada componente del nombre dado recursivamente, todos los componentes deben existir
--canonicalize-missing, -m: canonicalizar siguiendo cada enlace simbólico en cada componente del nombre dado recursivamente, sin requerimientos sobre la existencia de componentes
--no-newline, -n: no mostrar el delimitador final
--quiet, -q: suprimir la mayoría de mensajes de error
--silent, -s: suprimir la mayoría de mensajes de error
--verbose, -v: reportar mensaje de error
--zero, -z: separar salida con NUL en lugar de nueva línea

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Get the actual file to which the symlink points:

readlink {{path/to/file}}

Get the absolute path to a file:

readlink {{[-f|--canonicalize]}} {{path/to/file}}

realpath

v(uutils coreutils) 0.8.0

realpath [OPCIÓN]... ARCHIVO...

Imprimir la ruta resuelta

Options

--quiet, -q: No imprimir advertencias para rutas no válidas
--strip, --no-symlinks, -s: Solo quitar componentes ‘.’ y ‘..’, pero no resolver enlaces simbólicos
--zero, -z: Separar nombres de archivo de salida con \0 en lugar de nueva línea
--logical, -L: resolver componentes ‘..’ antes de enlaces simbólicos
--physical, -P: resolver enlaces simbólicos según se encuentren (predeterminado)
--canonicalize, -E: todo excepto el último componente debe existir (por defecto)
--canonicalize-existing, -e: canonicalizar siguiendo cada enlace simbólico en cada componente del nombre dado recursivamente, todos los componentes deben existir
--canonicalize-missing, -m: canonicalizar siguiendo cada enlace simbólico en cada componente del nombre dado recursivamente, sin requerimientos sobre la existencia de componentes
--relative-to=<DIR>: imprimir la ruta resuelta relativa a DIR
--relative-base=<DIR>: imprimir rutas absolutas a menos que las rutas estén bajo DIR

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Display the absolute path for a file or directory:

realpath {{path/to/file_or_directory}}

Require all path components to exist:

realpath {{[-e|--canonicalize-existing]}} {{path/to/file_or_directory}}

Resolve .. components before symlinks:

realpath {{[-L|--logical]}} {{path/to/file_or_directory}}

Disable symlink expansion:

realpath {{[-s|--no-symlinks]}} {{path/to/file_or_directory}}

Suppress error messages:

realpath {{[-q|--quiet]}} {{path/to/file_or_directory}}

rm

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

rm [OPCIÓN]... ARCHIVO...

Eliminar (desenlazar) el/los ARCHIVO(s)

Options

--force, -f: ignorar archivos y argumentos inexistentes, nunca avisar
-i: avisar antes de cada eliminación
-I: avisar una vez antes de eliminar más de tres archivos, o al eliminar recursivamente.
Menos intrusivo que -i, mientras aún da cierta protección contra la mayoría de errores
--interactive=<WHEN>: avisar según CUÁNDO: never, once (-I), o always (-i). Sin CUÁNDO,
avisa siempre
--one-file-system: al eliminar una jerarquía recursivamente, omitir cualquier directorio que esté en un sistema
de archivos diferente del argumento de línea de comandos correspondiente (NO
IMPLEMENTADO)
--no-preserve-root: no tratar ‘/’ especialmente
--preserve-root: no eliminar ‘/’ (por defecto)
--recursive, -r, -R: eliminar directorios y su contenido recursivamente
--dir, -d: eliminar directorios vacíos
--verbose, -v: explicar lo que se está haciendo
--progress, -g: exhibe una barra de progreso. Nota: esta característica no es admitida por GNU coreutils.
--presume-input-tty

Por defecto, rm no elimina directorios. Use la opción –recursive (-r o -R) para eliminar cada directorio listado, también, junto con todo su contenido

Para eliminar un archivo cuyo nombre comienza con ‘-’, por ejemplo ‘-foo’, use uno de estos comandos: rm – -foo

rm ./-foo

Note que si usa rm para eliminar un archivo, podría ser posible recuperar algo de su contenido, dada suficiente experiencia y/o tiempo. Para mayor aseguración de que el contenido sea verdaderamente irrecuperable, considere usar shred.

Examples

Elimina archivos específicos:

rm {{ruta/al/archivo1 ruta/al/archivo2 ...}}

Elimina archivos específicos ignorando los que no existen:

rm -f {{ruta/al/archivo1 ruta/al/archivo2 ...}}

Elimina varios archivos de forma interactiva, solicitando confirmación antes de eliminar cada archivo:

rm -i {{ruta/al/archivo1 ruta/al/archivo2 ...}}

Elimina archivos, imprimiendo un mensaje por cada archivo eliminado:

rm -v {{ruta/al/archivo1 ruta/al/archivo2 ...}}

Elimina, de forma recursiva, archivos y directorios:

rm -r {{ruta/al/directorio1 ruta/al/directorio2 ...}}

rmdir

v(uutils coreutils) 0.8.0

rmdir [OPCIÓN]... DIRECTORIO...

Eliminar el/los DIRECTORIO(s), si están vacíos.

Options

--ignore-fail-on-non-empty: ignorar cada fallo que se deba únicamente a que un directorio no está vacío
--parents, -p: eliminar DIRECTORIO y sus antecesores; ej., ‘rmdir -p a/b/c’ es similar a rmdir a/b/c a/b a
--verbose, -v: mostrar un diagnóstico para cada directorio procesado

Examples

Remove specific directories:

rmdir {{path/to/directory1 path/to/directory2 ...}}

Remove specific nested directories recursively:

rmdir {{[-p|--parents]}} {{path/to/directory1 path/to/directory2 ...}}

Clean a directory of empty directories:

rmdir *

runcon

v(uutils coreutils) 0.8.0

runcon CONTEXTO COMANDO [ARG...]
runcon [-c] [-u USUARIO] [-r ROL] [-t TIPO] [-l RANGO] COMANDO [ARG...]

Ejecutar comando con contexto de seguridad especificado bajo sistemas habilitados con SELinux.

Options

--compute, -c: Calcular contexto de transición de proceso antes de modificar.
--user=<USER>, -u <USER>: Establecer usuario USUARIO en el contexto de seguridad objetivo.
--role=<ROLE>, -r <ROLE>: Establecer rol ROL en el contexto de seguridad objetivo.
--type=<TYPE>, -t <TYPE>: Establecer tipo TIPO en el contexto de seguridad objetivo.
--range=<RANGE>, -l <RANGE>: Establecer rango RANGO en el contexto de seguridad objetivo.

Ejecutar COMANDO con CONTEXTO completamente especificado, o con contexto de seguridad actual o transicionado modificado por uno o más de NIVEL, ROL, TIPO, y USUARIO.

Si ninguno de –compute, –type, –user, –role o –range está especificado, entonces el primer argumento se usa como el contexto completo.

Note que solo contextos cuidadosamente elegidos es probable que se ejecuten exitosamente.

Si ni CONTEXTO ni COMANDO está especificado, se imprime el contexto de seguridad actual.

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Print the security context of the current execution context:

runcon

Specify the domain to run a command in:

runcon {{[-t|--type]}} {{domain}}_t {{command}}

Specify the context role to run a command with:

runcon {{[-r|--role]}} {{role}}_r {{command}}

Specify the full context to run a command with:

runcon {{user}}_u:{{role}}_r:{{domain}}_t {{command}}

seq

v(uutils coreutils) 0.8.0

seq [OPCIÓN]... ÚLTIMO
seq [OPCIÓN]... PRIMERO ÚLTIMO
seq [OPCIÓN]... PRIMERO INCREMENTO ÚLTIMO

Mostrar números de PRIMERO a ÚLTIMO, en pasos de INCREMENTO.

Options

--separator, -s: Carácter separador (por defecto \n)
--terminator, -t: Carácter terminador (por defecto \n)
--equal-width, -w: Igualar anchos de todos los números rellenando con ceros
--format, -f: usar FORMATO de punto flotante estilo printf

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Print a sequence from 1 to 10:

seq 10

Print a sequence from 10 to 20:

seq 10 20

Print every 3rd number from 5 to 20:

seq 5 3 20

Separate the output with a space instead of a newline:

seq {{[-s|--separator]}} " " {{5 3 20}}

Format output width to a minimum of 4 digits padding with zeros as necessary:

seq {{[-f|--format]}} "%04g" {{5 3 20}}

Print all numbers with the same width:

seq {{[-w|--equal-width]}} {{5 3 20}}

sha1sum

v(uutils coreutils) 0.8.0

sha1sum [OPTIONS] [FILE]...

Print or check the SHA1 checksums

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

Calcula la suma de comprobación SHA1 de uno o más archivos:

sha1sum {{ruta/al/archivo1 ruta/al/archivo2 ...}}

Calcula y guardar la lista de sumas de comprobación SHA1 en un archivo:

sha1sum {{ruta/al/archivo1 ruta/al/archivo2 ...}} > {{ruta/al/archivo.sha1}}

Calcula una suma de comprobación SHA1 a partir de stdin:

{{comando}} | sha1sum

Lee un archivo de sumas de comprobación SHA1 y nombres de archivo y verifica que todos los archivos tengan sumas de comprobación coincidentes:

sha1sum {{[-c|--check]}} {{ruta/al/archivo.sha1}}

Solo muestra un mensaje cuando faltan archivos o cuando falla la verificación:

sha1sum {{[-c|--check]}} --quiet {{ruta/al/archivo.sha1}}

Solo muestra un mensaje cuando falla la verificación, ignorando los archivos que faltan:

sha1sum --ignore-missing {{[-c|--check]}} --quiet {{ruta/al/archivo.sha1}}

Comprueba una suma de comprobación SHA1 conocida de un archivo:

echo {{suma_de_verificación_sha1_conocida_del_archivo}} {{ruta/al/archivo}} | sha1sum {{[-c|--check]}}

sha224sum

v(uutils coreutils) 0.8.0

sha224sum [OPTIONS] [FILE]...

Print or check the SHA224 checksums

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

Calcula la suma de comprobación SHA224 para uno o más archivos:

sha224sum {{ruta/al/archivo1 ruta/al/archivo2 ...}}

Calcula y guarda la lista de sumas de comprobación SHA224 en un archivo:

sha224sum {{ruta/al/archivo1 ruta/al/archivo2 ...}} > {{ruta/al/archivo.sha224}}

Calcula una suma de comprobación SHA224 desde stdin:

{{comando}} | sha224sum

Lee nombres de archivo y archivo de sumas de comprobación SHA224 y verifica que todos los archivos tengan sumas de comprobación coincidentes:

sha224sum {{[-c|--check]}} {{ruta/al/archivo.sha224}}

Muestra solo un mensaje para los archivos que faltan o cuando falla la verificación:

sha224sum {{[-c|--check]}} --quiet {{ruta/al/archivo.sha224}}

Muestra solo un mensaje cuando falla la verificación, ignorando los archivos que faltan:

sha224sum --ignore-missing {{[-c|--check]}} --quiet {{ruta/al/archivo.sha224}}

Comprueba una suma de comprobación SHA224 conocida de un archivo:

echo {{suma_de_comprobación_sha224_conocida_del_archivo}} {{ruta/al/archivo}} | sha224sum {{[-c|--check]}}

sha256sum

v(uutils coreutils) 0.8.0

sha256sum [OPTIONS] [FILE]...

Print or check the SHA256 checksums

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

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Calculate the SHA256 checksum for one or more files:

sha256sum {{path/to/file1 path/to/file2 ...}}

Calculate and save the list of SHA256 checksums to a file:

sha256sum {{path/to/file1 path/to/file2 ...}} > {{path/to/file.sha256}}

Calculate a SHA256 checksum from stdin:

{{command}} | sha256sum

Read a file of SHA256 checksums and filenames and verify all files have matching checksums:

sha256sum {{[-c|--check]}} {{path/to/file.sha256}}

Only show a message for missing files or when verification fails:

sha256sum {{[-c|--check]}} --quiet {{path/to/file.sha256}}

Only show a message when verification fails, ignoring missing files:

sha256sum --ignore-missing {{[-c|--check]}} --quiet {{path/to/file.sha256}}

Check a known SHA256 checksum of a file:

echo {{known_sha256_checksum_of_the_file}} {{path/to/file}} | sha256sum {{[-c|--check]}}

sha384sum

v(uutils coreutils) 0.8.0

sha384sum [OPTIONS] [FILE]...

Print or check the SHA384 checksums

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

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Calculate the SHA384 checksum for one or more files:

sha384sum {{path/to/file1 path/to/file2 ...}}

Calculate and save the list of SHA384 checksums to a file:

sha384sum {{path/to/file1 path/to/file2 ...}} > {{path/to/file.sha384}}

Calculate a SHA384 checksum from stdin:

{{command}} | sha384sum

Read a file of SHA384 checksums and filenames and verify all files have matching checksums:

sha384sum {{[-c|--check]}} {{path/to/file.sha384}}

Only show a message for missing files or when verification fails:

sha384sum {{[-c|--check]}} --quiet {{path/to/file.sha384}}

Only show a message when verification fails, ignoring missing files:

sha384sum --ignore-missing {{[-c|--check]}} --quiet {{path/to/file.sha384}}

Check a known SHA384 checksum of a file:

echo {{known_sha384_checksum_of_the_file}} {{path/to/file}} | sha384sum {{[-c|--check]}}

sha512sum

v(uutils coreutils) 0.8.0

sha512sum [OPTIONS] [FILE]...

Print or check the SHA512 checksums

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

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Calculate the SHA512 checksum for one or more files:

sha512sum {{path/to/file1 path/to/file2 ...}}

Calculate and save the list of SHA512 checksums to a file:

sha512sum {{path/to/file1 path/to/file2 ...}} > {{path/to/file.sha512}}

Calculate a SHA512 checksum from stdin:

{{command}} | sha512sum

Read a file of SHA512 checksums and filenames and verify all files have matching checksums:

sha512sum {{[-c|--check]}} {{path/to/file.sha512}}

Only show a message for missing files or when verification fails:

sha512sum {{[-c|--check]}} --quiet {{path/to/file.sha512}}

Only show a message when verification fails, ignoring missing files:

sha512sum --ignore-missing {{[-c|--check]}} --quiet {{path/to/file.sha512}}

Check a known SHA512 checksum of a file:

echo {{known_sha512_checksum_of_the_file}} {{path/to/file}} | sha512sum {{[-c|--check]}}

shred

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

shred [OPCIÓN]... ARCHIVO...

Sobrescribir los ARCHIVO(s) especificados repetidamente, para hacer más difícil incluso para sondeo de hardware muy costoso recuperar los datos.

Options

--force, -f: shred-force-help
--iterations=<NUMBER>, -n <NUMBER>: shred-iterations-help
--size=<N>, -s <N>: shred-size-help
-u: shred-deallocate-help
--remove=<HOW>: shred-remove-help
--verbose, -v: shred-verbose-help
--exact, -x: shred-exact-help
--zero, -z: shred-zero-help
--random-source: shred-random-source-help

Eliminar ARCHIVO(s) si se especifica –remove (-u). El predeterminado es no eliminar los archivos porque es común operar en archivos de dispositivo como /dev/hda, y esos archivos usualmente no deberían eliminarse.

PRECAUCIÓN: Note que shred se basa en una suposición muy importante: que el sistema de archivos sobrescribe datos en el lugar. Esta es la forma tradicional de hacer las cosas, pero muchos diseños de sistemas de archivos modernos no satisfacen esta suposición. Los siguientes son ejemplos de sistemas de archivos en los que shred no es efectivo, o no se garantiza que sea efectivo en todos los modos de sistema de archivos:

sistemas de archivos estructurados por registro o journal, como los suministrados con AIX y Solaris (y JFS, ReiserFS, XFS, Ext3, etc.)
sistemas de archivos que escriben datos redundantes y continúan incluso si algunas escrituras fallan, como sistemas de archivos basados en RAID
sistemas de archivos que hacen instantáneas, como el servidor NFS de Network Appliance
sistemas de archivos que almacenan en caché en ubicaciones temporales, como clientes NFS versión 3
sistemas de archivos comprimidos

En el caso de sistemas de archivos ext3, la exención anterior se aplica (y shred es así de efectividad limitada) solo en modo data=journal, que registra datos de archivo además de solo metadatos. En ambos modos data=ordered (predeterminado) y data=writeback, shred funciona como de costumbre. Los modos journal de Ext3 pueden cambiarse agregando la opción data=algo a las opciones de montaje para un sistema de archivos particular en el archivo /etc/fstab, como se documenta en la página de manual de mount (man mount).

Además, las copias de seguridad de sistema de archivos y espejos remotos pueden contener copias del archivo que no se pueden eliminar, y que permitirán que un archivo destruido se recupere más tarde.

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Overwrite a file:

shred {{path/to/file}}

Overwrite a file and show progress on the screen:

shred {{[-v|--verbose]}} {{path/to/file}}

Overwrite a file, leaving zeros instead of random data:

shred {{[-z|--zero]}} {{path/to/file}}

Overwrite a file a specific number of times:

shred {{[-n|--iterations]}} {{25}} {{path/to/file}}

Overwrite a file and remove it:

shred {{[-u|--remove]}} {{path/to/file}}

Overwrite a file 100 times, add a final overwrite with zeros, remove the file after overwriting it, and show verbose progress on the screen:

shred {{[-vzu|--verbose --zero --remove]}} {{[-n|--iterations]}} 100 {{path/to/file}}

shuf

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

shuf [OPCIÓN]... [ARCHIVO]
shuf -e [OPCIÓN]... [ARG]...
shuf -i LO-HI [OPCIÓN]...

Mezclar la entrada mostrando una permutación aleatoria de líneas de entrada. Cada permutación de salida es igualmente probable. Sin ARCHIVO, o cuando ARCHIVO es -, leer entrada estándar.

Options

--echo, -e: tratar cada ARG como una línea de entrada
--input-range=<LO-HI>, -i <LO-HI>: tratar cada número LO hasta HI como una línea de entrada
--head-count=<COUNT>, -n <COUNT>: mostrar como máximo CONTEO líneas
--output=<FILE>, -o <FILE>: escribir resultado a ARCHIVO en lugar de salida estándar
--random-seed=<STRING>: seed with STRING for reproducible output
--random-source=<FILE>: obtener bytes aleatorios de ARCHIVO
--repeat, -r: las líneas de salida pueden ser repetidas
--zero-terminated, -z: el delimitador de línea es NUL, no nueva línea

Examples

Randomize the order of lines in a file and output the result:

shuf {{path/to/file}}

Only output the first 5 entries of the result:

shuf {{[-n|--head-count]}} 5 {{path/to/file}}

Write the output to another file:

shuf {{path/to/input_file}} {{[-o|--output]}} {{path/to/output_file}}

Generate 3 random numbers in the range 1-10 (inclusive, numbers can repeat):

shuf {{[-n|--head-count]}} 3 {{[-i|--input-range]}} 1-10 {{[-r|--repeat]}}

sleep

v(uutils coreutils) 0.8.0

sleep NÚMERO[SUFIJO]...
sleep OPCIÓN

Pausar por NÚMERO segundos.

Options

: pausar por NÚMERO segundos

Pausar por NÚMERO segundos. SUFIJO puede ser ‘s’ para segundos (por defecto), ‘m’ para minutos, ‘h’ para horas o ‘d’ para días. A diferencia de la mayoría de implementaciones que requieren que NÚMERO sea un entero, aquí NÚMERO puede ser un número de punto flotante arbitrario. Dados dos o más argumentos, pausar por la cantidad de tiempo especificada por la suma de sus valores.

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Delay in seconds:

sleep {{seconds}}

Execute a specific command after 20 seconds delay:

sleep 20 && {{command}}

sort

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

sort [OPCIÓN]... [ARCHIVO]...

Mostrar concatenación ordenada de todos los ARCHIVO(s). Sin ARCHIVO, o cuando ARCHIVO es -, leer entrada estándar.

Options

--help: Mostrar información de ayuda.
--version: Mostrar información de versión.
--sort
--human-numeric-sort, -h: comparar según tamaños legibles por humanos, ej. 1M > 100k
--month-sort, -M: comparar según abreviación de nombre de mes
--numeric-sort, -n: comparar según valor numérico de cadena
--general-numeric-sort, -g: comparar según valor numérico general de cadena
--version-sort, -V: Ordenar por número de versión SemVer, ej. 1.12.2 > 1.1.2
--random-sort, -R: mezclar en orden aleatorio
--random-source=<FILE>: use FILE as a source of random data
--dictionary-order, -d: considerar solo espacios en blanco y caracteres alfanuméricos
--merge, -m: fusionar archivos ya ordenados; no ordenar
--check, -c: verificar entrada ordenada; no ordenar
--check-silent, -C: salir exitosamente si el archivo dado ya está ordenado, y salir con estado 1 de otra manera.
--ignore-case, -f: plegar caracteres de minúscula a mayúscula
--ignore-nonprinting, -i: ignorar caracteres no imprimibles
--ignore-leading-blanks, -b: ignorar espacios en blanco iniciales al encontrar claves de ordenamiento en cada línea
--output=<FILENAME>, -o <FILENAME>: escribir salida a NOMBREARCHIVO en lugar de stdout
--reverse, -r: invertir la salida
--stable, -s: estabilizar ordenamiento deshabilitando comparación de último recurso
--unique, -u: mostrar solo el primero de una secuencia igual
--key, -k: ordenar por una clave
--field-separator, -t: separador personalizado para -k
--zero-terminated, -z: el delimitador de línea es NUL, no nueva línea
--parallel=<NUM_THREADS>: cambiar el número de hilos ejecutándose concurrentemente a NUM_HILOS
--buffer-size=<SIZE>, -S <SIZE>: establece el TAMAÑO máximo de cada segmento en número de elementos ordenados
--temporary-directory=<DIR>, -T <DIR>: usar DIR para temporales, no $TMPDIR o /tmp
--compress-program=<PROG>: comprimir archivos temporales con PROG, descomprimir con PROG -d; PROG tiene que tomar entrada desde stdin y salida a stdout
--batch-size=<N_MERGE>: Fusionar como máximo N_FUSION entradas a la vez.
--files0-from=<NUL_FILE>: leer entrada de los archivos especificados por ARCHIVO_NUL terminado en NUL
--debug: subrayar las partes de la línea que realmente se usan para ordenar

El formato de clave es CAMPO[.CAR][OPCIONES][,CAMPO[.CAR]][OPCIONES].

Los campos por defecto están separados por el primer espacio en blanco después de un carácter que no sea espacio en blanco. Use -t para especificar un separador personalizado. En el caso por defecto, se agrega espacio en blanco al principio de cada campo. Sin embargo, los separadores personalizados no se incluyen en los campos.

CAMPO y CAR ambos empiezan en 1 (es decir, están indexados en 1). Si no hay final especificado después de una coma, el final será el final de la línea. Si CAR se establece en 0, significa el final del campo. CAR por defecto es 1 para la posición inicial y 0 para la posición final.

Las opciones válidas son: MbdfhnRrV. Anulan las opciones globales para esta clave.

Examples

Ordena un archivo en orden ascendente:

sort {{ruta/al/archivo}}

Ordena un archivo en orden descendente:

sort {{[-r|--reverse]}} {{ruta/al/archivo}}

Ordena un archivo sin distinguir entre mayúsculas y minúsculas:

sort {{[-f|--ignore-case]}} {{ruta/al/archivo}}

Ordena un archivo usando orden numérico en lugar de alfabético:

sort {{[-n|--numeric-sort]}} {{ruta/al/archivo}}

Ordena /etc/passwd por el tercer campo de cada línea numéricamente, usando : como separador de campos:

sort {{[-t|--field-separator]}} : {{[-k|--key]}} 3n /etc/passwd

Como el anterior, pero cuando los elementos del tercer campo son iguales, ordena por el cuarto campo con números con exponentes:

sort {{[-t|--field-separator]}} : {{[-k|--key]}} 3,3n {{[-k|--key]}} 4,4g /etc/passwd

Ordena un archivo conservando únicamente las líneas únicas:

sort {{[-u|--unique]}} {{ruta/al/archivo}}

Ordena un archivo, imprimiendo la salida en un archivo específico (puede usarse para ordenar un archivo en el sitio):

sort {{[-o|--output]}} {{ruta/al/archivo_de_salida}} {{ruta/al/archivo_de_entrada}}

split

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

split [OPCIÓN]... [ENTRADA [PREFIJO]]

Crear archivos de salida conteniendo secciones consecutivas o intercaladas de entrada

Options

--bytes=<SIZE>, -b <SIZE>: poner TAMAÑO bytes por archivo de salida
--line-bytes=<SIZE>, -C <SIZE>: poner como máximo TAMAÑO bytes de líneas por archivo de salida
--lines=<NUMBER>, -l <NUMBER>: poner NÚMERO líneas/registros por archivo de salida
--number=<CHUNKS>, -n <CHUNKS>: generar FRAGMENTOS archivos de salida; ver explicación abajo
--additional-suffix=<SUFFIX>: SUFIJO adicional para anexar a nombres de archivos de salida
--filter=<COMMAND>: escribir a COMANDO shell; el nombre de archivo es $FILE (Actualmente no implementado para Windows)
--elide-empty-files, -e: no generar archivos de salida vacíos con ‘-n’
-d: usar sufijos numéricos empezando en 0, no alfabéticos
--numeric-suffixes=<FROM>: igual que -d, pero permite establecer el valor de inicio
-x: usar sufijos hexadecimales empezando en 0, no alfabéticos
--hex-suffixes=<FROM>: igual que -x, pero permite establecer el valor de inicio
--suffix-length=<N>, -a <N>: generar sufijos de longitud N (predeterminado 2)
--verbose: imprimir un diagnóstico justo antes de que se abra cada archivo de salida
--separator=<SEP>, -t <SEP>: usar SEP en lugar de nueva línea como separador de registro; ‘\0’ (cero) especifica el carácter NUL
--io-blksize

Generar piezas de tamaño fijo de ENTRADA a PREFIJOaa, PREFIJOab, …; el tamaño predeterminado es 1000, y el PREFIJO predeterminado es ‘x’. Sin ENTRADA, o cuando ENTRADA es -, leer entrada estándar.

El argumento TAMAÑO es un entero y unidad opcional (ejemplo: 10K es 10*1024). Las unidades son K,M,G,T,P,E,Z,Y,R,Q (potencias de 1024) o KB,MB,… (potencias de 1000). También se pueden usar prefijos binarios: KiB=K, MiB=M, y así sucesivamente.

FRAGMENTOS puede ser:

N dividir en N archivos basado en tamaño de entrada
K/N generar el K-ésimo de N a stdout
l/N dividir en N archivos sin dividir líneas/registros
l/K/N generar el K-ésimo de N a stdout sin dividir líneas/registros
r/N como ‘l’ pero usar distribución round robin
r/K/N igualmente pero solo generar el K-ésimo de N a stdout

Examples

Split a file, each split having 10 lines (except the last split):

split {{[-l|--lines]}} 10 {{path/to/file}}

Split a file into 5 files. File is split such that each split has same size (except the last split):

split {{[-n|--number]}} 5 {{path/to/file}}

Split a file with 512 bytes in each split (except the last split; use 512k for kilobytes and 512m for megabytes):

split {{[-b|--bytes]}} 512 {{path/to/file}}

Split a file with at most 512 bytes in each split without breaking lines:

split {{[-C|--line-bytes]}} 512 {{path/to/file}}

Split into multiple files from stdin:

gzip {{[-cd|--stdout --decompress]}} {{path/to/compressed_file.gz}} | split {{[-l|--lines]}} {{1000}} - {{path/to/output}}

stat

v(uutils coreutils) 0.8.0

stat [OPCIÓN]... ARCHIVO...

Mostrar estado de archivo o sistema de archivos.

Options

--dereference, -L: seguir enlaces
--file-system, -f: mostrar estado de sistema de archivos en lugar de estado de archivo
--terse, -t: mostrar la información en forma concisa
--format=<FORMAT>, -c <FORMAT>: usar el FORMATO especificado en lugar del por defecto;
mostrar una nueva línea después de cada uso de FORMATO
--printf=<FORMAT>: como –format, pero interpretar escapes de barra invertida,
y no mostrar una nueva línea final obligatoria;
si quiere una nueva línea, incluya \n en FORMATO

Secuencias de formato válidas para archivos (sin --file-system):

-%a: derechos de acceso en octal (note las banderas printf ‘#’ y ‘0’) -%A: derechos de acceso en forma legible por humanos -%b: número de bloques asignados (ver %B) -%B: el tamaño en bytes de cada bloque reportado por %b -%C: cadena de contexto de seguridad SELinux -%d: número de dispositivo en decimal -%D: número de dispositivo en hex -%f: modo crudo en hex -%F: tipo de archivo -%g: ID de grupo del propietario -%G: nombre de grupo del propietario -%h: número de enlaces duros -%i: número de inodo -%m: punto de montaje -%n: nombre de archivo -%N: nombre de archivo con comillas con desreferencia (seguir) si es enlace simbólico -%o: sugerencia de tamaño óptimo de transferencia E/S -%s: tamaño total, en bytes -%t: tipo de dispositivo mayor en hex, para archivos especiales de dispositivo carácter/bloque -%T: tipo de dispositivo menor en hex, para archivos especiales de dispositivo carácter/bloque -%u: ID de usuario del propietario -%U: nombre de usuario del propietario -%w: tiempo de nacimiento del archivo, legible por humanos; - si desconocido -%W: tiempo de nacimiento del archivo, segundos desde Época; 0 si desconocido -%x: tiempo del último acceso, legible por humanos -%X: tiempo del último acceso, segundos desde Época -%y: tiempo de la última modificación de datos, legible por humanos

-%Y: tiempo de la última modificación de datos, segundos desde Época -%z: tiempo del último cambio de estado, legible por humanos -%Z: tiempo del último cambio de estado, segundos desde Época

Secuencias de formato válidas para sistemas de archivos:

-%a: bloques libres disponibles para no-superusuario -%b: bloques de datos totales en sistema de archivos -%c: nodos de archivo totales en sistema de archivos -%d: nodos de archivo libres en sistema de archivos -%f: bloques libres en sistema de archivos -%i: ID de sistema de archivos en hex -%l: longitud máxima de nombres de archivo -%n: nombre de archivo -%s: tamaño de bloque (para transferencias más rápidas) -%S: tamaño de bloque fundamental (para conteos de bloque) -%t: tipo de sistema de archivos en hex -%T: tipo de sistema de archivos en forma legible por humanos

NOTA: su shell puede tener su propia versión de stat, que usualmente reemplaza la versión descrita aquí. Por favor consulte la documentación de su shell para detalles sobre las opciones que soporta.

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Display properties about a specific file such as size, permissions, creation date, and access date among others:

stat {{path/to/file}}

Display properties about a specific file, only showing the raw result data without labels:

stat {{[-t|--terse]}} {{path/to/file}}

Display information about the filesystem where a specific file is located:

stat {{[-f|--file-system]}} {{path/to/file}}

Show only octal file permissions:

stat {{[-c|--format]}} "%a %n" {{path/to/file}}

Show the owner and group of a specific file:

stat {{[-c|--format]}} "%U %G" {{path/to/file}}

Show the size of a specific file in bytes:

stat {{[-c|--format]}} "%s %n" {{path/to/file}}

stdbuf

v(uutils coreutils) 0.8.0

stdbuf [OPCIÓN]... COMANDO

Ejecutar COMANDO, con operaciones de almacenamiento en búfer modificadas para sus flujos estándar.

Los argumentos obligatorios para opciones largas son obligatorios también para opciones cortas.

Options

--input=<MODE>, -i <MODE>: ajustar almacenamiento en búfer del flujo de entrada estándar
--output=<MODE>, -o <MODE>: ajustar almacenamiento en búfer del flujo de salida estándar
--error=<MODE>, -e <MODE>: ajustar almacenamiento en búfer del flujo de error estándar

Si MODO es ‘L’ el flujo correspondiente será almacenado en búfer por líneas. Esta opción no es válida con entrada estándar.

Si MODO es ‘0’ el flujo correspondiente no tendrá búfer.

De lo contrario, MODO es un número que puede ser seguido por uno de los siguientes:

KB 1000, K 1024, MB 10001000, M 10241024, y así sucesivamente para G, T, P, E, Z, Y. En este caso el flujo correspondiente será completamente almacenado en búfer con el tamaño de búfer establecido a MODO bytes.

NOTA: Si COMANDO ajusta el almacenamiento en búfer de sus flujos estándar (tee hace por ej.) entonces eso anulará las configuraciones correspondientes cambiadas por stdbuf. También algunos filtros (como dd y cat etc.) no usan flujos para E/S, y por lo tanto no son afectados por las configuraciones de stdbuf.

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Change stdin buffer size to 512 KiB:

stdbuf {{[-i|--input]}} 512K {{command}}

Change stdout buffer to line-buffered:

stdbuf {{[-o|--output]}} L {{command}}

Change stderr buffer to unbuffered:

stdbuf {{[-e|--error]}} 0 {{command}}

stty

v(uutils coreutils) 0.8.0

stty [-F DISPOSITIVO | --file=DISPOSITIVO] [CONFIGURACIÓN]...
o:  stty [-F DISPOSITIVO | --file=DISPOSITIVO] [-a|--all]
o:  stty [-F DISPOSITIVO | --file=DISPOSITIVO] [-g|--save]"

Declarar o cambiar características del terminal.

Options

--all, -a: stty-option-all
--save, -g: stty-option-save
--file=<DEVICE>, -F <DEVICE>: stty-option-file
: stty-option-settings

Examples

Muestra el tamaño actual del terminal:

stty size

Muestra todos los ajustes del terminal actual:

stty {{[-a|--all]}}

Establece el número de filas o columnas:

stty {{rows|cols}} {{cuenta}}

Obtiene la velocidad de transferencia real de un dispositivo:

stty {{[-F|--file]}} {{ruta/al/archivo_del_dispositivo}} speed

Restablece todos los modos a valores razonables para la terminal actual:

stty sane

Cambia entre el modo sin procesar y el modo normal:

stty {{raw|cooked}}

Activa o desactiva el eco de caracteres:

stty {{-echo|echo}}

Muestra la ayuda:

stty --help

sum

v(uutils coreutils) 0.8.0

sum [OPCIÓN]... [ARCHIVO]...

Suma de verificación y contar los bloques en un archivo.

Sin ARCHIVO, o cuando ARCHIVO es -, leer entrada estándar.

Options


-r: usar el algoritmo de suma BSD, usar bloques de 1K (predeterminado)
--sysv, -s: usar el algoritmo de suma System V, usar bloques de 512 bytes

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Compute a checksum with BSD-compatible algorithm and 1024-byte blocks:

sum {{path/to/file}}

Compute a checksum with System V-compatible algorithm and 512-byte blocks:

sum {{[-s|--sysv]}} {{path/to/file}}

sync

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

sync [OPCIÓN]... ARCHIVO...

Sincronizar escrituras en caché al almacenamiento persistente

Options

--file-system, -f: sincronizar los sistemas de archivos que contienen los archivos (solo Linux y Windows)
--data, -d: sincronizar solo datos de archivo, no metadatos innecesarios (solo Linux)

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Flush all pending write operations on all disks:

sync

Flush all pending write operations on a single file to disk:

sync {{path/to/file}}

Flush writes and drop filesystem caches (Linux only):

sync; echo 3 | sudo tee /proc/sys/vm/drop_caches

Flush disk writes and attempts to clear inactive memory and filesystem caches (macOS only):

sync; sudo purge

tac

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

tac [OPCIÓN]... [ARCHIVO]...

Escribir cada archivo a salida estándar, última línea primero.

Options

--before, -b: adjuntar el separador antes en lugar de después
--regex, -r: interpretar la secuencia como una expresión regular
--separator=<STRING>, -s <STRING>: usar CADENA como el separador en lugar de nueva línea

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Concatenate specific files in reversed order:

tac {{path/to/file1 path/to/file2 ...}}

Display stdin in reversed order:

{{cat path/to/file}} | tac

Use a specific separator:

tac {{[-s|--separator]}} {{separator}} {{path/to/file1 path/to/file2 ...}}

Use a specific regex as a separator:

tac {{[-r|--regex]}} {{[-s|--separator]}} {{separator}} {{path/to/file1 path/to/file2 ...}}

Use a separator before each file:

tac {{[-b|--before]}} {{path/to/file1 path/to/file2 ...}}

tail

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

tail [OPCIÓN]... [ARCHIVO]...

Mostrar las últimas 10 líneas de cada ARCHIVO a salida estándar. Con más de un ARCHIVO, preceder cada uno con un encabezado que muestre el nombre del archivo. Sin ARCHIVO, o cuando ARCHIVO es -, leer entrada estándar. Los argumentos obligatorios para las opciones largas también son obligatorios para las opciones cortas.

Options

--bytes, -c: Número de bytes a mostrar
--follow, -f: Mostrar el archivo conforme crece
--lines, -n: Número de líneas a mostrar
--pid=<PID>: Con -f, terminar después de que muera el ID de proceso, PID
--quiet, --silent, -q: Nunca mostrar encabezados con nombres de archivo
--sleep-interval=<N>, -s <N>: Número de segundos a dormir entre consultas del archivo cuando se ejecuta con -f
--max-unchanged-stats=<N>: Reabrir un ARCHIVO que no ha cambiado de tamaño después de N (por defecto 5) iteraciones para ver si ha sido desenlazado o renombrado (este es el caso usual de archivos de registro rotados); Esta opción solo tiene significado al consultar (es decir, con –use-polling) y cuando –follow=name
--verbose, -v: Siempre mostrar encabezados con nombres de archivo
--zero-terminated, -z: El delimitador de línea es NUL, no nueva línea
--use-polling: Deshabilitar soporte ‘inotify’ y usar consultas en su lugar
--retry: Seguir intentando abrir un archivo si es inaccesible
-F: Igual que –follow=name –retry
--debug: indicate which –follow implementation is used
--presume-input-pipe

Examples

Imprime las últimas líneas de ‘recuento’ de un archivo:

tail {{[-n|--lines]}} {{recuento}} {{ruta/al/archivo}}

Imprime un archivo desde una línea específica:

tail {{[-n|--lines]}} +{{recuento}} {{ruta/al/archivo}}

Imprime un número específico de bytes desde el final de algún archivo:

tail {{[-n|--lines]}} {{recuento}} {{ruta/al/archivo}}

Imprime las últimas líneas de un archivo en tiempo real hasta presionar <Ctrl c>:

tail {{[-f|--follow]}} {{ruta/al/archivo}}

Mantiene leyendo las últimas líneas de un archivo hasta presionar <Ctrl c>, aunque el archivo sea inaccesible:

tail {{[-F|--retry --follow]}} {{ruta/al/archivo}}

Imprime las últimas líneas de ‘recuento’ en ‘archivo’ y se actualiza cada ‘n’ segundos:

tail {{[-n|--lines]}} {{recuento}} {{[-s|--sleep-interval]}} {{segundos}} {{[-f|--follow]}} {{ruta/al/archivo}}

tee

v(uutils coreutils) 0.8.0

tee [OPCIÓN]... [ARCHIVO]...

Copiar entrada estándar a cada ARCHIVO, y también a salida estándar.

Options

--help, -h: Mostrar ayuda
--append, -a: anexar a los ARCHIVOs dados, no sobreescribir
--ignore-interrupts, -i: ignorar señales de interrupción (ignorado en plataformas no-Unix)

-p: establecer comportamiento de error de escritura (ignorado en plataformas no-Unix)
--output-error: establecer comportamiento de error de escritura

Si un ARCHIVO es -, se refiere a un archivo llamado - .

Examples

Copia la entrada estándar (stdin) a cada archivo, y también a la salida estándar (stdout):

echo "ejemplo" | tee {{ruta/al/archivo}}

Anexa a los archivos específicos, sin sobreescribir:

echo "ejemplo" | tee {{[-a|--append]}} {{ruta/al/archivo}}

Imprime la entrada estándar a la terminal, y también lo reenvía a otro programa para posterior procesamiento:

echo "ejemplo" | tee {{/dev/tty}} | {{xargs printf "[%s]"}}

Crea un directorio llamado “ejemplo”, cuenta el número de caracteres en “ejemplo” y escribe “ejemplo” a la terminal:

echo "ejemplo" | tee >(xargs mkdir) >(wc {{[-c|--bytes]}})

test

v(uutils coreutils) 0.8.0

test EXPRESIÓN
test
[ EXPRESIÓN ]
[ ]
[ OPCIÓN ]

Verificar tipos de archivo y comparar valores.

Options

Salir con el estado determinado por EXPRESIÓN.

Una EXPRESIÓN omitida es falsa por defecto. De lo contrario, EXPRESIÓN es verdadera o falsa y establece el estado de salida.

Es una de:

( EXPRESIÓN ) EXPRESIÓN es verdadera
! EXPRESIÓN EXPRESIÓN es falsa
EXPRESIÓN1 -a EXPRESIÓN2 tanto EXPRESIÓN1 como EXPRESIÓN2 son verdaderas
EXPRESIÓN1 -o EXPRESIÓN2 o EXPRESIÓN1 o EXPRESIÓN2 es verdadera

Operaciones de cadena:

-n CADENA la longitud de CADENA es distinta de cero
CADENA equivalente a -n CADENA
-z CADENA la longitud de CADENA es cero
CADENA1 = CADENA2 las cadenas son iguales
CADENA1 != CADENA2 las cadenas no son iguales

Comparaciones de enteros:

ENTERO1 -eq ENTERO2 ENTERO1 es igual a ENTERO2
ENTERO1 -ge ENTERO2 ENTERO1 es mayor o igual que ENTERO2
ENTERO1 -gt ENTERO2 ENTERO1 es mayor que ENTERO2
ENTERO1 -le ENTERO2 ENTERO1 es menor o igual que ENTERO2
ENTERO1 -lt ENTERO2 ENTERO1 es menor que ENTERO2
ENTERO1 -ne ENTERO2 ENTERO1 no es igual a ENTERO2

Operaciones de archivo:

ARCHIVO1 -ef ARCHIVO2 ARCHIVO1 y ARCHIVO2 tienen los mismos números de dispositivo e inode
ARCHIVO1 -nt ARCHIVO2 ARCHIVO1 es más nuevo (fecha de modificación) que ARCHIVO2
ARCHIVO1 -ot ARCHIVO2 ARCHIVO1 es más viejo que ARCHIVO2
-b ARCHIVO ARCHIVO existe y es especial de bloque
-c ARCHIVO ARCHIVO existe y es especial de carácter
-d ARCHIVO ARCHIVO existe y es un directorio
-e ARCHIVO ARCHIVO existe
-f ARCHIVO ARCHIVO existe y es un archivo regular
-g ARCHIVO ARCHIVO existe y tiene set-group-ID
-G ARCHIVO ARCHIVO existe y es propiedad del ID de grupo efectivo
-h ARCHIVO ARCHIVO existe y es un enlace simbólico (igual que -L)
-k ARCHIVO ARCHIVO existe y tiene su bit pegajoso establecido
-L ARCHIVO ARCHIVO existe y es un enlace simbólico (igual que -h)
-N ARCHIVO ARCHIVO existe y ha sido modificado desde que fue leído por última vez
-O ARCHIVO ARCHIVO existe y es propiedad del ID de usuario efectivo
-p ARCHIVO ARCHIVO existe y es una tubería con nombre
-r ARCHIVO ARCHIVO existe y se otorga permiso de lectura
-s ARCHIVO ARCHIVO existe y tiene un tamaño mayor que cero
-S ARCHIVO ARCHIVO existe y es un socket
-t FD el descriptor de archivo FD está abierto en un terminal
-u ARCHIVO ARCHIVO existe y su bit set-user-ID está establecido
-w ARCHIVO ARCHIVO existe y se otorga permiso de escritura
-x ARCHIVO ARCHIVO existe y se otorga permiso de ejecución (o búsqueda)

Excepto por -h y -L, todas las pruebas relacionadas con ARCHIVO desreferencian (siguen) enlaces simbólicos. Tenga cuidado que los paréntesis necesitan ser escapados (ej., por barras invertidas) para shells. ENTERO también puede ser -l CADENA, que evalúa a la longitud de CADENA.

NOTA: Los -a y -o binarios son inherentemente ambiguos. Use test EXPR1 && test EXPR2 o test EXPR1 || test EXPR2 en su lugar. NOTA: [ respeta las opciones –help y –version, pero test no. test trata cada una de esas como trata cualquier otra CADENA no vacía. NOTA: su shell puede tener su propia versión de test y/o [, que usualmente reemplaza la versión descrita aquí. Por favor consulte la documentación de su shell para detalles sobre las opciones que soporta.

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Test if a given variable is equal to a given string:

test "{{$MY_VAR}}" = "{{/bin/zsh}}"

Test if a given variable is empty ([z]ero length):

test -z "{{$GIT_BRANCH}}"

Test if a [f]ile exists:

test -f "{{path/to/file_or_directory}}"

Test if a [d]irectory does not exist:

test ! -d "{{path/to/directory}}"

If A is true, then do B, or C in the case of an error (notice that C may run even if A fails):

test {{condition}} && {{echo "true"}} || {{echo "false"}}

Use test in a conditional statement:

if test -f "{{path/to/file}}"; then echo "File exists"; else echo "File does not exist"; fi

timeout

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

timeout [OPCIÓN] DURACIÓN COMANDO...

Iniciar COMANDO, y terminarlo si aún se está ejecutando después de DURACIÓN.

Options

--foreground, -f: cuando no se ejecuta timeout directamente desde un prompt de shell, permitir que COMANDO lea del TTY y obtenga señales TTY; en este modo, los hijos de COMANDO no tendrán tiempo de espera
--kill-after, -k: también enviar una señal KILL si COMANDO aún se está ejecutando tanto tiempo después de que se envió la señal inicial
--preserve-status, -p: salir con el mismo estado que COMANDO, incluso cuando el comando agote el tiempo
--signal=<SIGNAL>, -s <SIGNAL>: especificar la señal a enviar en tiempo de espera; SEÑAL puede ser un nombre como ‘HUP’ o un número; vea ‘kill -l’ para una lista de señales
--verbose, -v: diagnosticar a stderr cualquier señal enviada al agotar tiempo
: a floating point number with an optional suffix: ‘s’ for seconds (the default), ‘m’ for minutes, ‘h’ for hours or ‘d’ for days ; a duration of 0 disables the associated timeout
: a command to execute with optional arguments

Upon timeout, send the TERM signal to COMMAND, if no other SIGNAL specified. The TERM signal kills any process that does not block or catch that signal. It may be necessary to use the KILL signal, since this signal can’t be caught.

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Run sleep 10 and terminate it after 3 seconds:

timeout 3s sleep 10

Send a signal to the command after the time limit expires (TERM by default, kill -l to list all signals):

timeout {{[-s|--signal]}} {{INT|HUP|KILL|...}} {{5s}} {{sleep 10}}

Send verbose output to stderr showing signal sent upon timeout:

timeout {{[-v|--verbose]}} {{0.5s|1m|1h|1d|...}} {{command}}

Preserve the exit status of the command regardless of timing out:

timeout {{[-p|--preserve-status]}} {{1s|1m|1h|1d|...}} {{command}}

Send a forceful KILL signal after certain duration if the command ignores initial signal upon timeout:

timeout {{[-k|--kill-after]}} {{5m}} {{30s}} {{command}}

touch

v(uutils coreutils) 0.8.0

touch [OPCIÓN]... [ARCHIVO]...

Actualizar los tiempos de acceso y modificación de cada ARCHIVO al tiempo actual.

Options

--help: Mostrar información de ayuda.
-a: cambiar solo el tiempo de acceso
-t <STAMP>: usar [[CC]YY]MMDDhhmm[.ss] en lugar del tiempo actual
--date=<STRING>, -d <STRING>: analizar argumento y usarlo en lugar del tiempo actual
-f: (ignored)
-m: cambiar solo el tiempo de modificación
--no-create, -c: no crear ningún archivo
--no-dereference, -h: afectar cada enlace simbólico en lugar de cualquier archivo referenciado (solo para sistemas que pueden cambiar las marcas de tiempo de un enlace simbólico)
--reference=<FILE>, -r <FILE>: usar los tiempos de este archivo en lugar del tiempo actual
--time=<WORD>: cambiar solo el tiempo especificado: “access”, “atime”, o “use” son equivalentes a -a; “modify” o “mtime” son equivalentes a -m

Examples

Crea los archivos especificados:

touch {{ruta/al/archivo1 ruta/al/archivo2 ...}}

Establece los tiempos de [a]cceso o [m]odificación al momento actual y no [c]rea un archivo si este no existe:

touch {{[-c|--no-create]}} -{{a|m}} {{ruta/al/archivo1 ruta/al/archivo2 ...}}

Establece los [t]iempos de un archivo a un valor específico y no [c]rea el archivo si no existe:

touch {{[-c|--no-create]}} -t {{YYYYMMDDHHMM.SS}} {{ruta/al/archivo1 ruta/al/archivo2 ...}}

Usa los tiempos de un archivo de [r]eferencia para establecer los tiempos en otro archivo y no [c]rea el archivo si no existe:

touch {{[-c|--no-create]}} {{[-r|--reference]}} {{ruta/al/archivo/de/referencia}} {{ruta/al/archivo1 ruta/al/archivo2 ...}}

tr

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

tr [OPCIÓN]... CONJUNTO1 [CONJUNTO2]

Traducir o eliminar caracteres

Options

--complement, -c, -C: usar el complemento de CONJUNTO1
--delete, -d: eliminar caracteres en CONJUNTO1, no traducir
--squeeze-repeats, -s: reemplazar cada secuencia de un carácter repetido que está listado en el último CONJUNTO especificado, con una sola ocurrencia de ese carácter
--truncate-set1, -t: primero truncar CONJUNTO1 a la longitud de CONJUNTO2

Traducir, comprimir y/o eliminar caracteres de entrada estándar, escribiendo a salida estándar.

Examples

Sustituye todas las apariciones de un carácter en un archivo e imprime el resultado:

tr < {{path/to/file}} {{find_character}} {{replace_character}}

Sustituye todas las apariciones de un carácter de la salida de otro comando:

echo {{text}} | tr {{find_character}} {{replace_character}}

Mapea cada carácter del primer conjunto al carácter correspondiente del segundo:

tr < {{path/to/file}} '{{abcd}}' '{{jkmn}}'

Elimina todas las apariciones del conjunto de caracteres especificado de la entrada:

tr < {{path/to/file}} {{[-d|--delete]}} '{{input_characters}}'

Comprime una serie de caracteres idénticos a un solo carácter:

tr < {{path/to/file}} {{[-s|--squeeze-repeats]}} '{{input_characters}}'

Traduce el contenido de un archivo a mayúsculas:

tr < {{path/to/file}} "[:lower:]" "[:upper:]"

Elimina los caracteres no imprimibles de un archivo:

tr < {{path/to/file}} {{[-cd|--complement --delete]}} "[:print:]"

true

v(uutils coreutils) 0.8.0

Devuelve verdadero, un estado de salida exitoso.

Inmediatamente devuelve el estado de salida 0, excepto cuando se invoca con una de las opciones reconocidas. En esos casos intentará escribir el texto de ayuda o versión. Cualquier error de E/S durante esta operación hace que el programa devuelva 1 en su lugar.

Options

--help: Mostrar información de ayuda
--version: true-version-text

Examples

Devuelve un código de salida satisfactorio:

true

Hace que un comando siempre finalice con 0:

{{comando}} || true

truncate

v(uutils coreutils) 0.8.0

truncate [OPCIÓN]... [ARCHIVO]...

Reducir o extender el tamaño de cada archivo al tamaño especificado.

Options

--io-blocks, -o: tratar TAMAÑO como el número de bloques de E/S del archivo en lugar de bytes (NO IMPLEMENTADO)
--no-create, -c: no crear archivos que no existen
--reference=<RFILE>, -r <RFILE>: basar el tamaño de cada archivo en el tamaño de RARCHIVO
--size=<SIZE>, -s <SIZE>: establecer o ajustar el tamaño de cada archivo según TAMAÑO, que está en bytes a menos que se especifique –io-blocks

TAMAÑO es un entero con un prefijo opcional y unidad opcional. Las unidades disponibles (K, M, G, T, P, E, Z, e Y) usan el siguiente formato: ‘KB’ => 1000 (kilobytes) ‘K’ => 1024 (kibibytes) ‘MB’ => 10001000 (megabytes) ‘M’ => 10241024 (mebibytes) ‘GB’ => 100010001000 (gigabytes) ‘G’ => 102410241024 (gibibytes) TAMAÑO también puede tener uno de los siguientes prefijos para ajustar el tamaño de cada archivo basado en su tamaño actual: ‘+’ => extender por ‘-’ => reducir por ‘<’ => a lo más ‘>’ => al menos ‘/’ => redondear hacia abajo a múltiplo de ‘%’ => redondear hacia arriba a múltiplo de

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Set a size of 10 GB to an existing file, or create a new file with the specified size:

truncate {{[-s|--size]}} 10G {{path/to/file}}

Extend the file size by 50 MiB, fill with holes (which reads as zero bytes):

truncate {{[-s|--size]}} +50M {{path/to/file}}

Shrink the file by 2 GiB, by removing data from the end of file:

truncate {{[-s|--size]}} -2G {{path/to/file}}

Empty the file’s content:

truncate {{[-s|--size]}} 0 {{path/to/file}}

Empty the file’s content, but do not create the file if it does not exist:

truncate {{[-s|--size]}} 0 {{[-c|--no-create]}} {{path/to/file}}

tsort

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

tsort [OPCIONES] ARCHIVO

Ordenamiento topológico de las cadenas en ARCHIVO. Las cadenas se definen como cualquier secuencia de tokens separados por espacios en blanco (tabulación, espacio, o nueva línea), ordenándolos basado en dependencias en un grafo acíclico dirigido (DAG). Útil para programación y determinar orden de ejecución. Si ARCHIVO no se pasa, se usa stdin en su lugar.

Options

-w

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Perform a topological sort consistent with a partial sort per line of input separated by blanks:

tsort {{path/to/file}}

Perform a topological sort consistent on strings:

echo -e "{{UI Backend\nBackend Database\nDocs UI}}" | tsort

tty

v(uutils coreutils) 0.8.0

tty [OPCIÓN]...

Imprimir el nombre de archivo del terminal conectado a la entrada estándar.

Options

--silent, --quiet, -s: no imprimir nada, solo devolver un estado de salida

Examples

Muestra el nombre del archivo de este terminal:

tty

uname

v(uutils coreutils) 0.8.0

uname [OPCIÓN]...

Mostrar cierta información del sistema. Sin OPCIÓN, igual que -s.

Options

--all, -a: Comportarse como si todas las opciones -mnrsvo fueran especificadas.
--kernel-name, -s: mostrar el nombre del kernel.
--nodename, -n: mostrar el nombre de nodo (el nombre de nodo puede ser un nombre por el cual el sistema es conocido en una red de comunicaciones).
--kernel-release, -r: declarar la versión del sistema operativo.
--kernel-version, -v: mostrar la versión del sistema operativo.
--machine, -m: mostrar el nombre de hardware de la máquina.
--operating-system, -o: mostrar el nombre del sistema operativo.
--processor, -p: mostrar el tipo de procesador (no portátil)
--hardware-platform, -i: mostrar la plataforma de hardware (no portátil)

Examples

Muestra el nombre del kernel:

uname

Muestra toda la información disponible del sistema:

uname {{[-a|--all]}}

Muestra la arquitectura del sistema y la información del procesador:

uname {{[-mp|--machine --processor]}}

Muestra el nombre del kernel, el release y la versión:

uname {{[-srv|--kernel-name --kernel-release --kernel-version]}}

Muestra el nombre del host del sistema:

uname {{[-n|--nodename]}}

Muestra el nombre del sistema operativo actual:

uname {{[-o|--operating-system]}}

Muestra la ayuda:

uname --help

unexpand

v(uutils coreutils) 0.8.0

unexpand [OPCIÓN]... [ARCHIVO]...

Convertir espacios en blanco en cada ARCHIVO a tabulaciones, escribiendo a la salida estándar. Sin ARCHIVO, o cuando ARCHIVO es -, leer entrada estándar.

Options


--all, -a: convertir todos los espacios en blanco, en lugar de solo los espacios en blanco iniciales
--first-only, -f: convertir solo secuencias iniciales de espacios en blanco (anula -a)
--tabs=<N, LIST>, -t <N, LIST>: usar LISTA separada por comas de posiciones de tabulación o tener tabulaciones separadas por N caracteres en lugar de 8 (habilita -a)
--no-utf8, -U: interpretar archivo de entrada como ASCII de 8-bit en lugar de UTF-8

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

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

unexpand {{path/to/file}}

Convert blanks to tabs, reading from stdout:

unexpand

Convert all blanks, instead of just initial blanks:

unexpand {{[-a|--all]}} {{path/to/file}}

Convert only leading sequences of blanks (overrides -a):

unexpand --first-only {{path/to/file}}

Have tabs a certain number of characters apart, not 8 (enables -a):

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

uniq

v(uutils coreutils) 0.8.0

uniq [OPCIÓN]... [ENTRADA [SALIDA]]

Reportar u omitir líneas repetidas.

Options

--all-repeated=<delimit-method>, -D <delimit-method>: mostrar todas las líneas duplicadas. La delimitación se hace con líneas en blanco. [por defecto: none]
--group=<group-method>: mostrar todos los elementos, separando grupos con una línea vacía. [por defecto: separate]
--check-chars=<N>, -w <N>: comparar no más de N caracteres en las líneas
--count, -c: prefijar líneas por el número de ocurrencias
--ignore-case, -i: ignorar diferencias de mayúsculas al comparar
--repeated, -d: solo mostrar líneas duplicadas
--skip-chars=<N>, -s <N>: evitar comparar los primeros N caracteres
--skip-fields=<N>, -f <N>: evitar comparar los primeros N campos
--unique, -u: solo mostrar líneas únicas
--zero-terminated, -z: terminar líneas con byte 0, no nueva línea

Filtrar líneas coincidentes adyacentes de ENTRADA (o entrada estándar), escribiendo a SALIDA (o salida estándar).

Nota: uniq no detecta líneas repetidas a menos que sean adyacentes. Puede que quiera ordenar la entrada primero, o usar sort -u sin uniq.

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Display each line once:

sort {{path/to/file}} | uniq

Display only unique lines:

sort {{path/to/file}} | uniq {{[-u|--unique]}}

Display only duplicate lines:

sort {{path/to/file}} | uniq {{[-d|--repeated]}}

Display number of occurrences of each line along with that line:

sort {{path/to/file}} | uniq {{[-c|--count]}}

Display number of occurrences of each line, sorted by the most frequent:

sort {{path/to/file}} | uniq {{[-c|--count]}} | sort {{[-nr|--numeric-sort --reverse]}}

Compare only the first 10 characters on each line for uniqueness:

sort {{path/to/file}} | uniq {{[-w|--check-chars]}} 10

Compare text after the first 5 characters on each line for uniqueness:

sort {{path/to/file}} | uniq {{[-s|--skip-chars]}} 5

unlink

v(uutils coreutils) 0.8.0

unlink ARCHIVO
unlink OPCIÓN

Desenlazar el archivo en ARCHIVO.

Options

Examples

The examples have not been translated yet and are shown in English. You can help by translating them on tldr-pages.

Remove the specified file if it is the last link:

unlink {{path/to/file}}

uptime

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

Options

--since, -s: uptime-help-since
: uptime-help-path
--pretty, -p: uptime-help-pretty

Examples

Imprime la hora actual, el tiempo de encendido, el número de usuarios conectados y otros datos:

uptime

Muestra solo el tiempo que el sistema ha estado encendido:

uptime {{[-p|--pretty]}}

Imprime la fecha y hora en que el sistema se encendió:

uptime {{[-s|--since]}}

Muestra los datos de tiempo en segundos:

uptime {{[-r|--raw]}}

Muestra la versión:

uptime {{[-V|--version]}}

users

v(uutils coreutils) 0.8.0

users [ARCHIVO]

Imprimir los nombres de usuario de usuarios actualmente conectados al host actual.

Options

Examples

Imprime los nombres de usuario conectados:

users

Muestra los nombres de usuario conectados según un archivo determinado:

users {{/var/log/wmtp}}

vdir

v(uutils coreutils) 0.8.0

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

Vea la documentación del comando original:

tldr ls

wc

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

wc [OPCIÓN]... [ARCHIVO]...

Mostrar conteos de nueva línea, palabra y byte para cada ARCHIVO, y una línea total si se especifica más de un ARCHIVO.

Options

--bytes, -c: mostrar los conteos de bytes
--chars, -m: mostrar los conteos de caracteres
--files0-from=<F>: leer entrada de los archivos especificados por
nombres terminados en NUL en el archivo F;
Si F es - entonces leer nombres de entrada estándar
--lines, -l: mostrar los conteos de nueva línea
--max-line-length, -L: mostrar la longitud de la línea más larga
--total=<WHEN>: cuándo mostrar una línea con conteos totales;
CUÁNDO puede ser: auto, always, only, never
--words, -w: mostrar los conteos de palabras
--debug

Examples

Cuenta todas las líneas en un archivo:

wc {{[-l|--lines]}} {{ruta/al/archivo}}

Cuenta todas las palabras en un archivo:

wc {{[-w|--words]}} {{ruta/al/archivo}}

Cuenta todos los bytes en un archivo:

wc {{[-c|--bytes]}} {{ruta/al/archivo}}

Cuenta todos los caracteres en un archivo (considerando los caracteres de varios bytes):

wc {{[-m|--chars]}} {{ruta/al/archivo}}

Cuenta todas las líneas, palabras y bytes desde stdin:

{{find .}} | wc

Cuenta la longitud de la línea más larga en número de caracteres:

wc {{[-L|--max-line-length]}} {{ruta/al/archivo}}

who

v(uutils coreutils) 0.8.0

who [OPCIÓN]... [ ARCHIVO | ARG1 ARG2 ]

Imprimir información sobre usuarios que están actualmente conectados.

Options

--all, -a: igual que -b -d –login -p -r -t -T -u
--boot, -b: hora del último arranque del sistema
--dead, -d: imprimir procesos muertos
--heading, -H: imprimir línea de encabezados de columna
--login, -l: imprimir procesos de inicio de sesión del sistema
--lookup: intentar canonicalizar nombres de host vía DNS
-m: solo nombre de host y usuario asociado con stdin
--process, -p: imprimir procesos activos generados por init
--count, -q: todos los nombres de inicio de sesión y número de usuarios conectados
--runlevel, -r: imprimir nivel de ejecución actual
--short, -s: imprimir solo nombre, línea y hora (predeterminado)
--time, -t: imprimir último cambio de reloj del sistema
--users, -u: listar usuarios conectados
--mesg, --message, --writable, -T, -w: agregar estado de mensaje del usuario como +, - o ?

Examples

Muestra el nombre de usuario, la línea y la hora de todas las sesiones conectadas actualmente:

who

Muestra toda la información disponible:

who {{[-a|--all]}}

Muestra toda la información disponible con encabezados de tabla:

who {{[-aH|--all --heading]}}

whoami

Some strings on this page have not been translated yet. You can help by translating them on Weblate.

v(uutils coreutils) 0.8.0

whoami

Mostrar el nombre de usuario actual.

Options

Examples

Vea la documentación del comando original:

tldr id

yes

v(uutils coreutils) 0.8.0

yes [CADENA]...

Mostrar repetidamente una línea con CADENA (o ‘y’)

Options

Examples

Retorna repetidamente “mensaje”:

yes {{mensaje}}

Retorna repetidamente “y”:

yes

Acepta todas las confirmaciones que muestre el comando apt-get:

yes | sudo apt-get install {{programa}}

Retorna repetidamente una nueva línea para aceptar siempre la opción predeterminada de una pregunta (prompt):

yes ''

Keyboard shortcuts

uutils Documentation