Come tagliare un'estensione di file da una stringa in JavaScript?

Ad esempio, supponendo che x = filename.jpg, voglio ottenere filename, dove filenamepotrebbe essere qualsiasi nome di file (supponiamo che il nome del file contenga solo [a-zA-Z0-9-_] per semplificare.).

Ho visto x.substring(0, x.indexOf('.jpg'))su frammenti di DZone , ma non avrebbe x.substring(0, x.length-4)funzionato meglio? Perché, lengthè una proprietà e non esegue il controllo dei caratteri mentre indexOf()è una funzione e fa il controllo dei caratteri.

Se conosci la lunghezza dell'estensione, puoi usare x.slice(0, -4)(dove 4 sono i tre caratteri dell'estensione e del punto).

Se non conosci la lunghezza di @John Hartsock regex sarebbe l'approccio giusto.

Se preferisci non usare espressioni regolari, puoi provare questo (meno performante):

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

Nota che fallirà sui file senza estensione.

Non sono sicuro di cosa potrebbe funzionare più velocemente, ma questo sarebbe più affidabile quando si tratta di estensione come .jpego.html

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

In node.js , il nome del file senza l'estensione può essere ottenuto come segue.

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

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

Ulteriori spiegazioni alla pagina della documentazione di Node.js.

x.length-4rappresenta solo estensioni di 3 caratteri. E se hai filename.jpego filename.pl?

MODIFICARE:

Per rispondere ... certo, se hai sempre un'estensione di .jpg, x.length-4funzionerebbe bene.

Tuttavia, se non conosci la lunghezza della tua estensione, una delle numerose soluzioni è migliore / più robusta.

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

O

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

O

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

OPPURE (con il nome file presupposto ha solo un punto)

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

OPPURE (anche con un solo punto)

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

Puoi forse usare il presupposto che l'ultimo punto sarà il delimitatore di estensione.

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

Se il file non ha estensione, restituirà una stringa vuota. Per risolvere questo uso questa funzione

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

Mi piace questo perché è una fodera che non è troppo difficile da leggere:

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

Nelle versioni di Node.js precedenti a 0.12.x:

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

Naturalmente questo funziona anche in 0.12.xe versioni successive.

Funziona anche quando il delimitatore non è presente nella stringa.

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"

Può anche essere usato come un liner in questo modo:

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

EDIT: questa è una soluzione più efficiente:

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

Non so se è un'opzione valida ma io uso questo:

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.

Non è solo un'operazione che conosco, ma almeno dovrebbe sempre funzionare!

AGGIORNAMENTO: Se vuoi un oneliner, eccoti qui:

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

Un altro one-liner:

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

Ecco un'altra soluzione basata su regex:

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

Questo dovrebbe solo tagliare l'ultimo segmento.

Semplice:

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

La risposta accettata rimuove solo l'ultima parte dell'estensione ( .jpeg), che potrebbe essere una buona scelta nella maggior parte dei casi.

Una volta ho dovuto rimuovere tutte le estensioni ( .tar.gz) e i nomi dei file erano limitati per non contenere punti (quindi 2015-01-01.backup.tarnon sarebbe un problema):

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

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

Se devi elaborare una variabile che contiene il percorso completo (es .:) thePath = "http://stackoverflow.com/directory/subdirectory/filename.jpg"e vuoi restituire solo il "nome file" puoi usare:

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

il risultato sarà theName == "nomefile" ;

Per provarlo scrivi il seguente comando nella finestra della console del tuo debugger di Chrome: window.location.pathname.split("/").slice(-1).join().split(".").shift()

Se devi elaborare solo il nome del file e la sua estensione (es .:) theNameWithExt = "filename.jpg":

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

il risultato sarà theName == "nomefile" , lo stesso di cui sopra;

Appunti:

1. Il primo è un po 'più lento perché esegue più operazioni; ma funziona in entrambi i casi, in altre parole può estrarre il nome del file senza estensione da una determinata stringa che contiene un percorso o un nome file con es. Mentre il secondo funziona solo se la variabile data contiene un nome file con ext come nomefile.ext ma è un po 'più veloce.
2. Entrambe le soluzioni funzionano per file sia locali che server;

Ma non posso dire nulla sul confronto delle prestazioni con altre risposte né sulla compatibilità del browser o del sistema operativo.

snippet di lavoro 1: il percorso completo

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

snippet di lavoro 2: il nome del file con estensione

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

snippet di lavoro 2: il nome del file con doppia estensione

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

Anche se è piuttosto tardi, aggiungerò un altro approccio per ottenere il nome del file senza estensione usando semplicemente il vecchio JS-

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

Node.js rimuove l'estensione dalla directory di mantenimento del percorso completo

https://stackoverflow.com/a/31615711/895245 per esempio ha fatto path/hello.html-> hello, ma se vuoi path/hello.html-> path/hello, puoi usare questo:

#!/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));

directory degli output:

path/hello

Anche https://stackoverflow.com/a/36099196/895245 raggiunge questo obiettivo, ma trovo questo approccio un po 'più semanticamente piacevole.

Testato in Node.js v10.15.2.

È qui che le espressioni regolari sono utili! Il .replace()metodo Javascript avrà un'espressione regolare e puoi utilizzarlo per ottenere ciò che desideri:

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

Un altro esempio: supponiamo che il nostro file sia un'immagine jpg >> es: var yourStr = 'test.jpg';

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

Puoi usare pathper manovrare.

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

Produzione

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

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

Questo è il codice che uso per rimuovere l'estensione da un nome file, senza usare regex o indexOf (indexOf non è supportato in IE8). Presuppone che l'estensione sia qualsiasi testo dopo l'ultimo '.' carattere.

Funziona per:

• file senza estensione: "myletter"
• file con '.' nel nome: "my.letter.txt"
• lunghezza sconosciuta dell'estensione del file: "my.letter.html"

Ecco il codice:

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

Vorrei usare qualcosa come x.substring (0, x.lastIndexOf ('.')). Se stai andando per le prestazioni, non andare per javascript :-p No, un'altra affermazione in realtà non ha importanza per il 99,99999% di tutti gli scopi.