continue
				}
				stats, err := disk.StatInfoFile(ctx, volume, file, true)
				if err != nil {
					continue
				}
				for _, si := range stats {
					found++
					var r io.ReadCloser
					if !si.Dir {
						r, err = disk.ReadFileStream(ctx, volume, si.Name, 0, si.Size)
						if err != nil {
							continue
						}
					} else {
						r = io.NopCloser(bytes.NewBuffer([]byte{}))
					}

* **Code asynchrone**
* **`async` et `await`**
* **Coroutines**

## Code asynchrone

Faire du code asynchrone signifie que le langage 💬 est capable de dire à l'ordinateur / au programme 🤖 qu'à un moment du code, il 🤖 devra attendre que *quelque chose d'autre* se termine autre part. Disons que ce *quelque chose d'autre* est appelé "fichier-lent" 📝.

}

func (p *xlStorageDiskIDCheck) ReadParts(ctx context.Context, volume string, partMetaPaths ...string) ([]*ObjectPartInfo, error) {
	ctx, done, err := p.TrackDiskHealth(ctx, storageMetricReadParts, volume, path.Dir(partMetaPaths[0]))
	if err != nil {
		return nil, err
	}
	defer done(0, &err)

	return p.storage.ReadParts(ctx, volume, partMetaPaths...)
}

            }
        }
    }

    void initialize(CliRequest cliRequest) throws ExitException {
        if (cliRequest.workingDirectory == null) {
            cliRequest.workingDirectory = System.getProperty("user.dir");
        }

        if (cliRequest.multiModuleProjectDirectory == null) {
            String basedirProperty = System.getProperty(MULTIMODULE_PROJECT_DIRECTORY);
            if (basedirProperty == null) {

pkg go/types, method (*Builtin) Pkg() *Package
pkg go/types, method (*Builtin) Pos() token.Pos
pkg go/types, method (*Builtin) String() string
pkg go/types, method (*Builtin) Type() Type
pkg go/types, method (*Chan) Dir() ChanDir
pkg go/types, method (*Chan) Elem() Type
pkg go/types, method (*Chan) String() string
pkg go/types, method (*Chan) Underlying() Type
pkg go/types, method (*Checker) Files([]*ast.File) error

		if err != nil {
			return nil, err
		}
		if store.getUsersSysType() == MinIOUsersSysType {
			groupsList := listedConfigItems[groupsListKey]
			for _, item := range groupsList {
				group := path.Dir(item)
				if err = iamOS.loadGroup(ctx, group, cache.iamGroupsMap); err != nil && !errors.Is(err, errNoSuchGroup) {
					return nil, fmt.Errorf("unable to load the group: %w", err)
				}
				groupSet.Add(group)
			}

			expectedRespStatus: http.StatusBadRequest,
		},
		// Test case - 3.
		// Test case with invalid source object.
		3: {
			bucketName:         bucketName,
			newObjectName:      "dir//newObject1",
			copySourceHeader:   url.QueryEscape(SlashSeparator + bucketName + SlashSeparator + objectName),
			accessKey:          credentials.AccessKey,
			secretKey:          credentials.SecretKey,

pkg go/ast, type CaseClause struct, List []Expr
pkg go/ast, type ChanDir int
pkg go/ast, type ChanType struct
pkg go/ast, type ChanType struct, Begin token.Pos
pkg go/ast, type ChanType struct, Dir ChanDir
pkg go/ast, type ChanType struct, Value Expr
pkg go/ast, type CommClause struct
pkg go/ast, type CommClause struct, Body []Stmt
pkg go/ast, type CommClause struct, Case token.Pos

pkg encoding/asn1, const TagBMPString = 30
pkg encoding/asn1, const TagBMPString ideal-int
pkg encoding/json, method (*Decoder) InputOffset() int64
pkg go/build, type Context struct, Dir string
pkg go/doc, func NewFromFiles(*token.FileSet, []*ast.File, string, ...interface{}) (*Package, error)
pkg go/doc, type Example struct, Suffix string
pkg go/doc, type Func struct, Examples []*Example

pkg reflect, func SliceOf(Type) Type
pkg reflect, method (Value) Convert(Type) Value
pkg reflect, type SelectCase struct
pkg reflect, type SelectCase struct, Chan Value
pkg reflect, type SelectCase struct, Dir SelectDir
pkg reflect, type SelectCase struct, Send Value
pkg reflect, type SelectDir int
pkg reflect, type Type interface, ConvertibleTo(Type) bool
pkg regexp, method (*Regexp) Longest()