Jak przyciąć rozszerzenie pliku z ciągu w JavaScript?

Na przykład, zakładając x = filename.jpg, że chcę uzyskać filename, gdzie filenamemoże być dowolna nazwa pliku (załóżmy, że nazwa pliku zawiera tylko [a-zA-Z0-9-_] w celu uproszczenia.).

Widziałem x.substring(0, x.indexOf('.jpg'))na fragmentach DZone , ale czy nie działałby x.substring(0, x.length-4)lepiej? Ponieważ lengthjest właściwością i nie sprawdza znaków, podczas gdy indexOf()jest funkcją i sprawdza znaki.

Jeśli znasz długość rozszerzenia, możesz użyć x.slice(0, -4)(gdzie 4 to trzy znaki rozszerzenia i kropka).

Jeśli nie znasz długości, wyrażenie regularne @John Hartsock byłoby właściwym podejściem.

Jeśli wolisz nie używać wyrażeń regularnych, możesz wypróbować to (mniej wydajne):

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

Pamiętaj, że nie powiedzie się na plikach bez rozszerzenia.

Nie jestem pewien, co by działało szybciej, ale byłoby to bardziej niezawodne, jeśli chodzi o rozszerzenie, takie jak .jpeglub.html

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

W node.js nazwę pliku bez rozszerzenia można uzyskać w następujący sposób.

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

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

Dalsze objaśnienia na stronie dokumentacji Node.js.

x.length-4uwzględnia tylko rozszerzenia 3 znaków. Co jeśli masz filename.jpeglub filename.pl?

EDYTOWAĆ:

Aby odpowiedzieć ... na pewno, jeśli zawsze masz rozszerzenie .jpg, x.length-4działałoby dobrze.

Jeśli jednak nie znasz długości swojego rozszerzenia, dowolne z wielu rozwiązań jest lepsze / bardziej niezawodne.

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

LUB

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

LUB

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

LUB (przy założeniu, że nazwa pliku ma tylko jedną kropkę)

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

LUB (także z tylko jedną kropką)

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

Być może możesz przyjąć założenie, że ostatnia kropka będzie ogranicznikiem rozszerzenia.

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

Jeśli plik nie ma rozszerzenia, zwróci pusty ciąg. Aby to naprawić, użyj tej funkcji

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

Podoba mi się ten, ponieważ jest to jeden liniowiec, który nie jest zbyt trudny do odczytania:

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

W wersjach Node.js wcześniejszych niż 0.12.x:

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

Oczywiście działa to również w wersji 0.12.xi późniejszych.

Działa to nawet wtedy, gdy ogranicznik nie występuje w ciągu.

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"

Może być również użyty jako jedna linijka:

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

EDYCJA: To jest bardziej wydajne rozwiązanie:

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

Nie wiem, czy jest to prawidłowa opcja, ale używam tego:

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.

Wiem, że to nie tylko jedna operacja, ale przynajmniej powinna zawsze działać!

AKTUALIZACJA: Jeśli chcesz oneliner, oto jesteś:

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

Kolejna linijka:

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

Oto inne rozwiązanie oparte na wyrażeniach regularnych:

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

To powinno odciąć tylko ostatni segment.

Prosty:

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

Zaakceptowana odpowiedź usuwa tylko ostatnią część rozszerzenia ( .jpeg), co może być dobrym wyborem w większości przypadków.

Kiedyś musiałem usunąć wszystkie rozszerzenia ( .tar.gz), a nazwy plików były ograniczone, aby nie zawierały kropek (więc 2015-01-01.backup.tarnie byłoby problemu):

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

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

Jeśli musisz przetworzyć zmienną zawierającą pełną ścieżkę (np .:) thePath = "http://stackoverflow.com/directory/subdirectory/filename.jpg"i chcesz zwrócić tylko „nazwę pliku”, możesz użyć:

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

wynikiem będzie nazwa == "nazwa pliku" ;

Aby spróbować, wpisz następującą komendę w oknie konsoli debuggera chrome: window.location.pathname.split("/").slice(-1).join().split(".").shift()

Jeśli musisz przetworzyć tylko nazwę pliku i jego rozszerzenie (np .:) theNameWithExt = "filename.jpg":

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

wynikiem będzie nazwa == „nazwa pliku” , taka sama jak powyżej;

Uwagi:

1. Pierwszy jest nieco wolniejszy, ponieważ wykonuje więcej operacji; ale działa w obu przypadkach, innymi słowy, może wyodrębnić nazwę pliku bez rozszerzenia z danego ciągu zawierającego ścieżkę lub nazwę pliku np. Podczas gdy drugi działa tylko wtedy, gdy dana zmienna zawiera nazwę pliku z rozszerzeniem jak filename.ext, ale jest nieco szybsza.
2. Oba rozwiązania działają zarówno z plikami lokalnymi, jak i serwerowymi;

Ale nie mogę powiedzieć nic o porównaniu wydajności z innymi odpowiedziami ani o zgodności przeglądarki lub systemu operacyjnego.

fragment roboczy 1: pełna ścieżka

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

fragment roboczy 2: nazwa pliku z rozszerzeniem

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

fragment roboczy 2: nazwa pliku z podwójnym rozszerzeniem

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

Chociaż jest dość późno, dodam inne podejście do uzyskania nazwy pliku bez rozszerzenia przy użyciu zwykłego starego JS-

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

Node.js usuwa rozszerzenie z katalogu prowadzącego pełną ścieżkę

https://stackoverflow.com/a/31615711/895245 na przykład zrobił path/hello.html-> hello, ale jeśli chcesz path/hello.html-> path/hello, możesz użyć tego:

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

wypisuje również katalog:

path/hello

https://stackoverflow.com/a/36099196/895245 również to osiąga, ale uważam, że to podejście jest nieco bardziej semantycznie przyjemne.

Testowane w Node.js 10.15.2.

Tutaj przydają się wyrażenia regularne! .replace()Metoda Javascript przyjmuje wyrażenie regularne i możesz go wykorzystać do osiągnięcia tego, co chcesz:

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

Kolejna linijka - zakładamy, że naszym plikiem jest obraz jpg >> np .: var yourStr = 'test.jpg';

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

Możesz użyć pathdo manewru.

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

Wynik

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

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

To jest kod, którego używam do usunięcia rozszerzenia z nazwy pliku, bez użycia wyrażenia regularnego lub indexOf (indexOf nie jest obsługiwany w IE8). Zakłada się, że rozszerzeniem jest dowolny tekst po ostatnim „.” postać.

Działa dla:

• pliki bez rozszerzenia: „myletter”
• pliki z „.” w nazwie: „my.letter.txt”
• nieznana długość rozszerzenia pliku: „my.letter.html”

Oto kod:

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

Chciałbym użyć czegoś takiego jak x.substring (0, x.lastIndexOf ('.')). Jeśli szukasz wydajności, nie używaj javascript :-p Nie, jeszcze jedno zdanie naprawdę nie ma znaczenia dla 99,99999% wszystkich celów.