Comment découper une extension de fichier à partir d'une chaîne en JavaScript?

Par exemple, en supposant que x = filename.jpgje veux obtenir filename, où filenamepourrait être n'importe quel nom de fichier (supposons que le nom de fichier ne contienne que [a-zA-Z0-9-_] pour simplifier.).

J'ai vu x.substring(0, x.indexOf('.jpg'))sur DZone Snippets , mais je n'aurais pas x.substring(0, x.length-4)mieux performé ? Parce que, lengthest une propriété et ne vérifie pas les caractères alors que indexOf()c'est une fonction et vérifie les caractères.

Si vous connaissez la longueur de l'extension, vous pouvez utiliser x.slice(0, -4)(où 4 représente les trois caractères de l'extension et le point).

Si vous ne connaissez pas la longueur des expressions régulières @John Hartsock serait la bonne approche.

Si vous préférez ne pas utiliser d'expressions régulières, vous pouvez essayer ceci (moins performant):

filename.split('.').slice(0, -1).join('.')

Notez qu'il échouera sur les fichiers sans extension.

Je ne sais pas ce qui fonctionnerait plus rapidement, mais ce serait plus fiable en ce qui concerne l'extension comme .jpegou.html

x.replace(/\.[^/.]+$/, "")

Dans node.js , le nom du fichier sans l'extension peut être obtenu comme suit.

const path = require('path');
const filename = 'hello.html';

path.parse(filename).name; // hello
path.parse(filename).ext;  // .html

Plus d'explications sur la page de documentation de Node.js.

x.length-4ne prend en compte que les extensions de 3 caractères. Et si vous avez filename.jpegou filename.pl?

ÉDITER:

Pour répondre ... bien sûr, si vous avez toujours une extension de .jpg, x.length-4cela fonctionnerait très bien.

Cependant, si vous ne connaissez pas la longueur de votre extension, l'une des nombreuses solutions est meilleure / plus robuste.

x = x.replace(/\..+$/, '');

OU

x = x.substring(0, x.lastIndexOf('.'));

OU

x = x.replace(/(.*)\.(.*?)$/, "$1");

