web-dev-qa-db-fra.com

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

Par exemple, en supposant que x = filename.jpg, je souhaite obtenir filename, où filename pourrait ê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 x.substring(0, x.length-4) n'a-t-il pas une meilleure performance? Parce que length est une propriété et ne vérifie pas les caractères, alors que indexOf() est une fonction et vérifie les caractères.

javascriptreplacesubstringsubstrindexof
225
ma11hew28

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, @John Hartsock regex 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.

111
Marek Sapota

Je ne sais pas ce qui fonctionnerait plus rapidement, mais ce serait plus fiable en ce qui concerne les extensions telles que .jpeg ou .html

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

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

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

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

Plus d'explications sur Node.jsdocumentation page.

146
Jibesh Patra

x.length-4 ne représente que les extensions de 3 caractères. Que faire si vous avez filename.jpegou filename.pl?

MODIFIER:

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

Cependant, si vous ne connaissez pas la longueur de votre extension, plusieurs solutions sont meilleures/plus robustes.

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

OR

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

OR

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

OU (avec l'hypothèse 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];
112
Jeff B

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 retournera 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);
}
36
Martin Algesten

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 aussi être utilisé comme un liner comme ceci:

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

EDIT: C’est une solution plus efficace:

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

J'aime celui-ci parce que c'est un one-line qui n'est pas trop difficile à lire:

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

Un autre one-liner:

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

Voici une autre solution basée sur regex:

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

Cela ne devrait couper que le dernier segment.

6
Chad Johnson

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 une opération que je connaisse, mais au moins ça devrait toujours marcher!

UPDATE: Si vous voulez un oneliner, vous êtes ici:

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

6
Giacomo Cerquone

Un simple:

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

La réponse acceptée supprime uniquement la dernière partie de l'extension (.jpeg), ce qui peut constituer un bon choix dans la plupart des cas.

Une fois, j'ai dû effacer toutes les extensions (.tar.gz) et les noms de fichiers ont été limités pour ne pas contenir de points (donc 2015-01-01.backup.tar ne poserait pas de problème):

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

Cela peut aussi être fait facilement avec path en utilisant les méthodes basename et extname.

const path = require('path')

path.basename('test.txt', path.extname('test.txt'))
4
DBrown

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

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

le résultat sera theName == "nom de fichier" ;

Pour l’essayer, écrivez la commande suivante dans la fenêtre de la 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 == "nom de fichier" , comme ci-dessus;

Remarques:

  1. Le premier est un peu plus lent car il effectue plus d'opérations mais fonctionne dans les deux cas, c’est-à-dire qu’il peut extraire le nom du fichier sans extension d’une chaîne donnée contenant un chemin ou un nom de fichier avec ex. Alors que la seconde ne fonctionne que si la variable donnée contient un nom de fichier avec ext tel que filename.ext, mais est un peu plus rapide.
  2. Les deux solutions fonctionnent à la fois pour les fichiers locaux et les fichiers du serveur;

Mais je ne peux rien dire sur la comparaison des performances avec d'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 une double extension 

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

3
willy wonka
var fileName = "something.extension";
fileName.slice(0, -path.extname(fileName).length) // === "something"
2
Yas

C'est ici que les expressions régulières sont utiles! La méthode .replace() de Javascript prend 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");
0
Alex
x.slice(0, -(x.split('.').pop().length + 1));
0
ishandutta2007

Vous pouvez utiliser path pour manœuvrer.

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

Sortie

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

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

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

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

Cela fonctionne pour:

  • fichiers sans extension: "myletter"
  • fichiers avec '.' au nom: "my.letter.txt"
  • longueur inconnue de l'extension de fichier: "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;
}
0
Little Brain