OU (avec l'hypothèse que le nom de fichier n'a qu'un seul point)

parts = x.match(/[^\.]+/);
x = parts[0];

OU (également avec un seul point)

parts = x.split(".");
x = parts[0];

Vous pouvez peut-être utiliser l'hypothèse que le dernier point sera le délimiteur d'extension.

var x = 'filename.jpg';
var f = x.substr(0, x.lastIndexOf('.'));

Si le fichier n'a pas d'extension, il renverra une chaîne vide. Pour résoudre ce problème, utilisez cette fonction

function removeExtension(filename){
    var lastDotPosition = filename.lastIndexOf(".");
    if (lastDotPosition === -1) return filename;
    else return filename.substr(0, lastDotPosition);
}

J'aime celui-ci car c'est un liner qui n'est pas trop difficile à lire:

filename.substring(0, filename.lastIndexOf('.')) || filename

Dans les versions de Node.js antérieures à 0.12.x:

path.basename(filename, path.extname(filename))

Bien sûr, cela fonctionne également dans 0.12.x et versions ultérieures.

Cela fonctionne, même lorsque le délimiteur n'est pas présent dans la chaîne.

String.prototype.beforeLastIndex = function (delimiter) {
    return this.split(delimiter).slice(0,-1).join(delimiter) || this + ""
}

"image".beforeLastIndex(".") // "image"
"image.jpeg".beforeLastIndex(".") // "image"
"image.second.jpeg".beforeLastIndex(".") // "image.second"
"image.second.third.jpeg".beforeLastIndex(".") // "image.second.third"

Peut également être utilisé comme une doublure comme ceci:

var filename = "this.is.a.filename.txt";
console.log(filename.split(".").slice(0,-1).join(".") || filename + "");

EDIT: Ceci est une solution plus efficace:

String.prototype.beforeLastIndex = function (delimiter) {
    return this.substr(0,this.lastIndexOf(delimiter)) || this + ""
}

Je ne sais pas si c'est une option valide mais j'utilise ceci:

name = filename.split(".");
// trimming with pop()
name.pop();
// getting the name with join()
name.join('.'); // we split by '.' and we join by '.' to restore other eventual points.

Ce n'est pas seulement une opération que je connais, mais au moins cela devrait toujours fonctionner!

MISE À JOUR: Si vous voulez un oneliner, vous êtes ici:

(name.split('.').slice(0, -1)).join('.')

Un autre doublure:

x.split(".").slice(0, -1).join(".")

Voici une autre solution basée sur regex:

filename.replace(/\.[^.$]+$/, '');

Cela ne devrait couper que le dernier segment.

Simple:

var n = str.lastIndexOf(".");
return n > -1 ? str.substr(0, n) : str;

La réponse acceptée ne retire que la dernière partie d'extension ( .jpeg), ce qui peut être un bon choix dans la plupart des cas.

Une fois, j'ai dû supprimer toutes les extensions ( .tar.gz) et les noms de fichiers ont été restreints pour ne pas contenir de points (ce 2015-01-01.backup.tarne serait donc pas un problème):

var name = "2015-01-01_backup.tar.gz";
name.replace(/(\.[^/.]+)+$/, "");

var fileName = "something.extension";
fileName.slice(0, -path.extname(fileName).length) // === "something"

Si vous devez traiter une variable qui contient le chemin complet (ex. thePath = "http://stackoverflow.com/directory/subdirectory/filename.jpg") Et que vous souhaitez retourner uniquement "nom de fichier", vous pouvez utiliser:

theName = thePath.split("/").slice(-1).join().split(".").shift();

le résultat sera theName == "filename" ;

Pour l'essayer, écrivez la commande suivante dans la fenêtre de console de votre débogueur Chrome: window.location.pathname.split("/").slice(-1).join().split(".").shift()

Si vous ne devez traiter que le nom du fichier et son extension (ex. theNameWithExt = "filename.jpg"):

theName = theNameWithExt.split(".").shift();

le résultat sera theName == "filename" , le même que ci-dessus;

Remarques:

1. Le premier est un peu plus lent car il effectue plus d'opérations; mais fonctionne dans les deux cas, en d'autres termes, il peut extraire le nom de fichier sans extension d'une chaîne donnée qui contient un chemin ou un nom de fichier avec ex. Alors que le second ne fonctionne que si la variable donnée contient un nom de fichier avec ext comme filename.ext mais est un peu plus rapide.
2. Les deux solutions fonctionnent pour les fichiers locaux et serveur;

Mais je ne peux rien dire sur la comparaison des performances avec les autres réponses ni sur la compatibilité du navigateur ou du système d'exploitation.

extrait de travail 1: le chemin complet

var thePath = "http://stackoverflow.com/directory/subdirectory/filename.jpg";
theName = thePath.split("/").slice(-1).join().split(".").shift();
alert(theName);

extrait de travail 2: le nom du fichier avec l'extension

var theNameWithExt = "filename.jpg";
theName = theNameWithExt.split("/").slice(-1).join().split(".").shift();
alert(theName);

extrait de travail 2: le nom du fichier avec double extension

var theNameWithExt = "filename.tar.gz";
theName = theNameWithExt.split("/").slice(-1).join().split(".").shift();
alert(theName);

Bien qu'il soit assez tard, j'ajouterai une autre approche pour obtenir le nom de fichier sans extension en utilisant du vieux JS simple

path.replace(path.substr(path.lastIndexOf('.')), '')

Node.js supprime l'extension du répertoire complet de conservation des chemins

https://stackoverflow.com/a/31615711/895245 par exemple a fait path/hello.html-> hello, mais si vous voulez path/hello.html-> path/hello, vous pouvez utiliser ceci:

#!/usr/bin/env node
const path = require('path');
const filename = 'path/hello.html';
const filename_parsed = path.parse(filename);
console.log(path.join(filename_parsed.dir, filename_parsed.name));

répertoire de sortie également:

path/hello

https://stackoverflow.com/a/36099196/895245 y parvient également, mais je trouve cette approche un peu plus sémantiquement agréable.

Testé dans Node.js v10.15.2.

C'est là que les expressions régulières sont utiles! La .replace()méthode Javascript prendra une expression régulière, et vous pouvez l'utiliser pour accomplir ce que vous voulez:

// assuming var x = filename.jpg or some extension
x = x.replace(/(.*)\.[^.]+$/, "$1");

Un autre liner - nous supposons que notre fichier est une image jpg >> ex: var yourStr = 'test.jpg';

    yourStr = yourStr.slice(0, -4); // 'test'

Vous pouvez utiliser pathpour manœuvrer.

var MYPATH = '/User/HELLO/WORLD/FILENAME.js';
var MYEXT = '.js';
var fileName = path.basename(MYPATH, MYEXT);
var filePath = path.dirname(MYPATH) + '/' + fileName;

Production

> filePath
'/User/HELLO/WORLD/FILENAME'
> fileName
'FILENAME'
> MYPATH
'/User/HELLO/WORLD/FILENAME.js'

x.slice(0, -(x.split('.').pop().length + 1));

C'est le code que j'utilise pour supprimer l'extension d'un nom de fichier, sans utiliser ni regex ni indexOf (indexOf n'est pas pris en charge dans IE8). Il suppose que l'extension est un texte après le dernier '.' personnage.

Cela fonctionne pour:

• fichiers sans extension: "myletter"
• fichiers avec '.' dans le nom: "my.letter.txt"
• longueur d'extension de fichier inconnue: "my.letter.html"

Voici le code:

var filename = "my.letter.txt" // some filename

var substrings = filename.split('.'); // split the string at '.'
if (substrings.length == 1)
{
  return filename; // there was no file extension, file was something like 'myfile'
}
else
{
  var ext = substrings.pop(); // remove the last element
  var name = substrings.join(""); // rejoin the remaining elements without separator
  name = ([name, ext]).join("."); // readd the extension
  return name;
}

J'utiliserais quelque chose comme x.substring (0, x.lastIndexOf ('.')). Si vous optez pour les performances, n'utilisez pas du tout le javascript :-p Non, une autre déclaration n'a vraiment aucune importance pour 99,99999% de tous les usages.